raylib 0.2.2 · OCaml Package

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 : (Constants.ConfigFlag.t list -> 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 _load_file_data : 
  (string ->
    Unsigned.uint Ctypes_static.ptr ->
    Unsigned.uchar Ctypes_static.ptr F.return)
    F.result

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

val get_file_mod_time : (string -> Signed.long F.return) F.result

val _compress_data : 
  (Unsigned.uchar Ctypes_static.ptr ->
    int ->
    int Ctypes_static.ptr ->
    Unsigned.uchar Ctypes_static.ptr F.return)
    F.result

val _decompress_data : 
  (Unsigned.uchar Ctypes_static.ptr ->
    int ->
    int Ctypes_static.ptr ->
    Unsigned.uchar Ctypes_static.ptr 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.MaterialMapType.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 ->
    Constants.ShaderLocationIndex.t F.return)
    F.result

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

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

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

val set_shader_value_texture : 
  (Types.Shader.t Ctypes.structure ->
    Constants.ShaderLocationIndex.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

package raylib

Parameters

Signature