Header File

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, GLvoid * 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)

genQueries(N)

Args: N
Returns: [Ids]
C-API: void glGenQueries(GLsizei n, GLuint * ids)

deleteQueries(N, Ids)

Args: N, <<[Ids]>>
Returns: ok
C-API: void glDeleteQueries(GLsizei n, const GLuint * ids)

isQuery(Id)

Args: Id
Returns: ?GL_BYTE
C-API: GLboolean glIsQuery(GLuint id)

beginQuery(Target, Id)

Args: Target, Id
Returns: ok
C-API: void glBeginQuery(GLenum target, GLuint id)

endQuery(Target)

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

getQueryiv(Target, Pname)

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

getQueryObjectiv(Id, Pname)

Args: Id, Pname
Returns: [Params]
C-API: void glGetQueryObjectiv(GLuint id, GLenum pname, GLint * params)

getQueryObjectuiv(Id, Pname)

Args: Id, Pname
Returns: [Params]
C-API: void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint * params)

bindBuffer(Target, Buffer)

Args: Target, Buffer
Returns: ok
C-API: void glBindBuffer(GLenum target, GLuint buffer)

deleteBuffers(N, Buffers)

Args: N, <<[Buffers]>>
Returns: ok
C-API: void glDeleteBuffers(GLsizei n, const GLuint * buffers)

genBuffers(N)

Args: N
Returns: [Buffers]
C-API: void glGenBuffers(GLsizei n, GLuint * buffers)

isBuffer(Buffer)

Args: Buffer
Returns: ?GL_BYTE
C-API: GLboolean glIsBuffer(GLuint buffer)

bufferData(Target, Size, Data, Usage)

Args: Target, Size, <<[Data]>>, Usage
Returns: ok
C-API: void glBufferData(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage)

bufferSubData(Target, Offset, Size, Data)

Args: Target, Offset, Size, <<[Data]>>
Returns: ok
C-API: void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data)

getBufferSubData(Target, Offset, Size, #sdlmem{bin=Data})

Args: Target, Offset, Size, #sdlmem{} = Data
Returns: ok
C-API: void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data)

unmapBuffer(Target)

Args: Target
Returns: ?GL_BYTE
C-API: GLboolean glUnmapBuffer(GLenum target)

getBufferParameteriv(Target, Pname)

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

getBufferPointerv(Target, Pname)

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

blendEquationSeparate(ModeRGB, ModeAlpha)

Args: ModeRGB, ModeAlpha
Returns: ok
C-API: void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)

drawBuffers(N, Bufs)

Args: N, <<[Bufs]>>
Returns: ok
C-API: void glDrawBuffers(GLsizei n, const GLenum * bufs)

stencilOpSeparate(Face, Sfail, Dpfail, Dppass)

Args: Face, Sfail, Dpfail, Dppass
Returns: ok
C-API: void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)

stencilFuncSeparate(Frontfunc, Backfunc, Ref, Mask)

Args: Frontfunc, Backfunc, Ref, Mask
Returns: ok
C-API: void glStencilFuncSeparate(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)

stencilMaskSeparate(Face, Mask)

Args: Face, Mask
Returns: ok
C-API: void glStencilMaskSeparate(GLenum face, GLuint mask)

attachShader(Program, Shader)

Args: Program, Shader
Returns: ok
C-API: void glAttachShader(GLuint program, GLuint shader)

bindAttribLocation(Program, Index, Name)

Args: Program, Index, <<[Name]>>
Returns: ok
C-API: void glBindAttribLocation(GLuint program, GLuint index, const GLchar * name)

compileShader(Shader)

Args: Shader
Returns: ok
C-API: void glCompileShader(GLuint shader)

createProgram()

Returns: ?GL_UNSIGNED_INT
C-API: GLuint glCreateProgram()

createShader(Type)

Args: Type
Returns: ?GL_UNSIGNED_INT
C-API: GLuint glCreateShader(GLenum type)

deleteProgram(Program)

Args: Program
Returns: ok
C-API: void glDeleteProgram(GLuint program)

deleteShader(Shader)

Args: Shader
Returns: ok
C-API: void glDeleteShader(GLuint shader)

detachShader(Program, Shader)

Args: Program, Shader
Returns: ok
C-API: void glDetachShader(GLuint program, GLuint shader)

disableVertexAttribArray(Index)

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

enableVertexAttribArray(Index)

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

getActiveAttrib(Program, Index, BufSize)

Args: Program, Index, BufSize
Returns: {[Length], [Size], [Type], [Name]}
C-API: void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name)

getActiveUniform(Program, Index, BufSize)

Args: Program, Index, BufSize
Returns: {[Length], [Size], [Type], [Name]}
C-API: void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name)

getAttachedShaders(Program, MaxCount)

Args: Program, MaxCount
Returns: {[Count], [Obj]}
C-API: void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * obj)

getAttribLocation(Program, Name)

Args: Program, <<[Name]>>
Returns: ?GL_INT
C-API: GLint glGetAttribLocation(GLuint program, const GLchar * name)

getProgramiv(Program, Pname)

Args: Program, Pname
Returns: [Params]
C-API: void glGetProgramiv(GLuint program, GLenum pname, GLint * params)

getProgramInfoLog(Program, BufSize)

Args: Program, BufSize
Returns: {[Length], [InfoLog]}
C-API: void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog)

getShaderiv(Shader, Pname)

Args: Shader, Pname
Returns: [Params]
C-API: void glGetShaderiv(GLuint shader, GLenum pname, GLint * params)

getShaderInfoLog(Shader, BufSize)

Args: Shader, BufSize
Returns: {[Length], [InfoLog]}
C-API: void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog)

getShaderSource(Shader, BufSize)

Args: Shader, BufSize
Returns: {[Length], [Source]}
C-API: void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source)

getUniformLocation(Program, Name)

Args: Program, <<[Name]>>
Returns: ?GL_INT
C-API: GLint glGetUniformLocation(GLuint program, const GLchar * name)

getUniformfv(Program, Location, #sdlmem{bin=Params})

Args: Program, Location, #sdlmem{} = Params
Returns: ok
C-API: void glGetUniformfv(GLuint program, GLint location, GLfloat * params)

getUniformiv(Program, Location, #sdlmem{bin=Params})

Args: Program, Location, #sdlmem{} = Params
Returns: ok
C-API: void glGetUniformiv(GLuint program, GLint location, GLint * params)

getVertexAttribdv(Index, Pname)

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

getVertexAttribfv(Index, Pname)

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

getVertexAttribiv(Index, Pname)

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

getVertexAttribPointerv(Index, Pname)

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

isProgram(Program)

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

isShader(Shader)

Args: Shader
Returns: ?GL_BYTE
C-API: GLboolean glIsShader(GLuint shader)

linkProgram(Program)

Args: Program
Returns: ok
C-API: void glLinkProgram(GLuint program)

shaderSource(Shader, Count, String, Length)

Args: Shader, Count, <<[Length]>>
Returns: ok
C-API: void glShaderSource(GLuint shader, GLsizei count, const GLchar* *string, const GLint * length)

useProgram(Program)

Args: Program
Returns: ok
C-API: void glUseProgram(GLuint program)

uniform1f(Location, V0)

Args: Location, V0
Returns: ok
C-API: void glUniform1f(GLint location, GLfloat v0)

uniform2f(Location, V0, V1)

Args: Location, V0, V1
Returns: ok
C-API: void glUniform2f(GLint location, GLfloat v0, GLfloat v1)

uniform3f(Location, V0, V1, V2)

Args: Location, V0, V1, V2
Returns: ok
C-API: void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)

uniform4f(Location, V0, V1, V2, V3)

Args: Location, V0, V1, V2, V3
Returns: ok
C-API: void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)

uniform1i(Location, V0)

Args: Location, V0
Returns: ok
C-API: void glUniform1i(GLint location, GLint v0)

uniform2i(Location, V0, V1)

Args: Location, V0, V1
Returns: ok
C-API: void glUniform2i(GLint location, GLint v0, GLint v1)

uniform3i(Location, V0, V1, V2)

Args: Location, V0, V1, V2
Returns: ok
C-API: void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)

uniform4i(Location, V0, V1, V2, V3)

Args: Location, V0, V1, V2, V3
Returns: ok
C-API: void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)

uniform1fv(Location, Count, Value)

Args: Location, Count, [Value1]
Returns: ok
C-API: void glUniform1fv(GLint location, GLsizei count, const GLfloat * value)

uniform2fv(Location, Count, Value)

Args: Location, Count, [{Value1,Value2}]
Returns: ok
C-API: void glUniform2fv(GLint location, GLsizei count, const GLfloat * value)

uniform3fv(Location, Count, Value)

Args: Location, Count, [{Value1,Value2,Value3}]
Returns: ok
C-API: void glUniform3fv(GLint location, GLsizei count, const GLfloat * value)

uniform4fv(Location, Count, Value)

Args: Location, Count, [{Value1,Value2,Value3,Value4}]
Returns: ok
C-API: void glUniform4fv(GLint location, GLsizei count, const GLfloat * value)

uniform1iv(Location, Count, Value)

Args: Location, Count, [Value1]
Returns: ok
C-API: void glUniform1iv(GLint location, GLsizei count, const GLint * value)

uniform2iv(Location, Count, Value)

Args: Location, Count, [{Value1,Value2}]
Returns: ok
C-API: void glUniform2iv(GLint location, GLsizei count, const GLint * value)

uniform3iv(Location, Count, Value)

Args: Location, Count, [{Value1,Value2,Value3}]
Returns: ok
C-API: void glUniform3iv(GLint location, GLsizei count, const GLint * value)

uniform4iv(Location, Count, Value)

Args: Location, Count, [{Value1,Value2,Value3,Value4}]
Returns: ok
C-API: void glUniform4iv(GLint location, GLsizei count, const GLint * value)

uniformMatrix2fv(Location, Count, Transpose, Value)

Args: Location, Count, Transpose, [{Value1,Value2,Value3,Value4}]
Returns: ok
C-API: void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)

uniformMatrix3fv(Location, Count, Transpose, Value)

Args: Location, Count, Transpose, [{Value1,Value2,Value3,Value4,Value5,Value6,Value7,Value8,Value9}]
Returns: ok
C-API: void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)

uniformMatrix4fv(Location, Count, Transpose, Value)

Args: Location, Count, Transpose, [{Value1,Value2,Value3,Value4,Value5,Value6,Value7,Value8,Value9,Value10,Value11,Value12,Value13,Value14,Value15,Value16}]
Returns: ok
C-API: void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)

validateProgram(Program)

Args: Program
Returns: ok
C-API: void glValidateProgram(GLuint program)

vertexAttrib1d(Index, X)

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

vertexAttrib1dv(Index, {V1})

Args: Index, {V1}
Returns: ok
C-API: void glVertexAttrib1dv(GLuint index, const GLdouble * v)

vertexAttrib1f(Index, X)

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

vertexAttrib1fv(Index, {V1})

Args: Index, {V1}
Returns: ok
C-API: void glVertexAttrib1fv(GLuint index, const GLfloat * v)

vertexAttrib1s(Index, X)

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

vertexAttrib1sv(Index, {V1})

Args: Index, {V1}
Returns: ok
C-API: void glVertexAttrib1sv(GLuint index, const GLshort * v)

vertexAttrib2d(Index, X, Y)

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

vertexAttrib2dv(Index, {V1,V2})

Args: Index, {V1,V2}
Returns: ok
C-API: void glVertexAttrib2dv(GLuint index, const GLdouble * v)

vertexAttrib2f(Index, X, Y)

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

vertexAttrib2fv(Index, {V1,V2})

Args: Index, {V1,V2}
Returns: ok
C-API: void glVertexAttrib2fv(GLuint index, const GLfloat * v)

vertexAttrib2s(Index, X, Y)

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

vertexAttrib2sv(Index, {V1,V2})

Args: Index, {V1,V2}
Returns: ok
C-API: void glVertexAttrib2sv(GLuint index, const GLshort * v)

vertexAttrib3d(Index, X, Y, Z)

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

vertexAttrib3dv(Index, {V1,V2,V3})

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

vertexAttrib3f(Index, X, Y, Z)

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

vertexAttrib3fv(Index, {V1,V2,V3})

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

vertexAttrib3s(Index, X, Y, Z)

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

vertexAttrib3sv(Index, {V1,V2,V3})

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

vertexAttrib4Nbv(Index, V)

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

vertexAttrib4Niv(Index, V)

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

vertexAttrib4Nsv(Index, V)

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

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

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

vertexAttrib4Nubv(Index, V)

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

vertexAttrib4Nuiv(Index, V)

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

vertexAttrib4Nusv(Index, V)

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

vertexAttrib4bv(Index, {V1,V2,V3,V4})

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

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

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

vertexAttrib4dv(Index, {V1,V2,V3,V4})

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

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

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

vertexAttrib4fv(Index, {V1,V2,V3,V4})

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

vertexAttrib4iv(Index, {V1,V2,V3,V4})

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

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

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

vertexAttrib4sv(Index, {V1,V2,V3,V4})

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

vertexAttrib4ubv(Index, {V1,V2,V3,V4})

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

vertexAttrib4uiv(Index, {V1,V2,V3,V4})

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

vertexAttrib4usv(Index, {V1,V2,V3,V4})

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

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

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

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)

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)

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

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

deleteObjectARB(Obj)

Args: Obj
Returns: ok
C-API: void glDeleteObjectARB(GLhandleARB obj)

getHandleARB(Pname)

Args: Pname
Returns: ?GL_UNSIGNED_INT
C-API: GLhandleARB glGetHandleARB(GLenum pname)

detachObjectARB(ContainerObj, AttachedObj)

Args: ContainerObj, AttachedObj
Returns: ok
C-API: void glDetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj)

createShaderObjectARB(ShaderType)

Args: ShaderType
Returns: ?GL_UNSIGNED_INT
C-API: GLhandleARB glCreateShaderObjectARB(GLenum shaderType)

createProgramObjectARB()

Returns: ?GL_UNSIGNED_INT
C-API: GLhandleARB glCreateProgramObjectARB()

attachObjectARB(ContainerObj, Obj)

Args: ContainerObj, Obj
Returns: ok
C-API: void glAttachObjectARB(GLhandleARB containerObj, GLhandleARB obj)

useProgramObjectARB(ProgramObj)

Args: ProgramObj
Returns: ok
C-API: void glUseProgramObjectARB(GLhandleARB programObj)

getObjectParameterfvARB(Obj, Pname)

Args: Obj, Pname
Returns: [Params]
C-API: void glGetObjectParameterfvARB(GLhandleARB obj, GLenum pname, GLfloat * params)

getObjectParameterivARB(Obj, Pname)

Args: Obj, Pname
Returns: [Params]
C-API: void glGetObjectParameterivARB(GLhandleARB obj, GLenum pname, GLint * params)

getInfoLogARB(Obj, MaxLength)

Args: Obj, MaxLength
Returns: {[Length], [InfoLog]}
C-API: void glGetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog)

getAttachedObjectsARB(ContainerObj, MaxCount)

Args: ContainerObj, MaxCount
Returns: {[Count], [Obj]}
C-API: void glGetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei * count, GLhandleARB * obj)

stencilOpSeparateATI(Face, Sfail, Dpfail, Dppass)

Args: Face, Sfail, Dpfail, Dppass
Returns: ok
C-API: void glStencilOpSeparateATI(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)

stencilFuncSeparateATI(Frontfunc, Backfunc, Ref, Mask)

Args: Frontfunc, Backfunc, Ref, Mask
Returns: ok
C-API: void glStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)

isRenderbufferEXT(Renderbuffer)

Args: Renderbuffer
Returns: ?GL_BYTE
C-API: GLboolean glIsRenderbufferEXT(GLuint renderbuffer)

bindRenderbufferEXT(Target, Renderbuffer)

Args: Target, Renderbuffer
Returns: ok
C-API: void glBindRenderbufferEXT(GLenum target, GLuint renderbuffer)

deleteRenderbuffersEXT(N, Renderbuffers)

Args: N, <<[Renderbuffers]>>
Returns: ok
C-API: void glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers)

genRenderbuffersEXT(N)

Args: N
Returns: [Renderbuffers]
C-API: void glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers)

renderbufferStorageEXT(Target, Internalformat, Width, Height)

Args: Target, Internalformat, Width, Height
Returns: ok
C-API: void glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)

getRenderbufferParameterivEXT(Target, Pname)

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

isFramebufferEXT(Framebuffer)

Args: Framebuffer
Returns: ?GL_BYTE
C-API: GLboolean glIsFramebufferEXT(GLuint framebuffer)

bindFramebufferEXT(Target, Framebuffer)

Args: Target, Framebuffer
Returns: ok
C-API: void glBindFramebufferEXT(GLenum target, GLuint framebuffer)

deleteFramebuffersEXT(N, Framebuffers)

Args: N, <<[Framebuffers]>>
Returns: ok
C-API: void glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers)

genFramebuffersEXT(N)

Args: N
Returns: [Framebuffers]
C-API: void glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers)

checkFramebufferStatusEXT(Target)

Args: Target
Returns: ?GL_INT
C-API: GLenum glCheckFramebufferStatusEXT(GLenum target)

framebufferTexture1DEXT(Target, Attachment, Textarget, Texture, Level)

Args: Target, Attachment, Textarget, Texture, Level
Returns: ok
C-API: void glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)

framebufferTexture2DEXT(Target, Attachment, Textarget, Texture, Level)

Args: Target, Attachment, Textarget, Texture, Level
Returns: ok
C-API: void glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)

framebufferTexture3DEXT(Target, Attachment, Textarget, Texture, Level, Zoffset)

Args: Target, Attachment, Textarget, Texture, Level, Zoffset
Returns: ok
C-API: void glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)

framebufferRenderbufferEXT(Target, Attachment, Renderbuffertarget, Renderbuffer)

Args: Target, Attachment, Renderbuffertarget, Renderbuffer
Returns: ok
C-API: void glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)

getFramebufferAttachmentParameterivEXT(Target, Attachment, Pname)

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

generateMipmapEXT(Target)

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