Module GL

module GL: sig .. end

OpenGL 2.1 Reference Pages

OpenGL Overview

Drawing Functions

type primitive = 

val glBegin : primitive:primitive -> unit

val glEnd : unit -> unit

val glVertex2 : x:float -> y:float -> unit

val glVertex3 : x:float -> y:float -> z:float -> unit

val glVertex4 : x:float -> y:float -> z:float -> w:float -> unit

val glVertex2v : float * float -> unit

val glVertex3v : float * float * float -> unit

val glVertex4v : float * float * float * float -> unit

val glNormal3 : nx:float -> ny:float -> nz:float -> unit

val glNormal3v : v:float * float * float -> unit

val glIndex : c:float -> unit

val glIndexi : c:int -> unit

val glColor3 : r:float -> g:float -> b:float -> unit

val glColor4 : r:float -> g:float -> b:float -> a:float -> unit

val glColor3v : v:float * float * float -> unit

val glColor4v : v:float * float * float * float -> unit

val glColor3c : r:char -> g:char -> b:char -> unit

val glColor4c : r:char -> g:char -> b:char -> a:char -> unit

val glColor3cv : v:char * char * char -> unit

val glColor4cv : v:char * char * char * char -> unit

val glEdgeFlag : flag:bool -> unit

val glRasterPos2 : x:float -> y:float -> unit

val glRasterPos3 : x:float -> y:float -> z:float -> unit

val glRasterPos4 : x:float -> y:float -> z:float -> w:float -> unit

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

val glRasterPos3i : x:int -> y:int -> z:int -> unit

val glRasterPos4i : x:int -> y:int -> z:int -> w:int -> unit

val glRasterPos2v : v:float * float -> unit

val glRasterPos3v : v:float * float * float -> unit

val glRasterPos4v : v:float * float * float * float -> unit

val glRasterPos2iv : v:int * int -> unit

val glRasterPos3iv : v:int * int * int -> unit

val glRasterPos4iv : v:int * int * int * int -> unit

All glRasterPos* functions are deprecated in core OpenGL 3.

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

val glRect : x1:float -> y1:float -> x2:float -> y2:float -> unit

Transformations

type matrix_mode = 

val glMatrixMode : mode:matrix_mode -> unit

val glViewport : x:int -> y:int -> width:int -> height:int -> unit

val glOrtho : left:float ->
       right:float -> bottom:float -> top:float -> near:float -> far:float -> unit

val glFrustum : left:float ->
       right:float -> bottom:float -> top:float -> near:float -> far:float -> unit

val glPushMatrix : unit -> unit

val glPopMatrix : unit -> unit

val glLoadIdentity : unit -> unit

val glRotatev : angle:float -> vec:float * float * float -> unit

val glRotate : angle:float -> x:float -> y:float -> z:float -> unit

val glTranslatev : float * float * float -> unit

val glTranslate : x:float -> y:float -> z:float -> unit

val glScalev : float * float * float -> unit

val glScale : x:float -> y:float -> z:float -> unit

val glMultMatrix : mat:float array array -> unit

val glMultMatrixFlat : float array -> unit

val glMultMatrixFlat_unsafe : float array -> unit

val glLoadMatrix : mat:float array array -> unit

val glLoadMatrixFlat : float array -> unit

val glLoadMatrixFlat_unsafe : float array -> unit

Miscellaneous

val glFlush : unit -> unit

type orientation = 

val glFrontFace : orientation:orientation -> unit

val glScissor : x:int -> y:int -> width:int -> height:int -> unit

val glFinish : unit -> unit

val glClearColor : r:float -> g:float -> b:float -> a:float -> unit

val glClearIndex : float -> unit

val glColorMask : r:bool -> g:bool -> b:bool -> a:bool -> unit

module Attrib: sig .. end

val glPushAttrib : attrib:Attrib.attrib_bit list -> unit

val glPopAttrib : unit -> unit

type face_mode = 

type polygon_mode = 

val glPolygonMode : face:face_mode -> mode:polygon_mode -> unit

val glGetPolygonMode : unit -> polygon_mode * polygon_mode

type clear_mask = 

val glClear : mask:clear_mask list -> unit

val glLineWidth : width:float -> unit

val glPointSize : size:float -> unit

type sprite_coord_origin = 

type point_parameter = 

val glPointParameter : point_parameter -> unit

type gl_func = 

val glAlphaFunc : func:gl_func -> ref:float -> unit

type hint_target = 

type hint_mode = 

val glHint : target:hint_target -> mode:hint_mode -> unit

val glCullFace : mode:face_mode -> unit

val glGetCullFaceMode : unit -> face_mode

val glLineStipple : factor:int -> pattern:int -> unit

type polygon_stipple_mask = (int, Stdlib.Bigarray.int8_unsigned_elt, Stdlib.Bigarray.c_layout)
       Stdlib.Bigarray.Array1.t 

val glPolygonStipple : mask:polygon_stipple_mask -> unit

val glPolygonStipple_unsafe : mask:polygon_stipple_mask -> unit

module DrawBuffer: sig .. end

val glDrawBuffer : mode:DrawBuffer.draw_buffer_mode -> unit

module ReadBuffer: sig .. end

val glReadBuffer : mode:ReadBuffer.read_buffer_mode -> unit

module Sfactor: sig .. end

module Dfactor: sig .. end

val glBlendFunc : sfactor:Sfactor.blend_sfactor -> dfactor:Dfactor.blend_dfactor -> unit

type blend_mode = 

val glBlendEquation : mode:blend_mode -> unit

module Op: sig .. end

val glLogicOp : opcode:Op.op_code -> unit

val glPolygonOffset : factor:float -> units:float -> unit

Lighting

type shade_mode = 

val glShadeModel : shade_mode -> unit

module Light: sig .. end

type gl_light = 

val glLight : light:gl_light -> pname:Light.light_pname -> unit

type color_control = 

type light_model = 

val glLightModel : light_model:light_model -> unit

See glGetLight for associated get.

module Material: sig .. end

val glMaterial : face:face_mode -> mode:Material.material_mode -> unit

module GetMat: sig .. end

val glGetMaterial4f : GetMat.face_mode ->
       mode:GetMat.get_material_4f -> float * float * float * float

val glGetMaterial1f : GetMat.face_mode -> mode:GetMat.get_material_1f -> float

val glGetMaterial3i : GetMat.face_mode -> mode:GetMat.get_material_3i -> int * int * int

type color_material_mode = 

val glColorMaterial : face:face_mode -> mode:color_material_mode -> unit

val glSecondaryColor3 : red:float -> green:float -> blue:float -> unit

Stenciling

val glStencilFunc : func:gl_func -> ref:int -> mask:int -> unit

val glStencilFuncn : func:gl_func -> ref:int -> mask:nativeint -> unit

val glStencilMask : mask:int -> unit

type stencil_op = 

val glStencilOp : sfail:stencil_op -> dpfail:stencil_op -> dppass:stencil_op -> unit

val glClearStencil : s:int -> unit

Depth Buffer

val glDepthRange : near:float -> far:float -> unit

val glClearDepth : depth:float -> unit

val glDepthFunc : func:gl_func -> unit

val glDepthMask : bool -> unit

Accumulation Buffer

type accum_op = 

val glAccum : op:accum_op -> value:float -> unit

val glClearAccum : r:float -> g:float -> b:float -> a:float -> unit

GL Capabilities

type gl_capability = 

val glEnable : cap:gl_capability -> unit

val glDisable : cap:gl_capability -> unit

module Enabled: sig .. end

val glIsEnabled : Enabled.enabled_cap -> bool

Texture mapping

type texture_id = private int 

val glGenTextures : n:int -> texture_id array

manual page

val glGenTexture : unit -> texture_id

module BindTex: sig .. end

val glBindTexture : target:BindTex.texture_binding -> texture:texture_id -> unit

val glUnbindTexture : target:BindTex.texture_binding -> unit

val glBindTexture2D : texture:texture_id -> unit

val glUnbindTexture2D : unit -> unit

val glDeleteTextures : textures:texture_id array -> unit

val glDeleteTexture : texture:texture_id -> unit

val glIsTexture : texture:texture_id -> bool

val glPrioritizeTextures : textures:texture_id array -> priority:float array -> unit

val glPrioritizeTexture : texture:texture_id -> priority:float -> unit

val glPrioritizeTexturesp : prioritized_textures:(texture_id * float) array -> unit

module TexEnv: sig .. end

val glTexEnv : TexEnv.texenv_target ->
       TexEnv.texenv_pname -> TexEnv.texenv_param -> unit

type tex_coord = 

type tex_coord_gen_func = 

type tex_gen_param = 

val glTexGen : tex_coord -> tex_coord_gen_func -> tex_gen_param -> unit

type tex_coord_fun_params = 

val glTexGenv : tex_coord ->
       tex_coord_fun_params -> float * float * float * float -> unit

val glTexGenva : tex_coord -> tex_coord_fun_params -> float array -> unit

module TexTarget: sig .. end

module InternalFormat: sig .. end

type pixel_data_format = 

type pixel_data_type = 

type img_input = 

type image_data = (int, Stdlib.Bigarray.int8_unsigned_elt, Stdlib.Bigarray.c_layout)
       Stdlib.Bigarray.Genarray.t 

val assert_size : width:int -> height:int -> unit

val glTexImage2D : target:TexTarget.target_2d ->
       level:int ->
       internal_format:InternalFormat.internal_format ->
       width:int ->
       height:int ->
       format_:pixel_data_format ->
       type_:pixel_data_type -> pixels:image_data -> unit

val glTexImage2D_str : target:TexTarget.target_2d ->
       level:int ->
       internal_format:InternalFormat.internal_format ->
       width:int ->
       height:int ->
       format_:pixel_data_format ->
       type_:pixel_data_type -> pixels:string -> unit

val glTexImage1D : target:TexTarget.target_1d ->
       level:int ->
       internal_format:InternalFormat.internal_format ->
       width:int ->
       format_:pixel_data_format ->
       type_:pixel_data_type -> pixels:image_data -> unit

val glTexImage3D : target:TexTarget.target_3d ->
       level:int ->
       internal_format:InternalFormat.internal_format ->
       width:int ->
       height:int ->
       depth:int ->
       format_:pixel_data_format ->
       type_:pixel_data_type -> pixels:image_data -> unit

val glTexCoord1 : s:float -> unit

val glTexCoord2 : s:float -> t:float -> unit

val glTexCoord3 : s:float -> t:float -> r:float -> unit

val glTexCoord4 : s:float -> t:float -> r:float -> q:float -> unit

val glTexCoord2v : v:float * float -> unit

val glTexCoord3v : v:float * float * float -> unit

val glTexCoord4v : v:float * float * float * float -> unit

module Min: sig .. end

module Mag: sig .. end

type wrap_param = 

module TexParam: sig .. end

val glTexParameter : target:TexParam.tex_param_target -> param:TexParam.tex_param -> unit

module CopyTex: sig .. end

val glCopyTexImage2D : target:CopyTex.copy_tex_target ->
       level:int ->
       internal_format:InternalFormat.internal_format ->
       x:int -> y:int -> width:int -> height:int -> border:int -> unit

val glSampleCoverage : value:float -> invert:bool -> unit

Raster functions

type pixel_packing_b = 

val glPixelStoreb : pixel_packing:pixel_packing_b -> param:bool -> unit

type pixel_packing_i = 

val glPixelStorei : pixel_packing:pixel_packing_i -> param:int -> unit

val glPixelZoom : xfactor:float -> yfactor:float -> unit

type pixel_map = 

val glPixelMapfv : map:pixel_map -> v:float array -> unit

val glBitmap : width:int ->
       height:int ->
       xorig:float ->
       yorig:float ->
       xmove:float ->
       ymove:float -> bitmap:('a, 'b, 'c) Stdlib.Bigarray.Array1.t -> unit

type pixel_type = 

val glCopyPixels : x:int -> y:int -> width:int -> height:int -> pixel_type:pixel_type -> unit

type pixel_transfer_i = 

type pixel_transfer_f = 

type pixel_transfer_b = 

type pixel_transfer_f_ARB = 

val glPixelTransferi : pname:pixel_transfer_i -> param:int -> unit

val glPixelTransferf : pname:pixel_transfer_f -> param:float -> unit

val glPixelTransferb : pname:pixel_transfer_b -> param:bool -> unit

val glPixelTransferfARB : pname:pixel_transfer_f_ARB -> param:float -> unit

module Framebuffer: sig .. end

val glReadPixelsBA_unsafe : x:int ->
       y:int ->
       width:int ->
       height:int ->
       Framebuffer.pixel_buffer_format ->
       Framebuffer.pixel_buffer_type -> image_data -> unit

val glReadPixelsBA : x:int ->
       y:int ->
       width:int ->
       height:int ->
       Framebuffer.pixel_buffer_format ->
       Framebuffer.pixel_buffer_type -> image_data -> unit

val glDrawPixels_str : width:int ->
       height:int ->
       format_:pixel_data_format ->
       type_:pixel_data_type -> pixels:string -> unit

Clipping

module Plane: sig .. end

val glClipPlane : plane:Plane.clip_plane -> equation:float array -> unit

val glClipPlane_unsafe : plane:Plane.clip_plane -> equation:float array -> unit

type clip_plane_i = 

val glClipPlanei : plane:clip_plane_i -> equation:float array -> unit

val glClipPlanei_unsafe : plane:clip_plane_i -> equation:float array -> unit

Evaluators

module Map1: sig .. end

val glMap1 : target:Map1.map1_target ->
       u1:float -> u2:float -> stride:int -> order:int -> points:float array -> unit

module Map2: sig .. end

val glMap2 : target:Map2.map2_target ->
       u1:float ->
       u2:float ->
       ustride:int ->
       uorder:int ->
       v1:float ->
       v2:float ->
       vstride:int -> vorder:int -> points:float array array array -> unit

val glEvalCoord1 : u:float -> unit

val glEvalCoord2 : u:float -> v:float -> unit

module EvalMesh1: sig .. end

module EvalMesh2: sig .. end

val glEvalMesh1 : mode:EvalMesh1.eval_mesh_1 -> i1:int -> i2:int -> unit

val glEvalMesh2 : mode:EvalMesh2.eval_mesh_2 -> i1:int -> i2:int -> j1:int -> j2:int -> unit

val glEvalPoint1 : i:int -> unit

val glEvalPoint2 : i:int -> j:int -> unit

val glMapGrid1 : un:int -> u1:float -> u2:float -> unit

val glMapGrid2 : un:int -> u1:float -> u2:float -> vn:int -> v1:float -> v2:float -> unit

Display Lists

type list_mode = 

val glNewList : gl_list:int -> mode:list_mode -> unit

val glEndList : unit -> unit

val glGenList : unit -> int

val glGenLists : range:int -> int

val glCallList : gl_list:int -> unit

val glCallLists : gl_lists:int array -> unit

val glDeleteLists : gl_list:int -> range:int -> unit

val glListBase : base:int -> unit

val glIsList : gl_list:int -> bool

val glGetListMode : unit -> list_mode

Picking

type render_mode = 

val glRenderMode : mode:render_mode -> int

val glInitNames : unit -> unit

val glLoadName : name:int -> unit

val glPushName : name:int -> unit

val glPopName : unit -> unit

type select_buffer 

val new_select_buffer : buffer_size:int -> select_buffer

val free_select_buffer : select_buffer:select_buffer -> unit

val select_buffer_get : select_buffer:select_buffer -> index:int -> int

val glSelectBuffer : buffer_size:int -> select_buffer:select_buffer -> unit

val glSelectBufferBA : (nativeint, Stdlib.Bigarray.nativeint_elt, Stdlib.Bigarray.c_layout)
       Stdlib.Bigarray.Array1.t -> unit

Fog

type fog_mode = 

type fog_coord_src = 

type fog_param = 

val glFog : pname:fog_param -> unit

GLSL Shaders

type shader_object 

type shader_program 

type shader_type = 

val glCreateShader : shader_type:shader_type -> shader_object

val glDeleteShader : shader:shader_object -> unit

val glIsShader : shader:shader_object -> bool

val glShaderSource : shader:shader_object -> string -> unit

val glCompileShader : shader:shader_object -> unit

val glCreateProgram : unit -> shader_program

val glDeleteProgram : program:shader_program -> unit

val glAttachShader : program:shader_program -> shader:shader_object -> unit

val glDetachShader : program:shader_program -> shader:shader_object -> unit

val glLinkProgram : program:shader_program -> unit

val glUseProgram : program:shader_program -> unit

val glUnuseProgram : unit -> unit

val glGetShaderCompileStatus : shader:shader_object -> bool

val glGetShaderCompileStatus_exn : shader:shader_object -> unit

val glGetUniformLocation : program:shader_program -> name:string -> int

type get_program_bool = 

type get_program_int = 

val glGetProgrami : program:shader_program -> pname:get_program_int -> int

val glGetProgramb : program:shader_program -> pname:get_program_bool -> bool

val glUniform1f : location:int -> v0:float -> unit

val glUniform2f : location:int -> v0:float -> v1:float -> unit

val glUniform3f : location:int -> v0:float -> v1:float -> v2:float -> unit

val glUniform4f : location:int -> v0:float -> v1:float -> v2:float -> v3:float -> unit

val glUniform1i : location:int -> v0:int -> unit

val glUniform2i : location:int -> v0:int -> v1:int -> unit

val glUniform3i : location:int -> v0:int -> v1:int -> v2:int -> unit

val glUniform4i : location:int -> v0:int -> v1:int -> v2:int -> v3:int -> unit

val glUniform1fv : location:int -> value:float array -> unit

val glUniform2fv : location:int -> count:int -> value:float array -> unit

val glUniform3fv : location:int -> count:int -> value:float array -> unit

val glUniform4fv : location:int -> count:int -> value:float array -> unit

val glUniform1iv : location:int -> value:int array -> unit

val glUniform2iv : location:int -> count:int -> value:int array -> unit

val glUniform3iv : location:int -> count:int -> value:int array -> unit

val glUniform4iv : location:int -> count:int -> value:int array -> unit

val glUniformMatrix2f : location:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix3f : location:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix4f : location:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix2x3f : location:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix3x2f : location:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix2x4f : location:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix4x2f : location:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix3x4f : location:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix4x3f : location:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix2fv : location:int -> count:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix3fv : location:int -> count:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix4fv : location:int -> count:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix2x3fv : location:int -> count:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix3x2fv : location:int -> count:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix2x4fv : location:int -> count:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix4x2fv : location:int -> count:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix3x4fv : location:int -> count:int -> transpose:bool -> value:float array -> unit

val glUniformMatrix4x3fv : location:int -> count:int -> transpose:bool -> value:float array -> unit

val glGetAttribLocation : program:shader_program -> name:string -> int

val glBindAttribLocation : program:shader_program -> index:int -> name:string -> unit

val glVertexAttrib1s : index:int -> v:int -> unit

val glVertexAttrib1d : index:int -> v:float -> unit

val glVertexAttrib2s : index:int -> v0:int -> v1:int -> unit

val glVertexAttrib2d : index:int -> v0:float -> v1:float -> unit

val glVertexAttrib3s : index:int -> v0:int -> v1:int -> v2:int -> unit

val glVertexAttrib3d : index:int -> v0:float -> v1:float -> v2:float -> unit

val glVertexAttrib4s : index:int -> v0:int -> v1:int -> v2:int -> v3:int -> unit

val glVertexAttrib4d : index:int -> v0:float -> v1:float -> v2:float -> v3:float -> unit

val glGetShaderInfoLog : shader:shader_object -> string

manual page

val glGetProgramInfoLog : program:shader_program -> string

manual page

val glEnableVertexAttribArray : index:int -> unit

val glDisableVertexAttribArray : index:int -> unit

Gets

module Get: sig .. end

manual page

val glGetBoolean1 : Get.get_boolean_1 -> bool

val glGetBoolean4 : Get.get_boolean_4 -> bool * bool * bool * bool

val glGetInteger4 : Get.get_integer_4 -> int * int * int * int

val glGetInteger1 : Get.get_integer_1 -> int

val glGetInteger2 : Get.get_integer_2 -> int * int

val glGetFloat4 : Get.get_float_4 -> float * float * float * float

val glGetFloat3 : Get.get_float_3 -> float * float * float

val glGetFloat2 : Get.get_float_2 -> float * float

val glGetFloat1 : Get.get_float_1 -> float

val glGetMatrix : Get.get_matrix -> float array array

val glGetMatrixFlat : Get.get_matrix -> float array

val glGetTextureBinding : Get.get_texture_binding -> texture_id

type get_string = 

val glGetString : name:get_string -> string

manual page

type gl_error = 

val glGetError : unit -> gl_error

type tuple_params = 

val glGetLight : light:gl_light -> pname:Get.get_light -> tuple_params

Multitexture

Multitexture Node, ARB multitexture wiki

type texture_i = 

val glActiveTexture : texture:texture_i -> unit

val glActiveTexturei : texture:int -> unit

val glMultiTexCoord2 : texture:texture_i -> s:float -> t:float -> unit

val glMultiTexCoord2i : texture:int -> s:float -> t:float -> unit

Library Version

val glmlite_version : int * int * int