accum(Op, Value)
alphaFunc(Func, Ref)
areTexturesResident(N, Textures)
arrayElement(I)
'begin'(Mode)
bindTexture(Target, Texture)
bitmap(Width, Height, Xorig, Yorig, Xmove, Ymove, Bitmap)
blendFunc(Sfactor, Dfactor)
callList(List)
callLists(N, Type, Lists)
clear(Mask)
clearAccum(Red, Green, Blue, Alpha)
clearColor(Red, Green, Blue, Alpha)
clearDepth(Depth)
clearIndex(C)
clearStencil(S)
clipPlane(Plane, Equation)
color3b(Red, Green, Blue)
color3bv({V1,V2,V3})
color3d(Red, Green, Blue)
color3dv({V1,V2,V3})
color3f(Red, Green, Blue)
color3fv({V1,V2,V3})
color3i(Red, Green, Blue)
color3iv({V1,V2,V3})
color3s(Red, Green, Blue)
color3sv({V1,V2,V3})
color3ub(Red, Green, Blue)
color3ubv({V1,V2,V3})
color3ui(Red, Green, Blue)
color3uiv({V1,V2,V3})
color3us(Red, Green, Blue)
color3usv({V1,V2,V3})
color4b(Red, Green, Blue, Alpha)
color4bv({V1,V2,V3,V4})
color4d(Red, Green, Blue, Alpha)
color4dv({V1,V2,V3,V4})
color4f(Red, Green, Blue, Alpha)
color4fv({V1,V2,V3,V4})
color4i(Red, Green, Blue, Alpha)
color4iv({V1,V2,V3,V4})
color4s(Red, Green, Blue, Alpha)
color4sv({V1,V2,V3,V4})
color4ub(Red, Green, Blue, Alpha)
color4ubv({V1,V2,V3,V4})
color4ui(Red, Green, Blue, Alpha)
color4uiv({V1,V2,V3,V4})
color4us(Red, Green, Blue, Alpha)
color4usv({V1,V2,V3,V4})
colorMask(Red, Green, Blue, Alpha)
colorMaterial(Face, Mode)
colorPointer(Size, Type, Stride, Pointer)
copyPixels(X, Y, Width, Height, Type)
copyTexImage1D(Target, Level, Internalformat, X, Y, Width, Border)
copyTexImage2D(Target, Level, Internalformat, X, Y, Width, Height, Border)
copyTexSubImage1D(Target, Level, Xoffset, X, Y, Width)
copyTexSubImage2D(Target, Level, Xoffset, Yoffset, X, Y, Width, Height)
cullFace(Mode)
deleteLists(List, Range)
deleteTextures(N, Textures)
depthFunc(Func)
depthMask(Flag)
depthRange(ZNear, ZFar)
disable(Cap)
disableClientState(Array)
drawArrays(Mode, First, Count)
drawBuffer(Mode)
drawElements(Mode, Count, Type, Indices)
drawPixels(Width, Height, Format, Type, Pixels)
edgeFlag(Flag)
edgeFlagPointer(Stride, Pointer)
edgeFlagv(Flag)
enable(Cap)
enableClientState(Array)
'end'()
endList()
evalCoord1d(U)
evalCoord1dv({U1})
evalCoord1f(U)
evalCoord1fv({U1})
evalCoord2d(U, V)
evalCoord2dv({U1,U2})
evalCoord2f(U, V)
evalCoord2fv({U1,U2})
evalMesh1(Mode, I1, I2)
evalMesh2(Mode, I1, I2, J1, J2)
evalPoint1(I)
evalPoint2(I, J)
feedbackBuffer(Size, Type, #sdlmem{bin=Buffer})
finish()
flush()
fogf(Pname, Param)
fogfv(Pname, Params)
fogi(Pname, Param)
fogiv(Pname, Params)
frontFace(Mode)
frustum(Left, Right, Bottom, Top, ZNear, ZFar)
genLists(Range)
genTextures(N)
getBooleanv(Pname)
getClipPlane(Plane)
getDoublev(Pname)
getError()
getFloatv(Pname)
getIntegerv(Pname)
getLightfv(Light, Pname)
getLightiv(Light, Pname)
getMapdv(Target, Query, #sdlmem{bin=V})
getMapfv(Target, Query, #sdlmem{bin=V})
getMapiv(Target, Query, #sdlmem{bin=V})
getMaterialfv(Face, Pname)
getMaterialiv(Face, Pname)
getPixelMapfv(Map, #sdlmem{bin=Values})
getPixelMapuiv(Map, #sdlmem{bin=Values})
getPixelMapusv(Map, #sdlmem{bin=Values})
getPointerv(Pname)
getPolygonStipple()
getString(Name)
getTexEnvfv(Target, Pname)
getTexEnviv(Target, Pname)
getTexGendv(Coord, Pname)
getTexGenfv(Coord, Pname)
getTexGeniv(Coord, Pname)
getTexImage(Target, Level, Format, Type, #sdlmem{bin=Pixels})
getTexLevelParameterfv(Target, Level, Pname)
getTexLevelParameteriv(Target, Level, Pname) Args: Op, Value
Returns: ok
C-API: void glAccum(GLenum op, GLfloat value)
Args: Func, Ref
Returns: ok
C-API: void glAlphaFunc(GLenum func, GLclampf ref)
Args: N, <<[Textures]>>
Returns: {?GL_BYTE, [Residences]}
C-API: GLboolean glAreTexturesResident(GLsizei n, const GLuint * textures, GLboolean * residences)
Args: I
Returns: ok
C-API: void glArrayElement(GLint i)
Args: Mode
Returns: ok
C-API: void glBegin(GLenum mode)
Args: Target, Texture
Returns: ok
C-API: void glBindTexture(GLenum target, GLuint texture)
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)
Args: Sfactor, Dfactor
Returns: ok
C-API: void glBlendFunc(GLenum sfactor, GLenum dfactor)
Args: List
Returns: ok
C-API: void glCallList(GLuint list)
Args: N, Type, <<[Lists]>>
Returns: ok
C-API: void glCallLists(GLsizei n, GLenum type, const GLvoid * lists)
Args: Mask
Returns: ok
C-API: void glClear(GLbitfield mask)
Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
Args: Depth
Returns: ok
C-API: void glClearDepth(GLclampd depth)
Args: C
Returns: ok
C-API: void glClearIndex(GLfloat c)
Args: S
Returns: ok
C-API: void glClearStencil(GLint s)
Args: Plane, <<[Equation]>>
Returns: ok
C-API: void glClipPlane(GLenum plane, const GLdouble * equation)
Args: Red, Green, Blue
Returns: ok
C-API: void glColor3b(GLbyte red, GLbyte green, GLbyte blue)
Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3bv( const GLbyte * v)
Args: Red, Green, Blue
Returns: ok
C-API: void glColor3d(GLdouble red, GLdouble green, GLdouble blue)
Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3dv( const GLdouble * v)
Args: Red, Green, Blue
Returns: ok
C-API: void glColor3f(GLfloat red, GLfloat green, GLfloat blue)
Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3fv( const GLfloat * v)
Args: Red, Green, Blue
Returns: ok
C-API: void glColor3i(GLint red, GLint green, GLint blue)
Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3iv( const GLint * v)
Args: Red, Green, Blue
Returns: ok
C-API: void glColor3s(GLshort red, GLshort green, GLshort blue)
Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3sv( const GLshort * v)
Args: Red, Green, Blue
Returns: ok
C-API: void glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3ubv( const GLubyte * v)
Args: Red, Green, Blue
Returns: ok
C-API: void glColor3ui(GLuint red, GLuint green, GLuint blue)
Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3uiv( const GLuint * v)
Args: Red, Green, Blue
Returns: ok
C-API: void glColor3us(GLushort red, GLushort green, GLushort blue)
Args: {V1,V2,V3}
Returns: ok
C-API: void glColor3usv( const GLushort * v)
Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4bv( const GLbyte * v)
Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4dv( const GLdouble * v)
Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4fv( const GLfloat * v)
Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4iv( const GLint * v)
Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4sv( const GLshort * v)
Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4ubv( const GLubyte * v)
Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4uiv( const GLuint * v)
Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
Args: {V1,V2,V3,V4}
Returns: ok
C-API: void glColor4usv( const GLushort * v)
Args: Red, Green, Blue, Alpha
Returns: ok
C-API: void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
Args: Face, Mode
Returns: ok
C-API: void glColorMaterial(GLenum face, GLenum mode)
Args: Size, Type, Stride, <<[Pointer]>>
Returns: ok
C-API: void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
Args: X, Y, Width, Height, Type
Returns: ok
C-API: void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
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)
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)
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)
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)
Args: Mode
Returns: ok
C-API: void glCullFace(GLenum mode)
Args: List, Range
Returns: ok
C-API: void glDeleteLists(GLuint list, GLsizei range)
Args: N, <<[Textures]>>
Returns: ok
C-API: void glDeleteTextures(GLsizei n, const GLuint * textures)
Args: Func
Returns: ok
C-API: void glDepthFunc(GLenum func)
Args: Flag
Returns: ok
C-API: void glDepthMask(GLboolean flag)
Args: ZNear, ZFar
Returns: ok
C-API: void glDepthRange(GLclampd zNear, GLclampd zFar)
Args: Cap
Returns: ok
C-API: void glDisable(GLenum cap)
Args: Array
Returns: ok
C-API: void glDisableClientState(GLenum array)
Args: Mode, First, Count
Returns: ok
C-API: void glDrawArrays(GLenum mode, GLint first, GLsizei count)
Args: Mode
Returns: ok
C-API: void glDrawBuffer(GLenum mode)
Args: Mode, Count, Type, <<[Indices]>>
Returns: ok
C-API: void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices)
Args: Width, Height, Format, Type, <<[Pixels]>>
Returns: ok
C-API: void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
Args: Flag
Returns: ok
C-API: void glEdgeFlag(GLboolean flag)
Args: Stride, <<[Pointer]>>
Returns: ok
C-API: void glEdgeFlagPointer(GLsizei stride, const GLboolean * pointer)
Args: <<[Flag]>>
Returns: ok
C-API: void glEdgeFlagv( const GLboolean * flag)
Args: Cap
Returns: ok
C-API: void glEnable(GLenum cap)
Args: Array
Returns: ok
C-API: void glEnableClientState(GLenum array)
Returns: ok
C-API: void glEnd()
Returns: ok
C-API: void glEndList()
Args: U
Returns: ok
C-API: void glEvalCoord1d(GLdouble u)
Args: {U1}
Returns: ok
C-API: void glEvalCoord1dv( const GLdouble * u)
Args: U
Returns: ok
C-API: void glEvalCoord1f(GLfloat u)
Args: {U1}
Returns: ok
C-API: void glEvalCoord1fv( const GLfloat * u)
Args: U, V
Returns: ok
C-API: void glEvalCoord2d(GLdouble u, GLdouble v)
Args: {U1,U2}
Returns: ok
C-API: void glEvalCoord2dv( const GLdouble * u)
Args: U, V
Returns: ok
C-API: void glEvalCoord2f(GLfloat u, GLfloat v)
Args: {U1,U2}
Returns: ok
C-API: void glEvalCoord2fv( const GLfloat * u)
Args: Mode, I1, I2
Returns: ok
C-API: void glEvalMesh1(GLenum mode, GLint i1, GLint i2)
Args: Mode, I1, I2, J1, J2
Returns: ok
C-API: void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
Args: I
Returns: ok
C-API: void glEvalPoint1(GLint i)
Args: I, J
Returns: ok
C-API: void glEvalPoint2(GLint i, GLint j)
Args: Size, Type, #sdlmem{} = Buffer
Returns: ok
C-API: void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat * buffer)
Returns: ok
C-API: void glFinish()
Returns: ok
C-API: void glFlush()
Args: Pname, Param
Returns: ok
C-API: void glFogf(GLenum pname, GLfloat param)
Args: Pname, <<[Params]>>
Returns: ok
C-API: void glFogfv(GLenum pname, const GLfloat * params)
Args: Pname, Param
Returns: ok
C-API: void glFogi(GLenum pname, GLint param)
Args: Pname, <<[Params]>>
Returns: ok
C-API: void glFogiv(GLenum pname, const GLint * params)
Args: Mode
Returns: ok
C-API: void glFrontFace(GLenum mode)
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)
Args: Range
Returns: ?GL_UNSIGNED_INT
C-API: GLuint glGenLists(GLsizei range)
Args: N
Returns: [Textures]
C-API: void glGenTextures(GLsizei n, GLuint * textures)
Args: Pname
Returns: [Params]
C-API: void glGetBooleanv(GLenum pname, GLboolean * params)
Args: Plane
Returns: [Equation]
C-API: void glGetClipPlane(GLenum plane, GLdouble * equation)
Args: Pname
Returns: [Params]
C-API: void glGetDoublev(GLenum pname, GLdouble * params)
Returns: ?GL_INT
C-API: GLenum glGetError()
Args: Pname
Returns: [Params]
C-API: void glGetFloatv(GLenum pname, GLfloat * params)
Args: Pname
Returns: [Params]
C-API: void glGetIntegerv(GLenum pname, GLint * params)
Args: Light, Pname
Returns: [Params]
C-API: void glGetLightfv(GLenum light, GLenum pname, GLfloat * params)
Args: Light, Pname
Returns: [Params]
C-API: void glGetLightiv(GLenum light, GLenum pname, GLint * params)
Args: Target, Query, #sdlmem{} = V
Returns: ok
C-API: void glGetMapdv(GLenum target, GLenum query, GLdouble * v)
Args: Target, Query, #sdlmem{} = V
Returns: ok
C-API: void glGetMapfv(GLenum target, GLenum query, GLfloat * v)
Args: Target, Query, #sdlmem{} = V
Returns: ok
C-API: void glGetMapiv(GLenum target, GLenum query, GLint * v)
Args: Face, Pname
Returns: [Params]
C-API: void glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
Args: Face, Pname
Returns: [Params]
C-API: void glGetMaterialiv(GLenum face, GLenum pname, GLint * params)
Args: Map, #sdlmem{} = Values
Returns: ok
C-API: void glGetPixelMapfv(GLenum map, GLfloat * values)
Args: Map, #sdlmem{} = Values
Returns: ok
C-API: void glGetPixelMapuiv(GLenum map, GLuint * values)
Args: Map, #sdlmem{} = Values
Returns: ok
C-API: void glGetPixelMapusv(GLenum map, GLushort * values)
Args: Pname
Returns: Params=#sdlmem{}
C-API: void glGetPointerv(GLenum pname, GLvoid* *params)
Returns: [Mask]
C-API: void glGetPolygonStipple(GLubyte * mask)
Args: Name
Returns: [?GL_UNSIGNED_BYTE]
C-API: GLubyte* glGetString(GLenum name)
Args: Target, Pname
Returns: [Params]
C-API: void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
Args: Target, Pname
Returns: [Params]
C-API: void glGetTexEnviv(GLenum target, GLenum pname, GLint * params)
Args: Coord, Pname
Returns: [Params]
C-API: void glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
Args: Coord, Pname
Returns: [Params]
C-API: void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
Args: Coord, Pname
Returns: [Params]
C-API: void glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
Args: Target, Level, Format, Type, #sdlmem{} = Pixels
Returns: ok
C-API: void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels)
Args: Target, Level, Pname
Returns: [Params]
C-API: void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params)
Args: Target, Level, Pname
Returns: [Params]
C-API: void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params)