1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
"""Extension module support methods
This module provides the tools required to check whether
an extension is available
"""
from OpenGL.latebind import LateBind
import logging
log = logging.getLogger( 'OpenGL.extensions' )
VERSION_PREFIX = 'GL_VERSION_GL_'
CURRENT_GL_VERSION = None
AVAILABLE_GL_EXTENSIONS = []
AVAILABLE_GLU_EXTENSIONS = []
def getGLVersion( ):
"""Retrieve 2-int declaration of major/minor GL version
returns [int(major),int(minor)] or False if not loaded
"""
global CURRENT_GL_VERSION
if not CURRENT_GL_VERSION:
from OpenGL.GL import glGetString, GL_VERSION
new = glGetString( GL_VERSION )
log.info( 'OpenGL Version: %s', new )
if new:
CURRENT_GL_VERSION = [
int(x) for x in new.split(' ',1)[0].split( '.' )
]
else:
return False # not yet loaded/supported
return CURRENT_GL_VERSION
def hasGLExtension( specifier ):
"""Given a string specifier, check for extension being available"""
global AVAILABLE_GL_EXTENSIONS
specifier = specifier.replace('.','_')
if specifier.startswith( VERSION_PREFIX ):
specifier = [
int(x)
for x in specifier[ len(VERSION_PREFIX):].split('_')
]
version = getGLVersion()
if not version:
return version
return specifier <= version
else:
from OpenGL.GL import glGetString, GL_EXTENSIONS
if not AVAILABLE_GL_EXTENSIONS:
AVAILABLE_GL_EXTENSIONS[:] = glGetString( GL_EXTENSIONS ).split()
result = specifier in AVAILABLE_GL_EXTENSIONS
log.info(
'GL Extension %s %s',
specifier,
['unavailable','available'][bool(result)]
)
return result
def hasGLUExtension( specifier ):
"""Given a string specifier, check for extension being available"""
from OpenGL.GLU import gluGetString, GLU_EXTENSIONS
if not AVAILABLE_GLU_EXTENSIONS:
AVAILABLE_GLU_EXTENSIONS[:] = gluGetString( GLU_EXTENSIONS )
return specifier.replace('.','_') in AVAILABLE_GLU_EXTENSIONS
class _Alternate( LateBind ):
def __init__( self, name, *alternates ):
"""Initialize set of alternative implementations of the same function"""
self.__name__ = name
self._alternatives = alternates
def __nonzero__( self ):
from OpenGL import error
try:
return bool( self.getFinalCall())
except error.NullFunctionError, err:
return False
def finalise( self ):
"""Call, doing a late lookup and bind to find an implementation"""
for alternate in self._alternatives:
if alternate:
log.info(
"""Chose alternate: %s from %s""",
alternate.__name__,
", ".join([x.__name__ for x in self._alternatives])
)
return alternate
from OpenGL import error
raise error.NullFunctionError(
"""Attempt to call an undefined alternate function (%s), check for bool(%s) before calling"""%(
', '.join([x.__name__ for x in self._alternatives]),
self.__name__,
)
)
def alternate( name, *functions ):
"""Construct a callable that functions as the first implementation found of given set of alternatives
if name is a function then its name will be used....
"""
if not isinstance( name, (str,unicode)):
functions = (name,)+functions
name = name.__name__
return type( name, (_Alternate,), {} )( name, *functions )
|
