package raylib

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Parameters
Signature

package raylib

raylib
- Raylib
  - Camera2D
  - Camera3D
  - CharInfo
  - Color
  - Font
  - Image
  - Matrix
  - NPatchInfo
  - Ray
  - RayHitInfo
  - Rectangle
  - RenderTexture2D
  - Texture2D
  - Vector2
  - Vector3
  - Vector4
raylib.c
- Raylib_c
  - Raylib_c_generated_functions
raylib.constants
- Raylib_generated_constants
raylib.functions
- Raylib_functions
  - Description
  - Types
    
    AudioStream
    
    BoneInfo
    
    BoundingBox
    
    Camera2D
    
    Camera3D
    
    CameraType
    
    CharInfo
    
    Color
    
    ConfigFlag
    
    Font
    
    Image
    
    Material
    
    MaterialMap
    
    Matrix
    
    Mesh
    
    Model
    
    ModelAnimation
    
    Music
    
    NPatchInfo
    
    NPatchType
    
    PixelFormat
    
    Ray
    
    RayHitInfo
    
    Rectangle
    
    RenderTexture2D
    
    Shader
    
    Sound
    
    Texture2D
    
    Transform
    
    Vector2
    
    Vector3
    
    Vector4
    
    Wave
raylib.types
- Raylib_types
  - Descriptions
    
    AudioStream
    
    BoneInfo
    
    BoundingBox
    
    Camera2D
    
    Camera3D
    
    CameraType
    
    CharInfo
    
    Color
    
    ConfigFlag
    
    Font
    
    Image
    
    Material
    
    MaterialMap
    
    Matrix
    
    Mesh
    
    Model
    
    ModelAnimation
    
    Music
    
    NPatchInfo
    
    NPatchType
    
    PixelFormat
    
    Ray
    
    RayHitInfo
    
    Rectangle
    
    RenderTexture2D
    
    Shader
    
    Sound
    
    Texture2D
    
    Transform
    
    Vector2
    
    Vector3
    
    Vector4
    
    Wave

Legend:
Library
Module
Module type
Parameter
Class
Class type

Parameters

module F : Ctypes.FOREIGN

Signature

val init_window : (int -> int -> string -> unit F.return) F.result

val window_should_close : (unit -> bool F.return) F.result

val close_window : (unit -> unit F.return) F.result

val is_window_ready : (unit -> bool F.return) F.result

val is_window_minimized : (unit -> bool F.return) F.result

val is_window_resized : (unit -> bool F.return) F.result

val is_window_hidden : (unit -> bool F.return) F.result

val is_window_fullscreen : (unit -> bool F.return) F.result

val toggle_fullscreen : (unit -> unit F.return) F.result

val unhide_window : (unit -> unit F.return) F.result

val hide_window : (unit -> unit F.return) F.result

val set_window_icon : 
  (Types.Image.t Ctypes.structure -> unit F.return) F.result

val set_window_title : (string -> unit F.return) F.result

val set_window_position : (int -> int -> unit F.return) F.result

val set_window_monitor : (int -> unit F.return) F.result

val set_window_min_size : (int -> int -> unit F.return) F.result

val set_window_size : (int -> int -> unit F.return) F.result

val get_window_handle : 
  (unit -> unit Ctypes_static.ptr option F.return) F.result

val get_screen_width : (unit -> int F.return) F.result

val get_screen_height : (unit -> int F.return) F.result

val get_monitor_count : (unit -> int F.return) F.result

val get_monitor_width : (int -> int F.return) F.result

val get_monitor_height : (int -> int F.return) F.result

val get_monitor_physical_width : (int -> int F.return) F.result

val get_monitor_physical_height : (int -> int F.return) F.result

val get_window_position : 
  (unit -> Types.Vector2.t Ctypes.structure F.return) F.result

val get_monitor_name : (int -> string F.return) F.result

val get_clipboard_text : (unit -> string option F.return) F.result

val set_clipboard_text : (string -> unit F.return) F.result

val show_cursor : (unit -> unit F.return) F.result

val hide_cursor : (unit -> unit F.return) F.result

val is_cursor_hidden : (unit -> bool F.return) F.result

val enable_cursor : (unit -> unit F.return) F.result

val disable_cursor : (unit -> unit F.return) F.result

val clear_background : 
  (Types.Color.t Ctypes.structure -> unit F.return) F.result

val begin_drawing : (unit -> unit F.return) F.result

val end_drawing : (unit -> unit F.return) F.result

val begin_mode_2d : 
  (Types.Camera2D.t Ctypes.structure -> unit F.return) F.result

val end_mode_2d : (unit -> unit F.return) F.result

val begin_mode_3d : 
  (Types.Camera3D.t Ctypes.structure -> unit F.return) F.result

val end_mode_3d : (unit -> unit F.return) F.result

val begin_texture_mode : 
  (Types.RenderTexture2D.t Ctypes.structure -> unit F.return) F.result

val end_texture_mode : (unit -> unit F.return) F.result

val begin_scissor_mode : (int -> int -> int -> int -> unit F.return) F.result

val end_scissor_mode : (unit -> unit F.return) F.result

val get_mouse_ray : 
  (Types.Vector2.t Ctypes.structure ->
    Types.Camera3D.t Ctypes.structure ->
    Types.Ray.t Ctypes.structure F.return)
    F.result

val get_camera_matrix : 
  (Types.Camera3D.t Ctypes.structure ->
    Types.Matrix.t Ctypes.structure F.return)
    F.result

val get_camera_matrix_2d : 
  (Types.Camera2D.t Ctypes.structure ->
    Types.Matrix.t Ctypes.structure F.return)
    F.result

val get_world_to_screen : 
  (Types.Vector3.t Ctypes.structure ->
    Types.Camera3D.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure F.return)
    F.result

val get_world_to_screen_ex : 
  (Types.Vector3.t Ctypes.structure ->
    Types.Camera3D.t Ctypes.structure ->
    int ->
    int ->
    Types.Vector2.t Ctypes.structure F.return)
    F.result

val get_world_to_screen_2d : 
  (Types.Vector2.t Ctypes.structure ->
    Types.Camera2D.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure F.return)
    F.result

val get_screen_to_world_2d : 
  (Types.Vector2.t Ctypes.structure ->
    Types.Camera2D.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure F.return)
    F.result

val set_target_fps : (int -> unit F.return) F.result

val get_f_p_s : (unit -> int F.return) F.result

val get_frame_time : (unit -> float F.return) F.result

val get_time : (unit -> float F.return) F.result

val color_to_int : (Types.Color.t Ctypes.structure -> int F.return) F.result

val color_normalize : 
  (Types.Color.t Ctypes.structure ->
    Types.Vector4.t Ctypes.structure F.return)
    F.result

val color_from_normalized : 
  (Types.Vector4.t Ctypes.structure ->
    Types.Color.t Ctypes.structure F.return)
    F.result

val color_to_hsv : 
  (Types.Color.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure F.return)
    F.result

val color_from_hsv : 
  (Types.Vector3.t Ctypes.structure ->
    Types.Color.t Ctypes.structure F.return)
    F.result

val get_color : (int -> Types.Color.t Ctypes.structure F.return) F.result

val fade : 
  (Types.Color.t Ctypes.structure ->
    float ->
    Types.Color.t Ctypes.structure F.return)
    F.result

val set_config_flags : (Unsigned.uint32 -> unit F.return) F.result

val set_trace_log_level : (Constants.TraceLogType.t -> unit F.return) F.result

val set_trace_log_exit : (Constants.TraceLogType.t -> unit F.return) F.result

val trace_log : (Constants.TraceLogType.t -> string -> unit F.return) F.result

val take_screenshot : (string -> unit F.return) F.result

val get_random_value : (int -> int -> int F.return) F.result

val save_storage_value : (int -> int -> unit F.return) F.result

val load_storage_value : (int -> int F.return) F.result

val open_u_r_l : (string -> unit F.return) F.result

val is_key_pressed : (Constants.Key.t -> bool F.return) F.result

val is_key_down : (Constants.Key.t -> bool F.return) F.result

val is_key_released : (Constants.Key.t -> bool F.return) F.result

val is_key_up : (Constants.Key.t -> bool F.return) F.result

val set_exit_key : (Constants.Key.t -> unit F.return) F.result

val get_key_pressed : (unit -> Constants.Key.t F.return) F.result

val is_gamepad_available : 
  (Constants.GamepadNumber.t -> bool F.return) F.result

val is_gamepad_name : 
  (Constants.GamepadNumber.t -> string -> bool F.return) F.result

val get_gamepad_name : (Constants.GamepadNumber.t -> string F.return) F.result

val is_gamepad_button_pressed : 
  (Constants.GamepadNumber.t ->
    Constants.GamepadButton.t ->
    bool F.return)
    F.result

val is_gamepad_button_down : 
  (Constants.GamepadNumber.t ->
    Constants.GamepadButton.t ->
    bool F.return)
    F.result

val is_gamepad_button_released : 
  (Constants.GamepadNumber.t ->
    Constants.GamepadButton.t ->
    bool F.return)
    F.result

val is_gamepad_button_up : 
  (Constants.GamepadNumber.t ->
    Constants.GamepadButton.t ->
    bool F.return)
    F.result

val get_gamepad_button_pressed : 
  (unit -> Constants.GamepadButton.t F.return) F.result

val get_gamepad_axis_count : 
  (Constants.GamepadNumber.t -> int F.return) F.result

val get_gamepad_axis_movement : 
  (Constants.GamepadNumber.t ->
    Constants.GamepadAxis.t ->
    float F.return)
    F.result

val is_mouse_button_pressed : 
  (Constants.MouseButton.t -> bool F.return) F.result

val is_mouse_button_down : (Constants.MouseButton.t -> bool F.return) F.result

val is_mouse_button_released : 
  (Constants.MouseButton.t -> bool F.return) F.result

val is_mouse_button_up : (Constants.MouseButton.t -> bool F.return) F.result

val get_mouse_x : (unit -> int F.return) F.result

val get_mouse_y : (unit -> int F.return) F.result

val get_mouse_position : 
  (unit -> Types.Vector2.t Ctypes.structure F.return) F.result

val set_mouse_position : (int -> int -> unit F.return) F.result

val set_mouse_offset : (int -> int -> unit F.return) F.result

val set_mouse_scale : (float -> float -> unit F.return) F.result

val get_mouse_wheel_move : (unit -> int F.return) F.result

val get_touch_x : (unit -> int F.return) F.result

val get_touch_y : (unit -> int F.return) F.result

val get_touch_position : 
  (int -> Types.Vector2.t Ctypes.structure F.return) F.result

val is_gesture_detected : (int -> bool F.return) F.result

val get_gesture_detected : (unit -> int F.return) F.result

val get_touch_points_count : (unit -> int F.return) F.result

val get_gesture_hold_duration : (unit -> float F.return) F.result

val get_gesture_drag_vector : 
  (unit -> Types.Vector2.t Ctypes.structure F.return) F.result

val get_gesture_drag_angle : (unit -> float F.return) F.result

val get_gesture_pinch_vector : 
  (unit -> Types.Vector2.t Ctypes.structure F.return) F.result

val get_gesture_pinch_angle : (unit -> float F.return) F.result

val set_camera_mode : 
  (Types.Camera3D.t Ctypes.structure ->
    Constants.CameraMode.t ->
    unit F.return)
    F.result

val update_camera : 
  (Types.Camera3D.t Ctypes.structure Ctypes_static.ptr ->
    unit F.return)
    F.result

val set_camera_pan_control : (int -> unit F.return) F.result

val set_camera_alt_control : (int -> unit F.return) F.result

val set_camera_smooth_zoom_control : (int -> unit F.return) F.result

val set_camera_move_controls : 
  (int -> int -> int -> int -> int -> int -> unit F.return) F.result

val draw_pixel : 
  (int -> int -> Types.Color.t Ctypes.structure -> unit F.return) F.result

val draw_pixel_v : 
  (Types.Vector2.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_line : 
  (int ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_line_v : 
  (Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_line_ex : 
  (Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_line_bezier : 
  (Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_line_strip : 
  (Types.Vector2.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_circle : 
  (int ->
    int ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_circle_sector : 
  (Types.Vector2.t Ctypes.structure ->
    float ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_circle_sector_lines : 
  (Types.Vector2.t Ctypes.structure ->
    float ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_circle_gradient : 
  (int ->
    int ->
    float ->
    Types.Color.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_circle_v : 
  (Types.Vector2.t Ctypes.structure ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_circle_lines : 
  (int ->
    int ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_ellipse : 
  (int ->
    int ->
    float ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_ellipse_lines : 
  (int ->
    int ->
    float ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_ring : 
  (Types.Vector2.t Ctypes.structure ->
    float ->
    float ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_ring_lines : 
  (Types.Vector2.t Ctypes.structure ->
    float ->
    float ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_rectangle : 
  (int ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_rectangle_v : 
  (Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_rectangle_rec : 
  (Types.Rectangle.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_rectangle_pro : 
  (Types.Rectangle.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_rectangle_gradient_v : 
  (int ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_rectangle_gradient_h : 
  (int ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_rectangle_gradient_ex : 
  (Types.Rectangle.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_rectangle_lines : 
  (int ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_rectangle_lines_ex : 
  (Types.Rectangle.t Ctypes.structure ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_rectangle_rounded : 
  (Types.Rectangle.t Ctypes.structure ->
    float ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_rectangle_rounded_lines : 
  (Types.Rectangle.t Ctypes.structure ->
    float ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_triangle : 
  (Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_triangle_lines : 
  (Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_triangle_fan : 
  (Types.Vector2.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_triangle_strip : 
  (Types.Vector2.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_poly : 
  (Types.Vector2.t Ctypes.structure ->
    int ->
    float ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_poly_lines : 
  (Types.Vector2.t Ctypes.structure ->
    int ->
    float ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val check_collision_recs : 
  (Types.Rectangle.t Ctypes.structure ->
    Types.Rectangle.t Ctypes.structure ->
    bool F.return)
    F.result

val check_collision_circles : 
  (Types.Vector2.t Ctypes.structure ->
    float ->
    Types.Vector2.t Ctypes.structure ->
    float ->
    bool F.return)
    F.result

val check_collision_circle_rec : 
  (Types.Vector2.t Ctypes.structure ->
    float ->
    Types.Rectangle.t Ctypes.structure ->
    bool F.return)
    F.result

val get_collision_rec : 
  (Types.Rectangle.t Ctypes.structure ->
    Types.Rectangle.t Ctypes.structure ->
    Types.Rectangle.t Ctypes.structure F.return)
    F.result

val check_collision_point_rec : 
  (Types.Vector2.t Ctypes.structure ->
    Types.Rectangle.t Ctypes.structure ->
    bool F.return)
    F.result

val check_collision_point_circle : 
  (Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    float ->
    bool F.return)
    F.result

val check_collision_point_triangle : 
  (Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    bool F.return)
    F.result

val load_image : (string -> Types.Image.t Ctypes.structure F.return) F.result

val load_image_ex : 
  (Types.Color.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    int ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val load_image_pro : 
  (unit Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val load_image_raw : 
  (string ->
    int ->
    int ->
    int ->
    int ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val unload_image : (Types.Image.t Ctypes.structure -> unit F.return) F.result

val export_image : 
  (Types.Image.t Ctypes.structure -> string -> unit F.return) F.result

val export_image_as_code : 
  (Types.Image.t Ctypes.structure -> string -> unit F.return) F.result

val gen_image_color : 
  (int ->
    int ->
    Types.Color.t Ctypes.structure ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val gen_image_gradient_v : 
  (int ->
    int ->
    Types.Color.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val gen_image_gradient_h : 
  (int ->
    int ->
    Types.Color.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val gen_image_gradient_radial : 
  (int ->
    int ->
    float ->
    Types.Color.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val gen_image_checked : 
  (int ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val gen_image_white_noise : 
  (int -> int -> float -> Types.Image.t Ctypes.structure F.return) F.result

val gen_image_perlin_noise : 
  (int ->
    int ->
    int ->
    int ->
    float ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val gen_image_cellular : 
  (int -> int -> int -> Types.Image.t Ctypes.structure F.return) F.result

val image_copy : 
  (Types.Image.t Ctypes.structure ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val image_from_image : 
  (Types.Image.t Ctypes.structure ->
    Types.Rectangle.t Ctypes.structure ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val image_text : 
  (string ->
    int ->
    Types.Color.t Ctypes.structure ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val image_text_ex : 
  (Types.Font.t Ctypes.structure ->
    string ->
    float ->
    float ->
    Types.Color.t Ctypes.structure ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val image_to_p_o_t : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_format : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val image_alpha_mask : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Image.t Ctypes.structure ->
    unit F.return)
    F.result

val image_alpha_clear : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Color.t Ctypes.structure ->
    float ->
    unit F.return)
    F.result

val image_alpha_crop : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    float ->
    unit F.return)
    F.result

val image_alpha_premultiply : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr -> unit F.return) F.result

val image_crop : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Rectangle.t Ctypes.structure ->
    unit F.return)
    F.result

val image_resize : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val image_resize_n_n : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val image_resize_canvas : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_mipmaps : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr -> unit F.return) F.result

val image_dither : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val image_flip_vertical : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr -> unit F.return) F.result

val image_flip_horizontal : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr -> unit F.return) F.result

val image_rotate_c_w : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr -> unit F.return) F.result

val image_rotate_c_c_w : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr -> unit F.return) F.result

val image_color_tint : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_color_invert : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr -> unit F.return) F.result

val image_color_grayscale : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr -> unit F.return) F.result

val image_color_contrast : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    float ->
    unit F.return)
    F.result

val image_color_brightness : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val image_color_replace : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Color.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val get_image_alpha_border : 
  (Types.Image.t Ctypes.structure ->
    float ->
    Types.Rectangle.t Ctypes.structure F.return)
    F.result

val image_clear_background : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_draw_pixel : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_draw_pixel_v : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Vector2.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_draw_line : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_draw_line_v : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_draw_circle : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_draw_circle_v : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Vector2.t Ctypes.structure ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_draw_rectangle : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_draw_rectangle_v : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_draw_rectangle_rec : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Rectangle.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_draw_rectangle_lines : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Rectangle.t Ctypes.structure ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_draw : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Image.t Ctypes.structure ->
    Types.Rectangle.t Ctypes.structure ->
    Types.Rectangle.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_draw_text : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Vector2.t Ctypes.structure ->
    string ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val image_draw_text_ex : 
  (Types.Image.t Ctypes.structure Ctypes_static.ptr ->
    Types.Vector2.t Ctypes.structure ->
    Types.Font.t Ctypes.structure ->
    string ->
    float ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val load_texture : 
  (string -> Types.Texture2D.t Ctypes.structure F.return) F.result

val load_texture_from_image : 
  (Types.Image.t Ctypes.structure ->
    Types.Texture2D.t Ctypes.structure F.return)
    F.result

val load_texture_cubemap : 
  (Types.Image.t Ctypes.structure ->
    int ->
    Types.Texture2D.t Ctypes.structure F.return)
    F.result

val load_render_texture : 
  (int -> int -> Types.RenderTexture2D.t Ctypes.structure F.return) F.result

val unload_texture : 
  (Types.Texture2D.t Ctypes.structure -> unit F.return) F.result

val unload_render_texture : 
  (Types.RenderTexture2D.t Ctypes.structure -> unit F.return) F.result

val update_texture : 
  (Types.Texture2D.t Ctypes.structure ->
    unit Ctypes_static.ptr ->
    unit F.return)
    F.result

val get_texture_data : 
  (Types.Texture2D.t Ctypes.structure ->
    Types.Image.t Ctypes.structure F.return)
    F.result

val get_screen_data : 
  (unit -> Types.Image.t Ctypes.structure F.return) F.result

val gen_texture_mipmaps : 
  (Types.Texture2D.t Ctypes.structure Ctypes_static.ptr ->
    unit F.return)
    F.result

val set_texture_filter : 
  (Types.Texture2D.t Ctypes.structure ->
    Constants.TextureFilterMode.t ->
    unit F.return)
    F.result

val set_texture_wrap : 
  (Types.Texture2D.t Ctypes.structure ->
    Constants.TextureWrapMode.t ->
    unit F.return)
    F.result

val draw_texture : 
  (Types.Texture2D.t Ctypes.structure ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_texture_v : 
  (Types.Texture2D.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_texture_ex : 
  (Types.Texture2D.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    float ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_texture_rec : 
  (Types.Texture2D.t Ctypes.structure ->
    Types.Rectangle.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_texture_quad : 
  (Types.Texture2D.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Rectangle.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_texture_pro : 
  (Types.Texture2D.t Ctypes.structure ->
    Types.Rectangle.t Ctypes.structure ->
    Types.Rectangle.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val get_pixel_data_size : (int -> int -> int -> int F.return) F.result

val get_font_default : 
  (unit -> Types.Font.t Ctypes.structure F.return) F.result

val load_font : (string -> Types.Font.t Ctypes.structure F.return) F.result

val load_font_ex : 
  (string ->
    int ->
    int Ctypes_static.ptr ->
    int ->
    Types.Font.t Ctypes.structure F.return)
    F.result

val load_font_from_image : 
  (Types.Image.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    int ->
    Types.Font.t Ctypes.structure F.return)
    F.result

val load_font_data : 
  (string ->
    int ->
    int Ctypes_static.ptr ->
    int ->
    int ->
    Types.CharInfo.t Ctypes.structure Ctypes_static.ptr F.return)
    F.result

val unload_font : (Types.Font.t Ctypes.structure -> unit F.return) F.result

val draw_fps : (int -> int -> unit F.return) F.result

val draw_text : 
  (string ->
    int ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_text_ex : 
  (Types.Font.t Ctypes.structure ->
    string ->
    Types.Vector2.t Ctypes.structure ->
    float ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_text_rec : 
  (Types.Font.t Ctypes.structure ->
    string ->
    Types.Rectangle.t Ctypes.structure ->
    float ->
    float ->
    bool ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_text_rec_ex : 
  (Types.Font.t Ctypes.structure ->
    string ->
    Types.Rectangle.t Ctypes.structure ->
    float ->
    float ->
    bool ->
    Types.Color.t Ctypes.structure ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_text_codepoint : 
  (Types.Font.t Ctypes.structure ->
    int ->
    Types.Vector2.t Ctypes.structure ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val measure_text : (string -> int -> int F.return) F.result

val measure_text_ex : 
  (Types.Font.t Ctypes.structure ->
    string ->
    float ->
    float ->
    Types.Vector2.t Ctypes.structure F.return)
    F.result

val get_glyph_index : 
  (Types.Font.t Ctypes.structure -> int -> int F.return) F.result

val text_copy : (string -> string -> int F.return) F.result

val text_is_equal : (string -> string -> bool F.return) F.result

val text_length : (string -> int F.return) F.result

val text_subtext : (string -> int -> int -> string F.return) F.result

val text_replace : (string -> string -> string -> string F.return) F.result

val text_insert : (string -> string -> int -> string F.return) F.result

val text_append : 
  (string -> string -> int Ctypes_static.ptr -> unit F.return) F.result

val text_find_index : (string -> string -> int F.return) F.result

val text_to_upper : (string -> string F.return) F.result

val text_to_lower : (string -> string F.return) F.result

val text_to_pascal : (string -> string F.return) F.result

val text_to_integer : (string -> int F.return) F.result

val text_to_utf8 : (int Ctypes_static.ptr -> int -> string F.return) F.result

val get_codepoints : 
  (string -> int Ctypes_static.ptr -> int Ctypes_static.ptr F.return) F.result

val get_codepoints_count : (string -> int F.return) F.result

val get_next_codepoint : 
  (string -> int Ctypes_static.ptr -> int F.return) F.result

val codepoint_to_utf8 : 
  (int -> int Ctypes_static.ptr -> string F.return) F.result

val draw_line_3d : 
  (Types.Vector3.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_point_3d : 
  (Types.Vector3.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_circle_3d : 
  (Types.Vector3.t Ctypes.structure ->
    float ->
    Types.Vector3.t Ctypes.structure ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_cube : 
  (Types.Vector3.t Ctypes.structure ->
    float ->
    float ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_cube_v : 
  (Types.Vector3.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_cube_wires : 
  (Types.Vector3.t Ctypes.structure ->
    float ->
    float ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_cube_wires_v : 
  (Types.Vector3.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_cube_texture : 
  (Types.Texture2D.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    float ->
    float ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_sphere : 
  (Types.Vector3.t Ctypes.structure ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_sphere_ex : 
  (Types.Vector3.t Ctypes.structure ->
    float ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_sphere_wires : 
  (Types.Vector3.t Ctypes.structure ->
    float ->
    int ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_cylinder : 
  (Types.Vector3.t Ctypes.structure ->
    float ->
    float ->
    float ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_cylinder_wires : 
  (Types.Vector3.t Ctypes.structure ->
    float ->
    float ->
    float ->
    int ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_plane : 
  (Types.Vector3.t Ctypes.structure ->
    Types.Vector2.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_grid : (int -> float -> unit F.return) F.result

val draw_gizmo : (Types.Vector3.t Ctypes.structure -> unit F.return) F.result

val load_model : (string -> Types.Model.t Ctypes.structure F.return) F.result

val load_model_from_mesh : 
  (Types.Mesh.t Ctypes.structure ->
    Types.Model.t Ctypes.structure F.return)
    F.result

val unload_model : (Types.Model.t Ctypes.structure -> unit F.return) F.result

val load_meshes : 
  (string ->
    int Ctypes_static.ptr ->
    Types.Mesh.t Ctypes.structure Ctypes_static.ptr option F.return)
    F.result

val export_mesh : 
  (Types.Mesh.t Ctypes.structure -> string -> unit F.return) F.result

val unload_mesh : (Types.Mesh.t Ctypes.structure -> unit F.return) F.result

val load_materials : 
  (string ->
    int Ctypes_static.ptr ->
    Types.Material.t Ctypes.structure Ctypes_static.ptr F.return)
    F.result

val load_material_default : 
  (unit -> Types.Material.t Ctypes.structure F.return) F.result

val unload_material : 
  (Types.Material.t Ctypes.structure -> unit F.return) F.result

val set_material_texture : 
  (Types.Material.t Ctypes.structure Ctypes_static.ptr ->
    Constants.MaterialMap.t ->
    Types.Texture2D.t Ctypes.structure ->
    unit F.return)
    F.result

val set_model_mesh_material : 
  (Types.Model.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val load_model_animations : 
  (string ->
    int Ctypes_static.ptr ->
    Types.ModelAnimation.t Ctypes.structure Ctypes_static.ptr F.return)
    F.result

val update_model_animation : 
  (Types.Model.t Ctypes.structure ->
    Types.ModelAnimation.t Ctypes.structure ->
    int ->
    unit F.return)
    F.result

val unload_model_animation : 
  (Types.ModelAnimation.t Ctypes.structure -> unit F.return) F.result

val is_model_animation_valid : 
  (Types.Model.t Ctypes.structure ->
    Types.ModelAnimation.t Ctypes.structure ->
    bool F.return)
    F.result

val gen_mesh_poly : 
  (int -> float -> Types.Mesh.t Ctypes.structure F.return) F.result

val gen_mesh_plane : 
  (float ->
    float ->
    int ->
    int ->
    Types.Mesh.t Ctypes.structure F.return)
    F.result

val gen_mesh_cube : 
  (float -> float -> float -> Types.Mesh.t Ctypes.structure F.return) F.result

val gen_mesh_sphere : 
  (float -> int -> int -> Types.Mesh.t Ctypes.structure F.return) F.result

val gen_mesh_hemi_sphere : 
  (float -> int -> int -> Types.Mesh.t Ctypes.structure F.return) F.result

val gen_mesh_cylinder : 
  (float -> float -> int -> Types.Mesh.t Ctypes.structure F.return) F.result

val gen_mesh_torus : 
  (float ->
    float ->
    int ->
    int ->
    Types.Mesh.t Ctypes.structure F.return)
    F.result

val gen_mesh_knot : 
  (float ->
    float ->
    int ->
    int ->
    Types.Mesh.t Ctypes.structure F.return)
    F.result

val gen_mesh_heightmap : 
  (Types.Image.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    Types.Mesh.t Ctypes.structure F.return)
    F.result

val gen_mesh_cubicmap : 
  (Types.Image.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    Types.Mesh.t Ctypes.structure F.return)
    F.result

val mesh_bounding_box : 
  (Types.Mesh.t Ctypes.structure ->
    Types.BoundingBox.t Ctypes.structure F.return)
    F.result

val mesh_tangents : 
  (Types.Mesh.t Ctypes.structure Ctypes_static.ptr -> unit F.return) F.result

val mesh_binormals : 
  (Types.Mesh.t Ctypes.structure Ctypes_static.ptr -> unit F.return) F.result

val draw_model : 
  (Types.Model.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_model_ex : 
  (Types.Model.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    float ->
    Types.Vector3.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_model_wires : 
  (Types.Model.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_model_wires_ex : 
  (Types.Model.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    float ->
    Types.Vector3.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_bounding_box : 
  (Types.BoundingBox.t Ctypes.structure ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_billboard : 
  (Types.Camera3D.t Ctypes.structure ->
    Types.Texture2D.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val draw_billboard_rec : 
  (Types.Camera3D.t Ctypes.structure ->
    Types.Texture2D.t Ctypes.structure ->
    Types.Rectangle.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    float ->
    Types.Color.t Ctypes.structure ->
    unit F.return)
    F.result

val check_collision_spheres : 
  (Types.Vector3.t Ctypes.structure ->
    float ->
    Types.Vector3.t Ctypes.structure ->
    float ->
    bool F.return)
    F.result

val check_collision_boxes : 
  (Types.BoundingBox.t Ctypes.structure ->
    Types.BoundingBox.t Ctypes.structure ->
    bool F.return)
    F.result

val check_collision_box_sphere : 
  (Types.BoundingBox.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    float ->
    bool F.return)
    F.result

val check_collision_ray_sphere : 
  (Types.Ray.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    float ->
    bool F.return)
    F.result

val check_collision_ray_sphere_ex : 
  (Types.Ray.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    float ->
    Types.Vector3.t Ctypes.structure Ctypes_static.ptr ->
    bool F.return)
    F.result

val check_collision_ray_box : 
  (Types.Ray.t Ctypes.structure ->
    Types.BoundingBox.t Ctypes.structure ->
    bool F.return)
    F.result

val get_collision_ray_model : 
  (Types.Ray.t Ctypes.structure ->
    Types.Model.t Ctypes.structure ->
    Types.RayHitInfo.t Ctypes.structure F.return)
    F.result

val get_collision_ray_triangle : 
  (Types.Ray.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    Types.Vector3.t Ctypes.structure ->
    Types.RayHitInfo.t Ctypes.structure F.return)
    F.result

val get_collision_ray_ground : 
  (Types.Ray.t Ctypes.structure ->
    float ->
    Types.RayHitInfo.t Ctypes.structure F.return)
    F.result

val load_shader : 
  (string -> string -> Types.Shader.t Ctypes.structure F.return) F.result

val load_shader_code : 
  (string -> string -> Types.Shader.t Ctypes.structure F.return) F.result

val unload_shader : (Types.Shader.t Ctypes.structure -> unit F.return) F.result

val get_shader_default : 
  (unit -> Types.Shader.t Ctypes.structure F.return) F.result

val get_texture_default : 
  (unit -> Types.Texture2D.t Ctypes.structure F.return) F.result

val get_shapes_texture : 
  (unit -> Types.Texture2D.t Ctypes.structure F.return) F.result

val get_shapes_texture_rec : 
  (unit -> Types.Rectangle.t Ctypes.structure F.return) F.result

val set_shapes_texture : 
  (Types.Texture2D.t Ctypes.structure ->
    Types.Rectangle.t Ctypes.structure ->
    unit F.return)
    F.result

val get_shader_location : 
  (Types.Shader.t Ctypes.structure -> string -> int F.return) F.result

val set_shader_value : 
  (Types.Shader.t Ctypes.structure ->
    Constants.ShaderLocation.t ->
    unit Ctypes_static.ptr ->
    Constants.ShaderUniformData.t ->
    unit F.return)
    F.result

val set_shader_value_v : 
  (Types.Shader.t Ctypes.structure ->
    Constants.ShaderLocation.t ->
    unit Ctypes_static.ptr ->
    Constants.ShaderUniformData.t ->
    int ->
    unit F.return)
    F.result

val set_shader_value_matrix : 
  (Types.Shader.t Ctypes.structure ->
    Constants.ShaderLocation.t ->
    Types.Matrix.t Ctypes.structure ->
    unit F.return)
    F.result

val set_shader_value_texture : 
  (Types.Shader.t Ctypes.structure ->
    Constants.ShaderLocation.t ->
    Types.Texture2D.t Ctypes.structure ->
    unit F.return)
    F.result

val set_matrix_projection : 
  (Types.Matrix.t Ctypes.structure -> unit F.return) F.result

val set_matrix_modelview : 
  (Types.Matrix.t Ctypes.structure -> unit F.return) F.result

val get_matrix_modelview : 
  (unit -> Types.Matrix.t Ctypes.structure F.return) F.result

val get_matrix_projection : 
  (unit -> Types.Matrix.t Ctypes.structure F.return) F.result

val gen_texture_cubemap : 
  (Types.Shader.t Ctypes.structure ->
    Types.Texture2D.t Ctypes.structure ->
    int ->
    Types.Texture2D.t Ctypes.structure F.return)
    F.result

val gen_texture_irradiance : 
  (Types.Shader.t Ctypes.structure ->
    Types.Texture2D.t Ctypes.structure ->
    int ->
    Types.Texture2D.t Ctypes.structure F.return)
    F.result

val gen_texture_prefilter : 
  (Types.Shader.t Ctypes.structure ->
    Types.Texture2D.t Ctypes.structure ->
    int ->
    Types.Texture2D.t Ctypes.structure F.return)
    F.result

val gen_texture_b_r_d_f : 
  (Types.Shader.t Ctypes.structure ->
    int ->
    Types.Texture2D.t Ctypes.structure F.return)
    F.result

val begin_shader_mode : 
  (Types.Shader.t Ctypes.structure -> unit F.return) F.result

val end_shader_mode : (unit -> unit F.return) F.result

val begin_blend_mode : (Constants.BlendMode.t -> unit F.return) F.result

val end_blend_mode : (unit -> unit F.return) F.result

val init_vr_simulator : (unit -> unit F.return) F.result

val close_vr_simulator : (unit -> unit F.return) F.result

val update_vr_tracking : 
  (Types.Camera3D.t Ctypes.structure Ctypes_static.ptr ->
    unit F.return)
    F.result

val is_vr_simulator_ready : (unit -> bool F.return) F.result

val toggle_vr_mode : (unit -> unit F.return) F.result

val begin_vr_drawing : (unit -> unit F.return) F.result

val end_vr_drawing : (unit -> unit F.return) F.result

val init_audio_device : (unit -> unit F.return) F.result

val close_audio_device : (unit -> unit F.return) F.result

val is_audio_device_ready : (unit -> bool F.return) F.result

val set_master_volume : (float -> unit F.return) F.result

val load_wave : (string -> Types.Wave.t Ctypes.structure F.return) F.result

val load_sound : (string -> Types.Sound.t Ctypes.structure F.return) F.result

val load_sound_from_wave : 
  (Types.Wave.t Ctypes.structure ->
    Types.Sound.t Ctypes.structure F.return)
    F.result

val update_sound : 
  (Types.Sound.t Ctypes.structure ->
    unit Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val unload_wave : (Types.Wave.t Ctypes.structure -> unit F.return) F.result

val unload_sound : (Types.Sound.t Ctypes.structure -> unit F.return) F.result

val export_wave : 
  (Types.Wave.t Ctypes.structure -> string -> unit F.return) F.result

val export_wave_as_code : 
  (Types.Wave.t Ctypes.structure -> string -> unit F.return) F.result

val play_sound : (Types.Sound.t Ctypes.structure -> unit F.return) F.result

val stop_sound : (Types.Sound.t Ctypes.structure -> unit F.return) F.result

val pause_sound : (Types.Sound.t Ctypes.structure -> unit F.return) F.result

val resume_sound : (Types.Sound.t Ctypes.structure -> unit F.return) F.result

val play_sound_multi : 
  (Types.Sound.t Ctypes.structure -> unit F.return) F.result

val stop_sound_multi : (unit -> unit F.return) F.result

val get_sounds_playing : (unit -> int F.return) F.result

val is_sound_playing : 
  (Types.Sound.t Ctypes.structure -> bool F.return) F.result

val set_sound_volume : 
  (Types.Sound.t Ctypes.structure -> float -> unit F.return) F.result

val set_sound_pitch : 
  (Types.Sound.t Ctypes.structure -> float -> unit F.return) F.result

val wave_format : 
  (Types.Wave.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val wave_copy : 
  (Types.Wave.t Ctypes.structure ->
    Types.Wave.t Ctypes.structure F.return)
    F.result

val wave_crop : 
  (Types.Wave.t Ctypes.structure Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val get_wave_data : 
  (Types.Wave.t Ctypes.structure -> float Ctypes_static.ptr F.return) F.result

val load_music_stream : 
  (string -> Types.Music.t Ctypes.structure F.return) F.result

val unload_music_stream : 
  (Types.Music.t Ctypes.structure -> unit F.return) F.result

val play_music_stream : 
  (Types.Music.t Ctypes.structure -> unit F.return) F.result

val update_music_stream : 
  (Types.Music.t Ctypes.structure -> unit F.return) F.result

val stop_music_stream : 
  (Types.Music.t Ctypes.structure -> unit F.return) F.result

val pause_music_stream : 
  (Types.Music.t Ctypes.structure -> unit F.return) F.result

val resume_music_stream : 
  (Types.Music.t Ctypes.structure -> unit F.return) F.result

val is_music_playing : 
  (Types.Music.t Ctypes.structure -> bool F.return) F.result

val set_music_volume : 
  (Types.Music.t Ctypes.structure -> float -> unit F.return) F.result

val set_music_pitch : 
  (Types.Music.t Ctypes.structure -> float -> unit F.return) F.result

val set_music_loop_count : 
  (Types.Music.t Ctypes.structure -> int -> unit F.return) F.result

val get_music_time_length : 
  (Types.Music.t Ctypes.structure -> float F.return) F.result

val get_music_time_played : 
  (Types.Music.t Ctypes.structure -> float F.return) F.result

val init_audio_stream : 
  (int -> int -> int -> Types.AudioStream.t Ctypes.structure F.return) F.result

val update_audio_stream : 
  (Types.AudioStream.t Ctypes.structure ->
    unit Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val close_audio_stream : 
  (Types.AudioStream.t Ctypes.structure -> unit F.return) F.result

val is_audio_stream_processed : 
  (Types.AudioStream.t Ctypes.structure -> bool F.return) F.result

val play_audio_stream : 
  (Types.AudioStream.t Ctypes.structure -> unit F.return) F.result

val pause_audio_stream : 
  (Types.AudioStream.t Ctypes.structure -> unit F.return) F.result

val resume_audio_stream : 
  (Types.AudioStream.t Ctypes.structure -> unit F.return) F.result

val is_audio_stream_playing : 
  (Types.AudioStream.t Ctypes.structure -> bool F.return) F.result

val stop_audio_stream : 
  (Types.AudioStream.t Ctypes.structure -> unit F.return) F.result

val set_audio_stream_volume : 
  (Types.AudioStream.t Ctypes.structure -> float -> unit F.return) F.result

val set_audio_stream_pitch : 
  (Types.AudioStream.t Ctypes.structure -> float -> unit F.return) F.result

val set_audio_stream_buffer_size_default : (int -> unit F.return) F.result