def testFixedCoshaderArrayParameters( self ) : shader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshaderArrayParameters.sl" ) n = GafferRenderMan.RenderManShader() n.loadShader( shader ) self.assertEqual( n["parameters"].keys(), [ "dynamicShaderArray", "fixedShaderArray" ] ) self.assertTrue( isinstance( n["parameters"]["fixedShaderArray"], Gaffer.CompoundPlug ) ) self.assertEqual( len( n["parameters"]["fixedShaderArray"] ), 4 ) self.assertTrue( isinstance( n["parameters"]["fixedShaderArray"]["fixedShaderArray0"], Gaffer.Plug ) ) self.assertTrue( isinstance( n["parameters"]["fixedShaderArray"]["fixedShaderArray1"], Gaffer.Plug ) ) self.assertTrue( isinstance( n["parameters"]["fixedShaderArray"]["fixedShaderArray2"], Gaffer.Plug ) ) self.assertTrue( isinstance( n["parameters"]["fixedShaderArray"]["fixedShaderArray3"], Gaffer.Plug ) ) state = n.state() self.assertEqual( state[0].parameters["fixedShaderArray"], IECore.StringVectorData( [ "" ] * 4 ) ) coshader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshader.sl" ) coshaderNode = GafferRenderMan.RenderManShader() coshaderNode.loadShader( coshader ) n["parameters"]["fixedShaderArray"]["fixedShaderArray0"].setInput( coshaderNode["out"] ) state = n.state() self.assertEqual( state[1].parameters["fixedShaderArray"], IECore.StringVectorData( [ state[0].parameters["__handle"].value, "", "", "" ] ) )
def testConvertFixedCoshaderArrayToDynamic( self ) : shader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshaderArrayParameters.sl" ) shaderV2 = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshaderArrayParametersV2.sl" ) coshader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshader.sl" ) s = Gaffer.ScriptNode() s["n"] = GafferRenderMan.RenderManShader() s["n"].loadShader( shader ) s["c"] = GafferRenderMan.RenderManShader() s["c"].loadShader( coshader ) s["n"]["parameters"]["fixedShaderArray"][0].setInput( s["c"]["out"] ) self.assertTrue( len( s["n"]["parameters"]["fixedShaderArray"] ), 4 ) s["n"].loadShader( shaderV2, keepExistingValues = True ) self.assertTrue( s["n"]["parameters"]["fixedShaderArray"][0].getInput().isSame( s["c"]["out"] ) ) self.assertTrue( s["n"]["parameters"]["fixedShaderArray"][1].getInput() is None ) s["n"]["parameters"]["fixedShaderArray"][0].setInput( None ) self.assertEqual( len( s["n"]["parameters"]["fixedShaderArray"] ), 1 ) self.assertTrue( s["n"]["parameters"]["fixedShaderArray"][0].getInput() is None )
def testDisablingCoshaders( self ) : shader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshaderParameter.sl" ) shaderNode = GafferRenderMan.RenderManShader() shaderNode.loadShader( shader ) coshader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshader.sl" ) coshaderNode = GafferRenderMan.RenderManShader() coshaderNode.loadShader( coshader ) shaderNode["parameters"]["coshaderParameter"].setInput( coshaderNode["out"] ) s = shaderNode.state() self.assertEqual( len( s ), 2 ) self.assertEqual( s[0].name, coshader ) self.assertEqual( s[1].name, shader ) h = shaderNode.stateHash() coshaderNode["enabled"].setValue( False ) s2 = shaderNode.state() self.assertEqual( len( s2 ), 1 ) self.assertEqual( s2[0].name, shader ) self.assertTrue( "coshaderParameter" not in s2[0].parameters ) self.assertNotEqual( shaderNode.stateHash(), h )
def testCoshaderPassThrough( self ) : shader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshaderParameter.sl" ) shaderNode = GafferRenderMan.RenderManShader() shaderNode.loadShader( shader ) passThroughCoshader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshaderWithPassThrough.sl" ) passThroughCoshaderNode = GafferRenderMan.RenderManShader() passThroughCoshaderNode.loadShader( passThroughCoshader ) coshader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshader.sl" ) coshaderNode = GafferRenderMan.RenderManShader() coshaderNode.loadShader( coshader ) shaderNode["parameters"]["coshaderParameter"].setInput( passThroughCoshaderNode["out"] ) passThroughCoshaderNode["parameters"]["aColorIWillTint"].setInput( coshaderNode["out"] ) h = shaderNode.stateHash() s = shaderNode.state() self.assertEqual( len( s ), 3 ) self.assertEqual( s[2].parameters["coshaderParameter"], s[1].parameters["__handle"] ) self.assertEqual( s[1].name, passThroughCoshader ) self.assertEqual( s[1].parameters["aColorIWillTint"], s[0].parameters["__handle"] ) self.assertEqual( s[0].name, coshader ) passThroughCoshaderNode["enabled"].setValue( False ) s = shaderNode.state() self.assertEqual( len( s ), 2 ) self.assertEqual( s[1].parameters["coshaderParameter"], s[0].parameters["__handle"] ) self.assertEqual( s[0].name, coshader )
def testDynamicCoshaderArrayParameters( self ) : coshader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshader.sl" ) coshaderNode = GafferRenderMan.RenderManShader() coshaderNode.loadShader( coshader ) shader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshaderArrayParameters.sl" ) shaderNode = GafferRenderMan.RenderManShader() shaderNode.loadShader( shader ) self.assertEqual( len( shaderNode["parameters"]["dynamicShaderArray"] ), 1 ) self.assertTrue( isinstance( shaderNode["parameters"]["dynamicShaderArray"][0], Gaffer.Plug ) ) self.assertTrue( shaderNode["parameters"]["dynamicShaderArray"][0].getInput() is None ) shaderNode["parameters"]["dynamicShaderArray"][0].setInput( coshaderNode["out"] ) self.assertEqual( len( shaderNode["parameters"]["dynamicShaderArray"] ), 2 ) self.assertTrue( isinstance( shaderNode["parameters"]["dynamicShaderArray"][0], Gaffer.Plug ) ) self.assertTrue( isinstance( shaderNode["parameters"]["dynamicShaderArray"][1], Gaffer.Plug ) ) self.assertTrue( shaderNode["parameters"]["dynamicShaderArray"][0].getInput().isSame( coshaderNode["out"] ) ) self.assertTrue( shaderNode["parameters"]["dynamicShaderArray"][1].getInput() is None ) shaderNode["parameters"]["dynamicShaderArray"][0].setInput( None ) self.assertEqual( len( shaderNode["parameters"]["dynamicShaderArray"] ), 1 ) self.assertTrue( isinstance( shaderNode["parameters"]["dynamicShaderArray"][0], Gaffer.Plug ) ) self.assertTrue( shaderNode["parameters"]["dynamicShaderArray"][0].getInput() is None )
def testAssignmentDirtyPropagation( self ) : shader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshaderParameter.sl" ) shaderNode = GafferRenderMan.RenderManShader() shaderNode.loadShader( shader ) coshader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshader.sl" ) coshaderNode = GafferRenderMan.RenderManShader() coshaderNode.loadShader( coshader ) shaderNode["parameters"]["coshaderParameter"].setInput( coshaderNode["out"] ) plane = GafferScene.Plane() assignment = GafferScene.ShaderAssignment() assignment["in"].setInput( plane["out"] ) assignment["shader"].setInput( shaderNode["out"] ) cs = GafferTest.CapturingSlot( assignment.plugDirtiedSignal() ) coshaderNode["parameters"]["floatParameter"].setValue( 12 ) dirtiedNames = [ x[0].fullName() for x in cs ] self.assertEqual( len( dirtiedNames ), 3 ) self.assertEqual( dirtiedNames[0], "ShaderAssignment.shader" ) self.assertEqual( dirtiedNames[1], "ShaderAssignment.out.attributes" ) self.assertEqual( dirtiedNames[2], "ShaderAssignment.out" )
def testFixedCoshaderArrayParameterHash( self ) : shader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshaderArrayParameters.sl" ) n = GafferRenderMan.RenderManShader() n.loadShader( shader ) h1 = n.stateHash() coshader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshader.sl" ) coshaderNode = GafferRenderMan.RenderManShader() coshaderNode.loadShader( coshader ) n["parameters"]["fixedShaderArray"]["fixedShaderArray0"].setInput( coshaderNode["out"] ) h2 = n.stateHash() self.assertNotEqual( h2, h1 ) n["parameters"]["fixedShaderArray"]["fixedShaderArray1"].setInput( coshaderNode["out"] ) h3 = n.stateHash() self.assertNotEqual( h3, h2 ) self.assertNotEqual( h3, h1 ) n["parameters"]["fixedShaderArray"]["fixedShaderArray1"].setInput( None ) n["parameters"]["fixedShaderArray"]["fixedShaderArray2"].setInput( coshaderNode["out"] ) h4 = n.stateHash() self.assertNotEqual( h4, h3 ) self.assertNotEqual( h4, h2 ) self.assertNotEqual( h4, h1 )
def testRender(self):
s = Gaffer.ScriptNode()
s["l"] = GafferRenderMan.RenderManLight()
s["l"].loadShader("pointlight")
s["l"]["parameters"]["lightcolor"].setValue(
IECore.Color3f(1, 0.5, 0.25))
s["l"]["transform"]["translate"]["z"].setValue(1)
s["p"] = GafferScene.Plane()
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(1)
s["g"] = GafferScene.Group()
s["g"]["in"].setInput(s["l"]["out"])
s["g"]["in1"].setInput(s["p"]["out"])
s["g"]["in2"].setInput(s["c"]["out"])
s["s"] = GafferRenderMan.RenderManShader()
s["s"].loadShader("matte")
s["a"] = GafferScene.ShaderAssignment()
s["a"]["in"].setInput(s["g"]["out"])
s["a"]["shader"].setInput(s["s"]["out"])
s["d"] = GafferScene.Outputs()
s["d"].addOutput(
"beauty",
IECore.Display("/tmp/testRenderManLight.exr", "exr", "rgba",
{"quantize": IECore.FloatVectorData([0, 0, 0, 0])}))
s["d"]["in"].setInput(s["a"]["out"])
s["o"] = GafferScene.StandardOptions()
s["o"]["options"]["renderCamera"]["value"].setValue("/group/camera")
s["o"]["options"]["renderCamera"]["enabled"].setValue(True)
s["o"]["in"].setInput(s["d"]["out"])
s["r"] = GafferRenderMan.RenderManRender()
s["r"]["ribFileName"].setValue("/tmp/testRenderManLight.rib")
s["r"]["in"].setInput(s["o"]["out"])
# must save the script for the procedural to load it
# in the render process. if we were using a dispatcher,
# that would have saved the script for us, but we're
# calling execute() directly so it is our responsibility.
s["fileName"].setValue("/tmp/testRenderManLight.gfr")
s.save()
s["r"].execute()
i = IECore.EXRImageReader("/tmp/testRenderManLight.exr").read()
e = IECore.ImagePrimitiveEvaluator(i)
r = e.createResult()
e.pointAtUV(IECore.V2f(0.5), r)
self.assertEqual(r.floatPrimVar(e.R()), 1)
self.assertEqual(r.floatPrimVar(e.G()), 0.5)
self.assertEqual(r.floatPrimVar(e.B()), 0.25)
def testRender(self):
s = Gaffer.ScriptNode()
s["fileName"].setValue("/tmp/testRenderManLight.gfr")
s["l"] = GafferRenderMan.RenderManLight()
s["l"].loadShader("pointlight")
s["l"]["parameters"]["lightcolor"].setValue(
IECore.Color3f(1, 0.5, 0.25))
s["l"]["transform"]["translate"]["z"].setValue(1)
s["p"] = GafferScene.Plane()
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(1)
s["g"] = GafferScene.Group()
s["g"]["in"].setInput(s["l"]["out"])
s["g"]["in1"].setInput(s["p"]["out"])
s["g"]["in2"].setInput(s["c"]["out"])
s["s"] = GafferRenderMan.RenderManShader()
s["s"].loadShader("matte")
s["a"] = GafferScene.ShaderAssignment()
s["a"]["in"].setInput(s["g"]["out"])
s["a"]["shader"].setInput(s["s"]["out"])
s["d"] = GafferScene.Displays()
s["d"].addDisplay(
"beauty",
IECore.Display("/tmp/testRenderManLight.exr", "exr", "rgba",
{"quantize": IECore.FloatVectorData([0, 0, 0, 0])}))
s["d"]["in"].setInput(s["a"]["out"])
s["o"] = GafferScene.StandardOptions()
s["o"]["options"]["renderCamera"]["value"].setValue("/group/camera")
s["o"]["options"]["renderCamera"]["enabled"].setValue(True)
s["o"]["in"].setInput(s["d"]["out"])
s["r"] = GafferRenderMan.RenderManRender()
s["r"]["ribFileName"].setValue("/tmp/testRenderManLight.rib")
s["r"]["in"].setInput(s["o"]["out"])
## \todo This fails because ExecutableRender::execute() doesn't wait for the
# subprocess to complete as it should. We need to make it wait, but we can't
# do that until we're using the LocalDespatcher in gui applications.
s["r"].execute([Gaffer.Context.current()])
i = IECore.EXRImageReader("/tmp/testRenderManLight.exr").read()
e = IECore.ImagePrimitiveEvaluator(i)
r = e.createResult()
e.pointAtUV(IECore.V2f(0.5), r)
self.assertEqual(r.floatPrimVar(e.R()), 1)
self.assertEqual(r.floatPrimVar(e.G()), 0.5)
self.assertEqual(r.floatPrimVar(e.B()), 0.25)
def __nodeCreator( nodeName, shaderName ) : shader = GafferRenderMan.RenderManShader.shaderLoader().read( shaderName + ".sdl" ) if shader.type == "light" : node = GafferRenderMan.RenderManLight( nodeName ) else : node = GafferRenderMan.RenderManShader( nodeName ) node.loadShader( shaderName ) return node
def testCorrespondingInput( self ) : coshader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshader.sl" ) coshaderNode = GafferRenderMan.RenderManShader() coshaderNode.loadShader( coshader ) self.assertEqual( coshaderNode.correspondingInput( coshaderNode["out"] ), None ) coshader2 = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshaderWithPassThrough.sl" ) coshaderNode2 = GafferRenderMan.RenderManShader() coshaderNode2.loadShader( coshader2 ) self.assertTrue( coshaderNode2.correspondingInput( coshaderNode2["out"] ).isSame( coshaderNode2["parameters"]["aColorIWillTint"] ) )
def testHiddenLight(self):
s = Gaffer.ScriptNode()
s["fileName"].setValue(self.temporaryDirectory() + "/test.gfr")
s["l"] = GafferRenderMan.RenderManLight()
s["l"]["name"].setValue("myLight")
s["l"].loadShader("pointlight")
s["g"] = GafferScene.Group()
s["g"]["in"][0].setInput(s["l"]["out"])
s["f1"] = GafferScene.PathFilter()
s["f2"] = GafferScene.PathFilter()
s["a1"] = GafferScene.StandardAttributes()
s["a1"]["attributes"]["visibility"]["enabled"].setValue(True)
s["a1"]["attributes"]["visibility"]["value"].setValue(False)
s["a1"]["in"].setInput(s["g"]["out"])
s["a1"]["filter"].setInput(s["f1"]["out"])
s["a2"] = GafferScene.StandardAttributes()
s["a2"]["attributes"]["visibility"]["enabled"].setValue(True)
s["a2"]["attributes"]["visibility"]["value"].setValue(True)
s["a2"]["in"].setInput(s["a1"]["out"])
s["a2"]["filter"].setInput(s["f2"]["out"])
s["r"] = GafferRenderMan.RenderManRender()
s["r"]["mode"].setValue("generate")
s["r"]["ribFileName"].setValue(self.temporaryDirectory() + "/test.rib")
s["r"]["in"].setInput(s["a2"]["out"])
s["r"].execute()
rib = "\n".join(
file(self.temporaryDirectory() + "/test.rib").readlines())
self.assertTrue("LightSource \"pointlight\"" in rib)
s["f1"]["paths"].setValue(IECore.StringVectorData(["/group"
])) # hide group
s["r"].execute()
rib = "\n".join(
file(self.temporaryDirectory() + "/test.rib").readlines())
self.assertTrue("LightSource \"pointlight\"" not in rib)
s["f2"]["paths"].setValue(IECore.StringVectorData(
["/group/myLight"])) # show coordsys (but parent still hidden)
s["r"].execute()
rib = "\n".join(
file(self.temporaryDirectory() + "/test.rib").readlines())
self.assertTrue("LightSource \"pointlight\"" not in rib)
def testSampleMotion(self):
s = Gaffer.ScriptNode()
s["fileName"].setValue(self.temporaryDirectory() + "/test.gfr")
s["p"] = GafferScene.Plane()
s["o"] = GafferScene.StandardOptions()
s["o"]["in"].setInput(s["p"]["out"])
s["r"] = GafferRenderMan.RenderManRender()
s["r"]["mode"].setValue("generate")
s["r"]["ribFileName"].setValue(self.temporaryDirectory() + "/test.rib")
s["r"]["in"].setInput(s["o"]["out"])
s["r"]["task"].execute()
rib = file(self.temporaryDirectory() + "/test.rib").read()
self.assertFalse("sampleMotion" in rib)
s["o"]["options"]["sampleMotion"]["enabled"].setValue(True)
s["o"]["options"]["sampleMotion"]["value"].setValue(False)
s["r"]["task"].execute()
rib = file(self.temporaryDirectory() + "/test.rib").read()
self.assertTrue('"int samplemotion" [ 0 ]' in rib)
def testPreWorldRenderables(self):
s = Gaffer.ScriptNode()
s["g"] = GafferSceneTest.CompoundObjectSource()
s["g"]["in"].setValue(
IECore.CompoundObject({
"bound": IECore.Box3fData(IECore.Box3f()),
"globals": {
"option:user:blah": IECore.ClippingPlane(),
},
}))
s["r"] = GafferRenderMan.RenderManRender()
s["r"]["mode"].setValue("generate")
s["r"]["ribFileName"].setValue(self.temporaryDirectory() + "/test.rib")
s["r"]["in"].setInput(s["g"]["out"])
s["r"].execute()
# node should have inserted a ClippingPlane into the rib by putting it
# in the options:
rib = "\n".join(
file(self.temporaryDirectory() + "/test.rib").readlines())
self.assertTrue("ClippingPlane" in rib)
def testDynamicLoadProcedural(self):
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["render"] = GafferRenderMan.RenderManRender()
s["render"]["in"].setInput(s["plane"]["out"])
s["render"]["mode"].setValue("generate")
s["render"]["ribFileName"].setValue(self.temporaryDirectory() +
"/test.rib")
s["fileName"].setValue(self.temporaryDirectory() + "/test.gfr")
s.save()
s["render"].execute()
self.assertTrue(os.path.exists(self.temporaryDirectory() +
"/test.rib"))
rib = "\n".join(
file(self.temporaryDirectory() + "/test.rib").readlines())
self.assertTrue("DynamicLoad" in rib)
self.assertFalse("Polygon" in rib)
def testOutputParameters( self ) : shader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/version3.sl" ) n = GafferRenderMan.RenderManShader() n.loadShader( shader ) self.failIf( "outputFloat" in n["parameters"].keys() )
def testChildNamesUpdateCrash(self):
# build a scene with a reasonably large hierarchy:
plane = GafferScene.Plane()
plane["dimensions"].setValue(IECore.V2f(1000, 1000))
seeds = GafferScene.Seeds()
seeds["in"].setInput(plane["out"])
seeds["parent"].setValue("/plane")
seeds["density"].setValue(0.01)
sphere = GafferScene.Sphere()
instancer = GafferScene.Instancer()
instancer["parent"].setValue("/plane/seeds")
instancer["in"].setInput(seeds["out"])
instancer["instance"].setInput(sphere["out"])
r = GafferRenderMan.InteractiveRenderManRender()
r["in"].setInput(instancer["out"])
r["state"].setValue(r.State.Running)
# change the child names a couple of times. There was a problem
# where a childnames check was happening asynchronously, leading
# to a crash, so we're gonna check this has been fixed:
seeds["density"].setValue(0)
seeds["density"].setValue(0.01)
r["state"].setValue(r.State.Stopped)
def testParameterOrdering( self ) : n = GafferRenderMan.RenderManShader() n.loadShader( "plastic" ) self.assertEqual( n["parameters"][0].getName(), "Ks" ) self.assertEqual( n["parameters"][1].getName(), "Kd" ) self.assertEqual( n["parameters"][2].getName(), "Ka" ) self.assertEqual( n["parameters"][3].getName(), "roughness" ) self.assertEqual( n["parameters"][4].getName(), "specularcolor" ) n = GafferRenderMan.RenderManShader() n.loadShader( "matte" ) self.assertEqual( n["parameters"][0].getName(), "Ka" ) self.assertEqual( n["parameters"][1].getName(), "Kd" )
def testBoundsAndImageOutput(self):
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["plane"]["transform"]["translate"].setValue(IECore.V3f(0, 0, -5))
s["outputs"] = GafferScene.Outputs()
s["outputs"].addOutput(
"beauty", IECore.Display("/tmp/test.tif", "tiff", "rgba", {}))
s["outputs"]["in"].setInput(s["plane"]["out"])
s["render"] = GafferRenderMan.RenderManRender()
s["render"]["in"].setInput(s["outputs"]["out"])
s["render"]["mode"].setValue("generate")
s["render"]["ribFileName"].setValue("/tmp/test.rib")
s["fileName"].setValue("/tmp/test.gfr")
s.save()
s["render"].execute()
self.assertTrue(os.path.exists("/tmp/test.rib"))
p = subprocess.Popen("renderdl " + "/tmp/test.rib",
shell=True,
stderr=subprocess.PIPE)
p.wait()
self.failIf("exceeded its bounds" in "".join(p.stderr.readlines()))
self.assertTrue(os.path.exists("/tmp/test.tif"))
def testCoshaderType( self ) : coshader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshader.sl" ) coshaderNode = GafferRenderMan.RenderManShader() coshaderNode.loadShader( coshader ) self.assertEqual( coshaderNode.state()[0].type, "ri:shader" )
def testParameterDefaultValue( self ) : shader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/coshaderParameter.sl" ) shaderNode = GafferRenderMan.RenderManShader() shaderNode.loadShader( shader ) self.assertEqual( shaderNode["parameters"]["floatParameter"].defaultValue(), 1 )
def testArrayParameters( self ) :
shader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/arrayParameters.sl" )
n = GafferRenderMan.RenderManShader()
n.loadShader( shader )
expected = {
"dynamicFloatArray" : IECore.FloatVectorData( [] ),
"fixedFloatArray" : IECore.FloatVectorData( [ 1, 2, 3, 4 ] ),
"dynamicStringArray" : IECore.StringVectorData( [ "dynamic", "arrays", "can", "still", "have", "defaults" ] ),
"fixedStringArray" : IECore.StringVectorData( [ "hello", "goodbye" ] ),
"dynamicColorArray" : IECore.Color3fVectorData( [ IECore.Color3f( 1 ), IECore.Color3f( 2 ) ] ),
"fixedColorArray" : IECore.Color3fVectorData( [ IECore.Color3f( 1 ), IECore.Color3f( 2 ) ] ),
"dynamicVectorArray" : IECore.V3fVectorData( [] ),
"fixedVectorArray" : IECore.V3fVectorData( [ IECore.V3f( x ) for x in range( 1, 6 ) ] ),
"dynamicPointArray" : IECore.V3fVectorData( [] ),
"fixedPointArray" : IECore.V3fVectorData( [ IECore.V3f( x ) for x in range( 1, 6 ) ] ),
"dynamicNormalArray" : IECore.V3fVectorData( [] ),
"fixedNormalArray" : IECore.V3fVectorData( [ IECore.V3f( x ) for x in range( 1, 6 ) ] ),
}
self.assertEqual( set( n["parameters"].keys() ), set( expected.keys() ) )
for name, value in expected.items() :
self.assertEqual( n["parameters"][name].defaultValue(), value )
self.assertEqual( n["parameters"][name].getValue(), value )
s = n.state()[0]
for name, value in expected.items() :
self.assertEqual( s.parameters[name], value )
def testReload( self ) : shader1 = self.compileShader( os.path.dirname( __file__ ) + "/shaders/version1.sl" ) shaderNode = GafferRenderMan.RenderManShader() shaderNode.loadShader( shader1 ) shaderNode["parameters"]["float1"].setValue( 0.1 ) shaderNode["parameters"]["string1"].setValue( "test" ) shaderNode["parameters"]["color1"].setValue( IECore.Color3f( 1, 2, 3 ) ) self.assertAlmostEqual( shaderNode["parameters"]["float1"].getValue(), 0.1 ) self.assertEqual( shaderNode["parameters"]["string1"].getValue(), "test" ) self.assertEqual( shaderNode["parameters"]["color1"].getValue(), IECore.Color3f( 1, 2, 3 ) ) shader2 = self.compileShader( os.path.dirname( __file__ ) + "/shaders/version2.sl" ) shaderNode.loadShader( shader2, keepExistingValues=True ) self.assertEqual( shaderNode["parameters"].keys(), [ "float1", "string1", "color1", "float2", "string2", "color2" ] ) self.assertAlmostEqual( shaderNode["parameters"]["float1"].getValue(), 0.1 ) self.assertEqual( shaderNode["parameters"]["string1"].getValue(), "test" ) self.assertEqual( shaderNode["parameters"]["color1"].getValue(), IECore.Color3f( 1, 2, 3 ) ) shaderNode.loadShader( shader1, keepExistingValues=True ) self.assertEqual( shaderNode["parameters"].keys(), [ "float1", "string1", "color1" ] ) self.assertAlmostEqual( shaderNode["parameters"]["float1"].getValue(), 0.1 ) self.assertEqual( shaderNode["parameters"]["string1"].getValue(), "test" ) self.assertEqual( shaderNode["parameters"]["color1"].getValue(), IECore.Color3f( 1, 2, 3 ) ) shaderNode.loadShader( shader1, keepExistingValues=False ) self.assertEqual( shaderNode["parameters"].keys(), [ "float1", "string1", "color1" ] ) self.assertEqual( shaderNode["parameters"]["float1"].getValue(), 1 ) self.assertEqual( shaderNode["parameters"]["string1"].getValue(), "" ) self.assertEqual( shaderNode["parameters"]["color1"].getValue(), IECore.Color3f( 1, 1, 1 ) )
def testReloadPreservesConnectionsWhenMinMaxOrDefaultChanges( self ) : shader1 = self.compileShader( os.path.dirname( __file__ ) + "/shaders/version1.sl", shaderName = "unversioned" ) n = GafferRenderMan.RenderManShader() n.loadShader( shader1 ) self.assertFalse( n["parameters"]["float1"].hasMinValue() ) self.assertFalse( n["parameters"]["float1"].hasMaxValue() ) self.assertEqual( n["parameters"]["string1"].defaultValue(), "" ) nn = Gaffer.Node() nn["outFloat"] = Gaffer.FloatPlug( direction = Gaffer.Plug.Direction.Out ) nn["outString"] = Gaffer.StringPlug( direction = Gaffer.Plug.Direction.Out ) n["parameters"]["float1"].setInput( nn["outFloat"] ) n["parameters"]["string1"].setInput( nn["outString"] ) shader2 = self.compileShader( os.path.dirname( __file__ ) + "/shaders/version2.sl", shaderName = "unversioned" ) GafferRenderMan.RenderManShader.shaderLoader().clear() n.loadShader( shader1, keepExistingValues=True ) self.assertTrue( n["parameters"]["float1"].hasMinValue() ) self.assertTrue( n["parameters"]["float1"].hasMaxValue() ) self.assertEqual( n["parameters"]["float1"].minValue(), -1 ) self.assertEqual( n["parameters"]["float1"].maxValue(), 2 ) self.assertEqual( n["parameters"]["string1"].defaultValue(), "newDefaultValue" ) self.assertTrue( n["parameters"]["float1"].getInput().isSame( nn["outFloat"] ) ) self.assertTrue( n["parameters"]["string1"].getInput().isSame( nn["outString"] ) )
def testPromotedCameraHitMode(self):
b = Gaffer.Box()
b["a"] = GafferRenderMan.RenderManAttributes()
p = b.promotePlug(b["a"]["attributes"]["cameraHitMode"])
self.assertEqual(Gaffer.NodeAlgo.presets(p["value"]),
["Shader", "Primitive"])
def testShaderHash( self ) : n = GafferRenderMan.RenderManShader() n.loadShader( "checker" ) h1 = n.stateHash() n["parameters"]["Kd"].setValue( 0.25 ) self.assertNotEqual( n.stateHash(), h1 )
def testRenderingDuringScriptDeletion(self):
s = Gaffer.ScriptNode()
s["p"] = GafferScene.Plane()
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(1)
s["g"] = GafferScene.Group()
s["g"]["in"].setInput(s["p"]["out"])
s["g"]["in1"].setInput(s["c"]["out"])
s["d"] = GafferScene.Outputs()
s["d"].addOutput(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"driverType": "ClientDisplayDriver",
"displayHost": "localhost",
"displayPort": "1559",
"remoteDisplayType": "GafferImage::GafferDisplayDriver",
"quantize": IECore.IntVectorData([0, 0, 0, 0]),
}))
s["d"]["in"].setInput(s["g"]["out"])
s["m"] = GafferImage.Display()
# connect a python function to the Display node image and data
# received signals. this emulates what the UI does.
def __displayCallback(plug):
pass
c = (
s["m"].imageReceivedSignal().connect(__displayCallback),
s["m"].dataReceivedSignal().connect(__displayCallback),
)
s["o"] = GafferScene.StandardOptions()
s["o"]["in"].setInput(s["d"]["out"])
s["o"]["options"]["renderCamera"]["enabled"].setValue(True)
s["o"]["options"]["renderCamera"]["value"].setValue("/group/plane")
s["r"] = GafferRenderMan.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(1)
# delete the script while the render is still progressing. when
# this occurs, deletion of the render node will be triggered, which
# will in turn stop the render. this may flush data to the display,
# in which case it will emit its data and image received signals
# on a separate thread. if we're still holding the gil on the main
# thread when this happens, we'll get a deadlock.
del s
def testHash(self):
c = Gaffer.Context()
c.setFrame(1)
c2 = Gaffer.Context()
c2.setFrame(2)
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["outputs"] = GafferScene.Outputs()
s["outputs"]["in"].setInput(s["plane"]["out"])
s["outputs"].addOutput(
"beauty",
IECore.Display("$renderDirectory/test.####.exr", "exr", "rgba",
{}))
s["render"] = GafferRenderMan.RenderManRender()
# no input scene produces no effect
with c:
self.assertEqual(s["render"]["task"].hash(), IECore.MurmurHash())
# now theres an scene to render, we get some output
s["render"]["in"].setInput(s["outputs"]["out"])
with c:
self.assertNotEqual(s["render"]["task"].hash(),
IECore.MurmurHash())
# output varies by time
with c:
h1 = s["render"]["task"].hash()
with c2:
h2 = s["render"]["task"].hash()
self.assertNotEqual(h1, h2)
# output varies by new Context entries
with c:
current = s["render"]["task"].hash()
c["renderDirectory"] = self.temporaryDirectory() + "/renderTests"
self.assertNotEqual(s["render"]["task"].hash(), current)
# output varies by changed Context entries
with c:
current = s["render"]["task"].hash()
c["renderDirectory"] = self.temporaryDirectory() + "/renderTests2"
self.assertNotEqual(s["render"]["task"].hash(), current)
# output doesn't vary by ui Context entries
with c:
current = s["render"]["task"].hash()
c["ui:something"] = "alterTheUI"
self.assertEqual(s["render"]["task"].hash(), current)
# also varies by input node
with c:
current = s["render"]["task"].hash()
s["render"]["in"].setInput(s["plane"]["out"])
self.assertNotEqual(s["render"]["task"].hash(), current)
def testWedge(self):
s = Gaffer.ScriptNode()
s["sphere"] = GafferScene.Sphere()
s["sphere"]["sets"].setValue("${wedge:value}")
s["filter"] = GafferScene.SetFilter()
s["filter"]["set"].setValue("hidden")
s["attributes"] = GafferScene.StandardAttributes()
s["attributes"]["attributes"]["visibility"]["enabled"].setValue(True)
s["attributes"]["attributes"]["visibility"]["value"].setValue(False)
s["attributes"]["filter"].setInput(s["filter"]["out"])
s["attributes"]["in"].setInput(s["sphere"]["out"])
s["outputs"] = GafferScene.Outputs()
s["outputs"].addOutput(
"beauty",
IECore.Display("/tmp/${wedge:value}.tif", "tiff", "rgba", {}))
s["outputs"]["in"].setInput(s["attributes"]["out"])
s["render"] = GafferRenderMan.RenderManRender()
s["render"]["ribFileName"].setValue("/tmp/test.rib")
s["render"]["in"].setInput(s["outputs"]["out"])
s["wedge"] = Gaffer.Wedge()
s["wedge"]["mode"].setValue(int(s["wedge"].Mode.StringList))
s["wedge"]["strings"].setValue(
IECore.StringVectorData(["visible", "hidden"]))
s["wedge"]["requirements"][0].setInput(s["render"]["requirement"])
s["fileName"].setValue("/tmp/test.gfr")
s.save()
dispatcher = Gaffer.LocalDispatcher()
dispatcher["jobsDirectory"].setValue("/tmp/testJobDirectory")
dispatcher["framesMode"].setValue(
Gaffer.Dispatcher.FramesMode.CurrentFrame)
dispatcher["executeInBackground"].setValue(False)
dispatcher.dispatch([s["wedge"]])
hidden = GafferImage.ImageReader()
hidden["fileName"].setValue("/tmp/hidden.tif")
visible = GafferImage.ImageReader()
visible["fileName"].setValue("/tmp/visible.tif")
hiddenStats = GafferImage.ImageStats()
hiddenStats["in"].setInput(hidden["out"])
visibleStats = GafferImage.ImageStats()
visibleStats["in"].setInput(visible["out"])
self.assertLess(hiddenStats["average"].getValue()[0], 0.05)
self.assertGreater(visibleStats["average"].getValue()[0], .35)
def testRenderingDuringScriptDeletion( self ) :
s = Gaffer.ScriptNode()
s["p"] = GafferScene.Plane()
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue( 1 )
s["g"] = GafferScene.Group()
s["g"]["in"][0].setInput( s["p"]["out"] )
s["g"]["in"][1].setInput( s["c"]["out"] )
s["d"] = GafferScene.Outputs()
s["d"].addOutput(
"beauty",
IECore.Display(
"test",
"ieDisplay",
"rgba",
{
"driverType" : "ClientDisplayDriver",
"displayHost" : "localhost",
"displayPort" : "1559",
"remoteDisplayType" : "GafferImage::GafferDisplayDriver",
"quantize" : IECore.IntVectorData( [ 0, 0, 0, 0 ] ),
}
)
)
s["d"]["in"].setInput( s["g"]["out"] )
# Emulate the connection the UI makes, so the Display knows someone is listening and
# it needs to actually make servers.
executeOnUIThreadConnection = GafferImage.Display.executeOnUIThreadSignal().connect( lambda f : f() )
s["m"] = GafferImage.Display()
s["o"] = GafferScene.StandardOptions()
s["o"]["in"].setInput( s["d"]["out"] )
s["o"]["options"]["renderCamera"]["enabled"].setValue( True )
s["o"]["options"]["renderCamera"]["value"].setValue( "/group/camera" )
s["r"] = GafferRenderMan.InteractiveRenderManRender()
s["r"]["in"].setInput( s["o"]["out"] )
s["r"]["state"].setValue( s["r"].State.Running )
time.sleep( 1 )
# delete the script while the render is still progressing. when
# this occurs, deletion of the render node will be triggered, which
# will in turn stop the render. this may flush data to the display,
# in which case it will emit its data and image received signals
# on a separate thread. if we're still holding the gil on the main
# thread when this happens, we'll get a deadlock.
del s
