def compileShaders(self):
"""Loads the ``glmesh`` vertex/fragment shader source and creates
:class:`.GLSLShader` instance(s).
"""
if self.threedee:
flatVertSrc = shaders.getVertexShader('glmesh_3d_flat')
flatFragSrc = shaders.getFragmentShader('glmesh_3d_flat')
dataVertSrc = shaders.getVertexShader('glmesh_3d_data')
dataFragSrc = shaders.getFragmentShader('glmesh_3d_data')
self.flatShader = shaders.GLSLShader(flatVertSrc,
flatFragSrc,
indexed=True)
self.dataShader = shaders.GLSLShader(dataVertSrc,
dataFragSrc,
indexed=True)
else:
vertSrc = shaders.getVertexShader('glmesh_2d_data')
fragSrc = shaders.getFragmentShader('glmesh_2d_data')
self.dataShader = shaders.GLSLShader(vertSrc, fragSrc)
def compileShaders(self):
"""Loads the ``glmesh`` vertex and fragment shader program source,
and creates :class:`.ARBPShader` instance(s).
"""
textures = {'cmap': 0, 'negCmap': 1}
shaderDir = shaders.getShaderDir()
if self.threedee:
flatVertSrc = shaders.getVertexShader('glmesh_3d_flat')
flatFragSrc = shaders.getFragmentShader('glmesh_3d_flat')
dataVertSrc = shaders.getVertexShader('glmesh_3d_data')
dataFragSrc = shaders.getFragmentShader('glmesh_3d_data')
self.flatShader = shaders.ARBPShader(flatVertSrc, flatFragSrc,
shaderDir)
self.dataShader = shaders.ARBPShader(dataVertSrc, dataFragSrc,
shaderDir, textures)
else:
vertSrc = shaders.getVertexShader('glmesh_2d_data')
fragSrc = shaders.getFragmentShader('glmesh_2d_data')
self.dataShader = shaders.ARBPShader(vertSrc, fragSrc, shaderDir)
def __initShader(self):
"""Called by :meth:`__init__` if this ``RenderTexture`` was
configured to use a colour and depth texture. Compiles
vertex/fragment shader programs which pass the colour and depth
values through.
These shaders are used if the :meth:`draw` or
:meth:`.Texture2D.drawOnBounds` methods are used with the
``useDepth=True`` argument.
"""
self.__shader = None
vertSrc = shaders.getVertexShader('rendertexture')
fragSrc = shaders.getFragmentShader('rendertexture')
shaderDir = shaders.getShaderDir()
if float(fslplatform.glVersion) < 2.1:
self.__shader = shaders.ARBPShader(vertSrc, fragSrc, shaderDir)
else:
self.__shader = shaders.GLSLShader(vertSrc, fragSrc)
self.__shader.load()
self.__shader.set('colourTexture', 0)
self.__shader.set('depthTexture', 1)
self.__shader.unload()
def __init__(self, filterName, texture):
"""Create a ``Filter``.
:arg filterName: Name of the filter to create.
:arg texture: Number of the texture unit that the filter input
texture will be bound to. This must be specified
when the shader program is compiled, to support
OpenGL 1.4.
"""
basename = filterName
filterName = 'filter_{}'.format(filterName)
vertSrc = shaders.getVertexShader('filter')
fragSrc = shaders.getFragmentShader(filterName)
self.__texture = texture
self.__basename = basename
if float(fslgl.GL_COMPATIBILITY) >= 2.1:
self.__shader = shaders.GLSLShader(vertSrc, fragSrc)
else:
constants = {n: 1 for n in GL14_CONSTANTS[basename]}
self.__shader = shaders.ARBPShader(vertSrc,
fragSrc,
shaders.getShaderDir(),
{'texture': texture},
constants=constants)
def compileShaders(self):
"""Creates a :class:`.ARBPShader` instance. """
if self.shader is not None:
self.shader.destroy()
if self.threedee: frag = 'glvolume_3d'
else: frag = 'glvolume'
vertSrc = shaders.getVertexShader('glvolume')
fragSrc = shaders.getFragmentShader(frag)
texes = {
'imageTexture': 0,
'colourTexture': 1,
'negColourTexture': 2,
'clipTexture': 3
}
constants = {'kill_fragments_early': not self.threedee}
if self.threedee:
if self.opts.clipMode == 'intersection': clipMode = 1
elif self.opts.clipMode == 'union': clipMode = 2
elif self.opts.clipMode == 'complement': clipMode = 3
else: clipMode = 0
constants['numSteps'] = self.opts.numInnerSteps
constants['clipMode'] = clipMode
constants['numClipPlanes'] = self.opts.numClipPlanes
texes['startingTexture'] = 4
texes['depthTexture'] = 5
self.shader = shaders.ARBPShader(vertSrc, fragSrc, shaders.getShaderDir(),
texes, constants)
def compileShaders(self):
"""Compiles vertex and fragment shaders. """
if self.shader is not None:
self.shader.destroy()
vertSrc = shaders.getVertexShader('glvolume')
fragSrc = shaders.getFragmentShader('glmip')
self.shader = shaders.GLSLShader(vertSrc, fragSrc)
def compileShaders(self):
"""Loads the vertex/fragment shader source code, and creates a
:class:`.GLSLShader` program.
"""
if self.shader is not None:
self.shader.destroy()
vertSrc = shaders.getVertexShader( 'glvolume')
fragSrc = shaders.getFragmentShader('glmask')
self.shader = shaders.GLSLShader(vertSrc, fragSrc)
def compileShaders(self):
"""Loads the vertex/fragment shader source code, and creates a
:class:`.GLSLShader` program.
"""
if self.shader is not None:
self.shader.destroy()
vertSrc = shaders.getVertexShader('glvolume')
fragSrc = shaders.getFragmentShader('glrgbvolume')
constants = {'textureIs2D': self.imageTexture.ndim == 2}
self.shader = shaders.GLSLShader(vertSrc, fragSrc, constants=constants)
def compileShaders(self):
"""Loads the vertex/fragment shader source, and creates a
:class:`.GLSLShader`.
"""
if self.shader is not None:
self.shader.destroy()
if self.threedee: prefix = 'glvolume_3d'
else: prefix = 'glvolume'
vertSrc = shaders.getVertexShader(prefix)
fragSrc = shaders.getFragmentShader(prefix)
self.shader = shaders.GLSLShader(vertSrc, fragSrc)
def compileShaders(self):
"""Loads the vertex/fragment shader source code, and creates a
:class:`.ARBPShader` program.
"""
if self.shader is not None:
self.shader.destroy()
vertSrc = shaders.getVertexShader('glvolume')
fragSrc = shaders.getFragmentShader('glmask')
textures = {
'imageTexture': 0,
}
self.shader = shaders.ARBPShader(vertSrc, fragSrc, shaders.getShaderDir(),
textures)
def compileShaders(self):
"""Loads vertex and fragment shader program source, and creates an
:class:`.ARBPShader` instance.
"""
if self.shader is not None:
self.shader.destroy()
vertSrc = shaders.getVertexShader('glvolume')
fragSrc = shaders.getFragmentShader('gllabel')
textures = {
'imageTexture': 0,
'lutTexture': 1,
}
self.shader = shaders.ARBPShader(vertSrc, fragSrc, shaders.getShaderDir(),
textures)
def compileShaders(self):
"""Loads the vertex/fragment shader source, and creates a
:class:`.GLSLShader`.
"""
if self.shader is not None:
self.shader.destroy()
if self.threedee: prefix = 'glvolume_3d'
else: prefix = 'glvolume'
env = {'textureIs2D': self.imageTexture.ndim == 2}
vertSrc = shaders.getVertexShader(prefix)
fragSrc = shaders.getFragmentShader(prefix)
self.shader = shaders.GLSLShader(vertSrc, fragSrc, constants=env)
def compileShaders(self):
"""Loads the vertex/fragment shader source code, and creates a
:class:`.GLSLShader` program.
"""
if self.shader is not None:
self.shader.destroy()
vertSrc = shaders.getVertexShader('glvolume')
fragSrc = shaders.getFragmentShader('glrgbvolume')
textures = {'imageTexture': 0}
constants = {'texture_is_2d': self.imageTexture.ndim == 2}
self.shader = shaders.ARBPShader(vertSrc,
fragSrc,
shaders.getShaderDir(),
textureMap=textures,
constants=constants)
def compileShaders(self, vertShader):
"""Compiles the vertex/fragment shader programs (by creating a
:class:`.GLSLShader` instance).
If the :attr:`.VectorOpts.colourImage` property is set, the ``glvolume``
fragment shader is used. Otherwise, the ``glvector`` fragment shader
is used.
"""
if self.shader is not None:
self.shader.destroy()
opts = self.opts
useVolumeFragShader = opts.colourImage is not None
if useVolumeFragShader: fragShader = 'glvolume'
else: fragShader = 'glvector'
vertSrc = shaders.getVertexShader(vertShader)
fragSrc = shaders.getFragmentShader(fragShader)
if useVolumeFragShader:
textures = {
'clipTexture': 1,
'imageTexture': 2,
'colourTexture': 3,
'negColourTexture': 3,
# glvolume frag shader expects a modulate
# alpha texture, but it is not used
'modulateTexture': 1,
}
else:
textures = {
'modulateTexture': 0,
'clipTexture': 1,
'vectorTexture': 4,
}
self.shader = shaders.ARBPShader(vertSrc, fragSrc, shaders.getShaderDir(),
textures)
def compileShaders(self):
"""Creates a :class:`.GLSLShader`, and attaches it to this :class:`.GLSH`
instance as an attribute called ``shader``.
"""
if self.shader is not None:
self.shader.destroy()
opts = self.opts
self.useVolumeFragShader = opts.colourImage is not None
if self.useVolumeFragShader:
vertShader = 'glsh_volume'
fragShader = 'glvolume'
else:
vertShader = 'glsh'
fragShader = 'glsh'
vertSrc = shaders.getVertexShader(vertShader)
fragSrc = shaders.getFragmentShader(fragShader)
self.shader = shaders.GLSLShader(vertSrc, fragSrc, indexed=True)
def compileShaders(self, vertShader, indexed=False):
"""Compiles the vertex/fragment shader programs (by creating a
:class:`.GLSLShader` instance).
If the :attr:`.VectorOpts.colourImage` property is set, the ``glvolume``
fragment shader is used. Otherwise, the ``glvector`` fragment shader
is used.
"""
if self.shader is not None:
self.shader.destroy()
opts = self.opts
useVolumeFragShader = opts.colourImage is not None
self.useVolumeFragShader = useVolumeFragShader
if useVolumeFragShader: fragShader = 'glvolume'
else: fragShader = 'glvector'
vertSrc = shaders.getVertexShader(vertShader)
fragSrc = shaders.getFragmentShader(fragShader)
return shaders.GLSLShader(vertSrc, fragSrc, indexed)
