def resizeEvent( self, event ) : if self.scene() is not None : self.scene().setSceneRect( 0, 0, event.size().width(), event.size().height() ) owner = GafferUI.Widget._owner( self ) # clear any existing errors that may trigger # error checking code in _resize implementations. while GL.glGetError() : pass owner._makeCurrent() # We need to call the init method after a GL context has been # created, but before any events requiring GL have been triggered. # We had been doing this from GLWidget.__draw(), but it was still # possible to trigger mouseMove events prior to drawing by hovering # over top of an about-to-become-visible GLWidget. resizeEvent # seems to always be triggered prior to both draw and mouseMove, # ensuring GL is initialized in time for those other events. # Calling it here does mean we call init() more than needed, # but it's safe. IECoreGL.init( True ) owner._resize( imath.V2i( event.size().width(), event.size().height() ) )
def testGeometryShader( self ) :
if IECoreGL.glslVersion() < 150 :
# can't test geometry shaders if they don't exist
return
geometrySource = """
#version 150
layout( triangles ) in;
layout( triangle_strip, max_vertices=3 ) out;
uniform float geometryShaderParameter = 0;
void main()
{
for( int i = 0; i < gl_in.length(); i++)
{
gl_Position = gl_in[i].gl_Position + vec4( geometryShaderParameter, 0, 0, 1 );
EmitVertex();
}
}
"""
s = IECoreGL.Shader( IECoreGL.Shader.defaultVertexSource(), geometrySource, IECoreGL.Shader.defaultFragmentSource() )
self.failUnless( "geometryShaderParameter" in s.uniformParameterNames() )
def testGeometryShaderViaFile( self ) :
if IECoreGL.glslVersion() < 150 :
# no point testing unavailable functionality
return
g = IECore.Group()
p = IECore.PointsPrimitive( IECore.V3fVectorData( [ IECore.V3f( 0 ) ] ) )
p["type"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Uniform, IECore.StringData( "gl:point" ) )
g.addChild( p )
g.addState( IECore.AttributeState( { "gl:pointsPrimitive:glPointWidth" : IECore.FloatData( 4 ) } ) )
g.addState( IECore.Shader( "pointTripler", "gl:surface" ) )
image = self.renderImage( g )
self.assertImageValues(
image,
[
( IECore.V2f( 0.125, 0.5 ), IECore.Color4f( 0, 0, 0, 0 ) ),
( IECore.V2f( 0.25, 0.5 ), IECore.Color4f( 1, 1, 1, 1 ) ),
( IECore.V2f( 0.375, 0.5 ), IECore.Color4f( 0, 0, 0, 0 ) ),
( IECore.V2f( 0.5, 0.5 ), IECore.Color4f( 1, 1, 1, 1 ) ),
( IECore.V2f( 0.625, 0.5 ), IECore.Color4f( 0, 0, 0, 0 ) ),
( IECore.V2f( 0.75, 0.5 ), IECore.Color4f( 1, 1, 1, 1 ) ),
( IECore.V2f( 0.875, 0.5 ), IECore.Color4f( 0, 0, 0, 0 ) ),
]
)
def __draw( self ) : # Qt sometimes enters our GraphicsScene.drawBackground() method # with a GL error flag still set. We unset it here so it won't # trigger our own error checking. while GL.glGetError() : pass if not self.__framebufferValid() : return # we need to call the init method after a GL context has been # created, and this seems like the only place that is guaranteed. # calling it here does mean we call init() way more than needed, # but it's safe. ## \todo: this might be removable if we can prove resizeEvent # is always called first. IECoreGL.init( True ) self._draw()
def runPointAtVTest( self, curvesPrimitive, expectedPositions=None, expectedLengths=None, visualTest=False, printPoints=False ) :
e = IECore.CurvesPrimitiveEvaluator( curvesPrimitive )
r = e.createResult()
p = IECore.V3fVectorData()
for ci in range( 0, curvesPrimitive.variableSize( IECore.PrimitiveVariable.Interpolation.Uniform ) ) :
numSamples = 50
for i in range( 0, numSamples ) :
s = e.pointAtV( ci, float( i ) / float( numSamples - 1 ), r )
self.failUnless( s )
p.append( r.point() )
if expectedPositions :
self.assertEqual( len( p ), len( expectedPositions ) )
for i in range( 0, len( p ) ) :
self.failUnless( p[i].equalWithAbsError( expectedPositions[i], 0.00001 ) )
if expectedLengths :
self.assertEqual( curvesPrimitive.numCurves(), len( expectedLengths ) )
linearNonPeriodic = ( curvesPrimitive.basis() == IECore.CubicBasisf.linear() ) and not curvesPrimitive.periodic()
for i in range( 0, curvesPrimitive.numCurves() ) :
if linearNonPeriodic :
self.assertEqual( e.curveLength( i ), expectedLengths[i] )
else :
self.assertAlmostEqual( e.curveLength( i ), expectedLengths[i], 5 )
if printPoints :
print repr( p ).replace( "),", "),\n" )
if visualTest :
import IECoreGL
IECoreGL.init( False )
r = IECoreGL.Renderer()
r.setOption( "gl:mode", IECore.StringData( "deferred" ) )
pointsPrimitive = IECore.PointsPrimitive( p )
pointsPrimitive["constantwidth"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Constant, IECore.FloatData( 0.1 ) )
with IECore.WorldBlock( r ) :
w = IECoreGL.SceneViewer( "scene", r.scene() )
with IECore.AttributeBlock( r ) :
r.shader( "surface", "red", { "gl:fragmentSource" : IECore.StringData( "void main() { gl_FragColor = vec4( 1, 0, 0, 1 ); }" ) } )
r.setAttribute( "gl:curvesPrimitive:useGLLines", IECore.BoolData( True ) )
curvesPrimitive.render( r )
with IECore.AttributeBlock( r ) :
r.shader( "surface", "blue", { "gl:fragmentSource" : IECore.StringData( "void main() { gl_FragColor = vec4( 0, 0, 1, 1 ); }" ) } )
pointsPrimitive.render( r )
w.start()
def testWindingOrder(self):
# camera facing single sided - should be visible
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("immediate"))
r.setOption("gl:searchPath:shader",
IECore.StringData(os.path.dirname(__file__) + "/shaders"))
r.camera(
"main", {
"projection":
IECore.StringData("orthographic"),
"resolution":
IECore.V2iData(IECore.V2i(256)),
"clippingPlanes":
IECore.V2fData(IECore.V2f(1, 1000)),
"screenWindow":
IECore.Box2fData(IECore.Box2f(IECore.V2f(-1), IECore.V2f(1)))
})
r.display(self.outputFileName, "tif", "rgba", {})
with IECore.WorldBlock(r):
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(0, 0, -5)))
r.setAttribute("doubleSided", IECore.BoolData(False))
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(IECore.Color3f(0, 0, 1))})
r.disk(1, 0, 360, {})
image = IECore.Reader.create(self.outputFileName).read()
dimensions = image.dataWindow.size() + IECore.V2i(1)
index = dimensions.x * dimensions.y / 2 + dimensions.x / 2
self.assertEqual(image["A"][index], 1)
# back facing single sided - should be invisible
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("immediate"))
r.setOption("gl:searchPath:shader",
IECore.StringData(os.path.dirname(__file__) + "/shaders"))
r.camera(
"main", {
"projection":
IECore.StringData("orthographic"),
"resolution":
IECore.V2iData(IECore.V2i(256)),
"clippingPlanes":
IECore.V2fData(IECore.V2f(1, 1000)),
"screenWindow":
IECore.Box2fData(IECore.Box2f(IECore.V2f(-1), IECore.V2f(1)))
})
r.display(self.outputFileName, "tif", "rgba", {})
with IECore.WorldBlock(r):
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(0, 0, -5)))
r.setAttribute("doubleSided", IECore.BoolData(False))
r.setAttribute("rightHandedOrientation", IECore.BoolData(False))
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(IECore.Color3f(0, 0, 1))})
r.disk(1, 0, 360, {})
image = IECore.Reader.create(self.outputFileName).read()
dimensions = image.dataWindow.size() + IECore.V2i(1)
index = dimensions.x * dimensions.y / 2 + dimensions.x / 2
self.assertEqual(image["A"][index], 0)
def testRegionSelect(self):
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("deferred"))
r.setOption("gl:searchPath:shader",
IECore.StringData(os.path.dirname(__file__) + "/shaders"))
with IECoreScene.WorldBlock(r):
r.concatTransform(imath.M44f().translate(imath.V3f(0, 0, -5)))
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(imath.Color3f(1, 0, 0))})
r.concatTransform(imath.M44f().translate(imath.V3f(-2, -2, 0)))
r.setAttribute("name", IECore.StringData("red"))
r.sphere(1, -1, 1, 360, {})
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(imath.Color3f(0, 1, 0))})
r.concatTransform(imath.M44f().translate(imath.V3f(0, 4, 0)))
r.setAttribute("name", IECore.StringData("green"))
r.sphere(1, -1, 1, 360, {})
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(imath.Color3f(0, 0, 1))})
r.concatTransform(imath.M44f().translate(imath.V3f(4, 0, 0)))
r.setAttribute("name", IECore.StringData("blue"))
r.sphere(1, -1, 1, 360, {})
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(imath.Color3f(1, 1, 1))})
r.concatTransform(imath.M44f().translate(imath.V3f(0, -4, 0)))
r.setAttribute("name", IECore.StringData("white"))
r.sphere(1, -1, 1, 360, {})
s = r.scene()
s.setCamera(IECoreGL.Camera(imath.M44f(), False))
ss = s.select(IECoreGL.Selector.Mode.GLSelect,
imath.Box2f(imath.V2f(0, 0.5), imath.V2f(0.5, 1)))
self.assertEqual(len(ss), 1)
self.assertEqual(
IECoreGL.NameStateComponent.nameFromGLName(ss[0].name), "red")
ss = s.select(IECoreGL.Selector.Mode.GLSelect,
imath.Box2f(imath.V2f(0), imath.V2f(0.5)))
self.assertEqual(len(ss), 1)
self.assertEqual(
IECoreGL.NameStateComponent.nameFromGLName(ss[0].name), "green")
ss = s.select(IECoreGL.Selector.Mode.GLSelect,
imath.Box2f(imath.V2f(0.5, 0), imath.V2f(1, 0.5)))
self.assertEqual(len(ss), 1)
self.assertEqual(
IECoreGL.NameStateComponent.nameFromGLName(ss[0].name), "blue")
ss = s.select(IECoreGL.Selector.Mode.GLSelect,
imath.Box2f(imath.V2f(0.5), imath.V2f(1)))
self.assertEqual(len(ss), 1)
self.assertEqual(
IECoreGL.NameStateComponent.nameFromGLName(ss[0].name), "white")
def testVertexAttributes( self ) :
# if rendering points and requiring custom vertex attributes to be passed
# to the fragment shader, you are now required to provide your own vertex shader.
# however, handy macros exist to make the instancing and aiming easy.
vertexSource = """
#include \"IECoreGL/PointsPrimitive.h\"
IECOREGL_POINTSPRIMITIVE_DECLAREVERTEXPARAMETERS
in vec3 instanceP;
in float vertexgreyTo255;
varying out float fragmentGrey;
void main()
{
mat4 instanceMatrix = IECOREGL_POINTSPRIMITIVE_INSTANCEMATRIX;
vec4 pCam = instanceMatrix * vec4( instanceP, 1 );
gl_Position = gl_ProjectionMatrix * pCam;
fragmentGrey = float( vertexgreyTo255 ) / 255.0;
}
"""
fragmentSource = """
varying float fragmentGrey;
void main()
{
gl_FragColor = vec4( fragmentGrey, fragmentGrey, fragmentGrey, 1 );
}
"""
numPoints = 100
p = IECore.V3fVectorData( numPoints )
g = IECore.IntVectorData( numPoints )
random.seed( 0 )
for i in range( 0, numPoints ) :
p[i] = IECore.V3f( random.random() * 4, random.random() * 4, random.random() * 4 )
g[i] = int( random.uniform( 0.0, 255.0 ) )
p = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, p )
g = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, g )
r = IECoreGL.Renderer()
r.setOption( "gl:mode", IECore.StringData( "immediate" ) )
r.setOption( "gl:searchPath:shaderInclude", IECore.StringData( "./glsl" ) )
r.camera( "main", {
"projection" : IECore.StringData( "orthographic" ),
"resolution" : IECore.V2iData( IECore.V2i( 256 ) ),
"clippingPlanes" : IECore.V2fData( IECore.V2f( 1, 1000 ) ),
"screenWindow" : IECore.Box2fData( IECore.Box2f( IECore.V2f( -3 ), IECore.V2f( 3 ) ) )
}
)
r.display( self.outputFileName, "exr", "rgba", {} )
with IECore.WorldBlock( r ) :
r.concatTransform( IECore.M44f.createTranslated( IECore.V3f( -2, -2, -10 ) ) )
r.shader( "surface", "grey", { "gl:vertexSource" : vertexSource, "gl:fragmentSource" : IECore.StringData( fragmentSource ) } )
r.points( numPoints, { "P" : p, "greyTo255" : g } )
reader = IECore.Reader.create( os.path.dirname( __file__ ) + "/expectedOutput/pointVertexAttributes.tif" )
reader['colorSpace'] = 'linear'
expectedImage = reader.read()
actualImage = IECore.Reader.create( self.outputFileName ).read()
self.assertEqual( IECore.ImageDiffOp()( imageA = expectedImage, imageB = actualImage, maxError = 0.05 ).value, False )
class UserAtributesTest(unittest.TestCase):
def testUserAttributesInDeferredMode(self):
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("deferred"))
r.worldBegin()
self.assertEqual(r.getAttribute("user:notSetYet"), None)
r.setAttribute("user:test", IECore.FloatData(1))
self.assertEqual(r.getAttribute("user:test"), IECore.FloatData(1))
r.attributeBegin()
self.assertEqual(r.getAttribute("user:test"), IECore.FloatData(1))
r.setAttribute("user:test2", IECore.IntData(10))
self.assertEqual(r.getAttribute("user:test2"), IECore.IntData(10))
r.attributeEnd()
self.assertEqual(r.getAttribute("user:test"), IECore.FloatData(1))
self.assertEqual(r.getAttribute("user:test2"), None)
r.worldEnd()
def performProceduralTest(self, threaded):
errors = list()
class SimpleProcedural(IECore.ParameterisedProcedural):
def __init__(s, level=0):
IECore.ParameterisedProcedural.__init__(s)
s.__level = level
def doBound(s, args):
return IECore.Box3f(IECore.V3f(-1), IECore.V3f(1))
def doRender(s, renderer, args):
try:
if s.__level == 0:
with IECore.AttributeBlock(renderer):
renderer.setAttribute("user:myTestAttribute",
IECore.IntData(11))
# rendering a child procedural
SimpleProcedural(1).render(renderer)
self.assertEqual(
renderer.getAttribute("user:myTestAttribute"),
IECore.IntData(11))
# rendering child procedural from inside a Group
g = IECore.Group()
g.addChild(SimpleProcedural(2))
g.render(renderer)
elif s.__level == 1:
self.assertEqual(
renderer.getAttribute("user:myTestAttribute"),
IECore.IntData(11))
elif s.__level == 2:
self.assertEqual(
renderer.getAttribute("user:myTestAttribute"),
IECore.IntData(11))
except Exception, e:
errors.append(IECore.exceptionInfo()[1])
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("deferred"))
with IECore.WorldBlock(r):
r.setAttribute("gl:procedural:reentrant",
IECore.BoolData(threaded))
p = SimpleProcedural()
p.render(r)
if errors:
raise Exception, "ERRORS:\n".join(errors)
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
##########################################################################
import unittest
import inspect
import os.path
import imath
import IECore
import IECoreScene
import IECoreGL
IECoreGL.init(False)
class TestSelection(unittest.TestCase):
def testSelect(self):
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("deferred"))
r.setOption("gl:searchPath:shader",
IECore.StringData(os.path.dirname(__file__) + "/shaders"))
with IECoreScene.WorldBlock(r):
r.concatTransform(imath.M44f().translate(imath.V3f(0, 0, -5)))
r.setAttribute("name", IECore.StringData("one"))
def setUp( self ) : GafferTest.TestCase.setUp( self ) IECoreGL.init( False )
def testStateComponentsUsage( self ): g = IECoreGL.Group() g.getState().add( IECoreGL.PointsPrimitive.UseGLPoints( IECoreGL.GLPointsUsage.ForPointsAndDisks ) ) g.getState().add( IECoreGL.PointsPrimitive.GLPointWidth( 2.3 ) )
def setUp( self ) : IECoreGL.init( False )
def testLoadGreyscale(self):
l = IECoreGL.TextureLoader(IECore.SearchPath("./"))
t = l.load("test/IECoreImage/data/jpg/greyscaleCheckerBoard.jpg")
self.assertTrue(isinstance(t, IECoreGL.LuminanceTexture))
def testLoadRGB(self):
l = IECoreGL.TextureLoader(IECore.SearchPath("./"))
t = l.load("test/IECoreImage/data/exr/carPark.exr")
self.assertTrue(isinstance(t, IECoreGL.ColorTexture))
def setUp(self):
IECoreGL.init(False)
def testWindingOrder(self):
# camera facing single sided - should be visible
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("immediate"))
r.setOption("gl:searchPath:shader",
IECore.StringData(os.path.dirname(__file__) + "/shaders"))
r.camera(
"main", {
"projection":
IECore.StringData("orthographic"),
"resolution":
IECore.V2iData(IECore.V2i(256)),
"clippingPlanes":
IECore.V2fData(IECore.V2f(1, 1000)),
"screenWindow":
IECore.Box2fData(IECore.Box2f(IECore.V2f(-1), IECore.V2f(1)))
})
r.display(self.outputFileName, "tif", "rgba", {})
with IECore.WorldBlock(r):
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(0, 0, -5)))
r.setAttribute("doubleSided", IECore.BoolData(False))
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(IECore.Color3f(0, 0, 1))})
r.disk(1, 0, 360, {})
image = IECore.Reader.create(self.outputFileName).read()
evaluator = IECore.ImagePrimitiveEvaluator(image)
result = evaluator.createResult()
evaluator.pointAtUV(IECore.V2f(0.5), result)
self.assertEqual(result.floatPrimVar(evaluator.A()), 1)
# back facing single sided - should be invisible
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("immediate"))
r.setOption("gl:searchPath:shader",
IECore.StringData(os.path.dirname(__file__) + "/shaders"))
r.camera(
"main", {
"projection":
IECore.StringData("orthographic"),
"resolution":
IECore.V2iData(IECore.V2i(256)),
"clippingPlanes":
IECore.V2fData(IECore.V2f(1, 1000)),
"screenWindow":
IECore.Box2fData(IECore.Box2f(IECore.V2f(-1), IECore.V2f(1)))
})
r.display(self.outputFileName, "tif", "rgba", {})
with IECore.WorldBlock(r):
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(0, 0, -5)))
r.setAttribute("doubleSided", IECore.BoolData(False))
r.setAttribute("rightHandedOrientation", IECore.BoolData(False))
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(IECore.Color3f(0, 0, 1))})
r.disk(1, 0, 360, {})
image = IECore.Reader.create(self.outputFileName).read()
evaluator = IECore.ImagePrimitiveEvaluator(image)
result = evaluator.createResult()
evaluator.pointAtUV(IECore.V2f(0.5), result)
self.assertEqual(result.floatPrimVar(evaluator.A()), 0)
def testUniformCs(self):
fragmentSource = """
#include "IECoreGL/FragmentShader.h"
IECOREGL_FRAGMENTSHADER_IN vec3 fragmentCs;
void main()
{
gl_FragColor = vec4( fragmentCs, 1.0 );
}
"""
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("immediate"))
r.camera(
"main", {
"projection":
IECore.StringData("orthographic"),
"resolution":
IECore.V2iData(imath.V2i(256)),
"clippingPlanes":
IECore.V2fData(imath.V2f(1, 1000)),
"screenWindow":
IECore.Box2fData(imath.Box2f(imath.V2f(-1), imath.V2f(1)))
})
r.display(self.outputFileName, "tif", "rgba", {})
with IECoreScene.WorldBlock(r):
r.concatTransform(imath.M44f().translate(imath.V3f(0, 0, -15)))
r.shader("surface", "test",
{"gl:fragmentSource": IECore.StringData(fragmentSource)})
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)), imath.V2i(2))
m["Cs"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Uniform,
IECore.Color3fVectorData([
imath.Color3f(1, 0, 0),
imath.Color3f(0, 1, 0),
imath.Color3f(0, 0, 1),
imath.Color3f(
1,
1,
1,
),
]))
m.render(r)
image = IECore.Reader.create(self.outputFileName).read()
dimensions = image.dataWindow.size() + imath.V2i(1)
index = dimensions.x * int(dimensions.y * 0.75) + int(
dimensions.x * 0.25)
self.assertEqual(image["R"][index], 1)
self.assertEqual(image["G"][index], 0)
self.assertEqual(image["B"][index], 0)
index = dimensions.x * int(dimensions.y * 0.75) + int(
dimensions.x * 0.75)
self.assertEqual(image["R"][index], 0)
self.assertEqual(image["G"][index], 1)
self.assertEqual(image["B"][index], 0)
index = dimensions.x * int(dimensions.y * 0.25) + int(
dimensions.x * 0.75)
self.assertEqual(image["R"][index], 1)
self.assertEqual(image["G"][index], 1)
self.assertEqual(image["B"][index], 1)
index = dimensions.x * int(dimensions.y * 0.25) + int(
dimensions.x * 0.25)
self.assertEqual(image["R"][index], 0)
self.assertEqual(image["G"][index], 0)
self.assertEqual(image["B"][index], 1)
def testVertexAttributes(self):
vertexSource = """
#include "IECoreGL/VertexShader.h"
IECOREGL_VERTEXSHADER_IN vec3 vertexP;
IECOREGL_VERTEXSHADER_IN vec2 vertexuv;
IECOREGL_VERTEXSHADER_OUT vec4 color;
void main()
{
vec4 pCam = gl_ModelViewMatrix * vec4( vertexP, 1 );
gl_Position = gl_ProjectionMatrix * pCam;
// Note that we're only flipping V here because the expected
// output image was generated with the wrong texture coordinates.
// It is _not_ expected that you would need to modify texture
// coordinates in the general case.
color = vec4(vertexuv.x, 1.0 - vertexuv.y, 0.0, 1.0);
}
"""
fragmentSource = """
varying vec4 color;
void main()
{
gl_FragColor = color;
}
"""
m = IECore.Reader.create(
"test/IECore/data/cobFiles/pSphereShape1.cob").read()
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("immediate"))
r.camera(
"main", {
"projection":
IECore.StringData("orthographic"),
"resolution":
IECore.V2iData(imath.V2i(256)),
"clippingPlanes":
IECore.V2fData(imath.V2f(1, 1000)),
"screenWindow":
IECore.Box2fData(imath.Box2f(imath.V2f(-1), imath.V2f(1)))
})
r.display(self.outputFileName, "tif", "rgba", {})
with IECoreScene.WorldBlock(r):
r.concatTransform(imath.M44f().translate(imath.V3f(0, 0, -15)))
r.shader(
"surface", "showUV", {
"gl:fragmentSource": IECore.StringData(fragmentSource),
"gl:vertexSource": IECore.StringData(vertexSource)
})
m.render(r)
reader = IECore.Reader.create(
os.path.dirname(__file__) + "/expectedOutput/meshST.tif")
reader["rawChannels"].setTypedValue(True)
expectedImage = reader.read()
actualImage = IECore.Reader.create(self.outputFileName).read()
self.assertEqual(
IECoreImage.ImageDiffOp()(imageA=expectedImage,
imageB=actualImage,
maxError=0.05).value, False)
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
##########################################################################
import unittest
import os.path
import IECore
import IECoreGL
IECoreGL.init( False )
class TestShader( unittest.TestCase ) :
def testConstructor( self ) :
self.assertRaises( RuntimeError, IECoreGL.Shader, "i don't think i'm valid", "me neither" )
vertexSource = """
void main()
{
gl_Position = ftransform();
}
"""
fragmentSource = """
def testRegionSelect(self):
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("deferred"))
r.setOption("gl:searchPath:shader",
IECore.StringData(os.path.dirname(__file__) + "/shaders"))
with IECore.WorldBlock(r):
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(0, 0, -5)))
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(IECore.Color3f(1, 0, 0))})
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(-2, -2, 0)))
r.setAttribute("name", IECore.StringData("red"))
r.geometry("sphere", {}, {})
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(IECore.Color3f(0, 1, 0))})
r.concatTransform(IECore.M44f.createTranslated(IECore.V3f(0, 4,
0)))
r.setAttribute("name", IECore.StringData("green"))
r.geometry("sphere", {}, {})
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(IECore.Color3f(0, 0, 1))})
r.concatTransform(IECore.M44f.createTranslated(IECore.V3f(4, 0,
0)))
r.setAttribute("name", IECore.StringData("blue"))
r.geometry("sphere", {}, {})
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(IECore.Color3f(1, 1, 1))})
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(0, -4, 0)))
r.setAttribute("name", IECore.StringData("white"))
r.geometry("sphere", {}, {})
s = r.scene()
s.setCamera(IECoreGL.PerspectiveCamera())
ss = s.select(IECoreGL.Selector.Mode.GLSelect,
IECore.Box2f(IECore.V2f(0, 0.5), IECore.V2f(0.5, 1)))
self.assertEqual(len(ss), 1)
self.assertEqual(ss[0].name.value(), "red")
ss = s.select(IECoreGL.Selector.Mode.GLSelect,
IECore.Box2f(IECore.V2f(0), IECore.V2f(0.5)))
self.assertEqual(len(ss), 1)
self.assertEqual(ss[0].name.value(), "green")
ss = s.select(IECoreGL.Selector.Mode.GLSelect,
IECore.Box2f(IECore.V2f(0.5, 0), IECore.V2f(1, 0.5)))
self.assertEqual(len(ss), 1)
self.assertEqual(ss[0].name.value(), "blue")
ss = s.select(IECoreGL.Selector.Mode.GLSelect,
IECore.Box2f(IECore.V2f(0.5), IECore.V2f(1)))
self.assertEqual(len(ss), 1)
self.assertEqual(ss[0].name.value(), "white")
