| """ctypes-based OpenGL wrapper for Python |
| |
| This is the PyOpenGL 3.x tree, it attempts to provide |
| a largely compatible API for code written with the |
| PyOpenGL 2.x series using the ctypes foreign function |
| interface system. |
| |
| Configuration Variables: |
| |
| There are a few configuration variables in this top-level |
| module. Applications should be the only code that tweaks |
| these variables, mid-level libraries should not take it |
| upon themselves to disable/enable features at this level. |
| The implication there is that your library code should be |
| able to work with any of the valid configurations available |
| with these sets of flags. |
| |
| Further, once any entry point has been loaded, the variables |
| can no longer be updated. The OpenGL._confligflags module |
| imports the variables from this location, and once that |
| import occurs the flags should no longer be changed. |
| |
| ERROR_CHECKING -- if set to a False value before |
| importing any OpenGL.* libraries will completely |
| disable error-checking. This can dramatically |
| improve performance, but makes debugging far |
| harder. |
| |
| This is intended to be turned off *only* in a |
| production environment where you *know* that |
| your code is entirely free of situations where you |
| use exception-handling to handle error conditions, |
| i.e. where you are explicitly checking for errors |
| everywhere they can occur in your code. |
| |
| Default: True |
| |
| ERROR_LOGGING -- If True, then wrap array-handler |
| functions with error-logging operations so that all exceptions |
| will be reported to log objects in OpenGL.logs, note that |
| this means you will get lots of error logging whenever you |
| have code that tests by trying something and catching an |
| error, this is intended to be turned on only during |
| development so that you can see why something is failing. |
| |
| Errors are normally logged to the OpenGL.errors logger. |
| |
| Only triggers if ERROR_CHECKING is True |
| |
| Default: False |
| |
| ERROR_ON_COPY -- if set to a True value before |
| importing the numpy/lists support modules, will |
| cause array operations to raise |
| OpenGL.error.CopyError if the operation |
| would cause a data-copy in order to make the |
| passed data-type match the target data-type. |
| |
| This effectively disables all list/tuple array |
| support, as they are inherently copy-based. |
| |
| This feature allows for optimisation of your |
| application. It should only be enabled during |
| testing stages to prevent raising errors on |
| recoverable conditions at run-time. |
| |
| Default: False |
| |
| CONTEXT_CHECKING -- if set to True, PyOpenGL will wrap |
| *every* GL and GLU call with a check to see if there |
| is a valid context. If there is no valid context |
| then will throw OpenGL.errors.NoContext. This is an |
| *extremely* slow check and is not enabled by default, |
| intended to be enabled in order to track down (wrong) |
| code that uses GL/GLU entry points before the context |
| has been initialized (something later Linux GLs are |
| very picky about). |
| |
| Default: False |
| |
| STORE_POINTERS -- if set to True, PyOpenGL array operations |
| will attempt to store references to pointers which are |
| being passed in order to prevent memory-access failures |
| if the pointed-to-object goes out of scope. This |
| behaviour is primarily intended to allow temporary arrays |
| to be created without causing memory errors, thus it is |
| trading off performance for safety. |
| |
| To use this flag effectively, you will want to first set |
| ERROR_ON_COPY to True and eliminate all cases where you |
| are copying arrays. Copied arrays *will* segfault your |
| application deep within the GL if you disable this feature! |
| |
| Once you have eliminated all copying of arrays in your |
| application, you will further need to be sure that all |
| arrays which are passed to the GL are stored for at least |
| the time period for which they are active in the GL. That |
| is, you must be sure that your array objects live at least |
| until they are no longer bound in the GL. This is something |
| you need to confirm by thinking about your application's |
| structure. |
| |
| When you are sure your arrays won't cause seg-faults, you |
| can set STORE_POINTERS=False in your application and enjoy |
| a (slight) speed up. |
| |
| Note: this flag is *only* observed when ERROR_ON_COPY == True, |
| as a safety measure to prevent pointless segfaults |
| |
| Default: True |
| |
| WARN_ON_FORMAT_UNAVAILABLE -- If True, generates |
| logging-module warn-level events when a FormatHandler |
| plugin is not loadable (with traceback). |
| |
| Default: False |
| |
| FULL_LOGGING -- If True, then wrap functions with |
| logging operations which reports each call along with its |
| arguments to the OpenGL.calltrace logger at the INFO |
| level. This is *extremely* slow. You should *not* enable |
| this in production code! |
| |
| You will need to have a logging configuration (e.g. |
| logging.basicConfig() |
| ) call in your top-level script to see the results of the |
| logging. |
| |
| Default: False |
| |
| ALLOW_NUMPY_SCALARS -- if True, we will wrap |
| all GLint/GLfloat calls conversions with wrappers |
| that allow for passing numpy scalar values. |
| |
| Note that this is experimental, *not* reliable, |
| and very slow! |
| |
| Note that byte/char types are not wrapped. |
| |
| Default: False |
| |
| UNSIGNED_BYTE_IMAGES_AS_STRING -- if True, we will return |
| GL_UNSIGNED_BYTE image-data as strings, instead of arrays |
| for glReadPixels and glGetTexImage |
| |
| Default: True |
| |
| FORWARD_COMPATIBLE_ONLY -- only include OpenGL 3.1 compatible |
| entry points. Note that this will generally break most |
| PyOpenGL code that hasn't been explicitly made "legacy free" |
| via a significant rewrite. |
| |
| Default: False |
| |
| SIZE_1_ARRAY_UNPACK -- if True, unpack size-1 arrays to be |
| scalar values, as done in PyOpenGL 1.5 -> 3.0.0, that is, |
| if a glGenList( 1 ) is done, return a uint rather than |
| an array of uints. |
| |
| Default: True |
| |
| USE_ACCELERATE -- if True, attempt to use the OpenGL_accelerate |
| package to provide Cython-coded accelerators for core wrapping |
| operations. |
| |
| Default: True |
| |
| MODULE_ANNOTATIONS -- if True, attempt to annotate alternates() and |
| constants to track in which module they are defined (only useful |
| for the documentation-generation passes, really). |
| |
| Default: False |
| """ |
| from OpenGL.version import __version__ |
| import os |
| def environ_key( name, default ): |
| composed = 'PYOPENGL_%s'%name.upper() |
| if composed in os.environ: |
| value = os.environ[composed] |
| if value.lower() in ('1','true'): |
| return True |
| else: |
| return False |
| return os.environ.get( composed, default ) |
|
|
| ERROR_CHECKING = environ_key( 'ERROR_CHECKING', True) |
| ERROR_LOGGING = environ_key( 'ERROR_LOGGING', False ) |
| ERROR_ON_COPY = environ_key( 'ERROR_ON_COPY', False ) |
| ARRAY_SIZE_CHECKING = environ_key( 'ARRAY_SIZE_CHECKING', True ) |
| STORE_POINTERS = environ_key( 'STORE_POINTERS', True ) |
| WARN_ON_FORMAT_UNAVAILABLE = False |
| FORWARD_COMPATIBLE_ONLY = False |
| SIZE_1_ARRAY_UNPACK = True |
| USE_ACCELERATE = environ_key( 'USE_ACCELERATE', True ) |
| CONTEXT_CHECKING = environ_key( 'CONTEXT_CHECKING', False ) |
|
|
| FULL_LOGGING = environ_key( 'FULL_LOGGING', False ) |
| ALLOW_NUMPY_SCALARS = environ_key( 'ALLOW_NUMPY_SCALARS', False ) |
| UNSIGNED_BYTE_IMAGES_AS_STRING = environ_key( 'UNSIGNED_BYTE_IMAGES_AS_STRING', True ) |
| MODULE_ANNOTATIONS = False |
|
|
| |
| from OpenGL.plugins import PlatformPlugin, FormatHandler |
| PlatformPlugin( 'nt', 'OpenGL.platform.win32.Win32Platform' ) |
| PlatformPlugin( 'linux2', 'OpenGL.platform.glx.GLXPlatform' ) |
| PlatformPlugin( 'darwin', 'OpenGL.platform.darwin.DarwinPlatform' ) |
| PlatformPlugin( 'posix', 'OpenGL.platform.glx.GLXPlatform' ) |
| PlatformPlugin( 'osmesa', 'OpenGL.platform.osmesa.OSMesaPlatform') |
| PlatformPlugin( 'egl', 'OpenGL.platform.egl.EGLPlatform') |
|
|
| import sys |
| if sys.version_info[0] < 3: |
| |
| _bi = '__builtin__' |
| else: |
| _bi = 'builtins' |
|
|
| FormatHandler( 'none', 'OpenGL.arrays.nones.NoneHandler', [ _bi+'.NoneType'],isOutput=False ) |
|
|
| if sys.version_info[0] < 3: |
| FormatHandler( 'str', 'OpenGL.arrays.strings.StringHandler',[_bi+'.str'], isOutput=False ) |
| FormatHandler( 'unicode', 'OpenGL.arrays.strings.UnicodeHandler',[_bi+'.unicode'], isOutput=False ) |
| else: |
| FormatHandler( 'bytes', 'OpenGL.arrays.strings.StringHandler',[_bi+'.bytes'], isOutput=False ) |
| FormatHandler( 'str', 'OpenGL.arrays.strings.UnicodeHandler',[_bi+'.str'], isOutput=False ) |
| |
| FormatHandler( 'list', 'OpenGL.arrays.lists.ListHandler', [ |
| _bi+'.list', |
| _bi+'.tuple', |
| ], isOutput=False ) |
| FormatHandler( 'numbers', 'OpenGL.arrays.numbers.NumberHandler', [ |
| _bi+'.int', |
| _bi+'.float', |
| _bi+'.long', |
| ], isOutput=False ) |
| FormatHandler( |
| 'ctypesarrays', 'OpenGL.arrays.ctypesarrays.CtypesArrayHandler', |
| [ |
| '_ctypes.ArrayType', |
| '_ctypes.PyCArrayType', |
| '_ctypes.Array', |
| '_ctypes.array.Array', |
| ], |
| isOutput=True, |
| ) |
| FormatHandler( |
| 'ctypesparameter', |
| 'OpenGL.arrays.ctypesparameters.CtypesParameterHandler', |
| [ |
| _bi+'.CArgObject', |
| 'ctypes.c_uint', |
| 'ctypes.c_int', |
| 'ctypes.c_float', |
| 'ctypes.c_double', |
| 'ctypes.c_ulong', |
| 'ctypes.c_long', |
| 'ctypes.c_longlong', |
| ], |
| isOutput=True, |
| ) |
| FormatHandler( 'ctypespointer', 'OpenGL.arrays.ctypespointers.CtypesPointerHandler',[ |
| 'ctypes.c_void_p', |
| '_ctypes._Pointer', |
| 'ctypes.c_char_p', |
| '_ctypes.pointer._Pointer', |
| ],isOutput=False ) |
| FormatHandler( 'numpy', 'OpenGL.arrays.numpymodule.NumpyHandler', [ |
| 'numpy.ndarray', |
| 'numpy.core.memmap.memmap', |
| ],isOutput=True ) |
| FormatHandler( 'buffer', 'OpenGL.arrays.buffers.BufferHandler', [ |
| 'OpenGL.arrays._buffers.Py_buffer', |
| _bi+'.memoryview', |
| _bi+'.bytearray', |
| ],isOutput=True ) |
| FormatHandler( 'vbo', 'OpenGL.arrays.vbo.VBOHandler', ['OpenGL.arrays.vbo.VBO','OpenGL_accelerate.vbo.VBO'],isOutput=False ) |
| FormatHandler( 'vbooffset', 'OpenGL.arrays.vbo.VBOOffsetHandler', ['OpenGL.arrays.vbo.VBOOffset','OpenGL_accelerate.vbo.VBOOffset'],isOutput=False ) |
|
|
