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