OpenGL.platform.baseplatform

Base class for platform implementations

Functions

_find_module( exclude = ('OpenGL.platform.baseplatform',) )

Classes

class _CheckContext( object ):

__call__( self , * args , ** named )

__getattr__( self , key )

__init__( self , func , ccisvalid )

__repr__( self )

__setattr__( self , key , value )

class _DeprecatedFunctionPointer( _NullFunctionPointer ):

__call__( self , * args , ** named )

class _NullFunctionPointer( object ):

Function-pointer-like object for undefined functions

__bool__( self )

Make this object appear to be NULL

__call__( self , * args , ** named )

__init__( self , name , dll , resultType , argTypes , argNames , extension = None , doc = None , deprecated = False , error_checker = None )

__nonzero__( self )

Make this object appear to be NULL

load( self )

Attempt to load the function again, presumably with a context this time

class BasePlatform( object ):

Base class for per-platform implementations

Attributes of note:

EXPORTED_NAMES: set of names exported via the platform module's namespace...

GL, GLU, GLUT, GLE, GLES1, GLES2, GLES3 -- ctypes libraries

DEFAULT_FUNCTION_TYPE: used as the default function type for functions unless overridden on a per-DLL basis with a "FunctionType" member

GLUT_GUARD_CALLBACKS: if True, the GLUT wrappers will provide guarding wrappers to prevent GLUT errors with uninitialised GLUT.

EXTENSIONS_USE_BASE_FUNCTIONS: if True, uses regular dll attribute-based lookup to retrieve extension function pointers.

CurrentContextIsValid

OpenGL

checkExtension( self , name )

Check whether the given extension is supported by current context

constructFunction( self , functionName , dll , resultType = <class 'ctypes.c_int'> , argTypes = () , doc = None , argNames = () , extension = None , deprecated = False , module = None , force_extension = False , error_checker = None )

Core operation to create a new base ctypes function

raises AttributeError if can't find the procedure...

copyBaseFunction( self , original )

Create a new base function based on an already-created function

This is normally used to provide type-specific convenience versions of a definition created by the automated generator.

createBaseFunction( self , functionName , dll , resultType = <class 'ctypes.c_int'> , argTypes = () , doc = None , argNames = () , extension = None , deprecated = False , module = None , error_checker = None )

Create a base function for given name

Normally you can just use the dll.name hook to get the object, but we want to be able to create different bindings for the same function, so we do the work manually here to produce a base function from a DLL.

createExtensionFunction( self , functionName , dll , resultType = <class 'ctypes.c_int'> , argTypes = () , doc = None , argNames = () , extension = None , deprecated = False , module = None , error_checker = None )

Create a base function for given name

errorChecking( self , func , dll , error_checker = None )

Add error checking to the function if appropriate

finalArgType( self , typ )

Retrieve a final type for arg-type

functionTypeFor( self , dll )

Given a DLL, determine appropriate function type...

GetCurrentContext( self )

Retrieve opaque pointer for the current context

getGLUTFontPointer( self , constant )

Retrieve a GLUT font pointer for this platform

install( self , namespace )

Install this platform instance into the platform module

nullFunction( self , functionName , dll , resultType = <class 'ctypes.c_int'> , argTypes = () , doc = None , argNames = () , extension = None , deprecated = False , module = None , error_checker = None )

Construct a "null" function pointer

wrapContextCheck( self , func , dll )

Wrap function with context-checking if appropriate

wrapLogging( self , func )

Wrap function with logging operations if appropriate

class lazy_property( object ):

__get__( self , obj , cls )

__init__( self , function )