def command( self, element, context=None ):
"""Parse command definition into structured format"""
proto = element.find( 'proto' )
if proto is not None:
name = as_8_bit(proto.find('name').text)
assert name, 'No name in command: %s'%(ET.tostring( element))
return_type = self._type_decl( proto )
assert return_type, 'No return type in command: %s'%(ET.tostring( element))
arg_names = []
arg_types = []
lengths = {}
groups = {}
for param in [x for x in element if x.tag == 'param']:
pname = as_8_bit(param.find( 'name' ).text)
arg_names.append( pname )
arg_types.append( self._type_decl( param ))
if param.get( 'len' ):
length = param.get('len')
while length.endswith( '*1' ):
length = length[:-2]
length = LENGTH_OVERRIDES.get(name,{}).get(pname,length)
lengths[pname] = length
if param.get( 'group' ):
groups[pname] = param.get('group')
aliases = []
for alias in [x for x in element if x.tag == 'alias']:
aliases.append( alias.get('name') )
# Process lengths to look for output parameters
outputs = self.output_mapping.get( name )
command = Command( name, return_type, arg_names, arg_types, aliases, lengths,groups, outputs=outputs )
self.command_set[name] = command
elif isinstance( context, (Require,Remove)):
context.append( self.command_set[element.get('name')])
def enum( self, element, context=None ):
if isinstance( context, EnumNamespace ):
name,value = as_8_bit(element.get('name')),element.get('value')
enum = Enum( name, value )
context.append( enum )
self.enumeration_set[name] = enum
elif isinstance( context, (Require,Remove)):
context.append( self.enumeration_set[element.get('name')] )
elif isinstance( context, EnumGroup ):
name = element.get('name')
assert name, 'No name on %s'%ET.tostring(element)
context.append( as_8_bit(name) )
def hasGLExtension( specifier ):
"""Given a string specifier, check for extension being available"""
global AVAILABLE_GL_EXTENSIONS
specifier = as_8_bit(specifier).replace(as_8_bit('.'),as_8_bit('_'))
if specifier.startswith( VERSION_PREFIX ):
specifier = [
int(x)
for x in specifier[ len(VERSION_PREFIX):].split(as_8_bit('_'))
]
version = getGLVersion()
if not version:
return version
return specifier <= version
else:
from OpenGL.GL import glGetString, GL_EXTENSIONS
from OpenGL import error
if not AVAILABLE_GL_EXTENSIONS:
try:
AVAILABLE_GL_EXTENSIONS[:] = glGetString( GL_EXTENSIONS ).split()
except (AttributeError, error.GLError) as err:
# OpenGL 3.0 deprecates glGetString( GL_EXTENSIONS )
from OpenGL.GL.VERSION.GL_3_0 import GL_NUM_EXTENSIONS, glGetStringi
from OpenGL.GL import glGetIntegerv
count = glGetIntegerv( GL_NUM_EXTENSIONS )
for i in range( count ):
extension = glGetStringi( GL_EXTENSIONS, i )
AVAILABLE_GL_EXTENSIONS.append(
extension
)
# Add included-by-reference extensions...
version = getGLVersion()
if not version:
# should not be possible?
return version
check = tuple( version[:2] )
for (v,v_exts) in VERSION_EXTENSIONS:
if v <= check:
for v_ext in v_exts:
if v_ext not in AVAILABLE_GL_EXTENSIONS:
AVAILABLE_GL_EXTENSIONS.append( v_ext )
else:
break
result = specifier in AVAILABLE_GL_EXTENSIONS
log.info(
'GL Extension %s %s',
specifier,
['unavailable','available'][bool(result)]
)
return result
def compileShader( source, shaderType ):
"""Compile shader source of given type
source -- GLSL source-code for the shader
shaderType -- GLenum GL_VERTEX_SHADER, GL_FRAGMENT_SHADER, etc,
returns GLuint compiled shader reference
raises RuntimeError when a compilation failure occurs
"""
if isinstance( source, (bytes,unicode)):
source = [ source ]
source = [ as_8_bit(s) for s in source ]
shader = glCreateShader(shaderType)
glShaderSource( shader, source )
glCompileShader( shader )
result = glGetShaderiv( shader, GL_COMPILE_STATUS )
if result == GL_FALSE:
# TODO: this will be wrong if the user has
# disabled traditional unpacking array support.
raise RuntimeError(
"""Shader compile failure (%s): %s"""%(
result,
glGetShaderInfoLog( shader ),
),
source,
shaderType,
)
return shader
def constructFunction(
self,
functionName, dll,
resultType=ctypes.c_int, argTypes=(),
doc = None, argNames = (),
extension = None,
deprecated = False,
module = None,
):
"""Core operation to create a new base ctypes function
raises AttributeError if can't find the procedure...
"""
if extension == 'GL_VERSION_GL_1_1':
extension = None
if extension and not self.checkExtension( extension ):
raise AttributeError( """Extension not available""" )
argTypes = [ self.finalArgType( t ) for t in argTypes ]
if extension and not self.EXTENSIONS_USE_BASE_FUNCTIONS:
# what about the VERSION values???
if self.checkExtension( extension ):
pointer = self.getExtensionProcedure( as_8_bit(functionName) )
if pointer:
func = self.functionTypeFor( dll )(
resultType,
*argTypes
)(
pointer
)
else:
raise AttributeError( """Extension %r available, but no pointer for function %r"""%(extension,functionName))
else:
raise AttributeError( """No extension %r"""%(extension,))
else:
func = ctypesloader.buildFunction(
self.functionTypeFor( dll )(
resultType,
*argTypes
),
functionName,
dll,
)
func.__doc__ = doc
func.argNames = list(argNames or ())
func.__name__ = functionName
func.DLL = dll
func.extension = extension
func.deprecated = deprecated
func = self.wrapLogging(
self.wrapContextCheck(
self.errorChecking( func, dll ),
dll,
)
)
if MODULE_ANNOTATIONS:
if not module:
module = _find_module( )
if module:
func.__module__ = module
return func
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(as_8_bit(' '),1)[0].split( as_8_bit('.') )
]
else:
return False # not yet loaded/supported
return CURRENT_GL_VERSION
def enums( self, element, context=None ):
name = as_8_bit(element.get('namespace'))
if name not in self.enum_namespaces:
namespace = EnumNamespace(name)
self.enum_namespaces[name] = namespace
else:
namespace = self.enum_namespaces[name]
self.dispatch( element, namespace )
def glGetUniformLocationARB( baseOperation, program, name ):
"""Check that name is a string with a null byte at the end of it"""
if not name:
raise ValueError( """Non-null name required""" )
name = as_8_bit( name )
if name[-1] != _NULL_8_BYTE:
name = name + _NULL_8_BYTE
return baseOperation( program, name )
def glutInit( *args ):
"""Initialise the GLUT library"""
global INITIALIZED
if INITIALIZED:
return args
INITIALIZED = True
if args:
arg,args = args[0],args[1:]
count = None
if isinstance(arg, integer_types):
# raw API style, (count, values)
count = arg
if count != len(args):
raise ValueError( """Specified count of %s does not match length (%s) of argument list %s"""%(
count, len(args), args,
))
elif isinstance( arg, (bytes,unicode)):
# passing in a sequence of strings as individual arguments
args = (arg,)+args
count = len(args)
else:
args = arg
count = len(args)
else:
count=0
args = []
args = [as_8_bit(x) for x in args]
if not count:
count, args = 1, [as_8_bit('foo')]
holder = (ctypes.c_char_p * len(args))()
for i,arg in enumerate(args):
holder[i] = arg
count = ctypes.c_int( count )
import os
currentDirectory = os.getcwd()
try:
# XXX need to check for error condition here...
_base_glutInit( ctypes.byref(count), holder )
finally:
os.chdir( currentDirectory )
return [
holder[i] for i in range( count.value )
]
def __call__( self, specifier ):
specifier = as_8_bit(specifier).replace(as_8_bit('.'),as_8_bit('_'))
if not specifier.startswith( self.prefix ):
return None
if specifier.startswith( self.version_prefix ):
specifier = [
int(x)
for x in specifier[ len(self.version_prefix):].split(as_8_bit('_'))
]
if specifier[:2] <= self.assumed_version:
return True
version = self.getVersion()
if not version:
return version
return specifier <= version
else:
extensions = self.getExtensions()
return extensions and specifier in extensions
def pullVersion( self ):
"""Retrieve 2-int declaration of major/minor GL version
returns [int(major),int(minor)] or False if not loaded
"""
from OpenGL import platform
if not platform.PLATFORM.CurrentContextIsValid():
return False
from OpenGL.raw.GL.VERSION.GL_1_1 import glGetString
from OpenGL.raw.GL.VERSION.GL_1_1 import GL_VERSION
new = glGetString( GL_VERSION )
self.version_string = new
if new:
return [
int(x) for x in new.split(as_8_bit(' '),1)[0].split( as_8_bit('.') )
]
else:
return False # not yet loaded/supported
def from_param(cls, value):
# TODO: raise CopyError if the flag is set!
converted = _bytes.as_8_bit(value)
result = StringHandler.from_param()
if converted is not value:
if ERROR_ON_COPY:
raise error.CopyError(
"""Unicode string passed, cannot copy with ERROR_ON_COPY set, please use 8-bit strings"""
)
result._temporary_array_ = converted
return result
def test_shader_compile_string( self ):
shader = glCreateShader(GL_VERTEX_SHADER)
SAMPLE_SHADER = '''#version 330
void main() { gl_Position = vec4(0,0,0,0);}'''
if OpenGL.ERROR_ON_COPY:
SAMPLE_SHADER = as_8_bit( SAMPLE_SHADER )
glShaderSource(shader, SAMPLE_SHADER)
glCompileShader(shader)
if not bool(glGetShaderiv(shader, GL_COMPILE_STATUS)) == True:
print('Info log:')
print(glGetShaderInfoLog(shader))
assert False, """Failed to compile"""
def initialize_presentation():
global CB_cycle_left
global CB_cycle_right
global CB_left
global CB_right
global dtLeft # period of left checkerboard
global dtRight # period of right checkerboard
global tLeft # time since left board rendered
global tRight # time since right board rendered
global t0 # initial time
global t_list_left
global t_list_right
global screen_limits
global xTranslateLeft
global xTranslateRight
global yTranslate
global esc_key
global render_time_list
global idleFunc_time_list
global idleFunc_call_list
# create checkerboards
cb1 = pl.CheckerBoard(1, color1 = [1.0, 1.0, 1.0], color2 = [0.0, 0.0, 0.0], width = 0.5)
cb2 = pl.CheckerBoard(1, color1 = [0.0, 0.0, 0.0], color2 = [1.0, 1.0, 1.0], width = 0.5)
CB_cycle_left = itertools.cycle((cb2, cb1))
CB_cycle_right = itertools.cycle((cb2, cb1))
CB_left = CB_cycle_left.next()
CB_right = CB_cycle_right.next()
# get time variables
dtLeft = 1.0/flash_rate_left
dtRight = 1.0/flash_rate_right
tLeft = tRight = t0 = time.time() # time since last change (CB_cycle_left, CB_cycle_right), start time
t_list_left = []
t_list_right = []
render_time_list = []
idleFunc_time_list = []
idleFunc_call_list = []
# get screen size and limits for setting gluOrtho2D
screen_size = get_screen_resolution()
#screen_size = (1440, 878) # HARDCODED screen size because xrandr takes a bit to run on macs
screen_limits = get_screen(screen_size = screen_size)
# get translation quantities for glTranslatef in render_routine
board_width = CB_left.width * CB_left.nrows
xTranslateLeft = - board_width / 2.0 - (0.5 * screen_limits[1]) # distance from origin to where left CB renders
xTranslateRight = - board_width / 2.0 + (0.5 * screen_limits[1]) # distance from origin to where right CB renders
yTranslate = -board_width / 2.0
# set value so esc key can be acted on
esc_key = as_8_bit( '\033' )
def output_wrapping( self ):
"""Generate output wrapping statements for our various functions"""
try:
statements = []
for function in self.registry.commands():
dependencies = function.size_dependencies
if dependencies: # temporarily just do single-output functions...
base = []
for param,dependency in sorted(dependencies.items()):
param = as_8_bit( param )
if isinstance( dependency, xmlreg.Output ):
statements.append( '# %s.%s is OUTPUT without known output size'%(
function.name,param,
))
if isinstance( dependency, xmlreg.Staticsize ):
base.append( '.setOutput(\n %(param)r,size=(%(dependency)r,),orPassIn=True\n)'%locals())
elif isinstance( dependency, xmlreg.Dynamicsize ):
base.append( '.setOutput(\n %(param)r,size=lambda x:(x,),pnameArg=%(dependency)r,orPassIn=True\n)'%locals())
elif isinstance( dependency, xmlreg.Multiple ):
pname,multiple = dependency
base.append( '.setOutput(\n %(param)r,size=lambda x:(x,%(multiple)s),pnameArg=%(pname)r,orPassIn=True\n)'%locals())
elif isinstance( dependency, xmlreg.Compsize ):
if len(dependency) == 1:
pname = dependency[0]
base.append( '.setOutput(\n %(param)r,size=_glgets._glget_size_mapping,pnameArg=%(pname)r,orPassIn=True\n)'%locals())
else:
statements.append('# OUTPUT %s.%s COMPSIZE(%s) '%(function.name,param,', '.join(dependency)) )
elif isinstance( dependency, xmlreg.StaticInput ):
base.append( '.setInputArraySize(\n %(param)r, %(dependency)s\n)'%locals())
elif isinstance( dependency, (xmlreg.DynamicInput, xmlreg.MultipleInput, xmlreg.Input) ):
if dependency is None:
continue
statements.append( '# INPUT %s.%s size not checked against %s'%(
function.name,
param,
dependency
))
base.append( '.setInputArraySize(\n %(param)r, None\n)'%locals())
if base:
base.insert(0, '%s=wrapper.wrapper(%s)'%(function.name,function.name) )
statements.append( ''.join(base ))
return '\n'.join( statements )
except Exception as err:
traceback.print_exc()
import pdb
pdb.set_trace()
def pullExtensions( self ):
from OpenGL import platform
if not platform.PLATFORM.CurrentContextIsValid():
return False
from OpenGL.raw.GL._types import GLint
from OpenGL.raw.GL.VERSION.GL_1_1 import glGetString, glGetError
from OpenGL.raw.GL.VERSION.GL_1_1 import GL_EXTENSIONS
from OpenGL import error
try:
extensions = glGetString( GL_EXTENSIONS )
if glGetError():
raise error.GLError()
if extensions:
extensions = extensions.split()
else:
return False
except (AttributeError, error.GLError):
# OpenGL 3.0 deprecates glGetString( GL_EXTENSIONS )
from OpenGL.raw.GL.VERSION.GL_3_0 import GL_NUM_EXTENSIONS, glGetStringi
from OpenGL.raw.GL.VERSION.GL_1_1 import glGetIntegerv
count = GLint()
glGetIntegerv( GL_NUM_EXTENSIONS, count )
extensions = []
for i in range( count.value ):
extension = glGetStringi( GL_EXTENSIONS, i )
extensions.append(
extension
)
# Add included-by-reference extensions...
version = self.getVersion()
if not version:
# should not be possible?
return version
check = tuple( version[:2] )
for (v,v_exts) in VERSION_EXTENSIONS:
if v <= check:
for v_ext in v_exts:
if v_ext not in extensions:
extensions.append( as_8_bit(v_ext) )
else:
break
return extensions
def test_shader_compile_string( self ):
shader = glCreateShader(GL_VERTEX_SHADER)
def glsl_version():
"""Parse GL_SHADING_LANGUAGE_VERSION into [int(major),int(minor)]"""
version = glGetString( GL_SHADING_LANGUAGE_VERSION )
version = [int(x) for x in version.split(as_8_bit('.'))[:2]]
return version
if glsl_version() < [3,3]:
return
SAMPLE_SHADER = '''#version 330
void main() { gl_Position = vec4(0,0,0,0);}'''
if OpenGL.ERROR_ON_COPY:
SAMPLE_SHADER = as_8_bit( SAMPLE_SHADER )
glShaderSource(shader, SAMPLE_SHADER)
glCompileShader(shader)
if not bool(glGetShaderiv(shader, GL_COMPILE_STATUS)) == True:
print('Info log:')
print(glGetShaderInfoLog(shader))
assert False, """Failed to compile"""
def __new__(cls, name, value=None):
"""Initialise the constant with the given name and value"""
if not isinstance(value, Constant):
if isinstance(value, float) and cls is not FloatConstant:
return FloatConstant(name, value)
elif isinstance(value, int) and cls is not IntConstant:
return IntConstant(name, value)
elif isinstance(value, long) and cls is not LongConstant:
return LongConstant(name, value)
elif isinstance(value, (bytes, unicode)) and cls is not StringConstant:
return StringConstant(name, as_8_bit(value))
if isinstance(value, integer_types):
if value > maxsize: # TODO: I'm guessing this should really by sizeof GLint, not
value = -(value & maxsize)
base = super(Constant, cls).__new__(cls, value)
base.name = name
if _configflags.MODULE_ANNOTATIONS:
frame = sys._getframe().f_back
if frame and frame.f_back and "__name__" in frame.f_back.f_globals:
base.__module__ = frame.f_back.f_globals["__name__"]
return base
def test_errors( self ):
"""Test for error catching/checking"""
try:
glClear( GL_INVALID_VALUE )
except Exception as err:
assert err.err == 1281, ("""Expected invalid value (1281)""", err.err)
else:
assert not OpenGL.ERROR_CHECKING, """No error on invalid glClear"""
try:
glColorPointer(GL_INVALID_VALUE,GL_BYTE,0,None)
except Exception as err:
assert err.err == 1281, ("""Expected invalid value (1281)""", err.err)
assert err.baseOperation, err.baseOperation
assert err.pyArgs == (GL_INVALID_VALUE, GL_BYTE, 0, None), err.pyArgs
assert err.cArgs == (GL_INVALID_VALUE, GL_BYTE, 0, None), err.cArgs
else:
assert not OpenGL.ERROR_CHECKING, """No error on invalid glColorPointer"""
try:
glBitmap(-1,-1,0,0,0,0,as_8_bit(""))
except Exception as err:
assert err.err in (1281,1282), ("""Expected invalid value (1281) or invalid operation (1282)""", err.err)
else:
assert not OpenGL.ERROR_CHECKING, """No error on invalid glBitmap"""
"""Extension module support methods
This module provides the tools required to check whether
an extension is available
"""
from OpenGL.latebind import LateBind
from OpenGL._bytes import bytes, as_8_bit
import OpenGL as root
import sys
import logging
log = logging.getLogger('OpenGL.extensions')
VERSION_PREFIX = as_8_bit('GL_VERSION_GL_')
CURRENT_GL_VERSION = None
AVAILABLE_GL_EXTENSIONS = []
AVAILABLE_GLU_EXTENSIONS = []
# version tuple -> list of implicitly included extensions...
VERSION_EXTENSIONS = [
((3, 0), [
'GL_ARB_vertex_array_object',
'GL_ARB_texture_buffer_object',
'GL_ARB_framebuffer_object',
'GL_ARB_map_buffer_range',
]),
((3, 1), [
'GL_ARB_copy_buffer',
'GL_ARB_uniform_buffer_object',
]),
((3, 2), [
'GL_ARB_draw_elements_base_vertex',
'GL_ARB_provoking_vertex',
def pullVersion( self ):
from OpenGL.GLU import gluGetString,GLU_VERSION
return [
int(x) for x in gluGetString( GLU_VERSION ).split(as_8_bit('_'))
if x.isdigit()
]
def stringArray( self, arg, baseOperation, args ):
"""Create basic array-of-strings object from pyArg"""
if isinstance( arg, (bytes,unicode) ):
arg = [arg]
value = [as_8_bit(x) for x in arg]
return value
"""Extension module support methods
This module provides the tools required to check whether
an extension is available
"""
from OpenGL.latebind import LateBind
from OpenGL._bytes import bytes,as_8_bit
import OpenGL as root
import sys
import logging
log = logging.getLogger( 'OpenGL.extensions' )
VERSION_PREFIX = as_8_bit('GL_VERSION_GL_')
CURRENT_GL_VERSION = None
AVAILABLE_GL_EXTENSIONS = []
AVAILABLE_GLU_EXTENSIONS = []
# version tuple -> list of implicitly included extensions...
VERSION_EXTENSIONS = [
((3,0), [
'GL_ARB_vertex_array_object',
'GL_ARB_texture_buffer_object',
'GL_ARB_framebuffer_object',
'GL_ARB_map_buffer_range',
]),
((3,1), [
'GL_ARB_copy_buffer',
'GL_ARB_uniform_buffer_object',
]),
((3,2), [
'GL_ARB_draw_elements_base_vertex',
'GL_ARB_provoking_vertex',
def asArray(self, value, typeCode=None):
value = _bytes.as_8_bit(value)
return StringHandler.asArray(self, value, typeCode=typeCode)
"""Extension module support methods
This module provides the tools required to check whether
an extension is available
"""
from OpenGL.latebind import LateBind
from OpenGL._bytes import bytes,unicode,as_8_bit
import OpenGL as root
import sys
import logging
_log = logging.getLogger( 'OpenGL.extensions' )
VERSION_PREFIX = as_8_bit('GL_VERSION_GL_')
CURRENT_GL_VERSION = None
AVAILABLE_GL_EXTENSIONS = []
AVAILABLE_GLU_EXTENSIONS = []
# version tuple -> list of implicitly included extensions...
VERSION_EXTENSIONS = [
((3,0), [
as_8_bit('GL_ARB_vertex_array_object'),
as_8_bit('GL_ARB_texture_buffer_object'),
as_8_bit('GL_ARB_framebuffer_object'),
as_8_bit('GL_ARB_map_buffer_range'),
]),
((3,1), [
as_8_bit('GL_ARB_copy_buffer'),
as_8_bit('GL_ARB_uniform_buffer_object'),
]),
((3,2), [
as_8_bit('GL_ARB_draw_elements_base_vertex'),
as_8_bit('GL_ARB_provoking_vertex'),
def output_wrapping(self):
"""Generate output wrapping statements for our various functions"""
try:
statements = []
for function in self.registry.commands():
dependencies = function.size_dependencies
if dependencies: # temporarily just do single-output functions...
base = []
for param, dependency in dependencies.items():
param = as_8_bit(param)
if isinstance(dependency, xmlreg.Output):
statements.append(
'# %s.%s is OUTPUT without known output size' %
(
function.name,
param,
))
if isinstance(dependency, xmlreg.Staticsize):
base.append(
'.setOutput(\n %(param)r,size=(%(dependency)r,),orPassIn=True\n)'
% locals())
elif isinstance(dependency, xmlreg.Dynamicsize):
base.append(
'.setOutput(\n %(param)r,size=lambda x:(x,),pnameArg=%(dependency)r,orPassIn=True\n)'
% locals())
elif isinstance(dependency, xmlreg.Multiple):
pname, multiple = dependency
base.append(
'.setOutput(\n %(param)r,size=lambda x:(x,%(multiple)s),pnameArg=%(pname)r,orPassIn=True\n)'
% locals())
elif isinstance(dependency, xmlreg.Compsize):
if len(dependency) == 1:
pname = dependency[0]
base.append(
'.setOutput(\n %(param)r,size=_glgets._glget_size_mapping,pnameArg=%(pname)r,orPassIn=True\n)'
% locals())
else:
statements.append(
'# OUTPUT %s.%s COMPSIZE(%s) ' %
(function.name, param,
','.join(dependency)))
elif isinstance(dependency, xmlreg.StaticInput):
base.append(
'.setInputArraySize(\n %(param)r, %(dependency)s\n)'
% locals())
elif isinstance(dependency,
(xmlreg.DynamicInput,
xmlreg.MultipleInput, xmlreg.Input)):
statements.append(
'# INPUT %s.%s size not checked against %s' %
(function.name, param, dependency))
base.append(
'.setInputArraySize(\n %(param)r, None\n)' %
locals())
if base:
base.insert(
0, '%s=wrapper.wrapper(%s)' %
(function.name, function.name))
statements.append(''.join(base))
return '\n'.join(statements)
except Exception as err:
traceback.print_exc()
import pdb
pdb.set_trace()
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(as_8_bit('.'),as_8_bit('_')) in AVAILABLE_GLU_EXTENSIONS
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(as_8_bit('.'),as_8_bit('_')) in AVAILABLE_GLU_EXTENSIONS
def stringArray( self, arg, baseOperation, args ):
"""Create basic array-of-strings object from pyArg"""
if isinstance( arg, bytes ):
arg = [arg]
value = [as_8_bit(x) for x in arg]
return value
def printFunction(name):
def onevent(*args):
print(('%s -> %s' % (name, ", ".join([str(a) for a in args]))))
return onevent
if __name__ == "__main__":
import sys
newArgv = glutInit(sys.argv)
print(('newArguments', newArgv))
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)
glutInitWindowSize(250, 250)
glutInitWindowPosition(100, 100)
window = glutCreateWindow(as_8_bit("hello"))
print(('window', repr(window)))
glutDisplayFunc(display)
glutReshapeFunc(reshape)
glutMouseFunc(printFunction('Mouse'))
glutEntryFunc(printFunction('Entry'))
glutKeyboardFunc(printFunction('Keyboard'))
glutKeyboardUpFunc(printFunction('KeyboardUp'))
glutMotionFunc(printFunction('Motion'))
glutPassiveMotionFunc(printFunction('PassiveMotion'))
glutVisibilityFunc(printFunction('Visibility'))
glutWindowStatusFunc(printFunction('WindowStatus'))
glutSpecialFunc(printFunction('Special'))
glutSpecialUpFunc(printFunction('SpecialUp'))
glutTimerFunc(1000, ontimer, 23)
def glsl_version():
"""Parse GL_SHADING_LANGUAGE_VERSION into [int(major),int(minor)]"""
version = glGetString( GL_SHADING_LANGUAGE_VERSION )
version = [int(x) for x in version.split(as_8_bit('.'))[:2]]
return version
def printFunction( name ):
def onevent( *args ):
print(('%s -> %s'%(name, ", ".join( [str(a) for a in args ]))))
return onevent
if __name__ == "__main__":
import sys
newArgv = glutInit(sys.argv)
print(('newArguments', newArgv))
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB )
glutInitWindowSize(250, 250)
glutInitWindowPosition(100, 100)
window = glutCreateWindow(as_8_bit("hello"))
print(('window', repr(window)))
glutDisplayFunc(display)
glutReshapeFunc(reshape)
glutMouseFunc(printFunction( 'Mouse' ))
glutEntryFunc(printFunction( 'Entry' ))
glutKeyboardFunc( printFunction( 'Keyboard' ))
glutKeyboardUpFunc( printFunction( 'KeyboardUp' ))
glutMotionFunc( printFunction( 'Motion' ))
glutPassiveMotionFunc( printFunction( 'PassiveMotion' ))
glutVisibilityFunc( printFunction( 'Visibility' ))
glutWindowStatusFunc( printFunction( 'WindowStatus' ))
glutSpecialFunc( printFunction( 'Special' ))
glutSpecialUpFunc( printFunction( 'SpecialUp' ))
glutTimerFunc( 1000, ontimer, 23 )
def show_glsl_version():
version = glGetString( GL_SHADING_LANGUAGE_VERSION )
version = version.split(as_8_bit(' '))[0]
version = [int(x) for x in version.split(as_8_bit('.'))[:2]]
return version
import sys
from OpenGL.GLUT import *
from OpenGL.GL import *
from OpenGL._bytes import as_8_bit
ESCAPE = as_8_bit('\033')
PROMPT = ("Press keys '1' - '0' to start callbacks",
"Press ESCAPE to exit.")
global AllTimers
AllTimers = []
class TimerCBOwner:
def __init__(self, name, delay, repeat):
global AllTimers
self.name = name
self.delay = delay
self.repeat = repeat
self.state = "WAITING"
glutTimerFunc(self.delay, self.cb, 0)
AllTimers += (self,)
glutPostRedisplay()
def getDescription(self):
return "%s: %s"%(self.name, self.state)
def cb(self, value):
self.state = "CALL %d"%value
if value + 1 == self.repeat:
def asArray( self, value, typeCode=None ):
value = _bytes.as_8_bit( value )
return StringHandler.asArray( self, value, typeCode=typeCode )
def main():
program = shaders.compileProgram(
shaders.compileShader([vertex_shader], GL_VERTEX_SHADER),
shaders.compileShader([geometry_shader], GL_GEOMETRY_SHADER)
)
# test that we can describe the attributes in the shader
for i in range( glGetProgramiv( program, GL_ACTIVE_ATTRIBUTES )):
name,size,type = glGetActiveAttrib( program, i )
print( 'Arribute %s(%i) -> %s %s'%(name,i,size,type))
length,size,type,name = GLsizei(),GLint(),GLenum(),(GLchar*8)()
glGetActiveAttrib( program, i, None, length,size,type,name )
assert length.value == len(name.value),(length.value,name.value)
assert type.value == 5126, type.value
for i in range( glGetProgramiv( program, GL_ACTIVE_UNIFORMS )):
name,size,type = glGetActiveUniform( program, i )
print( 'Uniform %s(%i) -> %s %s'%(name,i,size,type))
length,size,type,name = GLsizei(),GLint(),GLenum(),(GLchar*5)()
glGetActiveUniform( program, i, 5, length, size, type, name )
assert length.value == len(name.value),(length.value,name.value)
assert type.value == 5126, type.value
buff = (ctypes.c_char_p * 1)( as_8_bit("outValue\000") )
c_text = ctypes.cast(ctypes.pointer(buff), ctypes.POINTER(ctypes.POINTER(GLchar)))
# modifies the state in the linking of the program
glTransformFeedbackVaryings(program, 1, c_text, GL_INTERLEAVED_ATTRIBS);
# so have to re-link
glLinkProgram(program)
glUseProgram(program);
vao = glGenVertexArrays(1);
glBindVertexArray(vao);
data = (GLfloat * 5)(1.0, 2.0, 3.0, 4.0, 5.0)
vbo = glGenBuffers(1);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, ctypes.sizeof(data), data, GL_STATIC_DRAW);
inputAttrib = glGetAttribLocation(program, "inValue");
glEnableVertexAttribArray(inputAttrib);
glVertexAttribPointer(inputAttrib, 1, GL_FLOAT, GL_FALSE, 0, 0);
tbo = glGenBuffers(1);
glBindBuffer(GL_ARRAY_BUFFER, tbo);
glBufferData(GL_ARRAY_BUFFER, ctypes.sizeof(data) * 3, None, GL_STATIC_READ);
glEnable(GL_RASTERIZER_DISCARD);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tbo);
glBeginTransformFeedback(GL_TRIANGLES);
glDrawArrays(GL_POINTS, 0, 5);
glEndTransformFeedback();
glDisable(GL_RASTERIZER_DISCARD);
glFlush();
feedback = (GLfloat*15)(*([0]*15))
glGetBufferSubData(GL_TRANSFORM_FEEDBACK_BUFFER, 0, ctypes.sizeof(feedback), feedback);
for value in feedback:
print(value)
glutSwapBuffers()
def idle( ):
glutPostRedisplay()
starttime = time.time()
def rotation( period = 10):
"""Do rotation of the scene at given rate"""
angle = (((time.time()-starttime)%period)/period)* 360
glRotate( angle, 0,1,0)
return angle
from OpenGL._bytes import as_8_bit
ESC = as_8_bit( '\033' )
def key_pressed(*args):
# If escape is pressed, kill everything.
if args[0] == ESC:
sys.exit()
if __name__ == "__main__":
print("""You should see a polynomial curve rotating about the origin.""")
import sys
glutInit(sys.argv)
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
glutCreateWindow('Array Drawing Demo')
glutDisplayFunc(display)
glutIdleFunc(display)
glutKeyboardFunc(key_pressed)
def type( self, element, context=None ):
name = element.get('name')
if not name:
name = element.find('name').text
self.type_set[as_8_bit(name)] = element
def type(self, element, context=None):
name = element.get('name')
if not name:
name = element.find('name').text
self.type_set[as_8_bit(name)] = element
