Header File

The header file may include additional information gl.hrl

Exports

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)

getTexParameterfv(Target, Pname)

getTexParameteriv(Target, Pname)

hint(Target, Mode)

indexMask(Mask)

indexPointer(Type, Stride, Pointer)

indexd(C)

indexdv(C)

indexf(C)

indexfv(C)

indexi(C)

indexiv(C)

indexs(C)

indexsv(C)

indexub(C)

indexubv(C)

initNames()

interleavedArrays(Format, Stride, Pointer)

isEnabled(Cap)

isList(List)

isTexture(Texture)

lightModelf(Pname, Param)

lightModelfv(Pname, Params)

lightModeli(Pname, Param)

lightModeliv(Pname, Params)

lightf(Light, Pname, Param)

lightfv(Light, Pname, Params)

lighti(Light, Pname, Param)

lightiv(Light, Pname, Params)

lineStipple(Factor, Pattern)

lineWidth(Width)

listBase(Base)

loadIdentity()

loadMatrixd(M)

loadMatrixf(M)

loadName(Name)

logicOp(Opcode)

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

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

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

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

mapGrid1d(Un, U1, U2)

mapGrid1f(Un, U1, U2)

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

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

materialf(Face, Pname, Param)

materialfv(Face, Pname, Params)

materiali(Face, Pname, Param)

materialiv(Face, Pname, Params)

matrixMode(Mode)

multMatrixd(M)

multMatrixf(M)

newList(List, Mode)

normal3b(Nx, Ny, Nz)

normal3bv({V1,V2,V3})

normal3d(Nx, Ny, Nz)

normal3dv({V1,V2,V3})

normal3f(Nx, Ny, Nz)

normal3fv({V1,V2,V3})

normal3i(Nx, Ny, Nz)

normal3iv({V1,V2,V3})

normal3s(Nx, Ny, Nz)

normal3sv({V1,V2,V3})

normalPointer(Type, Stride, Pointer)

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

passThrough(Token)

pixelMapfv(Map, Mapsize, Values)

pixelMapuiv(Map, Mapsize, Values)

pixelMapusv(Map, Mapsize, Values)

pixelStoref(Pname, Param)

pixelStorei(Pname, Param)

pixelTransferf(Pname, Param)

pixelTransferi(Pname, Param)

pixelZoom(Xfactor, Yfactor)

pointSize(Size)

polygonMode(Face, Mode)

polygonOffset(Factor, Units)

polygonStipple(Mask)

popAttrib()

popClientAttrib()

popMatrix()

popName()

prioritizeTextures(N, Textures, Priorities)

pushAttrib(Mask)

pushClientAttrib(Mask)

pushMatrix()

pushName(Name)

rasterPos2d(X, Y)

rasterPos2dv({V1,V2})

rasterPos2f(X, Y)

rasterPos2fv({V1,V2})

rasterPos2i(X, Y)

rasterPos2iv({V1,V2})

rasterPos2s(X, Y)

rasterPos2sv({V1,V2})

rasterPos3d(X, Y, Z)

rasterPos3dv({V1,V2,V3})

rasterPos3f(X, Y, Z)

rasterPos3fv({V1,V2,V3})

rasterPos3i(X, Y, Z)

rasterPos3iv({V1,V2,V3})

rasterPos3s(X, Y, Z)

rasterPos3sv({V1,V2,V3})

rasterPos4d(X, Y, Z, W)

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

rasterPos4f(X, Y, Z, W)

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

rasterPos4i(X, Y, Z, W)

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

rasterPos4s(X, Y, Z, W)

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

readBuffer(Mode)

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

rectd(X1, Y1, X2, Y2)

rectdv(V1, V2)

rectf(X1, Y1, X2, Y2)

rectfv(V1, V2)

recti(X1, Y1, X2, Y2)

rectiv(V1, V2)

rects(X1, Y1, X2, Y2)

rectsv(V1, V2)

renderMode(Mode)

rotated(Angle, X, Y, Z)

rotatef(Angle, X, Y, Z)

scaled(X, Y, Z)

scalef(X, Y, Z)

scissor(X, Y, Width, Height)

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

shadeModel(Mode)

stencilFunc(Func, Ref, Mask)

stencilMask(Mask)

stencilOp(Fail, Zfail, Zpass)

texCoord1d(S)

texCoord1dv({V1})

texCoord1f(S)

texCoord1fv({V1})

texCoord1i(S)

texCoord1iv({V1})

texCoord1s(S)

texCoord1sv({V1})

texCoord2d(S, T)

texCoord2dv({V1,V2})

texCoord2f(S, T)

texCoord2fv({V1,V2})

texCoord2i(S, T)

texCoord2iv({V1,V2})

texCoord2s(S, T)

texCoord2sv({V1,V2})

texCoord3d(S, T, R)

texCoord3dv({V1,V2,V3})

texCoord3f(S, T, R)

texCoord3fv({V1,V2,V3})

texCoord3i(S, T, R)

texCoord3iv({V1,V2,V3})

texCoord3s(S, T, R)

texCoord3sv({V1,V2,V3})

texCoord4d(S, T, R, Q)

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

texCoord4f(S, T, R, Q)

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

texCoord4i(S, T, R, Q)

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

texCoord4s(S, T, R, Q)

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

texCoordPointer(Size, Type, Stride, Pointer)

texEnvf(Target, Pname, Param)

texEnvfv(Target, Pname, Params)

texEnvi(Target, Pname, Param)

texEnviv(Target, Pname, Params)

texGend(Coord, Pname, Param)

texGendv(Coord, Pname, Params)

texGenf(Coord, Pname, Param)

texGenfv(Coord, Pname, Params)

texGeni(Coord, Pname, Param)

texGeniv(Coord, Pname, Params)

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

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

texParameterf(Target, Pname, Param)

texParameterfv(Target, Pname, Params)

texParameteri(Target, Pname, Param)

texParameteriv(Target, Pname, Params)

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

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

translated(X, Y, Z)

translatef(X, Y, Z)

vertex2d(X, Y)

vertex2dv({V1,V2})

vertex2f(X, Y)

vertex2fv({V1,V2})

vertex2i(X, Y)

vertex2iv({V1,V2})

vertex2s(X, Y)

vertex2sv({V1,V2})

vertex3d(X, Y, Z)

vertex3dv({V1,V2,V3})

vertex3f(X, Y, Z)

vertex3fv({V1,V2,V3})

vertex3i(X, Y, Z)

vertex3iv({V1,V2,V3})

vertex3s(X, Y, Z)

vertex3sv({V1,V2,V3})

vertex4d(X, Y, Z, W)

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

vertex4f(X, Y, Z, W)

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

vertex4i(X, Y, Z, W)

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

vertex4s(X, Y, Z, W)

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

vertexPointer(Size, Type, Stride, Pointer)

viewport(X, Y, Width, Height)

blendColor(Red, Green, Blue, Alpha)

blendEquation(Mode)

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

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

colorTableParameterfv(Target, Pname, Params)

colorTableParameteriv(Target, Pname, Params)

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

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

getColorTableParameterfv(Target, Pname)

getColorTableParameteriv(Target, Pname)

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

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

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

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

convolutionParameterf(Target, Pname, Params)

convolutionParameterfv(Target, Pname, Params)

convolutionParameteri(Target, Pname, Params)

convolutionParameteriv(Target, Pname, Params)

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

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

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

getConvolutionParameterfv(Target, Pname)

getConvolutionParameteriv(Target, Pname)

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

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

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

getHistogramParameterfv(Target, Pname)

getHistogramParameteriv(Target, Pname)

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

getMinmaxParameterfv(Target, Pname)

getMinmaxParameteriv(Target, Pname)

histogram(Target, Width, Internalformat, Sink)

minmax(Target, Internalformat, Sink)

resetHistogram(Target)

resetMinmax(Target)

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

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

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

activeTexture(Texture)

clientActiveTexture(Texture)

multiTexCoord1d(Target, S)

multiTexCoord1dv(Target, {V1})

multiTexCoord1f(Target, S)

multiTexCoord1fv(Target, {V1})

multiTexCoord1i(Target, S)

multiTexCoord1iv(Target, {V1})

multiTexCoord1s(Target, S)

multiTexCoord1sv(Target, {V1})

multiTexCoord2d(Target, S, T)

multiTexCoord2dv(Target, {V1,V2})

multiTexCoord2f(Target, S, T)

multiTexCoord2fv(Target, {V1,V2})

multiTexCoord2i(Target, S, T)

multiTexCoord2iv(Target, {V1,V2})

multiTexCoord2s(Target, S, T)

multiTexCoord2sv(Target, {V1,V2})

multiTexCoord3d(Target, S, T, R)

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

multiTexCoord3f(Target, S, T, R)

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

multiTexCoord3i(Target, S, T, R)

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

multiTexCoord3s(Target, S, T, R)

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

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

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

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

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

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

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

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

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

loadTransposeMatrixf(M)

loadTransposeMatrixd(M)

multTransposeMatrixf(M)

multTransposeMatrixd(M)

sampleCoverage(Value, Invert)

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

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

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

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

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

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

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

blendFuncSeparate(SfactorRGB, DfactorRGB, SfactorAlpha, DfactorAlpha)

fogCoordf(Coord)

fogCoordfv(Coord)

fogCoordd(Coord)

fogCoorddv(Coord)

fogCoordPointer(Type, Stride, Pointer)

multiDrawArrays(Mode, First, Count, Primcount)

pointParameterf(Pname, Param)

pointParameterfv(Pname, Params)

pointParameteri(Pname, Param)

pointParameteriv(Pname, Params)

secondaryColor3b(Red, Green, Blue)

secondaryColor3bv({V1,V2,V3})

secondaryColor3d(Red, Green, Blue)

secondaryColor3dv({V1,V2,V3})

secondaryColor3f(Red, Green, Blue)

secondaryColor3fv({V1,V2,V3})

secondaryColor3i(Red, Green, Blue)

secondaryColor3iv({V1,V2,V3})

secondaryColor3s(Red, Green, Blue)

secondaryColor3sv({V1,V2,V3})

secondaryColor3ub(Red, Green, Blue)

secondaryColor3ubv({V1,V2,V3})

secondaryColor3ui(Red, Green, Blue)

secondaryColor3uiv({V1,V2,V3})

secondaryColor3us(Red, Green, Blue)

secondaryColor3usv({V1,V2,V3})

secondaryColorPointer(Size, Type, Stride, Pointer)

windowPos2d(X, Y)

windowPos2dv({V1,V2})

windowPos2f(X, Y)

windowPos2fv({V1,V2})

windowPos2i(X, Y)

windowPos2iv({V1,V2})

windowPos2s(X, Y)

windowPos2sv({V1,V2})

windowPos3d(X, Y, Z)

windowPos3dv({V1,V2,V3})

windowPos3f(X, Y, Z)

windowPos3fv({V1,V2,V3})

windowPos3i(X, Y, Z)

windowPos3iv({V1,V2,V3})

windowPos3s(X, Y, Z)

windowPos3sv({V1,V2,V3})

genQueries(N)

deleteQueries(N, Ids)

isQuery(Id)

beginQuery(Target, Id)

endQuery(Target)

getQueryiv(Target, Pname)

getQueryObjectiv(Id, Pname)

getQueryObjectuiv(Id, Pname)

bindBuffer(Target, Buffer)

deleteBuffers(N, Buffers)

genBuffers(N)

isBuffer(Buffer)

bufferData(Target, Size, Data, Usage)

bufferSubData(Target, Offset, Size, Data)

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

unmapBuffer(Target)

getBufferParameteriv(Target, Pname)

getBufferPointerv(Target, Pname)

blendEquationSeparate(ModeRGB, ModeAlpha)

drawBuffers(N, Bufs)

stencilOpSeparate(Face, Sfail, Dpfail, Dppass)

stencilFuncSeparate(Frontfunc, Backfunc, Ref, Mask)

stencilMaskSeparate(Face, Mask)

attachShader(Program, Shader)

bindAttribLocation(Program, Index, Name)

compileShader(Shader)

createProgram()

createShader(Type)

deleteProgram(Program)

deleteShader(Shader)

detachShader(Program, Shader)

disableVertexAttribArray(Index)

enableVertexAttribArray(Index)

getActiveAttrib(Program, Index, BufSize)

getActiveUniform(Program, Index, BufSize)

getAttachedShaders(Program, MaxCount)

getAttribLocation(Program, Name)

getProgramiv(Program, Pname)

getProgramInfoLog(Program, BufSize)

getShaderiv(Shader, Pname)

getShaderInfoLog(Shader, BufSize)

getShaderSource(Shader, BufSize)

getUniformLocation(Program, Name)

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

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

getVertexAttribdv(Index, Pname)

getVertexAttribfv(Index, Pname)

getVertexAttribiv(Index, Pname)

getVertexAttribPointerv(Index, Pname)

isProgram(Program)

isShader(Shader)

linkProgram(Program)

shaderSource(Shader, Count, String, Length)

useProgram(Program)

uniform1f(Location, V0)

uniform2f(Location, V0, V1)

uniform3f(Location, V0, V1, V2)

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

uniform1i(Location, V0)

uniform2i(Location, V0, V1)

uniform3i(Location, V0, V1, V2)

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

uniform1fv(Location, Count, Value)

uniform2fv(Location, Count, Value)

uniform3fv(Location, Count, Value)

uniform4fv(Location, Count, Value)

uniform1iv(Location, Count, Value)

uniform2iv(Location, Count, Value)

uniform3iv(Location, Count, Value)

uniform4iv(Location, Count, Value)

uniformMatrix2fv(Location, Count, Transpose, Value)

uniformMatrix3fv(Location, Count, Transpose, Value)

uniformMatrix4fv(Location, Count, Transpose, Value)

validateProgram(Program)

vertexAttrib1d(Index, X)

vertexAttrib1dv(Index, {V1})

vertexAttrib1f(Index, X)

vertexAttrib1fv(Index, {V1})

vertexAttrib1s(Index, X)

vertexAttrib1sv(Index, {V1})

vertexAttrib2d(Index, X, Y)

vertexAttrib2dv(Index, {V1,V2})

vertexAttrib2f(Index, X, Y)

vertexAttrib2fv(Index, {V1,V2})

vertexAttrib2s(Index, X, Y)

vertexAttrib2sv(Index, {V1,V2})

vertexAttrib3d(Index, X, Y, Z)

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

vertexAttrib3f(Index, X, Y, Z)

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

vertexAttrib3s(Index, X, Y, Z)

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

vertexAttrib4Nbv(Index, V)

vertexAttrib4Niv(Index, V)

vertexAttrib4Nsv(Index, V)

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

vertexAttrib4Nubv(Index, V)

vertexAttrib4Nuiv(Index, V)

vertexAttrib4Nusv(Index, V)

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

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

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

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

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

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

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

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

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

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

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

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

weightbvARB(Size, Weights)

weightsvARB(Size, Weights)

weightivARB(Size, Weights)

weightfvARB(Size, Weights)

weightdvARB(Size, Weights)

weightubvARB(Size, Weights)

weightusvARB(Size, Weights)

weightuivARB(Size, Weights)

weightPointerARB(Size, Type, Stride, Pointer)

vertexBlendARB(Count)

currentPaletteMatrixARB(Index)

matrixIndexubvARB(Size, Indices)

matrixIndexusvARB(Size, Indices)

matrixIndexuivARB(Size, Indices)

matrixIndexPointerARB(Size, Type, Stride, Pointer)

programStringARB(Target, Format, Len, String)

bindProgramARB(Target, Program)

deleteProgramsARB(N, Programs)

genProgramsARB(N)

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

programEnvParameter4dvARB(Target, Index, Params)

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

programEnvParameter4fvARB(Target, Index, Params)

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

programLocalParameter4dvARB(Target, Index, Params)

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

programLocalParameter4fvARB(Target, Index, Params)

getProgramEnvParameterdvARB(Target, Index)

getProgramEnvParameterfvARB(Target, Index)

getProgramLocalParameterdvARB(Target, Index)

getProgramLocalParameterfvARB(Target, Index)

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

deleteObjectARB(Obj)

getHandleARB(Pname)

detachObjectARB(ContainerObj, AttachedObj)

createShaderObjectARB(ShaderType)

createProgramObjectARB()

attachObjectARB(ContainerObj, Obj)

useProgramObjectARB(ProgramObj)

getObjectParameterfvARB(Obj, Pname)

getObjectParameterivARB(Obj, Pname)

getInfoLogARB(Obj, MaxLength)

getAttachedObjectsARB(ContainerObj, MaxCount)

stencilOpSeparateATI(Face, Sfail, Dpfail, Dppass)

stencilFuncSeparateATI(Frontfunc, Backfunc, Ref, Mask)

isRenderbufferEXT(Renderbuffer)

bindRenderbufferEXT(Target, Renderbuffer)

deleteRenderbuffersEXT(N, Renderbuffers)

genRenderbuffersEXT(N)

renderbufferStorageEXT(Target, Internalformat, Width, Height)

getRenderbufferParameterivEXT(Target, Pname)

isFramebufferEXT(Framebuffer)

bindFramebufferEXT(Target, Framebuffer)

deleteFramebuffersEXT(N, Framebuffers)

genFramebuffersEXT(N)

checkFramebufferStatusEXT(Target)

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

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

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

framebufferRenderbufferEXT(Target, Attachment, Renderbuffertarget, Renderbuffer)

getFramebufferAttachmentParameterivEXT(Target, Attachment, Pname)

generateMipmapEXT(Target)