Module Allegro

module Allegro: sig .. end

• General Functions
• Graphics modes
• Truecolor pixel formats
• Palette routines
• Converting between color formats
• Bitmap objects
• Loading image files
• Keyboard routines
• Timer routines
• Mouse routines
• Fixed point number
• Drawing primitives
• Sprites
• RLE Sprites
• Compiled Sprites
• Text output
• Transparency and patterned drawing
• Sound init routines
• Digital sample routines
• File and compression routines
• Datafile routines
• Polygon rendering
• 3D math routines
• Quaternion math routines
• GUI routines

General Functions

val allegro_init : unit -> unit

val allegro_exit : unit -> unit

val allegro_message : string -> unit

val get_allegro_error : unit -> string

val allegro_id : unit -> string

val allegro_version : unit -> int * int * int * string * int * int * int

val set_window_title : name:string -> unit

val cpu_vendor : unit -> string

val get_cpu_family : unit -> cpu_family

val os_version : unit -> int

val os_revision : unit -> int

val os_multitasking : unit -> bool

val desktop_color_depth : unit -> int

val get_desktop_resolution : unit -> int * int

Graphics Modes

val set_color_depth : depth:int -> unit

val get_color_depth : unit -> int

val get_screen_width : unit -> int

val get_screen_height : unit -> int

val get_virtual_width : unit -> int

val get_virtual_height : unit -> int

val request_refresh_rate : rate:int -> unit

val get_refresh_rate : unit -> int

val set_gfx_mode : gfx_driver:gfx_driver ->
       width:int -> height:int -> virtual_width:int -> virtual_height:int -> unit

val get_gfx_driver_name : unit -> string

val enable_triple_buffer : unit -> bool

val vsync : unit -> unit

val scroll_screen : x:int -> y:int -> unit

val request_scroll : x:int -> y:int -> unit

val poll_scroll : unit -> bool

val get_gfx_capabilities : unit -> gfx_capabilities list

val set_display_switch_mode : switch_mode -> unit

val get_display_switch_mode : unit -> switch_mode

val is_windowed_mode : unit -> bool

val allegro_vram_single_surface : unit -> bool

val allegro_dos : unit -> bool

Truecolor Pixel Formats

type color 

val makecol : r:int -> g:int -> b:int -> color

val makecol_depth : depth:int -> r:int -> g:int -> b:int -> color

val transparent : unit -> color

val makeacol : r:int -> g:int -> b:int -> a:int -> color

val makeacol_depth : depth:int -> r:int -> g:int -> b:int -> a:int -> color

val color_index : int -> color

val getr : color -> int

val getg : color -> int

val getb : color -> int

val geta : color -> int

val palette_color : int -> color

Display Dependent Pixel Format

val makecol8 : r:int -> g:int -> b:int -> color

val makecol15 : r:int -> g:int -> b:int -> color

val makecol16 : r:int -> g:int -> b:int -> color

val makecol24 : r:int -> g:int -> b:int -> color

val makecol32 : r:int -> g:int -> b:int -> color

val makeacol32 : r:int -> g:int -> b:int -> a:int -> color

val makecol15_dither : r:int -> g:int -> b:int -> x:int -> y:int -> color

val makecol16_dither : r:int -> g:int -> b:int -> x:int -> y:int -> color

val getr8 : color -> int

val getg8 : color -> int

val getb8 : color -> int

val getr15 : color -> int

val getg15 : color -> int

val getb15 : color -> int

val getr16 : color -> int

val getg16 : color -> int

val getb16 : color -> int

val getr24 : color -> int

val getg24 : color -> int

val getb24 : color -> int

val getr32 : color -> int

val getg32 : color -> int

val getb32 : color -> int

val geta32 : color -> int

val getr_depth : depth:int -> color -> int

val getg_depth : depth:int -> color -> int

val getb_depth : depth:int -> color -> int

val geta_depth : depth:int -> color -> int

Palette Routines

type palette 

val new_palette : unit -> palette

val free_palette : pal:palette -> unit

val set_palette : pal:palette -> unit

val get_palette : pal:palette -> unit

val set_color : index:int -> r:int -> g:int -> b:int -> a:int -> unit

val get_desktop_palette : unit -> palette

val generate_332_palette : pal:palette -> unit

val select_palette : pal:palette -> unit

val unselect_palette : unit -> unit

val palette_set_rgb : pal:palette -> i:int -> r:int -> g:int -> b:int -> unit

val palette_set_rgba : pal:palette -> i:int -> r:int -> g:int -> b:int -> a:int -> unit

val palette_get_rgb : pal:palette -> i:int -> int * int * int

val palette_get_rgba : pal:palette -> i:int -> int * int * int * int

val palette_copy_index : src:palette -> dst:palette -> i:int -> unit

Converting Between Color Formats

val hsv_to_rgb : h:float -> s:float -> v:float -> int * int * int

val rgb_to_hsv : r:int -> g:int -> b:int -> float * float * float

Bitmap Objects

type bitmap 

val get_screen : unit -> bitmap

val create_bitmap : width:int -> height:int -> bitmap

val create_sub_bitmap : parent:bitmap ->
       x:int -> y:int -> width:int -> height:int -> bitmap

val create_video_bitmap : width:int -> height:int -> bitmap

val create_system_bitmap : width:int -> height:int -> bitmap

val create_bitmap_ex : color_depth:int -> width:int -> height:int -> bitmap

val bitmap_color_depth : bmp:bitmap -> int

val destroy_bitmap : bmp:bitmap -> unit

val get_bitmap_width : bmp:bitmap -> int

val get_bitmap_height : bmp:bitmap -> int

val acquire_bitmap : bmp:bitmap -> unit

val release_bitmap : bmp:bitmap -> unit

val acquire_screen : unit -> unit

val release_screen : unit -> unit

val bitmap_mask_color : bmp:bitmap -> color

val is_same_bitmap : bmp1:bitmap -> bmp2:bitmap -> bool

val show_video_bitmap : bmp:bitmap -> unit

val request_video_bitmap : bmp:bitmap -> unit

val clear_bitmap : bmp:bitmap -> unit

val clear_to_color : bmp:bitmap -> color:color -> unit

val add_clip_rect : bmp:bitmap -> x1:int -> y1:int -> x2:int -> y2:int -> unit

val set_clip_rect : bmp:bitmap -> x1:int -> y1:int -> x2:int -> y2:int -> unit

val set_clip_state : bmp:bitmap -> bool -> unit

val get_clip_state : bmp:bitmap -> bool

val is_planar_bitmap : bmp:bitmap -> bool

val is_linear_bitmap : bmp:bitmap -> bool

val is_memory_bitmap : bmp:bitmap -> bool

val is_screen_bitmap : bmp:bitmap -> bool

val is_video_bitmap : bmp:bitmap -> bool

val is_system_bitmap : bmp:bitmap -> bool

val is_sub_bitmap : bmp:bitmap -> bool

Loading Image Files

val load_bitmap : string -> palette -> bitmap

val load_bmp : string -> palette -> bitmap

val load_lbm : string -> palette -> bitmap

val load_pcx : string -> palette -> bitmap

val load_tga : string -> palette -> bitmap

val blit : src:bitmap ->
       dest:bitmap ->
       src_x:int ->
       src_y:int -> dest_x:int -> dest_y:int -> width:int -> height:int -> unit

val masked_blit : src:bitmap ->
       dest:bitmap ->
       src_x:int ->
       src_y:int -> dest_x:int -> dest_y:int -> width:int -> height:int -> unit

val stretch_blit : src:bitmap ->
       dest:bitmap ->
       src_x:int ->
       src_y:int ->
       src_width:int ->
       src_height:int ->
       dest_x:int -> dest_y:int -> dest_width:int -> dest_height:int -> unit

val masked_stretch_blit : src:bitmap ->
       dest:bitmap ->
       src_x:int ->
       src_y:int ->
       src_width:int ->
       src_height:int ->
       dest_x:int -> dest_y:int -> dest_width:int -> dest_height:int -> unit

val set_color_conversion : color_conversion -> unit

Keyboard Routines

val install_keyboard : unit -> unit

val poll_keyboard : unit -> unit

val keypressed : unit -> bool

val readkey : unit -> char

val key_esc : unit -> bool

val key_enter : unit -> bool

val key_left : unit -> bool

val key_right : unit -> bool

val key_up : unit -> bool

val key_down : unit -> bool

val get_kb_flag : kb_flag -> bool

val readkey_scancode : unit -> scancode

val clear_keybuf : unit -> unit

val set_keyboard_rate : delay:int -> repeat:int -> unit

val remove_keyboard : unit -> unit

Timer Routines

val install_timer : unit -> unit

val retrace_count : unit -> int

val rest : time:int -> unit

Mouse Routines

val install_mouse : unit -> int

val poll_mouse : unit -> unit

val mouse_driver_name : unit -> string

val enable_hardware_cursor : unit -> unit

val disable_hardware_cursor : unit -> unit

val select_mouse_cursor : mouse_cursor -> unit

val set_mouse_cursor_bitmap : mouse_cursor -> bmp:bitmap -> unit

val show_mouse : bmp:bitmap -> unit

val hide_mouse : unit -> unit

val scare_mouse : unit -> unit

val scare_mouse_area : x:int -> y:int -> w:int -> h:int -> unit

val unscare_mouse : unit -> unit

val position_mouse : x:int -> y:int -> unit

val position_mouse_z : z:int -> unit

val set_mouse_range : x1:int -> y1:int -> x2:int -> y2:int -> unit

val set_mouse_speed : xspeed:int -> yspeed:int -> unit

val set_mouse_sprite : sprite:bitmap -> unit

val set_mouse_sprite_focus : x:int -> y:int -> unit

val get_mouse_mickeys : unit -> int * int

val get_mouse_x : unit -> int

val get_mouse_y : unit -> int

val get_mouse_z : unit -> int

val get_mouse_x_focus : unit -> int

val get_mouse_y_focus : unit -> int

val left_button_pressed : unit -> bool

val right_button_pressed : unit -> bool

val middle_button_pressed : unit -> bool

val get_mouse_b : unit -> int

val get_mouse_pos : unit -> int * int

Fixed Point Number

type fixed 

val itofix : int -> fixed

val fixtoi : fixed -> int

val ftofix : float -> fixed

val fixtof : fixed -> float

val fixadd : fixed -> fixed -> fixed

val fixsub : fixed -> fixed -> fixed

val fixdiv : fixed -> fixed -> fixed

val fixmul : fixed -> fixed -> fixed

val fixhypot : fixed -> fixed -> fixed

val fixceil : fixed -> int

val fixfloor : fixed -> int

val fixsin : fixed -> fixed

val fixcos : fixed -> fixed

val fixtan : fixed -> fixed

val fixasin : fixed -> fixed

val fixacos : fixed -> fixed

val fixatan : fixed -> fixed

val fixsqrt : fixed -> fixed

val to_rad : fixed -> fixed

val of_rad : fixed -> fixed

val fixminus : fixed -> fixed

val fixatan2 : y:fixed -> x:fixed -> fixed

Drawing Primitives

val putpixel : bmp:bitmap -> x:int -> y:int -> color:color -> unit

val rect : bmp:bitmap ->
       x1:int -> y1:int -> x2:int -> y2:int -> color:color -> unit

val rectfill : bmp:bitmap ->
       x1:int -> y1:int -> x2:int -> y2:int -> color:color -> unit

val arc : bmp:bitmap ->
       x:int ->
       y:int ->
       angle1:fixed ->
       angle2:fixed -> r:int -> color:color -> unit

val floodfill : bmp:bitmap -> x:int -> y:int -> color:color -> unit

val spline : bmp:bitmap ->
       x1:int ->
       y1:int ->
       x2:int ->
       y2:int -> x3:int -> y3:int -> x4:int -> y4:int -> color:color -> unit

val circle : bmp:bitmap ->
       x:int -> y:int -> radius:int -> color:color -> unit

val circlefill : bmp:bitmap ->
       x:int -> y:int -> radius:int -> color:color -> unit

val ellipse : bmp:bitmap ->
       x:int -> y:int -> rx:int -> ry:int -> color:color -> unit

val ellipsefill : bmp:bitmap ->
       x:int -> y:int -> rx:int -> ry:int -> color:color -> unit

val triangle : bmp:bitmap ->
       x1:int ->
       y1:int -> x2:int -> y2:int -> x3:int -> y3:int -> color:color -> unit

val line : bmp:bitmap ->
       x1:int -> y1:int -> x2:int -> y2:int -> color:color -> unit

val fastline : bmp:bitmap ->
       x1:int -> y1:int -> x2:int -> y2:int -> color:color -> unit

val vline : bmp:bitmap ->
       x:int -> y1:int -> y2:int -> color:color -> unit

val hline : bmp:bitmap ->
       x1:int -> y:int -> x2:int -> color:color -> unit

val getpixel : bmp:bitmap -> x:int -> y:int -> color

val do_circle : bmp:bitmap ->
       x:int ->
       y:int ->
       radius:int ->
       d:int -> proc:(bmp:bitmap -> x:int -> y:int -> d:int -> unit) -> unit

val do_ellipse : bmp:bitmap ->
       x:int ->
       y:int ->
       rx:int ->
       ry:int ->
       d:int -> proc:(bmp:bitmap -> x:int -> y:int -> d:int -> unit) -> unit

Sprites

val draw_sprite : bmp:bitmap -> sprite:bitmap -> x:int -> y:int -> unit

val draw_sprite_v_flip : bmp:bitmap -> sprite:bitmap -> x:int -> y:int -> unit

val draw_sprite_h_flip : bmp:bitmap -> sprite:bitmap -> x:int -> y:int -> unit

val draw_sprite_vh_flip : bmp:bitmap -> sprite:bitmap -> x:int -> y:int -> unit

val rotate_sprite : bmp:bitmap ->
       sprite:bitmap -> x:int -> y:int -> angle:fixed -> unit

val rotate_sprite_v_flip : bmp:bitmap ->
       sprite:bitmap -> x:int -> y:int -> angle:fixed -> unit

val rotate_scaled_sprite : bmp:bitmap ->
       sprite:bitmap ->
       x:int -> y:int -> angle:fixed -> scale:fixed -> unit

val rotate_scaled_sprite_v_flip : bmp:bitmap ->
       sprite:bitmap ->
       x:int -> y:int -> angle:fixed -> scale:fixed -> unit

val pivot_sprite : bmp:bitmap ->
       sprite:bitmap ->
       x:int -> y:int -> cx:int -> cy:int -> angle:fixed -> unit

val pivot_sprite_v_flip : bmp:bitmap ->
       sprite:bitmap ->
       x:int -> y:int -> cx:int -> cy:int -> angle:fixed -> unit

val pivot_scaled_sprite : bmp:bitmap ->
       sprite:bitmap ->
       x:int ->
       y:int ->
       cx:int -> cy:int -> angle:fixed -> scale:fixed -> unit

val pivot_scaled_sprite_v_flip : bmp:bitmap ->
       sprite:bitmap ->
       x:int ->
       y:int ->
       cx:int -> cy:int -> angle:fixed -> scale:fixed -> unit

val stretch_sprite : bmp:bitmap ->
       sprite:bitmap -> x:int -> y:int -> w:int -> h:int -> unit

val draw_character_ex : bmp:bitmap ->
       sprite:bitmap ->
       x:int -> y:int -> color:color -> bg:color -> unit

val draw_lit_sprite : bmp:bitmap ->
       sprite:bitmap -> x:int -> y:int -> color:color -> unit

val draw_trans_sprite : bmp:bitmap -> sprite:bitmap -> x:int -> y:int -> unit

val draw_gouraud_sprite : bmp:bitmap ->
       sprite:bitmap ->
       x:int ->
       y:int ->
       c1:color ->
       c2:color -> c3:color -> c4:color -> unit

RLE Sprites

type rle_sprite 

val get_rle_sprite : tmp:bitmap -> rle_sprite

val destroy_rle_sprite : rle_sprite -> unit

val draw_rle_sprite : bmp:bitmap -> sprite:rle_sprite -> x:int -> y:int -> unit

val draw_trans_rle_sprite : bmp:bitmap -> sprite:rle_sprite -> x:int -> y:int -> unit

val draw_lit_rle_sprite : bmp:bitmap ->
       sprite:rle_sprite -> x:int -> y:int -> color:color -> unit

Compiled Sprites

type compiled_sprite 

val get_compiled_sprite : bmp:bitmap -> planar:bool -> compiled_sprite

val destroy_compiled_sprite : sprite:compiled_sprite -> unit

val draw_compiled_sprite : bmp:bitmap ->
       sprite:compiled_sprite -> x:int -> y:int -> unit

Text Output

type font 

val get_font : unit -> font

val allegro_404_char : char -> unit

val text_length : f:font -> string -> int

val text_height : f:font -> int

val textout_ex : bmp:bitmap ->
       f:font ->
       str:string ->
       x:int -> y:int -> color:color -> bg:color -> unit

val textout_centre_ex : bmp:bitmap ->
       f:font ->
       str:string ->
       x:int -> y:int -> color:color -> bg:color -> unit

val textout_justify_ex : bmp:bitmap ->
       f:font ->
       str:string ->
       x1:int ->
       x2:int ->
       y:int -> diff:int -> color:color -> bg:color -> unit

val textout_right_ex : bmp:bitmap ->
       f:font ->
       str:string ->
       x:int -> y:int -> color:color -> bg:color -> unit

val textprintf_ex : bitmap ->
       font ->
       int ->
       int ->
       color -> color -> ('a, unit, string, unit) format4 -> 'a

val textprintf_centre_ex : bitmap ->
       font ->
       int ->
       int ->
       color -> color -> ('a, unit, string, unit) format4 -> 'a

val textprintf_justify_ex : bitmap ->
       font ->
       int ->
       int ->
       int ->
       int ->
       color -> color -> ('a, unit, string, unit) format4 -> 'a

val textprintf_right_ex : bitmap ->
       font ->
       int ->
       int ->
       color -> color -> ('a, unit, string, unit) format4 -> 'a

Fonts

val load_font : filename:string -> font * palette

val merge_fonts : f1:font -> f2:font -> font

val destroy_font : f:font -> unit

Transparency and Patterned Drawing

val drawing_mode : draw_mode:draw_mode -> unit

val xor_mode : on:bool -> unit

val solid_mode : unit -> unit

val set_trans_blender : r:int -> g:int -> b:int -> a:int -> unit

val set_alpha_blender : unit -> unit

val set_write_alpha_blender : unit -> unit

val set_add_blender : r:int -> g:int -> b:int -> a:int -> unit

val set_burn_blender : r:int -> g:int -> b:int -> a:int -> unit

val set_color_blender : r:int -> g:int -> b:int -> a:int -> unit

val set_difference_blender : r:int -> g:int -> b:int -> a:int -> unit

val set_dissolve_blender : r:int -> g:int -> b:int -> a:int -> unit

val set_dodge_blender : r:int -> g:int -> b:int -> a:int -> unit

val set_hue_blender : r:int -> g:int -> b:int -> a:int -> unit

val set_invert_blender : r:int -> g:int -> b:int -> a:int -> unit

val set_luminance_blender : r:int -> g:int -> b:int -> a:int -> unit

val set_multiply_blender : r:int -> g:int -> b:int -> a:int -> unit

val set_saturation_blender : r:int -> g:int -> b:int -> a:int -> unit

val set_screen_blender : r:int -> g:int -> b:int -> a:int -> unit

val digi_driver_name : unit -> string

Sound Init Routines

val install_sound : digi -> midi -> unit

val remove_sound : unit -> unit

val reserve_voices : digi_voices:int -> midi_voices:int -> unit

val set_volume_per_voice : scale:int -> unit

val set_volume : digi_volume:int -> midi_volume:int -> unit

val set_hardware_volume : digi_volume:int -> midi_volume:int -> unit

Digital Sample Routines

type sample 

val load_sample : filename:string -> sample

val destroy_sample : spl:sample -> unit

val adjust_sample : spl:sample -> vol:int -> pan:int -> freq:int -> loop:bool -> unit

val play_sample : spl:sample -> vol:int -> pan:int -> freq:int -> loop:bool -> int

val stop_sample : spl:sample -> unit

File and Compression Routines

val replace_filename : path:string -> filename:string -> string

Datafile Routines

type datafile 

val load_datafile : filename:string -> datafile

val unload_datafile : dat:datafile -> unit

val fixup_datafile : dat:datafile -> unit

val palette_dat : dat:datafile -> idx:int -> palette

val bitmap_dat : dat:datafile -> idx:int -> bitmap

val font_dat : dat:datafile -> idx:int -> font

val sample_dat : dat:datafile -> idx:int -> sample

val item_dat : dat:datafile -> idx:int -> 'a

GUI Routines

val gfx_mode_select_ex : unit -> gfx_driver * int * int * int

Polygon Rendering

type v3d = fixed Allegro._v3d 

type v3d_f = float Allegro._v3d 

val triangle3d : bmp:bitmap ->
       polytype:polytype ->
       tex:bitmap ->
       v1:v3d -> v2:v3d -> v3:v3d -> unit

val triangle3d_f : bmp:bitmap ->
       polytype:polytype ->
       tex:bitmap ->
       v1:v3d_f -> v2:v3d_f -> v3:v3d_f -> unit

val quad3d : bmp:bitmap ->
       polytype:polytype ->
       tex:bitmap ->
       v1:v3d -> v2:v3d -> v3:v3d -> v4:v3d -> unit

val quad3d_f : bmp:bitmap ->
       polytype:polytype ->
       tex:bitmap ->
       v1:v3d_f ->
       v2:v3d_f -> v3:v3d_f -> v4:v3d_f -> unit

val clear_scene : bmp:bitmap -> unit

val render_scene : unit -> unit

val create_scene : nedge:int -> npoly:int -> int

val destroy_scene : unit -> unit

type zbuffer 

val create_zbuffer : bmp:bitmap -> zbuffer

val create_sub_zbuffer : parent:zbuffer ->
       x:int -> y:int -> width:int -> height:int -> zbuffer

val set_zbuffer : zbuffer:zbuffer -> unit

val clear_zbuffer : zbuffer:zbuffer -> z:float -> unit

val destroy_zbuffer : zbuffer:zbuffer -> unit

3D Math Routines

type matrix 

type matrix_f 

val get_identity_matrix : unit -> matrix

val get_identity_matrix_f : unit -> matrix_f

val free_matrix : matrix -> unit

val make_matrix : v:(float * float * float) * (float * float * float) * (float * float * float) ->
       t:float * float * float -> matrix

val make_matrix_f : v:(float * float * float) * (float * float * float) * (float * float * float) ->
       t:float * float * float -> matrix_f

val new_matrix : unit -> matrix

val new_matrix_f : unit -> matrix_f

val get_translation_matrix : m:matrix ->
       x:fixed -> y:fixed -> z:fixed -> unit

val get_translation_matrix_f : m:matrix -> x:float -> y:float -> z:float -> unit

val get_scaling_matrix : m:matrix ->
       x:fixed -> y:fixed -> z:fixed -> unit

val get_scaling_matrix_f : m:matrix -> x:float -> y:float -> z:float -> unit

val get_x_rotate_matrix : m:matrix -> r:fixed -> unit

val get_x_rotate_matrix_f : m:matrix -> r:float -> unit

val get_y_rotate_matrix : m:matrix -> r:fixed -> unit

val get_y_rotate_matrix_f : m:matrix -> r:float -> unit

val get_z_rotate_matrix : m:matrix -> r:fixed -> unit

val get_z_rotate_matrix_f : m:matrix -> r:float -> unit

val get_rotation_matrix : m:matrix ->
       x:fixed -> y:fixed -> z:fixed -> unit

val get_rotation_matrix_f : m:matrix -> x:float -> y:float -> z:float -> unit

val get_align_matrix : m:matrix ->
       xfront:fixed ->
       yfront:fixed ->
       zfront:fixed ->
       xup:fixed -> yup:fixed -> zup:fixed -> unit

val get_align_matrix_f : m:matrix_f ->
       xfront:float ->
       yfront:float -> zfront:float -> xup:float -> yup:float -> zup:float -> unit

val get_vector_rotation_matrix : m:matrix ->
       x:fixed ->
       y:fixed -> z:fixed -> a:fixed -> unit

val get_vector_rotation_matrix_f : m:matrix_f -> x:float -> y:float -> z:float -> a:float -> unit

val get_transformation_matrix : m:matrix ->
       scale:fixed ->
       xrot:fixed ->
       yrot:fixed ->
       zrot:fixed ->
       x:fixed -> y:fixed -> z:fixed -> unit

val get_transformation_matrix_f : m:matrix_f ->
       scale:float ->
       xrot:float ->
       yrot:float -> zrot:float -> x:float -> y:float -> z:float -> unit

val get_camera_matrix : m:matrix ->
       x:fixed ->
       y:fixed ->
       z:fixed ->
       xfront:fixed ->
       yfront:fixed ->
       zfront:fixed ->
       xup:fixed ->
       yup:fixed ->
       zup:fixed -> fov:fixed -> aspect:fixed -> unit

val get_camera_matrix_f : m:matrix_f ->
       x:float ->
       y:float ->
       z:float ->
       xfront:float ->
       yfront:float ->
       zfront:float ->
       xup:float -> yup:float -> zup:float -> fov:float -> aspect:float -> unit

val qtranslate_matrix : m:matrix ->
       x:fixed -> y:fixed -> z:fixed -> unit

val qtranslate_matrix_f : m:matrix_f -> x:float -> y:float -> z:float -> unit

val qscale_matrix : m:matrix -> scale:fixed -> unit

val qscale_matrix_f : m:matrix_f -> scale:float -> unit

val matrix_mul : m1:matrix -> m2:matrix -> out:matrix -> unit

val matrix_mul_f : m1:matrix_f -> m2:matrix_f -> out:matrix_f -> unit

val vector_length : x:fixed -> y:fixed -> z:fixed -> fixed

val vector_length_f : x:float -> y:float -> z:float -> float

val apply_matrix : m:matrix ->
       x:fixed ->
       y:fixed ->
       z:fixed -> fixed * fixed * fixed

val apply_matrix_f : m:matrix_f -> x:float -> y:float -> z:float -> float * float * float

val set_projection_viewport : x:int -> y:int -> w:int -> h:int -> unit

val persp_project : x:fixed ->
       y:fixed -> z:fixed -> fixed * fixed

val persp_project_f : x:float -> y:float -> z:float -> float * float

Quaternion Math Routines

type quat 

val make_quat : w:float -> x:float -> y:float -> z:float -> quat

val free_quat : q:quat -> unit

val get_identity_quat : unit -> quat

val get_x_rotate_quat : q:quat -> r:float -> unit

val get_y_rotate_quat : q:quat -> r:float -> unit

val get_z_rotate_quat : q:quat -> r:float -> unit

val get_rotation_quat : q:quat -> x:float -> y:float -> z:float -> unit

val get_vector_rotation_quat : q:quat -> x:float -> y:float -> z:float -> a:float -> unit

val quat_to_matrix : q:quat -> matrix_f

val matrix_to_quat : m:matrix_f -> quat

val quat_mul : p:quat -> q:quat -> quat

val apply_quat : q:quat -> x:float -> y:float -> z:float -> float * float * float

val quat_interpolate : from:quat -> to_:quat -> t:float -> quat

val quat_slerp : from:quat ->
       to_:quat -> t:float -> how:how_slerp -> quat