def testImageOutput( self ) :
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["displays"] = GafferScene.Displays()
s["displays"].addDisplay(
"beauty",
IECore.Display(
"/tmp/test.####.tif",
"tiff",
"rgba",
{}
)
)
s["displays"]["in"].setInput( s["plane"]["out"] )
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput( s["displays"]["out"] )
s["render"]["verbosity"].setValue( 1 )
s["render"]["fileName"].setValue( "/tmp/test.####.ass" )
s["fileName"].setValue( self.__scriptFileName )
s.save()
c = Gaffer.Context()
for i in range( 1, 4 ) :
c.setFrame( i )
with c :
s["render"].execute( [ Gaffer.Context.current() ] )
for i in range( 1, 4 ) :
self.failUnless( os.path.exists( "/tmp/test.%04d.tif" % i ) )
def testBoundsAndImageOutput(self):
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["plane"]["transform"]["translate"].setValue(IECore.V3f(0, 0, -5))
s["displays"] = GafferScene.Displays()
s["displays"].addDisplay(
"beauty", IECore.Display("/tmp/test.tif", "tiff", "rgba", {}))
s["displays"]["in"].setInput(s["plane"]["out"])
s["render"] = GafferRenderMan.RenderManRender()
s["render"]["in"].setInput(s["displays"]["out"])
s["render"]["mode"].setValue("generate")
s["render"]["ribFileName"].setValue("/tmp/test.rib")
s["fileName"].setValue("/tmp/test.gfr")
s.save()
s["render"].execute([Gaffer.Context.current()])
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 testDisplayDirectoryCreation(self):
s = Gaffer.ScriptNode()
s["variables"].addMember("renderDirectory", "/tmp/openGLRenderTest")
s["plane"] = GafferScene.Plane()
s["displays"] = GafferScene.Displays()
s["displays"]["in"].setInput(s["plane"]["out"])
s["displays"].addDisplay(
"beauty",
IECore.Display("$renderDirectory/test.####.exr", "exr", "rgba",
{}))
s["render"] = GafferScene.OpenGLRender()
s["render"]["in"].setInput(s["displays"]["out"])
self.assertFalse(os.path.exists("/tmp/openGLRenderTest"))
self.assertFalse(os.path.exists("/tmp/openGLRenderTest/test.0001.exr"))
s["fileName"].setValue("/tmp/test.gfr")
with s.context():
s["render"].execute()
self.assertTrue(os.path.exists("/tmp/openGLRenderTest"))
self.assertTrue(os.path.exists("/tmp/openGLRenderTest/test.0001.exr"))
def testWaitForImage( self ) :
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["displays"] = GafferScene.Displays()
s["displays"].addDisplay(
"beauty",
IECore.Display(
"/tmp/test.tif",
"tiff",
"rgba",
{}
)
)
s["displays"]["in"].setInput( s["plane"]["out"] )
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput( s["displays"]["out"] )
s["render"]["verbosity"].setValue( 1 )
s["render"]["fileName"].setValue( "/tmp/test.ass" )
s["fileName"].setValue( self.__scriptFileName )
s["render"].execute( [ Gaffer.Context.current() ] )
self.failUnless( os.path.exists( "/tmp/test.tif" ) )
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.Displays()
s["d"].addDisplay(
"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 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 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.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"] )
# 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 test(self):
p = GafferScene.Plane()
displays = GafferScene.Displays()
displays["in"].setInput(p["out"])
# check that the scene hierarchy is passed through
self.assertEqual(displays["out"].object("/"), IECore.NullObject())
self.assertEqual(displays["out"].transform("/"), IECore.M44f())
self.assertEqual(
displays["out"].bound("/"),
IECore.Box3f(IECore.V3f(-0.5, -0.5, 0), IECore.V3f(0.5, 0.5, 0)))
self.assertEqual(displays["out"].childNames("/"),
IECore.InternedStringVectorData(["plane"]))
self.assertEqual(
displays["out"].object("/plane"),
IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(-0.5), IECore.V2f(0.5))))
self.assertEqual(displays["out"].transform("/plane"), IECore.M44f())
self.assertEqual(
displays["out"].bound("/plane"),
IECore.Box3f(IECore.V3f(-0.5, -0.5, 0), IECore.V3f(0.5, 0.5, 0)))
self.assertEqual(displays["out"].childNames("/plane"),
IECore.InternedStringVectorData())
# check that we have some displays
display = displays.addDisplay(
"beauty", IECore.Display("beauty.exr", "exr", "rgba"))
display["parameters"].addMember("test", IECore.FloatData(10))
displays.addDisplay(
"diffuse", IECore.Display("diffuse.exr", "exr",
"color aov_diffuse"))
g = displays["out"]["globals"].getValue()
self.assertEqual(len(g), 2)
self.assertEqual(
g["display:beauty.exr"],
IECore.Display("beauty.exr", "exr", "rgba", {"test": 10.0}))
self.assertEqual(
g["display:diffuse.exr"],
IECore.Display("diffuse.exr", "exr", "color aov_diffuse"))
# check that we can turn 'em off as well
display["active"].setValue(False)
g = displays["out"]["globals"].getValue()
self.assertEqual(len(g), 1)
self.assertEqual(
g["display:diffuse.exr"],
IECore.Display("diffuse.exr", "exr", "color aov_diffuse"))
def testParametersHaveUsefulNames(self):
displays = GafferScene.Displays()
displays.addDisplay(
"test",
IECore.Display("name", "type", "data", {
"paramA": 1,
"paramB": 2
}))
self.assertEqual(set(displays["displays"][0]["parameters"].keys()),
set(["paramA", "paramB"]))
def test( self ) :
self.assertFalse( os.path.exists( "/tmp/test.exr" ) )
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["plane"]["transform"]["translate"].setValue( IECore.V3f( 0, 0, -5 ) )
s["image"] = GafferImage.ImageReader()
s["image"]["fileName"].setValue( os.path.expandvars( "$GAFFER_ROOT/python/GafferTest/images/checker.exr" ) )
s["shader"] = GafferScene.OpenGLShader()
s["shader"].loadShader( "Texture" )
s["shader"]["parameters"]["texture"].setInput( s["image"]["out"] )
s["shader"]["parameters"]["mult"].setValue( 1 )
s["shader"]["parameters"]["tint"].setValue( IECore.Color4f( 1 ) )
s["assignment"] = GafferScene.ShaderAssignment()
s["assignment"]["in"].setInput( s["plane"]["out"] )
s["assignment"]["shader"].setInput( s["shader"]["out"] )
s["displays"] = GafferScene.Displays()
s["displays"].addDisplay(
"beauty",
IECore.Display(
"/tmp/test.exr",
"exr",
"rgba",
{}
)
)
s["displays"]["in"].setInput( s["assignment"]["out"] )
s["render"] = GafferScene.OpenGLRender()
s["render"]["in"].setInput( s["displays"]["out"] )
s["fileName"].setValue( "/tmp/test.gfr" )
s.save()
s["render"].execute( [ Gaffer.Context.current() ] )
self.assertTrue( os.path.exists( "/tmp/test.exr" ) )
i = IECore.EXRImageReader( "/tmp/test.exr" ).read()
e = IECore.ImagePrimitiveEvaluator( i )
r = e.createResult()
e.pointAtUV( IECore.V2f( 0.5 ), r )
self.assertAlmostEqual( r.floatPrimVar( e.R() ), 0.666666, 5 )
self.assertAlmostEqual( r.floatPrimVar( e.G() ), 0.666666, 5 )
self.assertEqual( r.floatPrimVar( e.B() ), 0 )
def testHashPassThrough(self):
# the hash of the per-object part of a displays output should be
# identical to the input, so that they share cache entries.
p = GafferScene.Plane()
displays = GafferScene.Displays()
displays["in"].setInput(p["out"])
self.assertSceneHashesEqual(p["out"],
displays["out"],
childPlugNames=("transform", "bound",
"attributes", "object",
"childNames"))
def testRenderToDisplayViaForegroundDispatch(self):
s = Gaffer.ScriptNode()
s["sphere"] = GafferScene.Sphere()
s["displays"] = GafferScene.Displays()
s["displays"].addDisplay(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
"driverType": "ClientDisplayDriver",
"displayHost": "localhost",
"displayPort": "1559",
"remoteDisplayType": "GafferImage::GafferDisplayDriver",
"handle": "myLovelyPlane",
}))
s["displays"]["in"].setInput(s["sphere"]["out"])
s["display"] = GafferImage.Display()
def __displayCallback(plug):
pass
# connect a python function to the Display node image and data
# received signals. this emulates what the UI does.
c = (
s["display"].imageReceivedSignal().connect(__displayCallback),
s["display"].dataReceivedSignal().connect(__displayCallback),
)
s["render"] = GafferRenderMan.RenderManRender()
s["render"]["ribFileName"].setValue("/tmp/test.rib")
s["render"]["in"].setInput(s["displays"]["out"])
s["fileName"].setValue("/tmp/test.gfr")
s.save()
# dispatch the render on the foreground thread. if we don't manage
# the GIL appropriately, we'll get a deadlock when the Display signals
# above try to enter python on the background thread.
dispatcher = Gaffer.LocalDispatcher()
dispatcher["jobDirectory"].setValue("/tmp/testJobDirectory")
dispatcher["framesMode"].setValue(
Gaffer.Dispatcher.FramesMode.CurrentFrame)
dispatcher["executeInBackground"].setValue(False)
dispatcher.dispatch([s["render"]])
def testExecutionHash(self):
c = Gaffer.Context()
c.setFrame(1)
c2 = Gaffer.Context()
c2.setFrame(2)
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["displays"] = GafferScene.Displays()
s["displays"]["in"].setInput(s["plane"]["out"])
s["displays"].addDisplay(
"beauty",
IECore.Display("$renderDirectory/test.####.exr", "exr", "rgba",
{}))
s["render"] = GafferRenderMan.RenderManRender()
# no input scene produces no effect
self.assertEqual(s["render"].executionHash(c), IECore.MurmurHash())
# now theres an scene to render, we get some output
s["render"]["in"].setInput(s["displays"]["out"])
self.assertNotEqual(s["render"].executionHash(c), IECore.MurmurHash())
# output varies by time
self.assertNotEqual(s["render"].executionHash(c),
s["render"].executionHash(c2))
# output varies by new Context entries
current = s["render"].executionHash(c)
c["renderDirectory"] = "/tmp/renderTests"
self.assertNotEqual(s["render"].executionHash(c), current)
# output varies by changed Context entries
current = s["render"].executionHash(c)
c["renderDirectory"] = "/tmp/renderTests2"
self.assertNotEqual(s["render"].executionHash(c), current)
# output doesn't vary by ui Context entries
current = s["render"].executionHash(c)
c["ui:something"] = "alterTheUI"
self.assertEqual(s["render"].executionHash(c), current)
# also varies by input node
current = s["render"].executionHash(c)
s["render"]["in"].setInput(s["plane"]["out"])
self.assertNotEqual(s["render"].executionHash(c), current)
def testDirectoryCreation( self ) :
s = Gaffer.ScriptNode()
s["variables"].addMember( "renderDirectory", "/tmp/renderTests" )
s["variables"].addMember( "assDirectory", "/tmp/assTests" )
s["plane"] = GafferScene.Plane()
s["displays"] = GafferScene.Displays()
s["displays"]["in"].setInput( s["plane"]["out"] )
s["displays"].addDisplay(
"beauty",
IECore.Display(
"$renderDirectory/test.####.exr",
"exr",
"rgba",
{}
)
)
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput( s["displays"]["out"] )
s["render"]["fileName"].setValue( "$assDirectory/test.####.ass" )
s["render"]["mode"].setValue( "generate" )
self.assertFalse( os.path.exists( "/tmp/renderTests" ) )
self.assertFalse( os.path.exists( "/tmp/assTests" ) )
self.assertFalse( os.path.exists( "/tmp/assTests/test.0001.ass" ) )
s["fileName"].setValue( "/tmp/test.gfr" )
s["render"].execute( [ s.context() ] )
self.assertTrue( os.path.exists( "/tmp/renderTests" ) )
self.assertTrue( os.path.exists( "/tmp/assTests" ) )
self.assertTrue( os.path.exists( "/tmp/assTests/test.0001.ass" ) )
# check it can cope with everything already existing
s["render"].execute( [ s.context() ] )
self.assertTrue( os.path.exists( "/tmp/renderTests" ) )
self.assertTrue( os.path.exists( "/tmp/assTests" ) )
self.assertTrue( os.path.exists( "/tmp/assTests/test.0001.ass" ) )
def testSerialisation(self):
s = Gaffer.ScriptNode()
s["displaysNode"] = GafferScene.Displays()
display = s["displaysNode"].addDisplay(
"beauty", IECore.Display("beauty.exr", "exr", "rgba"))
display["parameters"].addMember("test", IECore.FloatData(10))
ss = s.serialise()
s2 = Gaffer.ScriptNode()
s2.execute(ss)
g = s2["displaysNode"]["out"]["globals"].getValue()
self.assertEqual(len(g), 1)
self.assertEqual(
g["display:beauty.exr"],
IECore.Display("beauty.exr", "exr", "rgba", {"test": 10.0}))
self.assertEqual(len(s2["displaysNode"]["displays"]), 1)
self.assertTrue("displays1" not in s2["displaysNode"])
def testDirectoryCreation(self):
s = Gaffer.ScriptNode()
s["variables"].addMember("renderDirectory", "/tmp/renderTests")
s["variables"].addMember("ribDirectory", "/tmp/ribTests")
s["plane"] = GafferScene.Plane()
s["displays"] = GafferScene.Displays()
s["displays"]["in"].setInput(s["plane"]["out"])
s["displays"].addDisplay(
"beauty",
IECore.Display("$renderDirectory/test.####.exr", "exr", "rgba",
{}))
s["render"] = GafferRenderMan.RenderManRender()
s["render"]["in"].setInput(s["displays"]["out"])
s["render"]["ribFileName"].setValue("$ribDirectory/test.####.rib")
s["render"]["mode"].setValue("generate")
self.assertFalse(os.path.exists("/tmp/renderTests"))
self.assertFalse(os.path.exists("/tmp/ribTests"))
self.assertFalse(os.path.exists("/tmp/ribTests/test.0001.rib"))
s["fileName"].setValue("/tmp/test.gfr")
with s.context():
s["render"].execute()
self.assertTrue(os.path.exists("/tmp/renderTests"))
self.assertTrue(os.path.exists("/tmp/ribTests"))
self.assertTrue(os.path.exists("/tmp/ribTests/test.0001.rib"))
# check that having the directories already exist is ok too
with s.context():
s["render"].execute()
self.assertTrue(os.path.exists("/tmp/renderTests"))
self.assertTrue(os.path.exists("/tmp/ribTests"))
self.assertTrue(os.path.exists("/tmp/ribTests/test.0001.rib"))
def testLights(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.Displays()
s["d"].addDisplay(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
"driverType": "ImageDisplayDriver",
"handle": "myLovelyPlane",
}))
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.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
# start a render, give it time to finish, and check the output
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[0], IECore.Color3f(1, 0.5, 0.25))
# adjust a parameter, give it time to update, and check the output
s["l"]["parameters"]["lightcolor"].setValue(
IECore.Color3f(0.25, 0.5, 1))
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[2], IECore.Color3f(0.25, 0.5, 1))
# pause it, adjust a parameter, wait, and check that nothing changed
s["r"]["state"].setValue(s["r"].State.Paused)
s["l"]["parameters"]["lightcolor"].setValue(
IECore.Color3f(1, 0.5, 0.25))
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[2], IECore.Color3f(0.25, 0.5, 1))
# unpause it, wait, and check that the update happened
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[0], IECore.Color3f(1, 0.5, 0.25))
# turn off light updates, adjust a parameter, wait, and check nothing happened
s["r"]["updateLights"].setValue(False)
s["l"]["parameters"]["lightcolor"].setValue(
IECore.Color3f(0.25, 0.5, 1))
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[0], IECore.Color3f(1, 0.5, 0.25))
# turn light updates back on and check that it updates
s["r"]["updateLights"].setValue(True)
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[2], IECore.Color3f(0.25, 0.5, 1))
# stop the render, tweak a parameter and check that nothing happened
s["r"]["state"].setValue(s["r"].State.Stopped)
s["l"]["parameters"]["lightcolor"].setValue(
IECore.Color3f(1, 0.5, 0.25))
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[2], IECore.Color3f(0.25, 0.5, 1))
def testHideLight(self):
s = Gaffer.ScriptNode()
s["l"] = GafferRenderMan.RenderManLight()
s["l"].loadShader("pointlight")
s["l"]["transform"]["translate"]["z"].setValue(1)
s["v"] = GafferScene.StandardAttributes()
s["v"]["attributes"]["visibility"]["enabled"].setValue(True)
s["v"]["in"].setInput(s["l"]["out"])
s["p"] = GafferScene.Plane()
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(1)
s["g"] = GafferScene.Group()
s["g"]["in"].setInput(s["v"]["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(
"test", "ieDisplay", "rgba", {
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
"driverType": "ImageDisplayDriver",
"handle": "myLovelyPlane",
}))
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.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
# start a render, give it time to finish, and check the output
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertNotEqual(c[0], 0.0)
# remove the light by hiding it
s["v"]["attributes"]["visibility"]["value"].setValue(False)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c[0], 0.0)
# put the light back by showing it
s["v"]["attributes"]["visibility"]["value"].setValue(True)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertNotEqual(c[0], 0.0)
def testAddLight(self):
s = Gaffer.ScriptNode()
s["l"] = GafferRenderMan.RenderManLight()
s["l"].loadShader("pointlight")
s["l"]["parameters"]["lightcolor"].setValue(IECore.Color3f(1, 0, 0))
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(
"test", "ieDisplay", "rgba", {
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
"driverType": "ImageDisplayDriver",
"handle": "myLovelyPlane",
}))
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.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
# start a render, give it time to finish, and check the output
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[0], IECore.Color3f(1, 0, 0))
# add a light
s["l2"] = GafferRenderMan.RenderManLight()
s["l2"].loadShader("pointlight")
s["l2"]["parameters"]["lightcolor"].setValue(IECore.Color3f(0, 1, 0))
s["l2"]["transform"]["translate"]["z"].setValue(1)
s["g"]["in3"].setInput(s["l2"]["out"])
# give it time to update, and check the output
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[0], IECore.Color3f(1, 1, 0))
def testScopesDontLeak(self):
s = Gaffer.ScriptNode()
s["p"] = GafferScene.Plane()
s["p"]["transform"]["translate"].setValue(IECore.V3f(-0.6, -0.1, 0))
s["p1"] = GafferScene.Plane()
s["p1"]["transform"]["translate"].setValue(IECore.V3f(0.6, 0.1, 0))
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(2)
s["l"] = GafferRenderMan.RenderManLight()
s["l"].loadShader("ambientlight")
s["g"] = GafferScene.Group()
s["g"]["in"].setInput(s["p"]["out"])
s["g"]["in1"].setInput(s["p1"]["out"])
s["g"]["in2"].setInput(s["c"]["out"])
s["g"]["in3"].setInput(s["l"]["out"])
s["s"] = GafferRenderMan.RenderManShader()
s["s"].loadShader("checker")
s["s"]["parameters"]["blackcolor"].setValue(IECore.Color3f(1, 0, 0))
s["s"]["parameters"]["Ka"].setValue(1)
s["s"]["parameters"]["frequency"].setValue(1)
s["f"] = GafferScene.PathFilter()
s["f"]["paths"].setValue(IECore.StringVectorData(["/group/plane"]))
s["a"] = GafferScene.ShaderAssignment()
s["a"]["in"].setInput(s["g"]["out"])
s["a"]["shader"].setInput(s["s"]["out"])
s["a"]["filter"].setInput(s["f"]["match"])
s["d"] = GafferScene.Displays()
s["d"].addDisplay(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
"driverType": "ImageDisplayDriver",
"handle": "myLovelyPlanes",
}))
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"]["options"]["renderResolution"]["value"].setValue(
IECore.V2i(512))
s["o"]["options"]["renderResolution"]["enabled"].setValue(True)
s["o"]["in"].setInput(s["d"]["out"])
s["r"] = GafferRenderMan.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
# start a render, give it time to finish, and check the output.
# we should have a red plane on the left, and a facing ratio
# shaded plane on the right, because we attached no shader to the
# second plane.
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlanes"),
IECore.V2f(0.25, 0.5),
)
self.assertEqual(c, IECore.Color3f(1, 0, 0))
c1 = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlanes"),
IECore.V2f(0.75, 0.5),
)
self.assertTrue(c1[0] > 0.9)
self.assertEqual(c1[0], c1[1])
self.assertEqual(c1[0], c1[2])
# adjust a shader parameter, wait, and check that the plane
# on the left changed. check that the plane on the right didn't
# change at all.
s["s"]["parameters"]["blackcolor"].setValue(IECore.Color3f(0, 1, 0))
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlanes"),
IECore.V2f(0.25, 0.5),
)
self.assertEqual(c, IECore.Color3f(0, 1, 0))
c1 = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlanes"),
IECore.V2f(0.75, 0.5),
)
self.assertTrue(c1[0] > 0.9)
self.assertEqual(c1[0], c1[1])
self.assertEqual(c1[0], c1[2])
def testShaders(self):
s = Gaffer.ScriptNode()
s["p"] = GafferScene.Plane()
s["p"]["transform"]["translate"].setValue(IECore.V3f(-0.1, -0.1, 0))
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(1)
s["l"] = GafferRenderMan.RenderManLight()
s["l"].loadShader("ambientlight")
s["g"] = GafferScene.Group()
s["g"]["in"].setInput(s["p"]["out"])
s["g"]["in1"].setInput(s["c"]["out"])
s["g"]["in2"].setInput(s["l"]["out"])
s["s"] = GafferRenderMan.RenderManShader()
s["s"].loadShader("checker")
s["s"]["parameters"]["blackcolor"].setValue(
IECore.Color3f(1, 0.5, 0.25))
s["s"]["parameters"]["Ka"].setValue(1)
s["s"]["parameters"]["frequency"].setValue(1)
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(
"test", "ieDisplay", "rgba", {
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
"driverType": "ImageDisplayDriver",
"handle": "myLovelyPlane",
}))
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.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
# start a render, give it time to finish, and check the output
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c, IECore.Color3f(1, 0.5, 0.25))
# adjust a shader parameter, wait, and check that it changed
s["s"]["parameters"]["blackcolor"].setValue(IECore.Color3f(1, 1, 1))
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c, IECore.Color3f(1))
# turn off shader updates, do the same, and check that it hasn't changed
s["r"]["updateShaders"].setValue(False)
s["s"]["parameters"]["blackcolor"].setValue(IECore.Color3f(0.5))
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c, IECore.Color3f(1))
# turn shader updates back on, and check that it updates
s["r"]["updateShaders"].setValue(True)
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c, IECore.Color3f(0.5))
