target: the symbolic constant indicating which buffer type is intended
size: if provided, the count-in-bytes of the array
data: data-pointer to be used, may be None to initialize without copying over a data-set
usage: hint to the driver as to how to set up access to the buffer

Note: parameter "size" can be omitted, which makes the signature glBufferData( target, data, usage ) instead of: glBufferData( target, size, data, usage )

glBufferSubData( target , offset , size = None , data = None )

Copy subset of data into the currently bound vertex-buffer-data object

target: the symbolic constant indicating which buffer type is intended
offset: offset from beginning of buffer at which to copy bytes
size: the count-in-bytes of the array (if an int/long), if None, calculate size from data, if an array and data is None, use as data (i.e. the parameter can be omitted and calculated)
data: data-pointer to be used, may be None to initialize without copying over a data-set

Note that if size is not an int/long it is considered to be data *iff* data is None

glCallList( list )

glCallLists( lists , * args )

glCallLists( str( lists ) or lists[] ) -> None

Restricted version of glCallLists, takes a string or a GLuint compatible array data-type and passes into the base function.

glClampColor( target , clamp )

glClear( mask )

glClearAccum( red , green , blue , alpha )

glClearBufferfi( buffer , drawbuffer , depth , stencil )

glClearBufferfv( buffer , drawbuffer , value )

glClearBufferiv( buffer , drawbuffer , value )

glClearBufferuiv( buffer , drawbuffer , value )

glClearColor( red , green , blue , alpha )

glClearDepth( depth )

glClearIndex( c )

glClearStencil( s )

glClientActiveTexture( texture )

glClipPlane( plane , equation )

glColor3b( red , green , blue )

glColor3bv( v )

glColor3d( red , green , blue )

glColor3dv( v )

glColor3f( red , green , blue )

glColor3fv( v )

glColor3i( red , green , blue )

glColor3iv( v )

glColor3s( red , green , blue )

glColor3sv( v )

glColor3ub( red , green , blue )

glColor3ubv( v )

glColor3ui( red , green , blue )

glColor3uiv( v )

glColor3us( red , green , blue )

glColor3usv( v )

glColor4b( red , green , blue , alpha )

glColor4bv( v )

glColor4d( red , green , blue , alpha )

glColor4dv( v )

glColor4f( red , green , blue , alpha )

glColor4fv( v )

glColor4i( red , green , blue , alpha )

glColor4iv( v )

glColor4s( red , green , blue , alpha )

glColor4sv( v )

glColor4ub( red , green , blue , alpha )

glColor4ubv( v )

glColor4ui( red , green , blue , alpha )

glColor4uiv( v )

glColor4us( red , green , blue , alpha )

glColor4usv( v )

glColorMask( red , green , blue , alpha )

glColorMaski( index , r , g , b , a )

glColorMaterial( face , mode )

glColorPointer( size , type , stride , pointer )

glColorPointerb( pointer )

glColorPointerd( pointer )

glColorPointerf( pointer )

glColorPointeri( pointer )

glColorPointers( pointer )

glColorPointerub( pointer )

glColorPointerui( pointer )

glColorPointerus( pointer )

glColorSubTable( target , start , count , format , type , data )

glColorTable( target , internalformat , width , format , type , table )

glColorTableParameterfv( target , pname , params )

glColorTableParameteriv( target , pname , params )

glCompileShader( shader )

glCompressedTexImage1D( target , level , internalformat , width , border , imageSize , data )

glCompressedTexImage2D( target , level , internalformat , width , height , border , imageSize , data )

glCompressedTexImage3D( target , level , internalformat , width , height , depth , border , imageSize , data )

glCompressedTexSubImage1D( target , level , xoffset , width , format , imageSize , data )

glCompressedTexSubImage2D( target , level , xoffset , yoffset , width , height , format , imageSize , data )

glCompressedTexSubImage3D( target , level , xoffset , yoffset , zoffset , width , height , depth , format , imageSize , data )

glConvolutionFilter1D( target , internalformat , width , format , type , image )

glConvolutionFilter2D( target , internalformat , width , height , format , type , image )

glConvolutionParameterf( target , pname , params )

glConvolutionParameterfv( target , pname , params )

glConvolutionParameteri( target , pname , params )

glConvolutionParameteriv( target , pname , params )

glCopyColorSubTable( target , start , x , y , width )

glCopyColorTable( target , internalformat , x , y , width )

glCopyConvolutionFilter1D( target , internalformat , x , y , width )

glCopyConvolutionFilter2D( target , internalformat , x , y , width , height )

glCopyPixels( x , y , width , height , type )

glCopyTexImage1D( target , level , internalformat , x , y , width , border )

glCopyTexImage2D( target , level , internalformat , x , y , width , height , border )

glCopyTexSubImage1D( target , level , xoffset , x , y , width )

glCopyTexSubImage2D( target , level , xoffset , yoffset , x , y , width , height )

glCopyTexSubImage3D( target , level , xoffset , yoffset , zoffset , x , y , width , height )

glCreateProgram( ) -> <class 'ctypes.c_uint'>

glCreateShader( type ) -> <class 'ctypes.c_uint'>

glCullFace( mode )

glDeleteBuffers( n , buffers )

glDeleteLists( list , range )

glDeleteProgram( program )

glDeleteQueries( n , ids = None )

glDeleteShader( shader )

glDeleteTextures( array )

Delete specified set of textures

glDepthFunc( func )

glDepthMask( flag )

glDepthRange( near_val , far_val )

glDetachShader( program , shader )

glDisable( cap )

glDisableClientState( cap )

glDisableVertexAttribArray( index )

glDisablei( target , index )

glDrawArrays( mode , first , count )

glDrawArraysInstanced( mode , first , count , instancecount )

glDrawBuffer( mode )

glDrawBuffers( n = None , bufs = None )

glDrawBuffers( bufs ) -> bufs

Wrapper will calculate n from dims of bufs if only one argument is provided...

glDrawElements( mode , count , type , indices )

glDrawElementsInstanced( mode , count , type , indices , instancecount )

glDrawElementsub( mode , indices )

glDrawElementsui( mode , indices )

glDrawElementsus( mode , indices )

glDrawPixels( width , height , format , type , pixels )

glDrawPixelsb( format , pixels )

glDrawPixelsf( format , pixels )

glDrawPixelsi( format , pixels )

glDrawPixelss( format , pixels )

glDrawPixelsub( format , pixels )

glDrawPixelsui( format , pixels )

glDrawPixelsus( format , pixels )

glDrawRangeElements( mode , start , end , count , type , indices )

glEdgeFlag( flag )

glEdgeFlagPointer( stride , pointer )

glEdgeFlagPointerb( pointer )

glEdgeFlagv( flag )

glEnable( cap )

glEnableClientState( cap )

glEnableVertexAttribArray( index )

glEnablei( target , index )

glEnd( )

Finish GL geometry-definition mode, re-enable automatic error checking

glEndConditionalRender( )

glEndList( )

glEndQuery( target )

glEndTransformFeedback( )

glEvalCoord1d( u )

glEvalCoord1dv( u )

glEvalCoord1f( u )

glEvalCoord1fv( u )

glEvalCoord2d( u , v )

glEvalCoord2dv( u )

glEvalCoord2f( u , v )

glEvalCoord2fv( u )

glEvalMesh1( mode , i1 , i2 )

glEvalMesh2( mode , i1 , i2 , j1 , j2 )

glEvalPoint1( i )

glEvalPoint2( i , j )

glFinish( )

glFlush( )

glFogCoordPointer( type , stride , pointer )

glFogCoordd( coord )

glFogCoorddv( coord )

glFogCoordf( coord )

glFogCoordfv( coord )

glFogf( pname , param )

glFogfv( pname , params )

glFogi( pname , param )

glFogiv( pname , params )

glFramebufferTexture( target , attachment , texture , level )

glFrontFace( mode )

glFrustum( left , right , bottom , top , near_val , far_val )

glGenBuffers( n )

glGenLists( range ) -> <class 'ctypes.c_uint'>

glGenQueries( n , ids = None )

Generate n queries, if ids is None, is allocated

returns array of ids

glGenTextures( count , textures = None )

Generate count new texture names

Note: for compatibility with PyOpenGL 2.x and below, a count of 1 will return a single integer, rather than an array of integers.

glGetActiveAttrib( program , index , bufSize , length , size , type , name )

glGetActiveUniform( program , index )

Retrieve the name, size and type of the uniform of the index in the program

glGetAttachedShaders( obj )

Retrieve the attached objects as an array of GLhandle instances

glGetAttribLocation( program , name ) -> <class 'ctypes.c_int'>

Check that name is a string with a null byte at the end of it

glGetBoolean( pname )

glGetBooleani_v( target , index , data )

glGetBufferParameteri64v( target , pname , params )

glGetBufferParameteriv( target , pname )

glGetBufferPointerv( target , pname , params = None )

Retrieve a ctypes pointer to buffer's data

glGetBufferSubData( target , offset , size , data )

glGetClipPlane( plane , equation )

glGetColorTable( target , format , type )

Retrieve the current 1D color table as a bitmap

glGetColorTableParameterfv( target , pname )

glGetColorTableParameteriv( target , pname )

glGetCompressedTexImage( target , level , img )

glGetConvolutionFilter( target , format , type )

Retrieve 1 or 2D convolution parameter "kernels" as pixel data

glGetConvolutionParameterfv( target , pname )

glGetConvolutionParameteriv( target , pname )

glGetDouble( pname )

glGetError( ) -> <class 'ctypes.c_uint'>

glGetFloat( pname )

glGetFragDataLocation( program , name ) -> <class 'ctypes.c_int'>

glGetHistogram( target , reset , format , type , values = None )

Retrieve current 1D histogram as a 1D bitmap

glGetHistogramParameterfv( target , pname )

glGetHistogramParameteriv( target , pname )

glGetInteger64i_v( target , index , data )

glGetIntegeri_v( target , index , data )

glGetLightfv( light , pname )

glGetLightiv( light , pname )

glGetMapdv( target , query , v )

glGetMapfv( target , query , v )

glGetMapiv( target , query , v )

glGetMaterialfv( face , pname )

glGetMaterialiv( face , pname )

glGetMinmax( target , reset , format , type , values = None )

Retrieve minimum and maximum values as a 2-element image

glGetMinmaxParameterfv( target , pname , params )

glGetMinmaxParameteriv( target , pname , params )

glGetPixelMapfv( map )

glGetPixelMapuiv( map )

glGetPixelMapusv( map )

glGetPolygonStipple( )

glGetProgramInfoLog( obj )

Retrieve the shader program's error messages as a Python string

returns string which is '' if no message

glGetProgramiv( program , pname , params = None )

Will automatically allocate params if not provided

glGetQueryObjectiv( id , pname )

glGetQueryObjectuiv( id , pname )

glGetQueryiv( target , pname )

glGetSeparableFilter( target , format , type )

Retrieve 2 1D convolution parameter "kernels" as pixel data

glGetShaderInfoLog( obj )

Retrieve the shader's error messages as a Python string

returns string which is '' if no message

glGetShaderSource( obj )

Retrieve the program/shader's source code as a Python string

returns string which is '' if no source code

glGetShaderiv( shader , pname , status = None )

Retrieve the integer parameter for the given shader

shader: shader ID to query
pname: parameter name
status: pointer to integer to receive status or None to return the parameter as an integer value

returns integer if status parameter is None status if status parameter is not None

glGetString( name ) -> <class 'ctypes.c_char_p'>

glGetString( constant ) -> Current string value

glGetStringi( name , index ) -> <class 'ctypes.c_char_p'>

glGetTexEnvfv( target , pname )

glGetTexEnviv( target , pname )

glGetTexGendv( coord , pname )

glGetTexGenfv( coord , pname )

glGetTexGeniv( coord , pname )

glGetTexLevelParameterfv( target , level , pname )

glGetTexLevelParameteriv( target , level , pname )

glGetTexParameterIiv( target , pname , params )

glGetTexParameterIuiv( target , pname , params )

glGetTexParameterfv( target , pname )

glGetTexParameteriv( target , pname )

glGetTransformFeedbackVarying( program , index , bufSize , length , size , type , name )

glGetUniformLocation( program , name ) -> <class 'ctypes.c_int'>

Check that name is a string with a null byte at the end of it

glGetUniformfv( program , location , params )

glGetUniformiv( program , location , params )

glGetUniformuiv( program , location , params )

glGetVertexAttribIiv( index , pname , params )

glGetVertexAttribIuiv( index , pname , params )

glGetVertexAttribPointerv( index , pname , pointer )

glGetVertexAttribdv( index , pname , params )

glGetVertexAttribfv( index , pname , params )

glGetVertexAttribiv( index , pname , params )

glHint( target , mode )

glHistogram( target , width , internalformat , sink )

glIndexMask( mask )

glIndexPointer( type , stride , pointer )

glIndexPointerb( pointer )

glIndexPointerd( pointer )

glIndexPointerf( pointer )

glIndexPointeri( pointer )

glIndexPointers( pointer )

glIndexPointerub( pointer )

glIndexd( c )

glIndexdv( c )

glIndexf( c )

glIndexfv( c )

glIndexi( c )

glIndexiv( c )

glIndexs( c )

glIndexsv( c )

glIndexub( c )

glIndexubv( c )

glInitGl11VERSION( )

Return boolean indicating whether this extension is available

glInitNames( )

glInterleavedArrays( format , stride , pointer )

glIsBuffer( buffer ) -> <class 'ctypes.c_ubyte'>

glIsEnabled( cap ) -> <class 'ctypes.c_ubyte'>

glIsEnabledi( target , index ) -> <class 'ctypes.c_ubyte'>

glIsList( list ) -> <class 'ctypes.c_ubyte'>

glIsProgram( program ) -> <class 'ctypes.c_ubyte'>

glIsQuery( id ) -> <class 'ctypes.c_ubyte'>

glIsShader( shader ) -> <class 'ctypes.c_ubyte'>

glIsTexture( texture ) -> <class 'ctypes.c_ubyte'>

glLight( light , pname , params )

glLightModelf( pname , param )

glLightModelfv( pname , params )

glLightModeli( pname , param )

glLightModeliv( pname , params )

glLightf( light , pname , param )

glLighti( light , pname , param )

glLightiv( light , pname , params )

glLineStipple( factor , pattern )

glLineWidth( width )

glLinkProgram( program )

glListBase( base )

glLoadIdentity( )

glLoadMatrixd( m )

glLoadMatrixf( m )

glLoadName( name )

glLoadTransposeMatrixd( m )

glLoadTransposeMatrixf( m )

glLogicOp( opcode )

glMapBuffer( target , access ) -> <class 'ctypes.c_void_p'>

glMapGrid1d( un , u1 , u2 )

glMapGrid1f( un , u1 , u2 )

glMapGrid2d( un , u1 , u2 , vn , v1 , v2 )

glMapGrid2f( un , u1 , u2 , vn , v1 , v2 )

glMaterialf( face , pname , param )

glMaterialfv( face , pname , params )

glMateriali( face , pname , param )

glMaterialiv( face , pname , params )

glMatrixMode( mode )

glMinSampleShading( value )

glMinmax( target , internalformat , sink )

glMultMatrixd( m )

glMultMatrixf( m )

glMultTransposeMatrixd( m )

glMultTransposeMatrixf( m )

glMultiDrawArrays( mode , first , count , drawcount )

glMultiDrawElements( mode , count , type , indices , drawcount )

glMultiTexCoord1d( target , s )

glMultiTexCoord1dv( target , v )

glMultiTexCoord1f( target , s )

glMultiTexCoord1fv( target , v )

glMultiTexCoord1i( target , s )

glMultiTexCoord1iv( target , v )

glMultiTexCoord1s( target , s )

glMultiTexCoord1sv( target , v )

glMultiTexCoord2d( target , s , t )

glMultiTexCoord2dv( target , v )

glMultiTexCoord2f( target , s , t )

glMultiTexCoord2fv( target , v )

glMultiTexCoord2i( target , s , t )

glMultiTexCoord2iv( target , v )

glMultiTexCoord2s( target , s , t )

glMultiTexCoord2sv( target , v )

glMultiTexCoord3d( target , s , t , r )

glMultiTexCoord3dv( target , v )

glMultiTexCoord3f( target , s , t , r )

glMultiTexCoord3fv( target , v )

glMultiTexCoord3i( target , s , t , r )

glMultiTexCoord3iv( target , v )

glMultiTexCoord3s( target , s , t , r )

glMultiTexCoord3sv( target , v )

glMultiTexCoord4d( target , s , t , r , q )

glMultiTexCoord4dv( target , v )

glMultiTexCoord4f( target , s , t , r , q )

glMultiTexCoord4fv( target , v )

glMultiTexCoord4i( target , s , t , r , q )

glMultiTexCoord4iv( target , v )

glMultiTexCoord4s( target , s , t , r , q )

glMultiTexCoord4sv( target , v )

glNewList( list , mode )

glNormal( nx , ny , nz )

glNormal3b( nx , ny , nz )

glNormal3bv( v )

glNormal3dv( v )

glNormal3f( nx , ny , nz )

glNormal3fv( v )

glNormal3i( nx , ny , nz )

glNormal3iv( v )

glNormal3s( nx , ny , nz )

glNormal3sv( v )

glNormalPointer( type , stride , pointer )

glNormalPointerb( pointer )

glNormalPointerd( pointer )

glNormalPointerf( pointer )

glNormalPointeri( pointer )

glNormalPointers( pointer )

glOrtho( left , right , bottom , top , near_val , far_val )

glPassThrough( token )

glPixelMapfv( map , mapsize , values )

glPixelMapuiv( map , mapsize , values )

glPixelMapusv( map , mapsize , values )

glPixelStoref( pname , param )

glPixelStorei( pname , param )

glPixelTransferf( pname , param )

glPixelTransferi( pname , param )

glPixelZoom( xfactor , yfactor )

glPointParameterf( pname , param )

glPointParameterfv( pname , params )

glPointParameteri( pname , param )

glPointParameteriv( pname , params )

glPointSize( size )

glPolygonMode( face , mode )

glPolygonOffset( factor , units )

glPolygonStipple( mask )

glPopAttrib( )

glPopClientAttrib( )

glPopMatrix( )

glPopName( )

glPrimitiveRestartIndex( index )

glPrioritizeTextures( n , textures , priorities )

glPushAttrib( mask )

glPushClientAttrib( mask )

glPushMatrix( )

glPushName( name )

glRasterPos2d( x , y )

glRasterPos2dv( v )

glRasterPos2f( x , y )

glRasterPos2fv( v )

glRasterPos2i( x , y )

glRasterPos2iv( v )

glRasterPos2s( x , y )

glRasterPos2sv( v )

glRasterPos3d( x , y , z )

glRasterPos3dv( v )

glRasterPos3f( x , y , z )

glRasterPos3fv( v )

glRasterPos3i( x , y , z )

glRasterPos3iv( v )

glRasterPos3s( x , y , z )

glRasterPos3sv( v )

glRasterPos4d( x , y , z , w )

glRasterPos4dv( v )

glRasterPos4f( x , y , z , w )

glRasterPos4fv( v )

glRasterPos4i( x , y , z , w )

glRasterPos4iv( v )

glRasterPos4s( x , y , z , w )

glRasterPos4sv( v )

glReadBuffer( mode )

glRectd( x1 , y1 , x2 , y2 )

glRectdv( v1 , v2 )

glRectf( x1 , y1 , x2 , y2 )

glRectfv( v1 , v2 )

glRecti( x1 , y1 , x2 , y2 )

glRectiv( v1 , v2 )

glRects( x1 , y1 , x2 , y2 )

glRectsv( v1 , v2 )

glResetHistogram( target )

glResetMinmax( target )

glRotate( angle , x , y , z )

glRotatef( angle , x , y , z )

glSampleCoverage( value , invert )

glScale( x , y , z )

glScalef( x , y , z )

glScissor( x , y , width , height )

glSecondaryColor3b( red , green , blue )

glSecondaryColor3bv( v )

glSecondaryColor3d( red , green , blue )

glSecondaryColor3dv( v )

glSecondaryColor3f( red , green , blue )

glSecondaryColor3fv( v )

glSecondaryColor3i( red , green , blue )

glSecondaryColor3iv( v )

glSecondaryColor3s( red , green , blue )

glSecondaryColor3sv( v )

glSecondaryColor3ub( red , green , blue )

glSecondaryColor3ubv( v )

glSecondaryColor3ui( red , green , blue )

glSecondaryColor3uiv( v )

glSecondaryColor3us( red , green , blue )

glSecondaryColor3usv( v )

glSecondaryColorPointer( size , type , stride , pointer )

glSeparableFilter2D( target , internalformat , width , height , format , type , row , column )

glShadeModel( mode )

glStencilFunc( func , ref , mask )

glStencilFuncSeparate( face , func , ref , mask )

glStencilMask( mask )

glStencilMaskSeparate( face , mask )

glStencilOp( fail , zfail , zpass )

glStencilOpSeparate( face , sfail , dpfail , dppass )

glTexBuffer( target , internalformat , buffer )

glTexCoord( s , t )

glTexCoord1d( s )

glTexCoord1dv( v )

glTexCoord1f( s )

glTexCoord1fv( v )

glTexCoord1i( s )

glTexCoord1iv( v )

glTexCoord1s( s )

glTexCoord1sv( v )

glTexCoord2dv( v )

glTexCoord2f( s , t )

glTexCoord2fv( v )

glTexCoord2i( s , t )

glTexCoord2iv( v )

glTexCoord2s( s , t )

glTexCoord2sv( v )

glTexCoord3d( s , t , r )

glTexCoord3dv( v )

glTexCoord3f( s , t , r )

glTexCoord3fv( v )

glTexCoord3i( s , t , r )

glTexCoord3iv( v )

glTexCoord3s( s , t , r )

glTexCoord3sv( v )

glTexCoord4d( s , t , r , q )

glTexCoord4dv( v )

glTexCoord4f( s , t , r , q )

glTexCoord4fv( v )

glTexCoord4i( s , t , r , q )

glTexCoord4iv( v )

glTexCoord4s( s , t , r , q )

glTexCoord4sv( v )

glTexCoordPointer( size , type , stride , pointer )

glTexCoordPointerb( pointer )

glTexCoordPointerd( pointer )

glTexCoordPointerf( pointer )

glTexCoordPointeri( pointer )

glTexCoordPointers( pointer )

glTexEnvf( target , pname , param )

glTexEnvfv( target , pname , params )

glTexEnvi( target , pname , param )

glTexEnviv( target , pname , params )

glTexGend( coord , pname , param )

glTexGendv( coord , pname , params )

glTexGenf( coord , pname , param )

glTexGenfv( coord , pname , params )

glTexGeni( coord , pname , param )

glTexGeniv( coord , pname , params )

glTexImage1D( target , level , internalFormat , width , border , format , type , pixels )

glTexImage1Db( target , level , internalFormat , border , format , pixels )

glTexImage1Df( target , level , internalFormat , border , format , pixels )

glTexImage1Di( target , level , internalFormat , border , format , pixels )

glTexImage1Ds( target , level , internalFormat , border , format , pixels )

glTexImage1Dub( target , level , internalFormat , border , format , pixels )

glTexImage1Dui( target , level , internalFormat , border , format , pixels )

glTexImage1Dus( target , level , internalFormat , border , format , pixels )

glTexImage2D( target , level , internalFormat , width , height , border , format , type , pixels )

glTexImage2Db( target , level , internalFormat , border , format , pixels )

glTexImage2Df( target , level , internalFormat , border , format , pixels )

glTexImage2Di( target , level , internalFormat , border , format , pixels )

glTexImage2Ds( target , level , internalFormat , border , format , pixels )

glTexImage2Dub( target , level , internalFormat , border , format , pixels )

glTexImage2Dui( target , level , internalFormat , border , format , pixels )

glTexImage2Dus( target , level , internalFormat , border , format , pixels )

glTexImage3D( target , level , internalformat , width , height , depth , border , format , type , pixels )

glTexImage3Db( target , level , internalformat , width , height , depth , border , format , type , pixels )

glTexParameterIiv( target , pname , params )

glTexParameterIuiv( target , pname , params )

glTexParameterf( target , pname , param )

glTexParameterfv( target , pname , params )

glTexParameteri( target , pname , param )

glTexParameteriv( target , pname , params )

glTexSubImage1D( target , level , xoffset , width , format , type , pixels )

glTexSubImage1Db( target , level , xoffset , format , pixels )

glTexSubImage1Df( target , level , xoffset , format , pixels )

glTexSubImage1Di( target , level , xoffset , format , pixels )

glTexSubImage1Ds( target , level , xoffset , format , pixels )

glTexSubImage1Dub( target , level , xoffset , format , pixels )

glTexSubImage1Dui( target , level , xoffset , format , pixels )

glTexSubImage1Dus( target , level , xoffset , format , pixels )

glTexSubImage2D( target , level , xoffset , yoffset , width , height , format , type , pixels )

glTexSubImage2Db( target , level , xoffset , yoffset , format , pixels )

glTexSubImage2Df( target , level , xoffset , yoffset , format , pixels )

glTexSubImage2Di( target , level , xoffset , yoffset , format , pixels )

glTexSubImage2Ds( target , level , xoffset , yoffset , format , pixels )

glTexSubImage2Dub( target , level , xoffset , yoffset , format , pixels )

glTexSubImage2Dui( target , level , xoffset , yoffset , format , pixels )

glTexSubImage2Dus( target , level , xoffset , yoffset , format , pixels )

glTexSubImage3D( target , level , xoffset , yoffset , zoffset , width , height , depth , format , type , pixels )

glTexSubImage3Db( target , level , xoffset , yoffset , zoffset , width , height , depth , format , type , pixels )

glTransformFeedbackVaryings( program , count , varyings , bufferMode )

glTranslate( x , y , z )

glTranslatef( x , y , z )

glUniform1f( location , v0 )

glUniform1fv( location , count , value )

glUniform1i( location , v0 )

glUniform1iv( location , count , value )

glUniform1ui( location , v0 )

glUniform1uiv( location , count , value )

glUniform2f( location , v0 , v1 )

glUniform2fv( location , count , value )

glUniform2i( location , v0 , v1 )

glUniform2iv( location , count , value )

glUniform2ui( location , v0 , v1 )

glUniform2uiv( location , count , value )

glUniform3f( location , v0 , v1 , v2 )

glUniform3fv( location , count , value )

glUniform3i( location , v0 , v1 , v2 )

glUniform3iv( location , count , value )

glUniform3ui( location , v0 , v1 , v2 )

glUniform3uiv( location , count , value )

glUniform4f( location , v0 , v1 , v2 , v3 )

glUniform4fv( location , count , value )

glUniform4i( location , v0 , v1 , v2 , v3 )

glUniform4iv( location , count , value )

glUniform4ui( location , v0 , v1 , v2 , v3 )

glUniform4uiv( location , count , value )

glUniformMatrix2fv( location , count , transpose , value )

glUniformMatrix2x3fv( location , count , transpose , value )

glUniformMatrix2x4fv( location , count , transpose , value )

glUniformMatrix3fv( location , count , transpose , value )

glUniformMatrix3x2fv( location , count , transpose , value )

glUniformMatrix3x4fv( location , count , transpose , value )

glUniformMatrix4fv( location , count , transpose , value )

glUniformMatrix4x2fv( location , count , transpose , value )

glUniformMatrix4x3fv( location , count , transpose , value )

glUnmapBuffer( target ) -> <class 'ctypes.c_ubyte'>

glUseProgram( program )

glValidateProgram( program )

glVertex2d( x , y )

glVertex2dv( v )

glVertex2f( x , y )

glVertex2fv( v )

glVertex2i( x , y )

glVertex2iv( v )

glVertex2s( x , y )

glVertex2sv( v )

glVertex3d( x , y , z )

glVertex3dv( v )

glVertex3f( x , y , z )

glVertex3fv( v )

glVertex3i( x , y , z )

glVertex3iv( v )

glVertex3s( x , y , z )

glVertex3sv( v )

glVertex4d( x , y , z , w )

glVertex4dv( v )

glVertex4f( x , y , z , w )

glVertex4fv( v )

glVertex4i( x , y , z , w )

glVertex4iv( v )

glVertex4s( x , y , z , w )

glVertex4sv( v )

glVertexAttrib1d( index , x )

glVertexAttrib1dv( index , v )

glVertexAttrib1f( index , x )

glVertexAttrib1fv( index , v )

glVertexAttrib1s( index , x )

glVertexAttrib1sv( index , v )

glVertexAttrib2d( index , x , y )

glVertexAttrib2dv( index , v )

glVertexAttrib2f( index , x , y )

glVertexAttrib2fv( index , v )

glVertexAttrib2s( index , x , y )

glVertexAttrib2sv( index , v )

glVertexAttrib3d( index , x , y , z )

glVertexAttrib3dv( index , v )

glVertexAttrib3f( index , x , y , z )

glVertexAttrib3fv( index , v )

glVertexAttrib3s( index , x , y , z )

glVertexAttrib3sv( index , v )

glVertexAttrib4Nbv( index , v )

glVertexAttrib4Niv( index , v )

glVertexAttrib4Nsv( index , v )

glVertexAttrib4Nub( index , x , y , z , w )

glVertexAttrib4Nubv( index , v )

glVertexAttrib4Nuiv( index , v )

glVertexAttrib4Nusv( index , v )

glVertexAttrib4bv( index , v )

glVertexAttrib4d( index , x , y , z , w )

glVertexAttrib4dv( index , v )

glVertexAttrib4f( index , x , y , z , w )

glVertexAttrib4fv( index , v )

glVertexAttrib4iv( index , v )

glVertexAttrib4s( index , x , y , z , w )

glVertexAttrib4sv( index , v )

glVertexAttrib4ubv( index , v )

glVertexAttrib4uiv( index , v )

glVertexAttrib4usv( index , v )

glVertexAttribDivisor( index , divisor )

glVertexAttribI1i( index , x )

glVertexAttribI1iv( index , v )

glVertexAttribI1ui( index , x )

glVertexAttribI1uiv( index , v )

glVertexAttribI2i( index , x , y )

glVertexAttribI2iv( index , v )

glVertexAttribI2ui( index , x , y )

glVertexAttribI2uiv( index , v )

glVertexAttribI3i( index , x , y , z )

glVertexAttribI3iv( index , v )

glVertexAttribI3ui( index , x , y , z )

glVertexAttribI3uiv( index , v )

glVertexAttribI4bv( index , v )

glVertexAttribI4i( index , x , y , z , w )

glVertexAttribI4iv( index , v )

glVertexAttribI4sv( index , v )

glVertexAttribI4ubv( index , v )

glVertexAttribI4ui( index , x , y , z , w )

glVertexAttribI4uiv( index , v )

glVertexAttribI4usv( index , v )

glVertexAttribIPointer( index , size , type , stride , pointer )

glVertexAttribPointer( index , size , type , normalized , stride , pointer )

Set an attribute pointer for a given shader (index)

index: the index of the generic vertex to bind, see glGetAttribLocation for retrieval of the value, note that index is a global variable, not per-shader
size: number of basic elements per record, 1,2,3, or 4
type: enum constant for data-type
normalized: whether to perform int to float normalization on integer-type values
stride: stride in machine units (bytes) between consecutive records, normally used to create "interleaved" arrays
pointer: data-pointer which provides the data-values, normally a vertex-buffer-object or offset into the same.

This implementation stores a copy of the data-pointer in the contextdata structure in order to prevent null- reference errors in the renderer.

glVertexPointer( size , type , stride , pointer )

glVertexPointerb( pointer )

glVertexPointerd( pointer )

glVertexPointerf( pointer )

glVertexPointeri( pointer )

glVertexPointers( pointer )

glViewport( x , y , width , height )

glWindowPos2d( x , y )

glWindowPos2dv( v )

glWindowPos2f( x , y )

glWindowPos2fv( v )

glWindowPos2i( x , y )

glWindowPos2iv( v )

glWindowPos2s( x , y )

glWindowPos2sv( v )

glWindowPos3d( x , y , z )

glWindowPos3dv( v )

glWindowPos3f( x , y , z )

glWindowPos3fv( v )

glWindowPos3i( x , y , z )

glWindowPos3iv( v )

glWindowPos3s( x , y , z )

glWindowPos3sv( v )

Previous: OpenGL.AGL

OpenGL. GL

Next: OpenGL.GL.AMD