| """Exceptional cases that need some extra wrapping""" |
| from OpenGL import arrays |
| from OpenGL.arrays.arraydatatype import GLfloatArray |
| from OpenGL.lazywrapper import lazy as _lazy |
| from OpenGL.GL.VERSION import GL_1_1 as full |
| from OpenGL.raw.GL import _errors |
| from OpenGL._bytes import bytes |
| from OpenGL import _configflags |
| from OpenGL._null import NULL as _NULL |
| import ctypes |
|
|
| __all__ = [ |
| 'glBegin', |
| 'glCallLists', |
| 'glColor', |
| 'glDeleteTextures', |
| 'glEnd', |
| 'glMap1d', |
| 'glMap1f', |
| 'glMap2d', |
| 'glMap2f', |
| 'glMaterial', |
| 'glRasterPos', |
| 'glTexParameter', |
| 'glVertex', |
| 'glAreTexturesResident', |
| ] |
|
|
| glRasterPosDispatch = { |
| 2: full.glRasterPos2d, |
| 3: full.glRasterPos3d, |
| 4: full.glRasterPos4d, |
| } |
|
|
| if _configflags.ERROR_CHECKING: |
| @_lazy( full.glBegin ) |
| def glBegin( baseFunction, mode ): |
| """Begin GL geometry-definition mode, disable automatic error checking""" |
| _errors._error_checker.onBegin( ) |
| return baseFunction( mode ) |
| @_lazy( full.glEnd ) |
| def glEnd( baseFunction ): |
| """Finish GL geometry-definition mode, re-enable automatic error checking""" |
| _errors._error_checker.onEnd( ) |
| return baseFunction( ) |
| else: |
| glBegin = full.glBegin |
| glEnd = full.glEnd |
|
|
| @_lazy( full.glDeleteTextures ) |
| def glDeleteTextures( baseFunction, size, array=_NULL ): |
| """Delete specified set of textures |
| |
| If array is *not* passed then `size` must be a `GLuintArray` |
| compatible object which can be sized using `arraySize`, the |
| result of which will be used as size. |
| """ |
| if array is _NULL: |
| ptr = arrays.GLuintArray.asArray( size ) |
| size = arrays.GLuintArray.arraySize( ptr ) |
| else: |
| ptr = array |
| return baseFunction( size, ptr ) |
|
|
|
|
| def glMap2( baseFunction, arrayType ): |
| def glMap2( target, u1, u2, v1, v2, points): |
| """glMap2(target, u1, u2, v1, v2, points[][][]) -> None |
| |
| This is a completely non-standard signature which doesn't allow for most |
| of the funky uses with strides and the like, but it has been like this for |
| a very long time... |
| """ |
| ptr = arrayType.asArray( points ) |
| uorder,vorder,vstride = arrayType.dimensions( ptr ) |
| ustride = vstride*vorder |
| return baseFunction( |
| target, |
| u1, u2, |
| ustride, uorder, |
| v1, v2, |
| vstride, vorder, |
| ptr |
| ) |
| glMap2.__name__ = baseFunction.__name__ |
| glMap2.baseFunction = baseFunction |
| return glMap2 |
| glMap2d = glMap2( full.glMap2d, arrays.GLdoubleArray ) |
| glMap2f = glMap2( full.glMap2f, arrays.GLfloatArray ) |
| try: |
| del glMap2 |
| except NameError as err: |
| pass |
|
|
| def glMap1( baseFunction, arrayType ): |
| def glMap1(target,u1,u2,points): |
| """glMap1(target, u1, u2, points[][][]) -> None |
| |
| This is a completely non-standard signature which doesn't allow for most |
| of the funky uses with strides and the like, but it has been like this for |
| a very long time... |
| """ |
| ptr = arrayType.asArray( points ) |
| dims = arrayType.dimensions( ptr ) |
| uorder = dims[0] |
| ustride = dims[1] |
| return baseFunction( target, u1,u2,ustride,uorder, ptr ) |
| glMap1.__name__ == baseFunction.__name__ |
| glMap1.baseFunction = baseFunction |
| return glMap1 |
| glMap1d = glMap1( full.glMap1d, arrays.GLdoubleArray ) |
| glMap1f = glMap1( full.glMap1f, arrays.GLfloatArray ) |
| try: |
| del glMap1 |
| except NameError as err: |
| pass |
|
|
| def glRasterPos( *args ): |
| """Choose glRasterPosX based on number of args""" |
| if len(args) == 1: |
| |
| args = args[0] |
| function = glRasterPosDispatch[ len(args) ] |
| return function( *args ) |
|
|
| glVertexDispatch = { |
| 2: full.glVertex2d, |
| 3: full.glVertex3d, |
| 4: full.glVertex4d, |
| } |
| def glVertex( *args ): |
| """Choose glVertexX based on number of args""" |
| if len(args) == 1: |
| |
| args = args[0] |
| return glVertexDispatch[ len(args) ]( *args ) |
|
|
| @_lazy( full.glCallLists ) |
| def glCallLists( baseFunction, lists, *args ): |
| """glCallLists( bytes( lists ) or lists[] ) -> None |
| |
| Restricted version of glCallLists, takes a string or a GLuint compatible |
| array data-type and passes into the base function. |
| """ |
| if not len(args): |
| if isinstance( lists, bytes ): |
| return baseFunction( |
| len(lists), |
| full.GL_UNSIGNED_BYTE, |
| ctypes.c_void_p(arrays.GLubyteArray.dataPointer( lists )), |
| ) |
| ptr = arrays.GLuintArray.asArray( lists ) |
| size = arrays.GLuintArray.arraySize( ptr ) |
| return baseFunction( |
| size, |
| full.GL_UNSIGNED_INT, |
| ctypes.c_void_p( arrays.GLuintArray.dataPointer(ptr)) |
| ) |
| return baseFunction( lists, *args ) |
|
|
| def glTexParameter( target, pname, parameter ): |
| """Set a texture parameter, choose underlying call based on pname and parameter""" |
| if isinstance( parameter, float ): |
| return full.glTexParameterf( target, pname, parameter ) |
| elif isinstance( parameter, int ): |
| return full.glTexParameteri( target, pname, parameter ) |
| else: |
| value = GLfloatArray.asArray( parameter, full.GL_FLOAT ) |
| return full.glTexParameterfv( target, pname, value ) |
|
|
| def glMaterial( faces, constant, *args ): |
| """glMaterial -- convenience function to dispatch on argument type |
| |
| If passed a single argument in args, calls: |
| glMaterialfv( faces, constant, args[0] ) |
| else calls: |
| glMaterialf( faces, constant, *args ) |
| """ |
| if len(args) == 1: |
| arg = GLfloatArray.asArray( args[0] ) |
| if arg is None: |
| raise ValueError( """Null value in glMaterial: %s"""%(args,) ) |
| return full.glMaterialfv( faces, constant, arg ) |
| else: |
| return full.glMaterialf( faces, constant, *args ) |
|
|
| glColorDispatch = { |
| 3: full.glColor3fv, |
| 4: full.glColor4fv, |
| } |
|
|
| def glColor( *args ): |
| """glColor*f* -- convenience function to dispatch on argument type |
| |
| dispatches to glColor3f, glColor2f, glColor4f, glColor3f, glColor2f, glColor4f |
| depending on the arguments passed... |
| """ |
| arglen = len(args) |
| if arglen == 1: |
| arg = arrays.GLfloatArray.asArray( args[0] ) |
| function = glColorDispatch[arrays.GLfloatArray.arraySize( arg )] |
| return function( arg ) |
| elif arglen == 2: |
| return full.glColor2d( *args ) |
| elif arglen == 3: |
| return full.glColor3d( *args ) |
| elif arglen == 4: |
| return full.glColor4d( *args ) |
| else: |
| raise ValueError( """Don't know how to handle arguments: %s"""%(args,)) |
|
|
|
|
| |
| @_lazy( full.glAreTexturesResident ) |
| def glAreTexturesResident( baseFunction, *args ): |
| """Allow both Pythonic and C-style calls to glAreTexturesResident |
| |
| glAreTexturesResident( arrays.GLuintArray( textures) ) |
| |
| or |
| |
| glAreTexturesResident( int(n), arrays.GLuintArray( textures), arrays.GLuboolean( output) ) |
| |
| or |
| |
| glAreTexturesResident( int(n), arrays.GLuintArray( textures) ) |
| |
| returns the output arrays.GLubooleanArray |
| """ |
| if len(args) == 1: |
| |
| textures = args[0] |
| textures = arrays.GLuintArray.asArray( textures ) |
| n = arrays.GLuintArray.arraySize(textures) |
| output = arrays.GLbooleanArray.zeros( (n,)) |
| elif len(args) == 2: |
| try: |
| n = int( args[0] ) |
| except TypeError: |
| textures = args[0] |
| textures = arrays.GLuintArray.asArray( textures ) |
|
|
| n = arrays.GLuintArray.arraySize(textures) |
| output = args[1] |
| output = arrays.GLbooleanArray.asArray( output ) |
| else: |
| textures = args[1] |
| textures = arrays.GLuintArray.asArray( textures ) |
|
|
| output = arrays.GLbooleanArray.zeros( (n,)) |
| elif len(args) == 3: |
| n,textures,output = args |
| textures = arrays.GLuintArray.asArray( textures ) |
| output = arrays.GLbooleanArray.asArray( output ) |
| else: |
| raise TypeError( """Expected 1 to 3 arguments to glAreTexturesResident""" ) |
| texturePtr = arrays.GLuintArray.typedPointer( textures ) |
| outputPtr = arrays.GLbooleanArray.typedPointer( output ) |
| result = baseFunction( n, texturePtr, outputPtr ) |
| if result: |
| |
| for i in range(len(output)): |
| output[i] = 1 |
| return output |
|
|
