def testThreadedTextureLookups( self ) :
self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/sxTextureTest.sdl test/IECoreRI/shaders/sxTextureTest.sl" ), 0 )
points = self.__rectanglePoints( IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 255 ) ) )
# by default you should be able to run as many threads as the hardware will support
# concurrently.
for i in range( 0, 10 ) :
r = IECoreRI.SXRenderer()
r.shader( "surface", "test/IECoreRI/shaders/sxTextureTest.sdl", {
"fileName" : os.path.realpath( "./test/IECoreRI/data/textures/uvMap.256x256.tdl" ),
} )
# note the -1 when determining the number of threads. 3delight behaviour changed around
# 10.0.35, such that render:nthreads (which defaults to hardwareConcurrency()) is the
# number of threads that will be making Sx calls of any sort, whereas prior to that it
# was the number of threads that would actually call SxCallShader. because we've set up
# the renderer on this thread, it's taken one off the count for the number of threads we
# can spawn to do the shading.
threads = []
for i in range( 0, IECore.hardwareConcurrency() - 1 ) :
threads.append( threading.Thread( target = IECore.curry( r.shade, points ) ) )
for t in threads :
t.start()
for t in threads :
t.join()
# but if you want to use more then you need to let the library know about it
# by calling setOption( "ri:render:nthreads" )
for i in range( 0, 10 ) :
r = IECoreRI.SXRenderer()
# see above - we're adding one to number of threads we'll be using to do the shading,
# because we've also used a thread (the current thread) to perform the setup.
r.setOption( "ri:render:nthreads", IECore.IntData( IECore.hardwareConcurrency() * 2 + 1 ) )
r.shader( "surface", "test/IECoreRI/shaders/sxTextureTest.sdl", {
"fileName" : os.path.realpath( "./test/IECoreRI/data/textures/uvMap.256x256.tdl" ),
} )
threads = []
for i in range( 0, IECore.hardwareConcurrency() * 2 ) :
threads.append( threading.Thread( target = IECore.curry( r.shade, points ) ) )
for t in threads :
t.start()
for t in threads :
t.join()
def testBoolParameterSupport(self):
self.assertEqual(
os.system(
"shaderdl -o test/IECoreRI/shaders/sxParameterTest.sdl test/IECoreRI/shaders/sxParameterTest.sl"
), 0)
r = IECoreRI.SXRenderer()
r.shader(
"surface", "test/IECoreRI/shaders/sxParameterTest.sdl", {
"mustBeOne": IECore.BoolData(True),
"mustBeRed": IECore.Color3f(1, 0, 0),
"mustBeTwo": IECore.V3f(2),
"mustBeThree": IECore.V3f(3),
"mustBeFour": IECore.V3f(4),
"mustBeHelloWorld": "helloWorld",
"mustBeOneTwoThree": IECore.V3f(1, 2, 3),
})
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(1))
s = r.shade(self.__rectanglePoints(b))
self.assertEqual(s["Ci"][0], IECore.Color3f(0, 1, 0))
def testGetShaderInConstruct(self):
self.assertEqual(
os.system(
"shaderdl -Irsl -o test/IECoreRI/shaders/sxGetShaderTest.sdl test/IECoreRI/shaders/sxGetShaderTest.sl"
), 0)
self.assertEqual(
os.system(
"shaderdl -Irsl -o test/IECoreRI/shaders/sxCoshaderTest.sdl test/IECoreRI/shaders/sxCoshaderTest.sl"
), 0)
r = IECoreRI.SXRenderer()
with IECore.WorldBlock(r):
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(20, 10))
points = self.__rectanglePoints(b)
r.shader("shader", "test/IECoreRI/shaders/sxCoshaderTest", {
"__handle": "cs1",
"sColor": IECore.Color3f(0, 1, 0),
})
r.shader("surface", "test/IECoreRI/shaders/sxGetShaderTest",
{"coshader": IECore.StringData("cs1")})
s = r.shade(points, IECore.V2i(21, 11))
for i in range(0, len(points["P"])):
self.assertEqual(s["Ci"][i],
IECore.Color3f(0, points["s"][i], 0))
def test( self ) :
r = IECoreRI.SXRenderer()
points = IECore.CompoundData( {
"N" : self.__loadImage( "test/IECoreRI/data/sxInput/cowN.exr" ),
"Ng" : self.__loadImage( "test/IECoreRI/data/sxInput/cowN.exr" ),
"P" : self.__loadImage( "test/IECoreRI/data/sxInput/cowP.exr" ),
"I" : self.__loadImage( "test/IECoreRI/data/sxInput/cowI.exr" ),
} )
self.assertEqual( os.system( "shaderdl -o test/IECoreRI/shaders/sxTest.sdl test/IECoreRI/shaders/sxTest.sl" ), 0 )
r.shader( "surface", "test/IECoreRI/shaders/sxTest.sdl", { "noiseFrequency" : 1.0, "tint" : IECore.Color3f( 1 ) } )
s = r.shade( points )
self.assertEqual( len( s ), 6 )
self.failUnless( "outputFloat" in s )
self.failUnless( "outputColor" in s )
self.failUnless( "Ci" in s )
self.failUnless( "Oi" in s )
self.failUnless( "P" in s )
self.failUnless( "N" in s )
self.__assertVectorDataAlmostEqual( s["outputFloat"], IECore.ObjectReader( "test/IECoreRI/data/sxOutput/cowFloat.cob" ).read() )
self.__assertVectorDataAlmostEqual( s["outputColor"], IECore.ObjectReader( "test/IECoreRI/data/sxOutput/cowColor.cob" ).read() )
self.__assertVectorDataAlmostEqual( s["Ci"], IECore.ObjectReader( "test/IECoreRI/data/sxOutput/cowCI.cob" ).read() )
self.__assertVectorDataAlmostEqual( s["Oi"], IECore.ObjectReader( "test/IECoreRI/data/sxOutput/cowOI.cob" ).read() )
def testSplineParameter(self):
self.assertEqual(
os.system(
"shaderdl -Irsl -o test/IECoreRI/shaders/splineTest.sdl test/IECoreRI/shaders/splineTest.sl"
), 0)
r = IECoreRI.SXRenderer()
r.shader(
"surface", "test/IECoreRI/shaders/splineTest.sdl", {
"spl":
IECore.SplinefColor3fData(
IECore.SplinefColor3f(IECore.CubicBasisf.catmullRom(), (
(0, IECore.Color3f(1, 0, 0)),
(0, IECore.Color3f(1, 0, 0)),
(1, IECore.Color3f(0, 0, 1)),
(1, IECore.Color3f(0, 0, 1)),
)))
})
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(10))
s = r.shade(self.__rectanglePoints(b))
self.__assertVectorDataAlmostEqual(
s["Ci"],
IECore.ObjectReader(
"test/IECoreRI/data/sxOutput/spline.cob").read())
def testLights(self):
self.assertEqual(
os.system(
"shaderdl -Irsl -o test/IECoreRI/shaders/sxLightTest.sdl test/IECoreRI/shaders/sxLightTest.sl"
), 0)
self.assertEqual(
os.system(
"shaderdl -Irsl -o test/IECoreRI/shaders/sxIlluminanceTest.sdl test/IECoreRI/shaders/sxIlluminanceTest.sl"
), 0)
r = IECoreRI.SXRenderer()
with IECore.WorldBlock(r):
r.shader("surface", "test/IECoreRI/shaders/sxIlluminanceTest", {})
r.light("test/IECoreRI/shaders/sxLightTest", "light0", {})
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(20, 10))
points = self.__rectanglePoints(b)
s = r.shade(points, IECore.V2i(21, 11))
for i in range(0, len(points["P"])):
c = s["Ci"][i]
self.assertEqual(points["P"][i], IECore.V3f(c[0], c[1], c[2]))
def testPlaneShade(self):
r = IECoreRI.SXRenderer()
self.assertEqual(
os.system(
"shaderdl -o test/IECoreRI/shaders/sxStTest.sdl test/IECoreRI/shaders/sxStTest.sl"
), 0)
r.shader("surface", "test/IECoreRI/shaders/sxStTest.sdl", {})
data = r.shadePlane(IECore.V2i(64, 64))
del data["P"]
del data["N"]
self.assertEqual(
data,
IECore.Reader.create(
"test/IECoreRI/data/sxOutput/shadePlaneCompoundData.cob").read(
))
image = r.shadePlaneToImage(IECore.V2i(64, 64))
expectedImage = IECore.Reader.create(
"test/IECoreRI/data/sxOutput/shadePlaneImage.exr").read()
self.assertEqual(
IECore.ImageDiffOp()(imageA=image,
imageB=expectedImage,
maxError=0), IECore.BoolData(False))
def testDisplacementShader(self):
self.assertEqual(
os.system(
"shaderdl -Irsl -o test/IECoreRI/shaders/sxDisplacementTest.sdl test/IECoreRI/shaders/sxDisplacementTest.sl"
), 0)
r = IECoreRI.SXRenderer()
with IECore.WorldBlock(r):
r.shader("displacement",
"test/IECoreRI/shaders/sxDisplacementTest.sdl", {})
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(20, 10))
points = self.__rectanglePoints(b)
## need to use a grid topology if we want calculatenormal() to work
s = r.shade(points, IECore.V2i(21, 11))
self.assertEqual(len(s), 2)
self.failUnless("P" in s)
self.failUnless("N" in s)
for i in range(0, len(points["P"])):
self.failUnless(s["P"][i].equalWithAbsError(
points["P"][i] + points["N"][i], 0.001))
self.failUnless(s["N"][i].equalWithAbsError(
IECore.V3f(0, 0, 1), 0.001))
def testCoshadersWithGetVar(self):
self.assertEqual(
os.system(
"shaderdl -o test/IECoreRI/shaders/sxCoshaderTest.sdl test/IECoreRI/shaders/sxCoshaderTest.sl"
), 0)
self.assertEqual(
os.system(
"shaderdl -o test/IECoreRI/shaders/sxCoshaderTestMain.sdl test/IECoreRI/shaders/sxCoshaderTestMain.sl"
), 0)
r = IECoreRI.SXRenderer()
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(4))
points = self.__rectanglePoints(b)
points["forGetVar"] = IECore.Color3fVectorData(
[IECore.Color3f(x[0], x[1], x[2]) for x in points["P"]])
with IECore.WorldBlock(r):
r.shader("shader", "test/IECoreRI/shaders/sxCoshaderTest", {
"primVarName": "forGetVar",
"__handle": "cs1"
})
r.shader("surface", "test/IECoreRI/shaders/sxCoshaderTestMain",
{"coshaders": IECore.StringVectorData(["cs1"])})
s = r.shade(points)
self.assertEqual(s["Ci"], points["forGetVar"])
def testNonPredefinedPrimitiveVariablesForCoshaders(self):
self.assertEqual(
os.system(
"shaderdl -Irsl -o test/IECoreRI/shaders/sxCoshaderTestMain.sdl test/IECoreRI/shaders/sxCoshaderTestMain.sl"
), 0)
self.assertEqual(
os.system(
"shaderdl -Irsl -o test/IECoreRI/shaders/sxCoshaderTest.sdl test/IECoreRI/shaders/sxCoshaderTest.sl"
), 0)
r = IECoreRI.SXRenderer()
with IECore.WorldBlock(r):
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(20, 10))
points = self.__rectanglePoints(b)
points["colorPrimVar"] = IECore.Color3fVectorData(
[IECore.Color3f(v[0], v[1], v[2]) for v in points["P"]])
r.shader("shader", "test/IECoreRI/shaders/sxCoshaderTest",
{"__handle": "cs1"})
r.shader("surface", "test/IECoreRI/shaders/sxCoshaderTestMain",
{"coshaders": IECore.StringVectorData(["cs1"])})
s = r.shade(points, IECore.V2i(21, 11))
self.assertEqual(s["Ci"], points["colorPrimVar"])
def testCoordinateSystems( self ):
self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/sxCoordSystemTest.sdl test/IECoreRI/shaders/sxCoordSystemTest.sl" ), 0 )
points = self.__rectanglePoints( IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 1 ) ) )
r = IECoreRI.SXRenderer()
r.shader( "surface", "test/IECoreRI/shaders/sxCoordSystemTest.sdl", { "coordSysName" : IECore.StringData( "test1" ) } )
r.transformBegin()
r.setTransform( IECore.M44f.createTranslated( IECore.V3f(0,0,2) ) )
r.coordinateSystem( "test1" )
r.transformEnd()
r.transformBegin()
r.setTransform( IECore.M44f.createRotated( IECore.V3f(1,0,0) ) )
r.concatTransform( IECore.M44f.createTranslated( IECore.V3f(0,0,2) ) )
r.coordinateSystem( "test2" )
r.transformEnd()
s1 = r.shade( points )
for i in range( len( s1["Ci"] ) ):
self.assertEqual( points["P"][i] + IECore.V3f(0,0,2), IECore.V3f( s1["Ci"][i][0], s1["Ci"][i][1], s1["Ci"][i][2] ) )
r.shader( "surface", "test/IECoreRI/shaders/sxCoordSystemTest.sdl", { "coordSysName" : IECore.StringData( "test2" ) } )
s2 = r.shade( points )
for i in range( len( s2["Ci"] ) ):
shaderP = IECore.V3f( s2["Ci"][i][0], s2["Ci"][i][1], s2["Ci"][i][2] )
transP = points["P"][i] * IECore.M44f.createTranslated( IECore.V3f(0,0,2) ) * IECore.M44f.createRotated( IECore.V3f(1,0,0) )
self.failUnless( ( shaderP - transP ).length() < 1.e-5 )
def testFloat3PrimitiveVariable(self):
self.assertEqual(
os.system(
"shaderdl -o test/IECoreRI/shaders/sxParameterTest.sdl test/IECoreRI/shaders/sxParameterTest.sl"
), 0)
r = IECoreRI.SXRenderer()
r.shader(
"surface", "test/IECoreRI/shaders/sxParameterTest.sdl", {
"mustBeOne": 1.0,
"mustBeRed": IECore.Color3f(1, 0, 0),
"mustBeTwo": IECore.V3f(2),
"mustBeThree": IECore.V3f(3),
"mustBeFour": IECore.V3f(4),
"mustBeHelloWorld": "helloWorld",
})
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(10))
points = self.__rectanglePoints(b)
points["mustBeOneTwoThree"] = IECore.V3fVectorData(
[IECore.V3f(1, 2, 3)] * len(points["P"]))
s = r.shade(points)
for c in s["Ci"]:
self.assertEqual(c, IECore.Color3f(0, 1, 0))
def testUniformPrimitiveVariableShaderParameters(self):
self.assertEqual(
os.system(
"shaderdl -Irsl -o test/IECoreRI/shaders/sxUniformPrimitiveVariableShaderParameterTest.sdl test/IECoreRI/shaders/sxUniformPrimitiveVariableShaderParameterTest.sl"
), 0)
r = IECoreRI.SXRenderer()
with IECore.WorldBlock(r):
r.shader(
"surface",
"test/IECoreRI/shaders/sxUniformPrimitiveVariableShaderParameterTest",
{})
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(20, 10))
points = self.__rectanglePoints(b)
points["colorPrimVar"] = IECore.Color3fData(
IECore.Color3f(0, 0.5, 1))
points["floatPrimVar"] = IECore.FloatData(16.0)
points["vectorPrimVar"] = IECore.V3fData(IECore.V3f(0.25, 0.5, 2))
points["stringPrimVar"] = IECore.StringData("hello shader!")
points["stringVectorPrimVar"] = IECore.StringVectorData(
["who's", "a", "good", "boy"])
s = r.shade(points, IECore.V2i(21, 11))
for i in range(0, len(points["P"])):
self.assertEqual(s["Ci"][i], IECore.Color3f(0.125, 0.25, 0.5))
def testNonPredefinedPrimitiveVariables(self):
self.assertEqual(
os.system(
"shaderdl -Irsl -o test/IECoreRI/shaders/sxNonPredefinedPrimitiveVariableTest.sdl test/IECoreRI/shaders/sxNonPredefinedPrimitiveVariableTest.sl"
), 0)
r = IECoreRI.SXRenderer()
with IECore.WorldBlock(r):
r.shader(
"surface",
"test/IECoreRI/shaders/sxNonPredefinedPrimitiveVariableTest",
{})
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(20, 10))
points = self.__rectanglePoints(b)
points["colorPrimVar"] = IECore.Color3fVectorData(
[IECore.Color3f(v[0], v[1], v[2]) for v in points["P"]])
points["floatPrimVar"] = points["s"]
s = r.shade(points, IECore.V2i(21, 11))
for i in range(0, len(points["P"])):
c = points["colorPrimVar"][i]
c[0] = points["s"][i]
self.assertEqual(s["Ci"][i], c)
def testCoshadersStack( self ) :
self.assertEqual( os.system( "shaderdl -o test/IECoreRI/shaders/sxCoshaderTest.sdl test/IECoreRI/shaders/sxCoshaderTest.sl" ), 0 )
self.assertEqual( os.system( "shaderdl -o test/IECoreRI/shaders/sxCoshaderTestMain.sdl test/IECoreRI/shaders/sxCoshaderTestMain.sl" ), 0 )
r = IECoreRI.SXRenderer()
b = IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 100 ) )
points = self.__rectanglePoints( b )
with IECore.WorldBlock( r ) :
r.shader( "shader", "test/IECoreRI/shaders/sxCoshaderTest", { "shaderColor" : IECore.Color3f( 1, 0, 0 ), "__handle" : "cs1" } )
r.shader( "shader", "test/IECoreRI/shaders/sxCoshaderTest", { "sColor" : IECore.Color3f( 0, 1, 0 ), "__handle" : "cs2" } )
r.shader( "shader", "test/IECoreRI/shaders/sxCoshaderTest", { "tColor" : IECore.Color3f( 0, 0, 1 ), "__handle" : "cs3" } )
with IECore.AttributeBlock( r ) :
# these guys should be popped and therefore not affect the result
r.shader( "shader", "test/IECoreRI/shaders/sxCoshaderTest", { "shaderColor" : IECore.Color3f( 1, 1, 1 ), "__handle" : "cs1" } )
r.shader( "shader", "test/IECoreRI/shaders/sxCoshaderTest", { "sColor" : IECore.Color3f( 1, 1, 0 ), "__handle" : "cs2" } )
r.shader( "shader", "test/IECoreRI/shaders/sxCoshaderTest", { "tColor" : IECore.Color3f( 0.5, 0, 0.25 ), "__handle" : "cs3" } )
r.shader( "surface", "test/IECoreRI/shaders/sxCoshaderTestMain", { "coshaders" : IECore.StringVectorData( [ "cs1", "cs2", "cs3" ] ) } )
s = r.shade( points )
self.assertEqual( s["Ci"], IECore.ObjectReader( "test/IECoreRI/data/sxOutput/coshaders.cob" ).read() )
def testGetVar(self):
self.assertEqual(
os.system(
"shaderdl -Irsl -o test/IECoreRI/shaders/sxGetVarTest.sdl test/IECoreRI/shaders/sxGetVarTest.sl"
), 0)
r = IECoreRI.SXRenderer()
with IECore.WorldBlock(r):
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(20, 10))
points = self.__rectanglePoints(b)
points["floatValue1"] = points["s"]
points["floatValue2"] = points["t"]
r.shader("surface", "test/IECoreRI/shaders/sxGetVarTest", {})
s = r.shade(points, IECore.V2i(21, 11))
for i in range(0, len(s["Ci"])):
self.assertEqual(
s["Ci"][i],
IECore.Color3f(0, points["floatValue1"][i],
points["floatValue2"][i]))
def testNoShader(self):
r = IECoreRI.SXRenderer()
with IECore.WorldBlock(r):
self.assertRaises(
RuntimeError, r.shade,
self.__rectanglePoints(
IECore.Box2i(IECore.V2i(0), IECore.V2i(100))))
def testWrongSize( self ) :
self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/splineTest.sdl test/IECoreRI/shaders/splineTest.sl" ), 0 )
r = IECoreRI.SXRenderer()
r.shader( "surface", "test/IECoreRI/shaders/splineTest.sdl", {} )
p = self.__rectanglePoints( IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 10 ) ) )
del p["t"][-10:]
self.assertRaises( RuntimeError, r.shade, p )
def testMissingPredefinedVariables( self ) :
self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/splineTest.sdl test/IECoreRI/shaders/splineTest.sl" ), 0 )
r = IECoreRI.SXRenderer()
r.shader( "surface", "test/IECoreRI/shaders/splineTest.sdl", {} )
b = IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 100 ) )
points = self.__rectanglePoints( b )
del points["t"] # remove information the shader requires
s = r.shade( points )
def testStack(self):
self.assertEqual(
os.system(
"shaderdl -o test/IECoreRI/shaders/sxStackTest.sdl test/IECoreRI/shaders/sxStackTest.sl"
), 0)
r = IECoreRI.SXRenderer()
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(100))
points = self.__rectanglePoints(b)
self.assertEqual(r.getAttribute("color"),
IECore.Color3fData(IECore.Color3f(1)))
self.assertEqual(r.getAttribute("opacity"),
IECore.Color3fData(IECore.Color3f(1)))
with IECore.WorldBlock(r):
r.setAttribute("color", IECore.Color3f(1, 0, 0))
self.assertEqual(r.getAttribute("color"),
IECore.Color3fData(IECore.Color3f(1, 0, 0)))
r.shader("surface", "test/IECoreRI/shaders/sxStackTest.sdl",
{"blue": 1.0})
with IECore.AttributeBlock(r):
r.setAttribute("color", IECore.Color3f(0, 1, 0))
self.assertEqual(r.getAttribute("color"),
IECore.Color3fData(IECore.Color3f(0, 1, 0)))
r.shader("surface", "test/IECoreRI/shaders/sxStackTest.sdl",
{"blue": 0.5})
s = r.shade(points)
for c in s["Ci"]:
self.assertEqual(c, IECore.Color3f(0, 0, 0.5))
self.assertEqual(r.getAttribute("color"),
IECore.Color3fData(IECore.Color3f(1, 0, 0)))
s = r.shade(points)
for c in s["Ci"]:
self.assertEqual(c, IECore.Color3f(0, 0, 1))
self.assertEqual(r.getAttribute("color"),
IECore.Color3fData(IECore.Color3f(1)))
self.assertEqual(r.getAttribute("opacity"),
IECore.Color3fData(IECore.Color3f(1)))
def testZeroLength( self ) :
self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/splineTest.sdl test/IECoreRI/shaders/splineTest.sl" ), 0 )
r = IECoreRI.SXRenderer()
r.shader( "surface", "test/IECoreRI/shaders/splineTest.sdl", {} )
p = self.__rectanglePoints( IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 10 ) ) )
for k, v in p.items() :
del v[:]
self.assertRaises( RuntimeError, r.shade, p )
def testVVector( self ) :
self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/splineTest.sdl test/IECoreRI/shaders/splineTest.sl" ), 0 )
r = IECoreRI.SXRenderer()
r.shader( "surface", "test/IECoreRI/shaders/splineTest.sdl", {} )
p = self.__rectanglePoints( IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 10 ) ) )
# this should work, as you might want to use a V3f primvar called v (velocity) in
# your shader:
p["v"] = p["P"]
r.shade( p )
def testMultipleGrids( self ) :
self.assertEqual( os.system( "shaderdl -o test/IECoreRI/shaders/sxGridTest.sdl test/IECoreRI/shaders/sxGridTest.sl" ), 0 )
r = IECoreRI.SXRenderer()
b = IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 19, 9 ) )
points = self.__rectanglePoints( b )
with IECore.WorldBlock( r ) :
r.shader( "surface", "test/IECoreRI/shaders/sxGridTest", {} )
# there are 20 x 10 points in the input, so this call should shade four 10 x 5 grids:
r.shade( points, IECore.V2i( 10, 5 ) )
def testStringArrayOptions( self ):
self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/sxStringArrayOptionTest.sdl test/IECoreRI/shaders/sxStringArrayOptionTest.sl" ), 0 )
points = self.__rectanglePoints( IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 1 ) ) )
r = IECoreRI.SXRenderer()
r.shader( "surface", "test/IECoreRI/shaders/sxStringArrayOptionTest.sdl", {} )
s = r.shade( points )
self.assertEqual( s["Ci"][0], IECore.Color3f( 0,0,0 ) )
r.setOption( "user:stringArray", IECore.StringVectorData( ["this","should","work"] ) )
s = r.shade( points )
self.assertEqual( s["Ci"][0], IECore.Color3f( 1,1,1 ) )
def testUserOptions( self ):
self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/sxUserOptionTest.sdl test/IECoreRI/shaders/sxUserOptionTest.sl" ), 0 )
points = self.__rectanglePoints( IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 1 ) ) )
r = IECoreRI.SXRenderer()
r.shader( "surface", "test/IECoreRI/shaders/sxUserOptionTest.sdl", {} )
s = r.shade( points )
self.assertEqual( s["Ci"][0], IECore.Color3f( 0,0,0 ) )
r.setOption( "user:outputColor", IECore.FloatData( 1 ) )
s = r.shade( points )
self.assertEqual( s["Ci"][0], IECore.Color3f( 1,1,1 ) )
def testPredefinedPrimitiveVariables( self ) :
self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/sxPredefinedPrimitiveVariableTest.sdl test/IECoreRI/shaders/sxPredefinedPrimitiveVariableTest.sl" ), 0 )
r = IECoreRI.SXRenderer()
with IECore.WorldBlock( r ) :
r.shader( "surface", "test/IECoreRI/shaders/sxPredefinedPrimitiveVariableTest", {} )
b = IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 20, 10 ) )
points = self.__rectanglePoints( b )
s = r.shade( points, IECore.V2i( 21, 11 ) )
for i in range( 0, len( points["P"] ) ) :
self.assertEqual( s["Ci"][i], IECore.Color3f( 1, 1, 1 ) )
def testGrids(self):
self.assertEqual(
os.system(
"shaderdl -o test/IECoreRI/shaders/sxGridTest.sdl test/IECoreRI/shaders/sxGridTest.sl"
), 0)
r = IECoreRI.SXRenderer()
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(20, 10))
points = self.__rectanglePoints(b)
with IECore.WorldBlock(r):
r.shader("surface", "test/IECoreRI/shaders/sxGridTest", {})
# not providing enough points for the grid should raise
self.assertRaises(RuntimeError, r.shade, points,
IECore.V2i(100, 500))
s = r.shade(points)
del s[
"P"] # test data on disk was created before we supported P as an output
del s[
"N"] # test data on disk was created before we supported N as an output
self.assertEqual(
s,
IECore.ObjectReader(
"test/IECoreRI/data/sxOutput/noGrid.cob").read())
s = r.shade(points, IECore.V2i(21, 11))
del s[
"P"] # test data on disk was created before we supported P as an output
del s[
"N"] # test data on disk was created before we supported N as an output
self.assertEqual(
s,
IECore.ObjectReader(
"test/IECoreRI/data/sxOutput/grid.cob").read())
def testThreading(self):
# set up a renderer with a shader in it
self.assertEqual(
os.system(
"shaderdl -o test/IECoreRI/shaders/sxTest.sdl test/IECoreRI/shaders/sxTest.sl"
), 0)
r = IECoreRI.SXRenderer()
r.shader("surface", "test/IECoreRI/shaders/sxTest.sdl", {
"noiseFrequency": 1.0,
"tint": IECore.Color3f(1)
})
# and get some points to shade
points = IECore.CompoundData({
"N":
self.__loadImage("test/IECoreRI/data/sxInput/cowN.exr"),
"Ng":
self.__loadImage("test/IECoreRI/data/sxInput/cowN.exr"),
"P":
self.__loadImage("test/IECoreRI/data/sxInput/cowP.exr"),
"I":
self.__loadImage("test/IECoreRI/data/sxInput/cowI.exr"),
})
# shade in lots of different threads at the same time
def s(i):
results[i] = r.shade(points)
threads = []
results = []
for i in range(0, 300):
threads.append(threading.Thread(target=IECore.curry(s, i)))
results.append(None)
for t in threads:
t.start()
for t in threads:
t.join()
# and check that it all worked
cowFloat = IECore.ObjectReader(
"test/IECoreRI/data/sxOutput/cowFloat.cob").read()
cowColor = IECore.ObjectReader(
"test/IECoreRI/data/sxOutput/cowColor.cob").read()
cowCI = IECore.ObjectReader(
"test/IECoreRI/data/sxOutput/cowCI.cob").read()
cowOI = IECore.ObjectReader(
"test/IECoreRI/data/sxOutput/cowOI.cob").read()
# check that the first set of results is close enough to the expected results.
# we allow some small variation as 3delight's noise routines seem to yield
# veryvery small differences between some versions.
self.__assertVectorDataAlmostEqual(results[0]["outputFloat"], cowFloat)
self.__assertVectorDataAlmostEqual(results[0]["outputColor"], cowColor)
self.__assertVectorDataAlmostEqual(results[0]["Ci"], cowCI)
self.__assertVectorDataAlmostEqual(results[0]["Oi"], cowOI)
# check that all results are exactly equal to the first set. even if we
# accept small variations between different 3delight versions we don't accept
# variation within one version.
for s in results:
self.assertEqual(len(s), 6)
self.failUnless("outputFloat" in s)
self.failUnless("outputColor" in s)
self.failUnless("Ci" in s)
self.failUnless("Oi" in s)
self.failUnless("P" in s)
self.failUnless("N" in s)
self.assertEqual(s["outputFloat"], results[0]["outputFloat"])
self.assertEqual(s["outputColor"], results[0]["outputColor"])
self.assertEqual(s["Ci"], results[0]["Ci"])
self.assertEqual(s["Oi"], results[0]["Oi"])
