|
|
"""Implementation of OpenGL errors/exceptions |
|
|
|
|
|
Note that OpenGL-ctypes will also throw standard errors, |
|
|
such as TypeError or ValueError when appropriate. |
|
|
|
|
|
ErrorChecker is an _ErrorChecker instance that allows you |
|
|
to register a new error-checking function for use |
|
|
throughout the system. |
|
|
""" |
|
|
import logging |
|
|
_log = logging.getLogger( 'OpenGL.error' ) |
|
|
from OpenGL import platform, _configflags |
|
|
from ctypes import ArgumentError |
|
|
__all__ = ( |
|
|
"Error",'GLError','GLUError','GLUTError', |
|
|
'GLerror','GLUerror','GLUTerror','ArgumentError', |
|
|
) |
|
|
|
|
|
class Error( Exception ): |
|
|
"""Base class for all PyOpenGL-specific exception classes""" |
|
|
class NoContext( Error ): |
|
|
"""Raised to indicate that there is no currently active context |
|
|
|
|
|
Technically almost *any* OpenGL call can segfault if there is |
|
|
no active context. The OpenGL.CHECK_CONTEXT flag, if enabled |
|
|
will cause this error to be raised whenever a GL or GLU call is |
|
|
issued (via PyOpenGL) if there is no currently valid context. |
|
|
""" |
|
|
class CopyError( Error ): |
|
|
"""Raised to indicate that operation requires data-copying |
|
|
|
|
|
if you set: |
|
|
OpenGL.ERROR_ON_COPY = True |
|
|
|
|
|
before importing OpenGL.GL, this error will be raised when |
|
|
a passed argument would require a copy to be made. |
|
|
""" |
|
|
|
|
|
class NullFunctionError( Error ): |
|
|
"""Error raised when an undefined function is called""" |
|
|
|
|
|
class GLError( Error ): |
|
|
"""OpenGL core error implementation class |
|
|
|
|
|
Primary purpose of this error class is to allow for |
|
|
annotating an error with more details about the calling |
|
|
environment so that it's easier to debug errors in the |
|
|
wrapping process. |
|
|
|
|
|
Attributes: |
|
|
|
|
|
err -- the OpenGL error code for the error |
|
|
result -- the OpenGL result code for the operation |
|
|
baseOperation -- the "function" being called |
|
|
pyArgs -- the translated set of Python arguments |
|
|
cArgs -- the Python objects matching 1:1 the C arguments |
|
|
cArguments -- ctypes-level arguments to the operation, |
|
|
often raw integers for pointers and the like |
|
|
description -- OpenGL description of the error (textual) |
|
|
""" |
|
|
def __init__( |
|
|
self, |
|
|
err=None, |
|
|
result=None, |
|
|
cArguments=None, |
|
|
baseOperation=None, |
|
|
pyArgs=None, |
|
|
cArgs=None, |
|
|
description=None, |
|
|
): |
|
|
"""Initialise the GLError, storing metadata for later display""" |
|
|
( |
|
|
self.err, self.result, self.cArguments, |
|
|
self.baseOperation, self.pyArgs, self.cArgs, |
|
|
self.description |
|
|
) = ( |
|
|
err, result, cArguments, |
|
|
baseOperation, pyArgs, cArgs, |
|
|
description |
|
|
) |
|
|
DISPLAY_ORDER = ( |
|
|
'err', |
|
|
'description', |
|
|
'baseOperation', |
|
|
'pyArgs', |
|
|
'cArgs', |
|
|
'cArguments', |
|
|
'result', |
|
|
) |
|
|
def __str__( self ): |
|
|
"""Create a fully formatted representation of the error""" |
|
|
args = [] |
|
|
for property in self.DISPLAY_ORDER: |
|
|
value = getattr( self, property, None ) |
|
|
if value is not None or property=='description': |
|
|
formatFunction = 'format_%s'%(property) |
|
|
if hasattr( self, formatFunction ): |
|
|
args.append( getattr(self,formatFunction)( property, value )) |
|
|
else: |
|
|
args.append( '%s = %s'%( |
|
|
property, |
|
|
self.shortRepr( value ), |
|
|
)) |
|
|
return '%s(\n\t%s\n)'%(self.__class__.__name__, ',\n\t'.join( |
|
|
[x for x in args if x] |
|
|
)) |
|
|
def __repr__( self ): |
|
|
"""Produce a much shorter version of the error as a string""" |
|
|
return '%s( %s )'%( |
|
|
self.__class__.__name__, |
|
|
", ".join([x for x in [ |
|
|
'err=%s'%(self.err), |
|
|
self.format_description( 'description', self.description ) or '', |
|
|
self.format_baseOperation( 'baseOperation', self.baseOperation ) or '', |
|
|
] if x]) |
|
|
) |
|
|
def format_description( self, property, value ): |
|
|
"""Format description using GLU's gluErrorString""" |
|
|
if value is None and self.err is not None: |
|
|
try: |
|
|
from OpenGL.GLU import gluErrorString |
|
|
self.description = value = gluErrorString( self.err ) |
|
|
except Exception as err: |
|
|
return None |
|
|
if value is None: |
|
|
return None |
|
|
return '%s = %s'%( |
|
|
property, |
|
|
self.shortRepr( value ), |
|
|
) |
|
|
def shortRepr( self, value, firstLevel=True ): |
|
|
"""Retrieve short representation of the given value""" |
|
|
if isinstance( value, (list,tuple) ) and value and len(repr(value))>=40: |
|
|
if isinstance( value, list ): |
|
|
template = '[\n\t\t%s\n\t]' |
|
|
else: |
|
|
template = '(\n\t\t%s,\n\t)' |
|
|
return template%( ",\n\t\t".join( |
|
|
[ |
|
|
self.shortRepr(x,False) for x in value |
|
|
] |
|
|
)) |
|
|
r = repr( value ) |
|
|
if len(r) < 120: |
|
|
return r |
|
|
else: |
|
|
return r[:117] + '...' |
|
|
def format_baseOperation( self, property, value ): |
|
|
"""Format a baseOperation reference for display""" |
|
|
if hasattr( value, '__name__' ): |
|
|
return '%s = %s'%( property, value.__name__ ) |
|
|
else: |
|
|
return '%s = %r'%( property, value ) |
|
|
|
|
|
class GLUError( Error ): |
|
|
"""GLU error implementation class""" |
|
|
|
|
|
class GLUTError( Error ): |
|
|
"""GLUT error implementation class""" |
|
|
|
|
|
|
|
|
if _configflags.ERROR_CHECKING: |
|
|
from OpenGL import acceleratesupport |
|
|
_ErrorChecker = None |
|
|
if acceleratesupport.ACCELERATE_AVAILABLE: |
|
|
try: |
|
|
from OpenGL_accelerate.errorchecker import _ErrorChecker |
|
|
except ImportError as err: |
|
|
_log.warn( """OpenGL_accelerate seems to be installed, but unable to import error checking entry point!""" ) |
|
|
if _ErrorChecker is None: |
|
|
class _ErrorChecker( object ): |
|
|
"""Per-API error-checking object |
|
|
|
|
|
Attributes: |
|
|
_registeredChecker -- the checking function enabled when |
|
|
not doing onBegin/onEnd processing |
|
|
_currentChecker -- currently active checking function |
|
|
""" |
|
|
_getErrors = None |
|
|
def __init__( self, platform, baseOperation=None, noErrorResult=0 ): |
|
|
"""Initialize from a platform module/reference""" |
|
|
self._isValid = platform.CurrentContextIsValid |
|
|
self._getErrors = baseOperation |
|
|
self._noErrorResult = noErrorResult |
|
|
if self._getErrors: |
|
|
if _configflags.CONTEXT_CHECKING: |
|
|
self._registeredChecker = self.safeGetError |
|
|
else: |
|
|
self._registeredChecker = self._getErrors |
|
|
else: |
|
|
self._registeredChecker = self.nullGetError |
|
|
self._currentChecker = self._registeredChecker |
|
|
def __bool__( self ): |
|
|
"""We are "true" if we actually do anything""" |
|
|
if self._registeredChecker is self.nullGetError: |
|
|
return False |
|
|
return True |
|
|
def safeGetError( self ): |
|
|
"""Check for error, testing for context before operation""" |
|
|
if self._isValid(): |
|
|
return self._getErrors() |
|
|
return None |
|
|
def nullGetError( self ): |
|
|
"""Used as error-checker when no error checking should be done""" |
|
|
return self._noErrorResult |
|
|
def glCheckError( |
|
|
self, |
|
|
result, |
|
|
baseOperation=None, |
|
|
cArguments=None, |
|
|
*args |
|
|
): |
|
|
"""Base GL Error checker compatible with new ctypes errcheck protocol |
|
|
|
|
|
This function will raise a GLError with just the calling information |
|
|
available at the C-calling level, i.e. the error code, cArguments, |
|
|
baseOperation and result. Higher-level code is responsible for any |
|
|
extra annotations. |
|
|
|
|
|
Note: |
|
|
glCheckError relies on glBegin/glEnd interactions to |
|
|
prevent glGetError being called during a glBegin/glEnd |
|
|
sequence. If you are calling glBegin/glEnd in C you |
|
|
should call onBegin and onEnd appropriately. |
|
|
""" |
|
|
err = self._currentChecker() |
|
|
if err != self._noErrorResult: |
|
|
raise GLError( |
|
|
err, |
|
|
result, |
|
|
cArguments = cArguments, |
|
|
baseOperation = baseOperation, |
|
|
) |
|
|
return result |
|
|
def onBegin( self ): |
|
|
"""Called by glBegin to record the fact that glGetError won't work""" |
|
|
self._currentChecker = self.nullGetError |
|
|
def onEnd( self ): |
|
|
"""Called by glEnd to record the fact that glGetError will work""" |
|
|
self._currentChecker = self._registeredChecker |
|
|
else: |
|
|
_ErrorChecker = None |
|
|
|
|
|
GLUerror = GLUError |
|
|
GLerror = GLError |
|
|
GLUTerror = GLUTError |
|
|
|
