|
|
"""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 ) |
|
|
|
