|
|
"""Convenience module providing common shader entry points |
|
|
|
|
|
The point of this module is to allow client code to use |
|
|
OpenGL Core names to reference shader-related operations |
|
|
even if the local hardware only supports ARB extension-based |
|
|
shader rendering. |
|
|
|
|
|
There are also two utility methods compileProgram and compileShader |
|
|
which make it easy to create demos which are shader-using. |
|
|
""" |
|
|
import logging |
|
|
log = logging.getLogger( __name__ ) |
|
|
from OpenGL import GL |
|
|
from OpenGL.GL.ARB import ( |
|
|
shader_objects, fragment_shader, vertex_shader, vertex_program, |
|
|
geometry_shader4, separate_shader_objects, get_program_binary, |
|
|
) |
|
|
from OpenGL.extensions import alternate |
|
|
from OpenGL._bytes import bytes,unicode,as_8_bit |
|
|
|
|
|
__all__ = [ |
|
|
'glAttachShader', |
|
|
'glDeleteShader', |
|
|
'glGetProgramInfoLog', |
|
|
'glGetShaderInfoLog', |
|
|
'glGetProgramiv', |
|
|
'glGetShaderiv', |
|
|
'compileProgram', |
|
|
'compileShader', |
|
|
'GL_VALIDATE_STATUS', |
|
|
'GL_LINK_STATUS', |
|
|
|
|
|
] |
|
|
|
|
|
def _alt( base, name ): |
|
|
if hasattr( GL, base ): |
|
|
root = getattr( GL, base ) |
|
|
if hasattr(root,'__call__'): |
|
|
globals()[base] = alternate( |
|
|
getattr(GL,base), |
|
|
getattr(module,name) |
|
|
) |
|
|
__all__.append( base ) |
|
|
else: |
|
|
globals()[base] = root |
|
|
__all__.append( base ) |
|
|
return True |
|
|
return False |
|
|
_excludes = ['glGetProgramiv'] |
|
|
for module in ( |
|
|
shader_objects,fragment_shader,vertex_shader,vertex_program, |
|
|
geometry_shader4, |
|
|
): |
|
|
for name in dir(module): |
|
|
found = None |
|
|
for suffix in ('ObjectARB','_ARB','ARB'): |
|
|
if name.endswith( suffix ): |
|
|
found = False |
|
|
base = name[:-(len(suffix))] |
|
|
if base not in _excludes: |
|
|
if _alt( base, name ): |
|
|
found = True |
|
|
break |
|
|
if found is False: |
|
|
log.debug( '''Found no alternate for: %s.%s''', |
|
|
module.__name__,name, |
|
|
) |
|
|
|
|
|
glAttachShader = alternate( GL.glAttachShader,shader_objects.glAttachObjectARB ) |
|
|
glDetachShader = alternate( GL.glDetachShader,shader_objects.glDetachObjectARB ) |
|
|
glDeleteShader = alternate( GL.glDeleteShader,shader_objects.glDeleteObjectARB ) |
|
|
glGetAttachedShaders = alternate( GL.glGetAttachedShaders, shader_objects.glGetAttachedObjectsARB ) |
|
|
|
|
|
glGetProgramInfoLog = alternate( GL.glGetProgramInfoLog, shader_objects.glGetInfoLogARB ) |
|
|
glGetShaderInfoLog = alternate( GL.glGetShaderInfoLog, shader_objects.glGetInfoLogARB ) |
|
|
|
|
|
glGetShaderiv = alternate( GL.glGetShaderiv, shader_objects.glGetObjectParameterivARB ) |
|
|
glGetProgramiv = alternate( GL.glGetProgramiv, shader_objects.glGetObjectParameterivARB ) |
|
|
|
|
|
GL_VALIDATE_STATUS = GL.GL_VALIDATE_STATUS |
|
|
GL_COMPILE_STATUS = GL.GL_COMPILE_STATUS |
|
|
GL_LINK_STATUS = GL.GL_LINK_STATUS |
|
|
GL_FALSE = GL.GL_FALSE |
|
|
GL_TRUE = GL.GL_TRUE |
|
|
|
|
|
class ShaderProgram( int ): |
|
|
"""Integer sub-class with context-manager operation""" |
|
|
def __enter__( self ): |
|
|
"""Start use of the program""" |
|
|
glUseProgram( self ) |
|
|
def __exit__( self, typ, val, tb ): |
|
|
"""Stop use of the program""" |
|
|
glUseProgram( 0 ) |
|
|
|
|
|
def check_validate( self ): |
|
|
"""Check that the program validates |
|
|
|
|
|
Validation has to occur *after* linking/loading |
|
|
|
|
|
raises RuntimeError on failures |
|
|
""" |
|
|
glValidateProgram( self ) |
|
|
validation = glGetProgramiv( self, GL_VALIDATE_STATUS ) |
|
|
if validation == GL_FALSE: |
|
|
raise RuntimeError( |
|
|
"""Validation failure (%r): %s"""%( |
|
|
validation, |
|
|
glGetProgramInfoLog( self ), |
|
|
)) |
|
|
return self |
|
|
|
|
|
def check_linked( self ): |
|
|
"""Check link status for this program |
|
|
|
|
|
raises RuntimeError on failures |
|
|
""" |
|
|
link_status = glGetProgramiv( self, GL_LINK_STATUS ) |
|
|
if link_status == GL_FALSE: |
|
|
raise RuntimeError( |
|
|
"""Link failure (%s): %s"""%( |
|
|
link_status, |
|
|
glGetProgramInfoLog( self ), |
|
|
)) |
|
|
return self |
|
|
|
|
|
def retrieve( self ): |
|
|
"""Attempt to retrieve binary for this compiled shader |
|
|
|
|
|
Note that binaries for a program are *not* generally portable, |
|
|
they should be used solely for caching compiled programs for |
|
|
local use; i.e. to reduce compilation overhead. |
|
|
|
|
|
returns (format,binaryData) for the shader program |
|
|
""" |
|
|
from OpenGL.raw.GL._types import GLint,GLenum |
|
|
from OpenGL.arrays import GLbyteArray |
|
|
size = GLint() |
|
|
glGetProgramiv( self, get_program_binary.GL_PROGRAM_BINARY_LENGTH, size ) |
|
|
result = GLbyteArray.zeros( (size.value,)) |
|
|
size2 = GLint() |
|
|
format = GLenum() |
|
|
get_program_binary.glGetProgramBinary( self, size.value, size2, format, result ) |
|
|
return format.value, result |
|
|
def load( self, format, binary ): |
|
|
"""Attempt to load binary-format for a pre-compiled shader |
|
|
|
|
|
See notes in retrieve |
|
|
""" |
|
|
get_program_binary.glProgramBinary( self, format, binary, len(binary)) |
|
|
self.check_validate() |
|
|
self.check_linked() |
|
|
return self |
|
|
|
|
|
def compileProgram(*shaders, **named): |
|
|
"""Create a new program, attach shaders and validate |
|
|
|
|
|
shaders -- arbitrary number of shaders to attach to the |
|
|
generated program. |
|
|
separable (keyword only) -- set the separable flag to allow |
|
|
for partial installation of shader into the pipeline (see |
|
|
glUseProgramStages) |
|
|
retrievable (keyword only) -- set the retrievable flag to |
|
|
allow retrieval of the program binary representation, (see |
|
|
glProgramBinary, glGetProgramBinary) |
|
|
|
|
|
This convenience function is *not* standard OpenGL, |
|
|
but it does wind up being fairly useful for demos |
|
|
and the like. You may wish to copy it to your code |
|
|
base to guard against PyOpenGL changes. |
|
|
|
|
|
Usage: |
|
|
|
|
|
shader = compileProgram( |
|
|
compileShader( source, GL_VERTEX_SHADER ), |
|
|
compileShader( source2, GL_FRAGMENT_SHADER ), |
|
|
) |
|
|
glUseProgram( shader ) |
|
|
|
|
|
Note: |
|
|
If (and only if) validation of the linked program |
|
|
*passes* then the passed-in shader objects will be |
|
|
deleted from the GL. |
|
|
|
|
|
returns ShaderProgram() (GLuint) program reference |
|
|
raises RuntimeError when a link/validation failure occurs |
|
|
""" |
|
|
program = glCreateProgram() |
|
|
if named.get('separable'): |
|
|
glProgramParameteri( program, separate_shader_objects.GL_PROGRAM_SEPARABLE, GL_TRUE ) |
|
|
if named.get('retrievable'): |
|
|
glProgramParameteri( program, get_program_binary.GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE ) |
|
|
for shader in shaders: |
|
|
glAttachShader(program, shader) |
|
|
program = ShaderProgram( program ) |
|
|
glLinkProgram(program) |
|
|
program.check_validate() |
|
|
program.check_linked() |
|
|
for shader in shaders: |
|
|
glDeleteShader(shader) |
|
|
return program |
|
|
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 not(result): |
|
|
|
|
|
|
|
|
raise RuntimeError( |
|
|
"""Shader compile failure (%s): %s"""%( |
|
|
result, |
|
|
glGetShaderInfoLog( shader ), |
|
|
), |
|
|
source, |
|
|
shaderType, |
|
|
) |
|
|
return shader |
|
|
|
