gl

### Header File

The header file may include additional information gl.hrl

### Exports

accum(Op, Value)

Args: Op, Value
Returns: ok
C-API: void glAccum(GLenum op, GLfloat value)

alphaFunc(Func, Ref)

Args: Func, Ref
Returns: ok
C-API: void glAlphaFunc(GLenum func, GLclampf ref)

areTexturesResident(N, Textures)

Args: N, <<[Textures]>>
Returns: {?GL_BYTE, [Residences]}
C-API: GLboolean glAreTexturesResident(GLsizei n, const GLuint * textures, GLboolean * residences)

arrayElement(I)

Args: I
Returns: ok
C-API: void glArrayElement(GLint i)

'begin'(Mode)

Args: Mode
Returns: ok
C-API: void glBegin(GLenum mode)

bindTexture(Target, Texture)

Args: Target, Texture
Returns: ok
C-API: void glBindTexture(GLenum target, GLuint texture)

bitmap(Width, Height, Xorig, Yorig, Xmove, Ymove, Bitmap)

Args: Width, Height, Xorig, Yorig, Xmove, Ymove, <<[Bitmap]>>
Returns: ok
C-API: void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap)

blendFunc(Sfactor, Dfactor)

Args: Sfactor, Dfactor
Returns: ok
C-API: void glBlendFunc(GLenum sfactor, GLenum dfactor)

callList(List)

Args: List
Returns: ok
C-API: void glCallList(GLuint list)

callLists(N, Type, Lists)

Args: N, Type, <<[Lists]>>
Returns: ok
C-API: void glCallLists(GLsizei n, GLenum type, const GLvoid * lists)

clear(Mask)

Args: Mask
Returns: ok
C-API: void glClear(GLbitfield mask)

clearAccum(Red, Green, Blue, Alpha)

Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)

clearColor(Red, Green, Blue, Alpha)

Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)

clearDepth(Depth)

Args: Depth
Returns: ok
C-API: void glClearDepth(GLclampd depth)

clearIndex(C)

Args: C
Returns: ok
C-API: void glClearIndex(GLfloat c)

clearStencil(S)

Args: S
Returns: ok
C-API: void glClearStencil(GLint s)

clipPlane(Plane, Equation)

Args: Plane, <<[Equation]>>
Returns: ok
C-API: void glClipPlane(GLenum plane, const GLdouble * equation)

color3b(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glColor3b(GLbyte red, GLbyte green, GLbyte blue)

color3bv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3bv( const GLbyte * v)

color3d(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glColor3d(GLdouble red, GLdouble green, GLdouble blue)

color3dv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3dv( const GLdouble * v)

color3f(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glColor3f(GLfloat red, GLfloat green, GLfloat blue)

color3fv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3fv( const GLfloat * v)

color3i(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glColor3i(GLint red, GLint green, GLint blue)

color3iv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3iv( const GLint * v)

color3s(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glColor3s(GLshort red, GLshort green, GLshort blue)

color3sv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3sv( const GLshort * v)

color3ub(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glColor3ub(GLubyte red, GLubyte green, GLubyte blue)

color3ubv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3ubv( const GLubyte * v)

color3ui(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glColor3ui(GLuint red, GLuint green, GLuint blue)

color3uiv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3uiv( const GLuint * v)

color3us(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glColor3us(GLushort red, GLushort green, GLushort blue)

color3usv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3usv( const GLushort * v)

color4b(Red, Green, Blue, Alpha)

Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)

color4bv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4bv( const GLbyte * v)

color4d(Red, Green, Blue, Alpha)

Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)

color4dv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4dv( const GLdouble * v)

color4f(Red, Green, Blue, Alpha)

Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)

color4fv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4fv( const GLfloat * v)

color4i(Red, Green, Blue, Alpha)

Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4i(GLint red, GLint green, GLint blue, GLint alpha)

color4iv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4iv( const GLint * v)

color4s(Red, Green, Blue, Alpha)

Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)

color4sv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4sv( const GLshort * v)

color4ub(Red, Green, Blue, Alpha)

Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)

color4ubv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4ubv( const GLubyte * v)

color4ui(Red, Green, Blue, Alpha)

Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)

color4uiv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4uiv( const GLuint * v)

color4us(Red, Green, Blue, Alpha)

Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)

color4usv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4usv( const GLushort * v)

colorMask(Red, Green, Blue, Alpha)

Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)

colorMaterial(Face, Mode)

Args: Face, Mode
Returns: ok
C-API: void glColorMaterial(GLenum face, GLenum mode)

colorPointer(Size, Type, Stride, Pointer)

Args: Size, Type, Stride, <<[Pointer]>>
Returns: ok
C-API: void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)

copyPixels(X, Y, Width, Height, Type)

Args: X, Y, Width, Height, Type
Returns: ok
C-API: void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)

copyTexImage1D(Target, Level, Internalformat, X, Y, Width, Border)

Args: Target, Level, Internalformat, X, Y, Width, Border
Returns: ok
C-API: void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)

copyTexImage2D(Target, Level, Internalformat, X, Y, Width, Height, Border)

Args: Target, Level, Internalformat, X, Y, Width, Height, Border
Returns: ok
C-API: void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)

copyTexSubImage1D(Target, Level, Xoffset, X, Y, Width)

Args: Target, Level, Xoffset, X, Y, Width
Returns: ok
C-API: void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)

copyTexSubImage2D(Target, Level, Xoffset, Yoffset, X, Y, Width, Height)

Args: Target, Level, Xoffset, Yoffset, X, Y, Width, Height
Returns: ok
C-API: void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)

cullFace(Mode)

Args: Mode
Returns: ok
C-API: void glCullFace(GLenum mode)

deleteLists(List, Range)

Args: List, Range
Returns: ok
C-API: void glDeleteLists(GLuint list, GLsizei range)

deleteTextures(N, Textures)

Args: N, <<[Textures]>>
Returns: ok
C-API: void glDeleteTextures(GLsizei n, const GLuint * textures)

depthFunc(Func)

Args: Func
Returns: ok
C-API: void glDepthFunc(GLenum func)

depthMask(Flag)

Args: Flag
Returns: ok
C-API: void glDepthMask(GLboolean flag)

depthRange(ZNear, ZFar)

Args: ZNear, ZFar
Returns: ok
C-API: void glDepthRange(GLclampd zNear, GLclampd zFar)

disable(Cap)

Args: Cap
Returns: ok
C-API: void glDisable(GLenum cap)

disableClientState(Array)

Args: Array
Returns: ok
C-API: void glDisableClientState(GLenum array)

drawArrays(Mode, First, Count)

Args: Mode, First, Count
Returns: ok
C-API: void glDrawArrays(GLenum mode, GLint first, GLsizei count)

drawBuffer(Mode)

Args: Mode
Returns: ok
C-API: void glDrawBuffer(GLenum mode)

drawElements(Mode, Count, Type, Indices)

Args: Mode, Count, Type, <<[Indices]>>
Returns: ok
C-API: void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices)

drawPixels(Width, Height, Format, Type, Pixels)

Args: Width, Height, Format, Type, <<[Pixels]>>
Returns: ok
C-API: void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)

edgeFlag(Flag)

Args: Flag
Returns: ok
C-API: void glEdgeFlag(GLboolean flag)

edgeFlagPointer(Stride, Pointer)

Args: Stride, <<[Pointer]>>
Returns: ok
C-API: void glEdgeFlagPointer(GLsizei stride, const GLboolean * pointer)

edgeFlagv(Flag)

Args: <<[Flag]>>
Returns: ok
C-API: void glEdgeFlagv( const GLboolean * flag)

enable(Cap)

Args: Cap
Returns: ok
C-API: void glEnable(GLenum cap)

enableClientState(Array)

Args: Array
Returns: ok
C-API: void glEnableClientState(GLenum array)

'end'()

Returns: ok
C-API: void glEnd()

endList()

Returns: ok
C-API: void glEndList()

evalCoord1d(U)

Args: U
Returns: ok
C-API: void glEvalCoord1d(GLdouble u)

evalCoord1dv({U1})

Args: {U1}
Returns: ok
C-API: void glEvalCoord1dv( const GLdouble * u)

evalCoord1f(U)

Args: U
Returns: ok
C-API: void glEvalCoord1f(GLfloat u)

evalCoord1fv({U1})

Args: {U1}
Returns: ok
C-API: void glEvalCoord1fv( const GLfloat * u)

evalCoord2d(U, V)

Args: U, V
Returns: ok
C-API: void glEvalCoord2d(GLdouble u, GLdouble v)

evalCoord2dv({U1,U2})

Args: {U1,U2}
Returns: ok
C-API: void glEvalCoord2dv( const GLdouble * u)

evalCoord2f(U, V)

Args: U, V
Returns: ok
C-API: void glEvalCoord2f(GLfloat u, GLfloat v)

evalCoord2fv({U1,U2})

Args: {U1,U2}
Returns: ok
C-API: void glEvalCoord2fv( const GLfloat * u)

evalMesh1(Mode, I1, I2)

Args: Mode, I1, I2
Returns: ok
C-API: void glEvalMesh1(GLenum mode, GLint i1, GLint i2)

evalMesh2(Mode, I1, I2, J1, J2)

Args: Mode, I1, I2, J1, J2
Returns: ok
C-API: void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)

evalPoint1(I)

Args: I
Returns: ok
C-API: void glEvalPoint1(GLint i)

evalPoint2(I, J)

Args: I, J
Returns: ok
C-API: void glEvalPoint2(GLint i, GLint j)

feedbackBuffer(Size, Type, #sdlmem{bin=Buffer})

Args: Size, Type, #sdlmem{} = Buffer
Returns: ok
C-API: void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat * buffer)

finish()

Returns: ok
C-API: void glFinish()

flush()

Returns: ok
C-API: void glFlush()

fogf(Pname, Param)

Args: Pname, Param
Returns: ok
C-API: void glFogf(GLenum pname, GLfloat param)

fogfv(Pname, Params)

Args: Pname, <<[Params]>>
Returns: ok
C-API: void glFogfv(GLenum pname, const GLfloat * params)

fogi(Pname, Param)

Args: Pname, Param
Returns: ok
C-API: void glFogi(GLenum pname, GLint param)

fogiv(Pname, Params)

Args: Pname, <<[Params]>>
Returns: ok
C-API: void glFogiv(GLenum pname, const GLint * params)

frontFace(Mode)

Args: Mode
Returns: ok
C-API: void glFrontFace(GLenum mode)

frustum(Left, Right, Bottom, Top, ZNear, ZFar)

Args: Left, Right, Bottom, Top, ZNear, ZFar
Returns: ok
C-API: void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)

genLists(Range)

Args: Range
Returns: ?GL_UNSIGNED_INT
C-API: GLuint glGenLists(GLsizei range)

genTextures(N)

Args: N
Returns: [Textures]
C-API: void glGenTextures(GLsizei n, GLuint * textures)

getBooleanv(Pname)

Args: Pname
Returns: [Params]
C-API: void glGetBooleanv(GLenum pname, GLboolean * params)

getClipPlane(Plane)

Args: Plane
Returns: [Equation]
C-API: void glGetClipPlane(GLenum plane, GLdouble * equation)

getDoublev(Pname)

Args: Pname
Returns: [Params]
C-API: void glGetDoublev(GLenum pname, GLdouble * params)

getError()

Returns: ?GL_INT
C-API: GLenum glGetError()

getFloatv(Pname)

Args: Pname
Returns: [Params]
C-API: void glGetFloatv(GLenum pname, GLfloat * params)

getIntegerv(Pname)

Args: Pname
Returns: [Params]
C-API: void glGetIntegerv(GLenum pname, GLint * params)

getLightfv(Light, Pname)

Args: Light, Pname
Returns: [Params]
C-API: void glGetLightfv(GLenum light, GLenum pname, GLfloat * params)

getLightiv(Light, Pname)

Args: Light, Pname
Returns: [Params]
C-API: void glGetLightiv(GLenum light, GLenum pname, GLint * params)

getMapdv(Target, Query, #sdlmem{bin=V})

Args: Target, Query, #sdlmem{} = V
Returns: ok
C-API: void glGetMapdv(GLenum target, GLenum query, GLdouble * v)

getMapfv(Target, Query, #sdlmem{bin=V})

Args: Target, Query, #sdlmem{} = V
Returns: ok
C-API: void glGetMapfv(GLenum target, GLenum query, GLfloat * v)

getMapiv(Target, Query, #sdlmem{bin=V})

Args: Target, Query, #sdlmem{} = V
Returns: ok
C-API: void glGetMapiv(GLenum target, GLenum query, GLint * v)

getMaterialfv(Face, Pname)

Args: Face, Pname
Returns: [Params]
C-API: void glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)

getMaterialiv(Face, Pname)

Args: Face, Pname
Returns: [Params]
C-API: void glGetMaterialiv(GLenum face, GLenum pname, GLint * params)

getPixelMapfv(Map, #sdlmem{bin=Values})

Args: Map, #sdlmem{} = Values
Returns: ok
C-API: void glGetPixelMapfv(GLenum map, GLfloat * values)

getPixelMapuiv(Map, #sdlmem{bin=Values})

Args: Map, #sdlmem{} = Values
Returns: ok
C-API: void glGetPixelMapuiv(GLenum map, GLuint * values)

getPixelMapusv(Map, #sdlmem{bin=Values})

Args: Map, #sdlmem{} = Values
Returns: ok
C-API: void glGetPixelMapusv(GLenum map, GLushort * values)

getPointerv(Pname)

Args: Pname
Returns: Params=#sdlmem{}
C-API: void glGetPointerv(GLenum pname, GLvoid* *params)

getPolygonStipple()

Returns: [Mask]
C-API: void glGetPolygonStipple(GLubyte * mask)

getString(Name)

Args: Name
Returns: [?GL_UNSIGNED_BYTE]
C-API: GLubyte* glGetString(GLenum name)

getTexEnvfv(Target, Pname)

Args: Target, Pname
Returns: [Params]
C-API: void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)

getTexEnviv(Target, Pname)

Args: Target, Pname
Returns: [Params]
C-API: void glGetTexEnviv(GLenum target, GLenum pname, GLint * params)

getTexGendv(Coord, Pname)

Args: Coord, Pname
Returns: [Params]
C-API: void glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)

getTexGenfv(Coord, Pname)

Args: Coord, Pname
Returns: [Params]
C-API: void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)

getTexGeniv(Coord, Pname)

Args: Coord, Pname
Returns: [Params]
C-API: void glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)

getTexImage(Target, Level, Format, Type, #sdlmem{bin=Pixels})

Args: Target, Level, Format, Type, #sdlmem{} = Pixels
Returns: ok
C-API: void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels)

getTexLevelParameterfv(Target, Level, Pname)

Args: Target, Level, Pname
Returns: [Params]
C-API: void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params)

getTexLevelParameteriv(Target, Level, Pname)

Args: Target, Level, Pname
Returns: [Params]
C-API: void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params)

getTexParameterfv(Target, Pname)

Args: Target, Pname
Returns: [Params]
C-API: void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)

getTexParameteriv(Target, Pname)

Args: Target, Pname
Returns: [Params]
C-API: void glGetTexParameteriv(GLenum target, GLenum pname, GLint * params)

hint(Target, Mode)

Args: Target, Mode
Returns: ok
C-API: void glHint(GLenum target, GLenum mode)

indexMask(Mask)

Args: Mask
Returns: ok
C-API: void glIndexMask(GLuint mask)

indexPointer(Type, Stride, Pointer)

Args: Type, Stride, <<[Pointer]>>
Returns: ok
C-API: void glIndexPointer(GLenum type, GLsizei stride, const GLvoid * pointer)

indexd(C)

Args: C
Returns: ok
C-API: void glIndexd(GLdouble c)

indexdv(C)

Args: <<[C]>>
Returns: ok
C-API: void glIndexdv( const GLdouble * c)

indexf(C)

Args: C
Returns: ok
C-API: void glIndexf(GLfloat c)

indexfv(C)

Args: <<[C]>>
Returns: ok
C-API: void glIndexfv( const GLfloat * c)

indexi(C)

Args: C
Returns: ok
C-API: void glIndexi(GLint c)

indexiv(C)

Args: <<[C]>>
Returns: ok
C-API: void glIndexiv( const GLint * c)

indexs(C)

Args: C
Returns: ok
C-API: void glIndexs(GLshort c)

indexsv(C)

Args: <<[C]>>
Returns: ok
C-API: void glIndexsv( const GLshort * c)

indexub(C)

Args: C
Returns: ok
C-API: void glIndexub(GLubyte c)

indexubv(C)

Args: <<[C]>>
Returns: ok
C-API: void glIndexubv( const GLubyte * c)

initNames()

Returns: ok
C-API: void glInitNames()

interleavedArrays(Format, Stride, Pointer)

Args: Format, Stride, <<[Pointer]>>
Returns: ok
C-API: void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid * pointer)

isEnabled(Cap)

Args: Cap
Returns: ?GL_BYTE
C-API: GLboolean glIsEnabled(GLenum cap)

isList(List)

Args: List
Returns: ?GL_BYTE
C-API: GLboolean glIsList(GLuint list)

isTexture(Texture)

Args: Texture
Returns: ?GL_BYTE
C-API: GLboolean glIsTexture(GLuint texture)

lightModelf(Pname, Param)

Args: Pname, Param
Returns: ok
C-API: void glLightModelf(GLenum pname, GLfloat param)

lightModelfv(Pname, Params)

Args: Pname, <<[Params]>>
Returns: ok
C-API: void glLightModelfv(GLenum pname, const GLfloat * params)

lightModeli(Pname, Param)

Args: Pname, Param
Returns: ok
C-API: void glLightModeli(GLenum pname, GLint param)

lightModeliv(Pname, Params)

Args: Pname, <<[Params]>>
Returns: ok
C-API: void glLightModeliv(GLenum pname, const GLint * params)

lightf(Light, Pname, Param)

Args: Light, Pname, Param
Returns: ok
C-API: void glLightf(GLenum light, GLenum pname, GLfloat param)

lightfv(Light, Pname, Params)

Args: Light, Pname, <<[Params]>>
Returns: ok
C-API: void glLightfv(GLenum light, GLenum pname, const GLfloat * params)

lighti(Light, Pname, Param)

Args: Light, Pname, Param
Returns: ok
C-API: void glLighti(GLenum light, GLenum pname, GLint param)

lightiv(Light, Pname, Params)

Args: Light, Pname, <<[Params]>>
Returns: ok
C-API: void glLightiv(GLenum light, GLenum pname, const GLint * params)

lineStipple(Factor, Pattern)

Args: Factor, Pattern
Returns: ok
C-API: void glLineStipple(GLint factor, GLushort pattern)

lineWidth(Width)

Args: Width
Returns: ok
C-API: void glLineWidth(GLfloat width)

listBase(Base)

Args: Base
Returns: ok
C-API: void glListBase(GLuint base)

loadIdentity()

Returns: ok
C-API: void glLoadIdentity()

loadMatrixd(M)

Args: <<[M]>>
Returns: ok
C-API: void glLoadMatrixd( const GLdouble * m)

loadMatrixf(M)

Args: <<[M]>>
Returns: ok
C-API: void glLoadMatrixf( const GLfloat * m)

loadName(Name)

Args: Name
Returns: ok
C-API: void glLoadName(GLuint name)

logicOp(Opcode)

Args: Opcode
Returns: ok
C-API: void glLogicOp(GLenum opcode)

map1d(Target, U1, U2, Stride, Order, Points)

Args: Target, U1, U2, Stride, Order, <<[Points]>>
Returns: ok
C-API: void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points)

map1f(Target, U1, U2, Stride, Order, Points)

Args: Target, U1, U2, Stride, Order, <<[Points]>>
Returns: ok
C-API: void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points)

map2d(Target, U1, U2, Ustride, Uorder, V1, V2, Vstride, Vorder, Points)

Args: Target, U1, U2, Ustride, Uorder, V1, V2, Vstride, Vorder, <<[Points]>>
Returns: ok
C-API: void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points)

map2f(Target, U1, U2, Ustride, Uorder, V1, V2, Vstride, Vorder, Points)

Args: Target, U1, U2, Ustride, Uorder, V1, V2, Vstride, Vorder, <<[Points]>>
Returns: ok
C-API: void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points)

mapGrid1d(Un, U1, U2)

Args: Un, U1, U2
Returns: ok
C-API: void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)

mapGrid1f(Un, U1, U2)

Args: Un, U1, U2
Returns: ok
C-API: void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)

mapGrid2d(Un, U1, U2, Vn, V1, V2)

Args: Un, U1, U2, Vn, V1, V2
Returns: ok
C-API: void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)

mapGrid2f(Un, U1, U2, Vn, V1, V2)

Args: Un, U1, U2, Vn, V1, V2
Returns: ok
C-API: void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)

materialf(Face, Pname, Param)

Args: Face, Pname, Param
Returns: ok
C-API: void glMaterialf(GLenum face, GLenum pname, GLfloat param)

materialfv(Face, Pname, Params)

Args: Face, Pname, <<[Params]>>
Returns: ok
C-API: void glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)

materiali(Face, Pname, Param)

Args: Face, Pname, Param
Returns: ok
C-API: void glMateriali(GLenum face, GLenum pname, GLint param)

materialiv(Face, Pname, Params)

Args: Face, Pname, <<[Params]>>
Returns: ok
C-API: void glMaterialiv(GLenum face, GLenum pname, const GLint * params)

matrixMode(Mode)

Args: Mode
Returns: ok
C-API: void glMatrixMode(GLenum mode)

multMatrixd(M)

Args: <<[M]>>
Returns: ok
C-API: void glMultMatrixd( const GLdouble * m)

multMatrixf(M)

Args: <<[M]>>
Returns: ok
C-API: void glMultMatrixf( const GLfloat * m)

newList(List, Mode)

Args: List, Mode
Returns: ok
C-API: void glNewList(GLuint list, GLenum mode)

normal3b(Nx, Ny, Nz)

Args: Nx, Ny, Nz
Returns: ok
C-API: void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)

normal3bv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glNormal3bv( const GLbyte * v)

normal3d(Nx, Ny, Nz)

Args: Nx, Ny, Nz
Returns: ok
C-API: void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)

normal3dv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glNormal3dv( const GLdouble * v)

normal3f(Nx, Ny, Nz)

Args: Nx, Ny, Nz
Returns: ok
C-API: void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)

normal3fv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glNormal3fv( const GLfloat * v)

normal3i(Nx, Ny, Nz)

Args: Nx, Ny, Nz
Returns: ok
C-API: void glNormal3i(GLint nx, GLint ny, GLint nz)

normal3iv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glNormal3iv( const GLint * v)

normal3s(Nx, Ny, Nz)

Args: Nx, Ny, Nz
Returns: ok
C-API: void glNormal3s(GLshort nx, GLshort ny, GLshort nz)

normal3sv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glNormal3sv( const GLshort * v)

normalPointer(Type, Stride, Pointer)

Args: Type, Stride, <<[Pointer]>>
Returns: ok
C-API: void glNormalPointer(GLenum type, GLsizei stride, const GLvoid * pointer)

ortho(Left, Right, Bottom, Top, ZNear, ZFar)

Args: Left, Right, Bottom, Top, ZNear, ZFar
Returns: ok
C-API: void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)

passThrough(Token)

Args: Token
Returns: ok
C-API: void glPassThrough(GLfloat token)

pixelMapfv(Map, Mapsize, Values)

Args: Map, Mapsize, <<[Values]>>
Returns: ok
C-API: void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat * values)

pixelMapuiv(Map, Mapsize, Values)

Args: Map, Mapsize, <<[Values]>>
Returns: ok
C-API: void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint * values)

pixelMapusv(Map, Mapsize, Values)

Args: Map, Mapsize, <<[Values]>>
Returns: ok
C-API: void glPixelMapusv(GLenum map, GLint mapsize, const GLushort * values)

pixelStoref(Pname, Param)

Args: Pname, Param
Returns: ok
C-API: void glPixelStoref(GLenum pname, GLfloat param)

pixelStorei(Pname, Param)

Args: Pname, Param
Returns: ok
C-API: void glPixelStorei(GLenum pname, GLint param)

pixelTransferf(Pname, Param)

Args: Pname, Param
Returns: ok
C-API: void glPixelTransferf(GLenum pname, GLfloat param)

pixelTransferi(Pname, Param)

Args: Pname, Param
Returns: ok
C-API: void glPixelTransferi(GLenum pname, GLint param)

pixelZoom(Xfactor, Yfactor)

Args: Xfactor, Yfactor
Returns: ok
C-API: void glPixelZoom(GLfloat xfactor, GLfloat yfactor)

pointSize(Size)

Args: Size
Returns: ok
C-API: void glPointSize(GLfloat size)

polygonMode(Face, Mode)

Args: Face, Mode
Returns: ok
C-API: void glPolygonMode(GLenum face, GLenum mode)

polygonOffset(Factor, Units)

Args: Factor, Units
Returns: ok
C-API: void glPolygonOffset(GLfloat factor, GLfloat units)

polygonStipple(Mask)

Args: <<[Mask]>>
Returns: ok
C-API: void glPolygonStipple( const GLubyte * mask)

popAttrib()

Returns: ok
C-API: void glPopAttrib()

popClientAttrib()

Returns: ok
C-API: void glPopClientAttrib()

popMatrix()

Returns: ok
C-API: void glPopMatrix()

popName()

Returns: ok
C-API: void glPopName()

prioritizeTextures(N, Textures, Priorities)

Args: N, <<[Textures]>>, <<[Priorities]>>
Returns: ok
C-API: void glPrioritizeTextures(GLsizei n, const GLuint * textures, const GLclampf * priorities)

pushAttrib(Mask)

Args: Mask
Returns: ok
C-API: void glPushAttrib(GLbitfield mask)

pushClientAttrib(Mask)

Args: Mask
Returns: ok
C-API: void glPushClientAttrib(GLbitfield mask)

pushMatrix()

Returns: ok
C-API: void glPushMatrix()

pushName(Name)

Args: Name
Returns: ok
C-API: void glPushName(GLuint name)

rasterPos2d(X, Y)

Args: X, Y
Returns: ok
C-API: void glRasterPos2d(GLdouble x, GLdouble y)

rasterPos2dv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glRasterPos2dv( const GLdouble * v)

rasterPos2f(X, Y)

Args: X, Y
Returns: ok
C-API: void glRasterPos2f(GLfloat x, GLfloat y)

rasterPos2fv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glRasterPos2fv( const GLfloat * v)

rasterPos2i(X, Y)

Args: X, Y
Returns: ok
C-API: void glRasterPos2i(GLint x, GLint y)

rasterPos2iv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glRasterPos2iv( const GLint * v)

rasterPos2s(X, Y)

Args: X, Y
Returns: ok
C-API: void glRasterPos2s(GLshort x, GLshort y)

rasterPos2sv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glRasterPos2sv( const GLshort * v)

rasterPos3d(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)

rasterPos3dv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glRasterPos3dv( const GLdouble * v)

rasterPos3f(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)

rasterPos3fv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glRasterPos3fv( const GLfloat * v)

rasterPos3i(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glRasterPos3i(GLint x, GLint y, GLint z)

rasterPos3iv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glRasterPos3iv( const GLint * v)

rasterPos3s(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glRasterPos3s(GLshort x, GLshort y, GLshort z)

rasterPos3sv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glRasterPos3sv( const GLshort * v)

rasterPos4d(X, Y, Z, W)

Args: X, Y, Z, W
Returns: ok
C-API: void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)

rasterPos4dv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glRasterPos4dv( const GLdouble * v)

rasterPos4f(X, Y, Z, W)

Args: X, Y, Z, W
Returns: ok
C-API: void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)

rasterPos4fv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glRasterPos4fv( const GLfloat * v)

rasterPos4i(X, Y, Z, W)

Args: X, Y, Z, W
Returns: ok
C-API: void glRasterPos4i(GLint x, GLint y, GLint z, GLint w)

rasterPos4iv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glRasterPos4iv( const GLint * v)

rasterPos4s(X, Y, Z, W)

Args: X, Y, Z, W
Returns: ok
C-API: void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)

rasterPos4sv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glRasterPos4sv( const GLshort * v)

readBuffer(Mode)

Args: Mode
Returns: ok
C-API: void glReadBuffer(GLenum mode)

readPixels(X, Y, Width, Height, Format, Type, #sdlmem{bin=Pixels})

Args: X, Y, Width, Height, Format, Type, #sdlmem{} = Pixels
Returns: ok
C-API: void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels)

rectd(X1, Y1, X2, Y2)

Args: X1, Y1, X2, Y2
Returns: ok
C-API: void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)

rectdv(V1, V2)

Args: <<[V1]>>, <<[V2]>>
Returns: ok
C-API: void glRectdv( const GLdouble * v1, const GLdouble * v2)

rectf(X1, Y1, X2, Y2)

Args: X1, Y1, X2, Y2
Returns: ok
C-API: void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)

rectfv(V1, V2)

Args: <<[V1]>>, <<[V2]>>
Returns: ok
C-API: void glRectfv( const GLfloat * v1, const GLfloat * v2)

recti(X1, Y1, X2, Y2)

Args: X1, Y1, X2, Y2
Returns: ok
C-API: void glRecti(GLint x1, GLint y1, GLint x2, GLint y2)

rectiv(V1, V2)

Args: <<[V1]>>, <<[V2]>>
Returns: ok
C-API: void glRectiv( const GLint * v1, const GLint * v2)

rects(X1, Y1, X2, Y2)

Args: X1, Y1, X2, Y2
Returns: ok
C-API: void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)

rectsv(V1, V2)

Args: <<[V1]>>, <<[V2]>>
Returns: ok
C-API: void glRectsv( const GLshort * v1, const GLshort * v2)

renderMode(Mode)

Args: Mode
Returns: ?GL_INT
C-API: GLint glRenderMode(GLenum mode)

rotated(Angle, X, Y, Z)

Args: Angle, X, Y, Z
Returns: ok
C-API: void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)

rotatef(Angle, X, Y, Z)

Args: Angle, X, Y, Z
Returns: ok
C-API: void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)

scaled(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glScaled(GLdouble x, GLdouble y, GLdouble z)

scalef(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glScalef(GLfloat x, GLfloat y, GLfloat z)

scissor(X, Y, Width, Height)

Args: X, Y, Width, Height
Returns: ok
C-API: void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)

selectBuffer(Size, #sdlmem{bin=Buffer})

Args: Size, #sdlmem{} = Buffer
Returns: ok
C-API: void glSelectBuffer(GLsizei size, GLuint * buffer)

shadeModel(Mode)

Args: Mode
Returns: ok
C-API: void glShadeModel(GLenum mode)

stencilFunc(Func, Ref, Mask)

Args: Func, Ref, Mask
Returns: ok
C-API: void glStencilFunc(GLenum func, GLint ref, GLuint mask)

stencilMask(Mask)

Args: Mask
Returns: ok
C-API: void glStencilMask(GLuint mask)

stencilOp(Fail, Zfail, Zpass)

Args: Fail, Zfail, Zpass
Returns: ok
C-API: void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)

texCoord1d(S)

Args: S
Returns: ok
C-API: void glTexCoord1d(GLdouble s)

texCoord1dv({V1})

Args: {V1}
Returns: ok
C-API: void glTexCoord1dv( const GLdouble * v)

texCoord1f(S)

Args: S
Returns: ok
C-API: void glTexCoord1f(GLfloat s)

texCoord1fv({V1})

Args: {V1}
Returns: ok
C-API: void glTexCoord1fv( const GLfloat * v)

texCoord1i(S)

Args: S
Returns: ok
C-API: void glTexCoord1i(GLint s)

texCoord1iv({V1})

Args: {V1}
Returns: ok
C-API: void glTexCoord1iv( const GLint * v)

texCoord1s(S)

Args: S
Returns: ok
C-API: void glTexCoord1s(GLshort s)

texCoord1sv({V1})

Args: {V1}
Returns: ok
C-API: void glTexCoord1sv( const GLshort * v)

texCoord2d(S, T)

Args: S, T
Returns: ok
C-API: void glTexCoord2d(GLdouble s, GLdouble t)

texCoord2dv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glTexCoord2dv( const GLdouble * v)

texCoord2f(S, T)

Args: S, T
Returns: ok
C-API: void glTexCoord2f(GLfloat s, GLfloat t)

texCoord2fv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glTexCoord2fv( const GLfloat * v)

texCoord2i(S, T)

Args: S, T
Returns: ok
C-API: void glTexCoord2i(GLint s, GLint t)

texCoord2iv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glTexCoord2iv( const GLint * v)

texCoord2s(S, T)

Args: S, T
Returns: ok
C-API: void glTexCoord2s(GLshort s, GLshort t)

texCoord2sv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glTexCoord2sv( const GLshort * v)

texCoord3d(S, T, R)

Args: S, T, R
Returns: ok
C-API: void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)

texCoord3dv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glTexCoord3dv( const GLdouble * v)

texCoord3f(S, T, R)

Args: S, T, R
Returns: ok
C-API: void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)

texCoord3fv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glTexCoord3fv( const GLfloat * v)

texCoord3i(S, T, R)

Args: S, T, R
Returns: ok
C-API: void glTexCoord3i(GLint s, GLint t, GLint r)

texCoord3iv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glTexCoord3iv( const GLint * v)

texCoord3s(S, T, R)

Args: S, T, R
Returns: ok
C-API: void glTexCoord3s(GLshort s, GLshort t, GLshort r)

texCoord3sv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glTexCoord3sv( const GLshort * v)

texCoord4d(S, T, R, Q)

Args: S, T, R, Q
Returns: ok
C-API: void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)

texCoord4dv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glTexCoord4dv( const GLdouble * v)

texCoord4f(S, T, R, Q)

Args: S, T, R, Q
Returns: ok
C-API: void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)

texCoord4fv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glTexCoord4fv( const GLfloat * v)

texCoord4i(S, T, R, Q)

Args: S, T, R, Q
Returns: ok
C-API: void glTexCoord4i(GLint s, GLint t, GLint r, GLint q)

texCoord4iv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glTexCoord4iv( const GLint * v)

texCoord4s(S, T, R, Q)

Args: S, T, R, Q
Returns: ok
C-API: void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)

texCoord4sv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glTexCoord4sv( const GLshort * v)

texCoordPointer(Size, Type, Stride, Pointer)

Args: Size, Type, Stride, <<[Pointer]>>
Returns: ok
C-API: void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)

texEnvf(Target, Pname, Param)

Args: Target, Pname, Param
Returns: ok
C-API: void glTexEnvf(GLenum target, GLenum pname, GLfloat param)

texEnvfv(Target, Pname, Params)

Args: Target, Pname, <<[Params]>>
Returns: ok
C-API: void glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params)

texEnvi(Target, Pname, Param)

Args: Target, Pname, Param
Returns: ok
C-API: void glTexEnvi(GLenum target, GLenum pname, GLint param)

texEnviv(Target, Pname, Params)

Args: Target, Pname, <<[Params]>>
Returns: ok
C-API: void glTexEnviv(GLenum target, GLenum pname, const GLint * params)

texGend(Coord, Pname, Param)

Args: Coord, Pname, Param
Returns: ok
C-API: void glTexGend(GLenum coord, GLenum pname, GLdouble param)

texGendv(Coord, Pname, Params)

Args: Coord, Pname, <<[Params]>>
Returns: ok
C-API: void glTexGendv(GLenum coord, GLenum pname, const GLdouble * params)

texGenf(Coord, Pname, Param)

Args: Coord, Pname, Param
Returns: ok
C-API: void glTexGenf(GLenum coord, GLenum pname, GLfloat param)

texGenfv(Coord, Pname, Params)

Args: Coord, Pname, <<[Params]>>
Returns: ok
C-API: void glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params)

texGeni(Coord, Pname, Param)

Args: Coord, Pname, Param
Returns: ok
C-API: void glTexGeni(GLenum coord, GLenum pname, GLint param)

texGeniv(Coord, Pname, Params)

Args: Coord, Pname, <<[Params]>>
Returns: ok
C-API: void glTexGeniv(GLenum coord, GLenum pname, const GLint * params)

texImage1D(Target, Level, Internalformat, Width, Border, Format, Type, Pixels)

Args: Target, Level, Internalformat, Width, Border, Format, Type, <<[Pixels]>>
Returns: ok
C-API: void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels)

texImage2D(Target, Level, Internalformat, Width, Height, Border, Format, Type, Pixels)

Args: Target, Level, Internalformat, Width, Height, Border, Format, Type, <<[Pixels]>>
Returns: ok
C-API: void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)

texParameterf(Target, Pname, Param)

Args: Target, Pname, Param
Returns: ok
C-API: void glTexParameterf(GLenum target, GLenum pname, GLfloat param)

texParameterfv(Target, Pname, Params)

Args: Target, Pname, <<[Params]>>
Returns: ok
C-API: void glTexParameterfv(GLenum target, GLenum pname, const GLfloat * params)

texParameteri(Target, Pname, Param)

Args: Target, Pname, Param
Returns: ok
C-API: void glTexParameteri(GLenum target, GLenum pname, GLint param)

texParameteriv(Target, Pname, Params)

Args: Target, Pname, <<[Params]>>
Returns: ok
C-API: void glTexParameteriv(GLenum target, GLenum pname, const GLint * params)

texSubImage1D(Target, Level, Xoffset, Width, Format, Type, Pixels)

Args: Target, Level, Xoffset, Width, Format, Type, <<[Pixels]>>
Returns: ok
C-API: void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)

texSubImage2D(Target, Level, Xoffset, Yoffset, Width, Height, Format, Type, Pixels)

Args: Target, Level, Xoffset, Yoffset, Width, Height, Format, Type, <<[Pixels]>>
Returns: ok
C-API: void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)

translated(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glTranslated(GLdouble x, GLdouble y, GLdouble z)

translatef(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glTranslatef(GLfloat x, GLfloat y, GLfloat z)

vertex2d(X, Y)

Args: X, Y
Returns: ok
C-API: void glVertex2d(GLdouble x, GLdouble y)

vertex2dv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glVertex2dv( const GLdouble * v)

vertex2f(X, Y)

Args: X, Y
Returns: ok
C-API: void glVertex2f(GLfloat x, GLfloat y)

vertex2fv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glVertex2fv( const GLfloat * v)

vertex2i(X, Y)

Args: X, Y
Returns: ok
C-API: void glVertex2i(GLint x, GLint y)

vertex2iv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glVertex2iv( const GLint * v)

vertex2s(X, Y)

Args: X, Y
Returns: ok
C-API: void glVertex2s(GLshort x, GLshort y)

vertex2sv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glVertex2sv( const GLshort * v)

vertex3d(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glVertex3d(GLdouble x, GLdouble y, GLdouble z)

vertex3dv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glVertex3dv( const GLdouble * v)

vertex3f(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glVertex3f(GLfloat x, GLfloat y, GLfloat z)

vertex3fv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glVertex3fv( const GLfloat * v)

vertex3i(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glVertex3i(GLint x, GLint y, GLint z)

vertex3iv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glVertex3iv( const GLint * v)

vertex3s(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glVertex3s(GLshort x, GLshort y, GLshort z)

vertex3sv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glVertex3sv( const GLshort * v)

vertex4d(X, Y, Z, W)

Args: X, Y, Z, W
Returns: ok
C-API: void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)

vertex4dv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glVertex4dv( const GLdouble * v)

vertex4f(X, Y, Z, W)

Args: X, Y, Z, W
Returns: ok
C-API: void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)

vertex4fv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glVertex4fv( const GLfloat * v)

vertex4i(X, Y, Z, W)

Args: X, Y, Z, W
Returns: ok
C-API: void glVertex4i(GLint x, GLint y, GLint z, GLint w)

vertex4iv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glVertex4iv( const GLint * v)

vertex4s(X, Y, Z, W)

Args: X, Y, Z, W
Returns: ok
C-API: void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)

vertex4sv({V1,V2,V3,V4})

Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glVertex4sv( const GLshort * v)

vertexPointer(Size, Type, Stride, Pointer)

Args: Size, Type, Stride, <<[Pointer]>>
Returns: ok
C-API: void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)

viewport(X, Y, Width, Height)

Args: X, Y, Width, Height
Returns: ok
C-API: void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)

blendColor(Red, Green, Blue, Alpha)

Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)

blendEquation(Mode)

Args: Mode
Returns: ok
C-API: void glBlendEquation(GLenum mode)

drawRangeElements(Mode, Start, End, Count, Type, Indices)

Args: Mode, Start, End, Count, Type, <<[Indices]>>
Returns: ok
C-API: void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)

colorTable(Target, Internalformat, Width, Format, Type, Table)

Args: Target, Internalformat, Width, Format, Type, <<[Table]>>
Returns: ok
C-API: void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)

colorTableParameterfv(Target, Pname, Params)

Args: Target, Pname, <<[Params]>>
Returns: ok
C-API: void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params)

colorTableParameteriv(Target, Pname, Params)

Args: Target, Pname, <<[Params]>>
Returns: ok
C-API: void glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params)

copyColorTable(Target, Internalformat, X, Y, Width)

Args: Target, Internalformat, X, Y, Width
Returns: ok
C-API: void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)

getColorTable(Target, Format, Type, #sdlmem{bin=Table})

Args: Target, Format, Type, #sdlmem{} = Table
Returns: ok
C-API: void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * table)

getColorTableParameterfv(Target, Pname)

Args: Target, Pname
Returns: [Params]
C-API: void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params)

getColorTableParameteriv(Target, Pname)

Args: Target, Pname
Returns: [Params]
C-API: void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params)

colorSubTable(Target, Start, Count, Format, Type, Data)

Args: Target, Start, Count, Format, Type, <<[Data]>>
Returns: ok
C-API: void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)

copyColorSubTable(Target, Start, X, Y, Width)

Args: Target, Start, X, Y, Width
Returns: ok
C-API: void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)

convolutionFilter1D(Target, Internalformat, Width, Format, Type, Image)

Args: Target, Internalformat, Width, Format, Type, <<[Image]>>
Returns: ok
C-API: void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)

convolutionFilter2D(Target, Internalformat, Width, Height, Format, Type, Image)

Args: Target, Internalformat, Width, Height, Format, Type, <<[Image]>>
Returns: ok
C-API: void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)

convolutionParameterf(Target, Pname, Params)

Args: Target, Pname, Params
Returns: ok
C-API: void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)

convolutionParameterfv(Target, Pname, Params)

Args: Target, Pname, <<[Params]>>
Returns: ok
C-API: void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params)

convolutionParameteri(Target, Pname, Params)

Args: Target, Pname, Params
Returns: ok
C-API: void glConvolutionParameteri(GLenum target, GLenum pname, GLint params)

convolutionParameteriv(Target, Pname, Params)

Args: Target, Pname, <<[Params]>>
Returns: ok
C-API: void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params)

copyConvolutionFilter1D(Target, Internalformat, X, Y, Width)

Args: Target, Internalformat, X, Y, Width
Returns: ok
C-API: void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)

copyConvolutionFilter2D(Target, Internalformat, X, Y, Width, Height)

Args: Target, Internalformat, X, Y, Width, Height
Returns: ok
C-API: void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)

getConvolutionFilter(Target, Format, Type, #sdlmem{bin=Image})

Args: Target, Format, Type, #sdlmem{} = Image
Returns: ok
C-API: void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid * image)

getConvolutionParameterfv(Target, Pname)

Args: Target, Pname
Returns: [Params]
C-API: void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)

getConvolutionParameteriv(Target, Pname)

Args: Target, Pname
Returns: [Params]
C-API: void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params)

getSeparableFilter(Target, Format, Type, #sdlmem{bin=Row}, #sdlmem{bin=Column}, #sdlmem{bin=Span})

Args: Target, Format, Type, #sdlmem{} = Row, #sdlmem{} = Column, #sdlmem{} = Span
Returns: ok
C-API: void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span)

separableFilter2D(Target, Internalformat, Width, Height, Format, Type, Row, Column)

Args: Target, Internalformat, Width, Height, Format, Type, <<[Row]>>, <<[Column]>>
Returns: ok
C-API: void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column)

getHistogram(Target, Reset, Format, Type, #sdlmem{bin=Values})

Args: Target, Reset, Format, Type, #sdlmem{} = Values
Returns: ok
C-API: void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)

getHistogramParameterfv(Target, Pname)

Args: Target, Pname
Returns: [Params]
C-API: void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)

getHistogramParameteriv(Target, Pname)

Args: Target, Pname
Returns: [Params]
C-API: void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params)

getMinmax(Target, Reset, Format, Type, #sdlmem{bin=Values})

Args: Target, Reset, Format, Type, #sdlmem{} = Values
Returns: ok
C-API: void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)

getMinmaxParameterfv(Target, Pname)

Args: Target, Pname
Returns: [Params]
C-API: void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params)

getMinmaxParameteriv(Target, Pname)

Args: Target, Pname
Returns: [Params]
C-API: void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)

histogram(Target, Width, Internalformat, Sink)

Args: Target, Width, Internalformat, Sink
Returns: ok
C-API: void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)

minmax(Target, Internalformat, Sink)

Args: Target, Internalformat, Sink
Returns: ok
C-API: void glMinmax(GLenum target, GLenum internalformat, GLboolean sink)

resetHistogram(Target)

Args: Target
Returns: ok
C-API: void glResetHistogram(GLenum target)

resetMinmax(Target)

Args: Target
Returns: ok
C-API: void glResetMinmax(GLenum target)

texImage3D(Target, Level, Internalformat, Width, Height, Depth, Border, Format, Type, Pixels)

Args: Target, Level, Internalformat, Width, Height, Depth, Border, Format, Type, <<[Pixels]>>
Returns: ok
C-API: void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)

texSubImage3D(Target, Level, Xoffset, Yoffset, Zoffset, Width, Height, Depth, Format, Type, Pixels)

Args: Target, Level, Xoffset, Yoffset, Zoffset, Width, Height, Depth, Format, Type, <<[Pixels]>>
Returns: ok
C-API: void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)

copyTexSubImage3D(Target, Level, Xoffset, Yoffset, Zoffset, X, Y, Width, Height)

Args: Target, Level, Xoffset, Yoffset, Zoffset, X, Y, Width, Height
Returns: ok
C-API: void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)

activeTexture(Texture)

Args: Texture
Returns: ok
C-API: void glActiveTexture(GLenum texture)

clientActiveTexture(Texture)

Args: Texture
Returns: ok
C-API: void glClientActiveTexture(GLenum texture)

multiTexCoord1d(Target, S)

Args: Target, S
Returns: ok
C-API: void glMultiTexCoord1d(GLenum target, GLdouble s)

multiTexCoord1dv(Target, {V1})

Args: Target, {V1}
Returns: ok
C-API: void glMultiTexCoord1dv(GLenum target, const GLdouble * v)

multiTexCoord1f(Target, S)

Args: Target, S
Returns: ok
C-API: void glMultiTexCoord1f(GLenum target, GLfloat s)

multiTexCoord1fv(Target, {V1})

Args: Target, {V1}
Returns: ok
C-API: void glMultiTexCoord1fv(GLenum target, const GLfloat * v)

multiTexCoord1i(Target, S)

Args: Target, S
Returns: ok
C-API: void glMultiTexCoord1i(GLenum target, GLint s)

multiTexCoord1iv(Target, {V1})

Args: Target, {V1}
Returns: ok
C-API: void glMultiTexCoord1iv(GLenum target, const GLint * v)

multiTexCoord1s(Target, S)

Args: Target, S
Returns: ok
C-API: void glMultiTexCoord1s(GLenum target, GLshort s)

multiTexCoord1sv(Target, {V1})

Args: Target, {V1}
Returns: ok
C-API: void glMultiTexCoord1sv(GLenum target, const GLshort * v)

multiTexCoord2d(Target, S, T)

Args: Target, S, T
Returns: ok
C-API: void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)

multiTexCoord2dv(Target, {V1,V2})

Args: Target, {V1,V2}
Returns: ok
C-API: void glMultiTexCoord2dv(GLenum target, const GLdouble * v)

multiTexCoord2f(Target, S, T)

Args: Target, S, T
Returns: ok
C-API: void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)

multiTexCoord2fv(Target, {V1,V2})

Args: Target, {V1,V2}
Returns: ok
C-API: void glMultiTexCoord2fv(GLenum target, const GLfloat * v)

multiTexCoord2i(Target, S, T)

Args: Target, S, T
Returns: ok
C-API: void glMultiTexCoord2i(GLenum target, GLint s, GLint t)

multiTexCoord2iv(Target, {V1,V2})

Args: Target, {V1,V2}
Returns: ok
C-API: void glMultiTexCoord2iv(GLenum target, const GLint * v)

multiTexCoord2s(Target, S, T)

Args: Target, S, T
Returns: ok
C-API: void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)

multiTexCoord2sv(Target, {V1,V2})

Args: Target, {V1,V2}
Returns: ok
C-API: void glMultiTexCoord2sv(GLenum target, const GLshort * v)

multiTexCoord3d(Target, S, T, R)

Args: Target, S, T, R
Returns: ok
C-API: void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)

multiTexCoord3dv(Target, {V1,V2,V3})

Args: Target, {V1,V2,V3}
Returns: ok
C-API: void glMultiTexCoord3dv(GLenum target, const GLdouble * v)

multiTexCoord3f(Target, S, T, R)

Args: Target, S, T, R
Returns: ok
C-API: void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)

multiTexCoord3fv(Target, {V1,V2,V3})

Args: Target, {V1,V2,V3}
Returns: ok
C-API: void glMultiTexCoord3fv(GLenum target, const GLfloat * v)

multiTexCoord3i(Target, S, T, R)

Args: Target, S, T, R
Returns: ok
C-API: void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)

multiTexCoord3iv(Target, {V1,V2,V3})

Args: Target, {V1,V2,V3}
Returns: ok
C-API: void glMultiTexCoord3iv(GLenum target, const GLint * v)

multiTexCoord3s(Target, S, T, R)

Args: Target, S, T, R
Returns: ok
C-API: void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)

multiTexCoord3sv(Target, {V1,V2,V3})

Args: Target, {V1,V2,V3}
Returns: ok
C-API: void glMultiTexCoord3sv(GLenum target, const GLshort * v)

multiTexCoord4d(Target, S, T, R, Q)

Args: Target, S, T, R, Q
Returns: ok
C-API: void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)

multiTexCoord4dv(Target, {V1,V2,V3,V4})

Args: Target, {V1,V2,V3,V4}
Returns: ok
C-API: void glMultiTexCoord4dv(GLenum target, const GLdouble * v)

multiTexCoord4f(Target, S, T, R, Q)

Args: Target, S, T, R, Q
Returns: ok
C-API: void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)

multiTexCoord4fv(Target, {V1,V2,V3,V4})

Args: Target, {V1,V2,V3,V4}
Returns: ok
C-API: void glMultiTexCoord4fv(GLenum target, const GLfloat * v)

multiTexCoord4i(Target, S, T, R, Q)

Args: Target, S, T, R, Q
Returns: ok
C-API: void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)

multiTexCoord4iv(Target, {V1,V2,V3,V4})

Args: Target, {V1,V2,V3,V4}
Returns: ok
C-API: void glMultiTexCoord4iv(GLenum target, const GLint * v)

multiTexCoord4s(Target, S, T, R, Q)

Args: Target, S, T, R, Q
Returns: ok
C-API: void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)

multiTexCoord4sv(Target, {V1,V2,V3,V4})

Args: Target, {V1,V2,V3,V4}
Returns: ok
C-API: void glMultiTexCoord4sv(GLenum target, const GLshort * v)

loadTransposeMatrixf(M)

Args: <<[M]>>
Returns: ok
C-API: void glLoadTransposeMatrixf( const GLfloat * m)

loadTransposeMatrixd(M)

Args: <<[M]>>
Returns: ok
C-API: void glLoadTransposeMatrixd( const GLdouble * m)

multTransposeMatrixf(M)

Args: <<[M]>>
Returns: ok
C-API: void glMultTransposeMatrixf( const GLfloat * m)

multTransposeMatrixd(M)

Args: <<[M]>>
Returns: ok
C-API: void glMultTransposeMatrixd( const GLdouble * m)

sampleCoverage(Value, Invert)

Args: Value, Invert
Returns: ok
C-API: void glSampleCoverage(GLclampf value, GLboolean invert)

compressedTexImage3D(Target, Level, Internalformat, Width, Height, Depth, Border, ImageSize, Data)

Args: Target, Level, Internalformat, Width, Height, Depth, Border, ImageSize, <<[Data]>>
Returns: ok
C-API: void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data)

compressedTexImage2D(Target, Level, Internalformat, Width, Height, Border, ImageSize, Data)

Args: Target, Level, Internalformat, Width, Height, Border, ImageSize, <<[Data]>>
Returns: ok
C-API: void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data)

compressedTexImage1D(Target, Level, Internalformat, Width, Border, ImageSize, Data)

Args: Target, Level, Internalformat, Width, Border, ImageSize, <<[Data]>>
Returns: ok
C-API: void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data)

compressedTexSubImage3D(Target, Level, Xoffset, Yoffset, Zoffset, Width, Height, Depth, Format, ImageSize, Data)

Args: Target, Level, Xoffset, Yoffset, Zoffset, Width, Height, Depth, Format, ImageSize, <<[Data]>>
Returns: ok
C-API: void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data)

compressedTexSubImage2D(Target, Level, Xoffset, Yoffset, Width, Height, Format, ImageSize, Data)

Args: Target, Level, Xoffset, Yoffset, Width, Height, Format, ImageSize, <<[Data]>>
Returns: ok
C-API: void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data)

compressedTexSubImage1D(Target, Level, Xoffset, Width, Format, ImageSize, Data)

Args: Target, Level, Xoffset, Width, Format, ImageSize, <<[Data]>>
Returns: ok
C-API: void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data)

getCompressedTexImage(Target, Level, #sdlmem{bin=Img})

Args: Target, Level, #sdlmem{} = Img
Returns: ok
C-API: void glGetCompressedTexImage(GLenum target, GLint level, void * img)

blendFuncSeparate(SfactorRGB, DfactorRGB, SfactorAlpha, DfactorAlpha)

Args: SfactorRGB, DfactorRGB, SfactorAlpha, DfactorAlpha
Returns: ok
C-API: void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)

fogCoordf(Coord)

Args: Coord
Returns: ok
C-API: void glFogCoordf(GLfloat coord)

fogCoordfv(Coord)

Args: <<[Coord]>>
Returns: ok
C-API: void glFogCoordfv( const GLfloat * coord)

fogCoordd(Coord)

Args: Coord
Returns: ok
C-API: void glFogCoordd(GLdouble coord)

fogCoorddv(Coord)

Args: <<[Coord]>>
Returns: ok
C-API: void glFogCoorddv( const GLdouble * coord)

fogCoordPointer(Type, Stride, Pointer)

Args: Type, Stride, <<[Pointer]>>
Returns: ok
C-API: void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid * pointer)

multiDrawArrays(Mode, First, Count, Primcount)

Args: Mode, <<[First]>>, <<[Count]>>, Primcount
Returns: ok
C-API: void glMultiDrawArrays(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount)

pointParameterf(Pname, Param)

Args: Pname, Param
Returns: ok
C-API: void glPointParameterf(GLenum pname, GLfloat param)

pointParameterfv(Pname, Params)

Args: Pname, <<[Params]>>
Returns: ok
C-API: void glPointParameterfv(GLenum pname, const GLfloat * params)

pointParameteri(Pname, Param)

Args: Pname, Param
Returns: ok
C-API: void glPointParameteri(GLenum pname, GLint param)

pointParameteriv(Pname, Params)

Args: Pname, <<[Params]>>
Returns: ok
C-API: void glPointParameteriv(GLenum pname, const GLint * params)

secondaryColor3b(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)

secondaryColor3bv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glSecondaryColor3bv( const GLbyte * v)

secondaryColor3d(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)

secondaryColor3dv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glSecondaryColor3dv( const GLdouble * v)

secondaryColor3f(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)

secondaryColor3fv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glSecondaryColor3fv( const GLfloat * v)

secondaryColor3i(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glSecondaryColor3i(GLint red, GLint green, GLint blue)

secondaryColor3iv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glSecondaryColor3iv( const GLint * v)

secondaryColor3s(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)

secondaryColor3sv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glSecondaryColor3sv( const GLshort * v)

secondaryColor3ub(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)

secondaryColor3ubv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glSecondaryColor3ubv( const GLubyte * v)

secondaryColor3ui(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)

secondaryColor3uiv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glSecondaryColor3uiv( const GLuint * v)

secondaryColor3us(Red, Green, Blue)

Args: Red, Green, Blue
Returns: ok
C-API: void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)

secondaryColor3usv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glSecondaryColor3usv( const GLushort * v)

secondaryColorPointer(Size, Type, Stride, Pointer)

Args: Size, Type, Stride, <<[Pointer]>>
Returns: ok
C-API: void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)

windowPos2d(X, Y)

Args: X, Y
Returns: ok
C-API: void glWindowPos2d(GLdouble x, GLdouble y)

windowPos2dv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glWindowPos2dv( const GLdouble * v)

windowPos2f(X, Y)

Args: X, Y
Returns: ok
C-API: void glWindowPos2f(GLfloat x, GLfloat y)

windowPos2fv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glWindowPos2fv( const GLfloat * v)

windowPos2i(X, Y)

Args: X, Y
Returns: ok
C-API: void glWindowPos2i(GLint x, GLint y)

windowPos2iv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glWindowPos2iv( const GLint * v)

windowPos2s(X, Y)

Args: X, Y
Returns: ok
C-API: void glWindowPos2s(GLshort x, GLshort y)

windowPos2sv({V1,V2})

Args: {V1,V2}
Returns: ok
C-API: void glWindowPos2sv( const GLshort * v)

windowPos3d(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)

windowPos3dv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glWindowPos3dv( const GLdouble * v)

windowPos3f(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)

windowPos3fv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glWindowPos3fv( const GLfloat * v)

windowPos3i(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glWindowPos3i(GLint x, GLint y, GLint z)

windowPos3iv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glWindowPos3iv( const GLint * v)

windowPos3s(X, Y, Z)

Args: X, Y, Z
Returns: ok
C-API: void glWindowPos3s(GLshort x, GLshort y, GLshort z)

windowPos3sv({V1,V2,V3})

Args: {V1,V2,V3}
Returns: ok
C-API: void glWindowPos3sv( const GLshort * v)

weightbvARB(Size, Weights)

Args: Size, <<[Weights]>>
Returns: ok
C-API: void glWeightbvARB(GLint size, const GLbyte * weights)

weightsvARB(Size, Weights)

Args: Size, <<[Weights]>>
Returns: ok
C-API: void glWeightsvARB(GLint size, const GLshort * weights)

weightivARB(Size, Weights)

Args: Size, <<[Weights]>>
Returns: ok
C-API: void glWeightivARB(GLint size, const GLint * weights)

weightfvARB(Size, Weights)

Args: Size, <<[Weights]>>
Returns: ok
C-API: void glWeightfvARB(GLint size, const GLfloat * weights)

weightdvARB(Size, Weights)

Args: Size, <<[Weights]>>
Returns: ok
C-API: void glWeightdvARB(GLint size, const GLdouble * weights)

weightubvARB(Size, Weights)

Args: Size, <<[Weights]>>
Returns: ok
C-API: void glWeightubvARB(GLint size, const GLubyte * weights)

weightusvARB(Size, Weights)

Args: Size, <<[Weights]>>
Returns: ok
C-API: void glWeightusvARB(GLint size, const GLushort * weights)

weightuivARB(Size, Weights)

Args: Size, <<[Weights]>>
Returns: ok
C-API: void glWeightuivARB(GLint size, const GLuint * weights)

weightPointerARB(Size, Type, Stride, Pointer)

Args: Size, Type, Stride, <<[Pointer]>>
Returns: ok
C-API: void glWeightPointerARB(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)

vertexBlendARB(Count)

Args: Count
Returns: ok
C-API: void glVertexBlendARB(GLint count)

currentPaletteMatrixARB(Index)

Args: Index
Returns: ok
C-API: void glCurrentPaletteMatrixARB(GLint index)

matrixIndexubvARB(Size, Indices)

Args: Size, <<[Indices]>>
Returns: ok
C-API: void glMatrixIndexubvARB(GLint size, const GLubyte * indices)

matrixIndexusvARB(Size, Indices)

Args: Size, <<[Indices]>>
Returns: ok
C-API: void glMatrixIndexusvARB(GLint size, const GLushort * indices)

matrixIndexuivARB(Size, Indices)

Args: Size, <<[Indices]>>
Returns: ok
C-API: void glMatrixIndexuivARB(GLint size, const GLuint * indices)

matrixIndexPointerARB(Size, Type, Stride, Pointer)

Args: Size, Type, Stride, <<[Pointer]>>
Returns: ok
C-API: void glMatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)

vertexAttrib1dARB(Index, X)

Args: Index, X
Returns: ok
C-API: void glVertexAttrib1dARB(GLuint index, GLdouble x)

vertexAttrib1dvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib1dvARB(GLuint index, const GLdouble * v)

vertexAttrib1fARB(Index, X)

Args: Index, X
Returns: ok
C-API: void glVertexAttrib1fARB(GLuint index, GLfloat x)

vertexAttrib1fvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib1fvARB(GLuint index, const GLfloat * v)

vertexAttrib1sARB(Index, X)

Args: Index, X
Returns: ok
C-API: void glVertexAttrib1sARB(GLuint index, GLshort x)

vertexAttrib1svARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib1svARB(GLuint index, const GLshort * v)

vertexAttrib2dARB(Index, X, Y)

Args: Index, X, Y
Returns: ok
C-API: void glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)

vertexAttrib2dvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib2dvARB(GLuint index, const GLdouble * v)

vertexAttrib2fARB(Index, X, Y)

Args: Index, X, Y
Returns: ok
C-API: void glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)

vertexAttrib2fvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib2fvARB(GLuint index, const GLfloat * v)

vertexAttrib2sARB(Index, X, Y)

Args: Index, X, Y
Returns: ok
C-API: void glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)

vertexAttrib2svARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib2svARB(GLuint index, const GLshort * v)

vertexAttrib3dARB(Index, X, Y, Z)

Args: Index, X, Y, Z
Returns: ok
C-API: void glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z)

vertexAttrib3dvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib3dvARB(GLuint index, const GLdouble * v)

vertexAttrib3fARB(Index, X, Y, Z)

Args: Index, X, Y, Z
Returns: ok
C-API: void glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)

vertexAttrib3fvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib3fvARB(GLuint index, const GLfloat * v)

vertexAttrib3sARB(Index, X, Y, Z)

Args: Index, X, Y, Z
Returns: ok
C-API: void glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)

vertexAttrib3svARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib3svARB(GLuint index, const GLshort * v)

vertexAttrib4NbvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4NbvARB(GLuint index, const GLbyte * v)

vertexAttrib4NivARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4NivARB(GLuint index, const GLint * v)

vertexAttrib4NsvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4NsvARB(GLuint index, const GLshort * v)

vertexAttrib4NubARB(Index, X, Y, Z, W)

Args: Index, X, Y, Z, W
Returns: ok
C-API: void glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)

vertexAttrib4NubvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4NubvARB(GLuint index, const GLubyte * v)

vertexAttrib4NuivARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4NuivARB(GLuint index, const GLuint * v)

vertexAttrib4NusvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4NusvARB(GLuint index, const GLushort * v)

vertexAttrib4bvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4bvARB(GLuint index, const GLbyte * v)

vertexAttrib4dARB(Index, X, Y, Z, W)

Args: Index, X, Y, Z, W
Returns: ok
C-API: void glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)

vertexAttrib4dvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4dvARB(GLuint index, const GLdouble * v)

vertexAttrib4fARB(Index, X, Y, Z, W)

Args: Index, X, Y, Z, W
Returns: ok
C-API: void glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

vertexAttrib4fvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4fvARB(GLuint index, const GLfloat * v)

vertexAttrib4ivARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4ivARB(GLuint index, const GLint * v)

vertexAttrib4sARB(Index, X, Y, Z, W)

Args: Index, X, Y, Z, W
Returns: ok
C-API: void glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)

vertexAttrib4svARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4svARB(GLuint index, const GLshort * v)

vertexAttrib4ubvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4ubvARB(GLuint index, const GLubyte * v)

vertexAttrib4uivARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4uivARB(GLuint index, const GLuint * v)

vertexAttrib4usvARB(Index, V)

Args: Index, <<[V]>>
Returns: ok
C-API: void glVertexAttrib4usvARB(GLuint index, const GLushort * v)

vertexAttribPointerARB(Index, Size, Type, Normalized, Stride, Pointer)

Args: Index, Size, Type, Normalized, Stride, <<[Pointer]>>
Returns: ok
C-API: void glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer)

enableVertexAttribArrayARB(Index)

Args: Index
Returns: ok
C-API: void glEnableVertexAttribArrayARB(GLuint index)

disableVertexAttribArrayARB(Index)

Args: Index
Returns: ok
C-API: void glDisableVertexAttribArrayARB(GLuint index)

programStringARB(Target, Format, Len, String)

Args: Target, Format, Len, <<[String]>>
Returns: ok
C-API: void glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string)

bindProgramARB(Target, Program)

Args: Target, Program
Returns: ok
C-API: void glBindProgramARB(GLenum target, GLuint program)

deleteProgramsARB(N, Programs)

Args: N, <<[Programs]>>
Returns: ok
C-API: void glDeleteProgramsARB(GLsizei n, const GLuint * programs)

genProgramsARB(N)

Args: N
Returns: [Programs]
C-API: void glGenProgramsARB(GLsizei n, GLuint * programs)

programEnvParameter4dARB(Target, Index, X, Y, Z, W)

Args: Target, Index, X, Y, Z, W
Returns: ok
C-API: void glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)

programEnvParameter4dvARB(Target, Index, Params)

Args: Target, Index, <<[Params]>>
Returns: ok
C-API: void glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)

programEnvParameter4fARB(Target, Index, X, Y, Z, W)

Args: Target, Index, X, Y, Z, W
Returns: ok
C-API: void glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

programEnvParameter4fvARB(Target, Index, Params)

Args: Target, Index, <<[Params]>>
Returns: ok
C-API: void glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)

programLocalParameter4dARB(Target, Index, X, Y, Z, W)

Args: Target, Index, X, Y, Z, W
Returns: ok
C-API: void glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)

programLocalParameter4dvARB(Target, Index, Params)

Args: Target, Index, <<[Params]>>
Returns: ok
C-API: void glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)

programLocalParameter4fARB(Target, Index, X, Y, Z, W)

Args: Target, Index, X, Y, Z, W
Returns: ok
C-API: void glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

programLocalParameter4fvARB(Target, Index, Params)

Args: Target, Index, <<[Params]>>
Returns: ok
C-API: void glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)

getProgramEnvParameterdvARB(Target, Index)

Args: Target, Index
Returns: [Params]
C-API: void glGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble * params)

getProgramEnvParameterfvARB(Target, Index)

Args: Target, Index
Returns: [Params]
C-API: void glGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat * params)

getProgramLocalParameterdvARB(Target, Index)

Args: Target, Index
Returns: [Params]
C-API: void glGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble * params)

getProgramLocalParameterfvARB(Target, Index)

Args: Target, Index
Returns: [Params]
C-API: void glGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat * params)

getProgramivARB(Target, Pname)

Args: Target, Pname
Returns: [Params]
C-API: void glGetProgramivARB(GLenum target, GLenum pname, GLint * params)

getProgramStringARB(Target, Pname, #sdlmem{bin=String})

Args: Target, Pname, #sdlmem{} = String
Returns: ok
C-API: void glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)

getVertexAttribdvARB(Index, Pname)

Args: Index, Pname
Returns: [Params]
C-API: void glGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble * params)

getVertexAttribfvARB(Index, Pname)

Args: Index, Pname
Returns: [Params]
C-API: void glGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat * params)

getVertexAttribivARB(Index, Pname)

Args: Index, Pname
Returns: [Params]
C-API: void glGetVertexAttribivARB(GLuint index, GLenum pname, GLint * params)

getVertexAttribPointervARB(Index, Pname)

Args: Index, Pname
Returns: Pointer=#sdlmem{}
C-API: void glGetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid* *pointer)

isProgramARB(Program)

Args: Program
Returns: ?GL_BYTE
C-API: GLboolean glIsProgramARB(GLuint program)