def testExecuteWithStringSubstitutions(self):
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["render"] = GafferArnold.ArnoldRender()
s["render"]["mode"].setValue(s["render"].Mode.SceneDescriptionMode)
s["render"]["in"].setInput(s["plane"]["out"])
s["render"]["fileName"].setValue(self.temporaryDirectory() +
"/test.####.ass")
s["fileName"].setValue(self.__scriptFileName)
s.save()
p = subprocess.Popen(
"gaffer execute " + self.__scriptFileName + " -frames 1-3",
shell=True,
stderr=subprocess.PIPE,
)
p.wait()
self.failIf(p.returncode)
for i in range(1, 4):
self.failUnless(
os.path.exists(self.temporaryDirectory() +
"/test.%04d.ass" % i))
def testAdaptors( self ) : sphere = GafferScene.Sphere() def a() : result = GafferArnold.ArnoldAttributes() result["attributes"]["matte"]["enabled"].setValue( True ) result["attributes"]["matte"]["value"].setValue( True ) return result GafferScene.RendererAlgo.registerAdaptor( "Test", a ) sphere = GafferScene.Sphere() render = GafferArnold.ArnoldRender() render["in"].setInput( sphere["out"] ) render["mode"].setValue( render.Mode.SceneDescriptionMode ) render["fileName"].setValue( self.temporaryDirectory() + "/test.ass" ) render["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) node = arnold.AiNodeLookUpByName( "/sphere" ) self.assertEqual( arnold.AiNodeGetBool( node, "matte" ), True )
def testAbortRaises(self):
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["plane"]["transform"]["translate"]["z"].setValue(-10)
s["shader"] = GafferArnold.ArnoldShader()
s["shader"].loadShader("image")
# Missing texture should cause render to abort
s["shader"]["parameters"]["filename"].setValue("iDontExist")
s["filter"] = GafferScene.PathFilter()
s["filter"]["paths"].setValue(IECore.StringVectorData(["/plane"]))
s["shaderAssignment"] = GafferScene.ShaderAssignment()
s["shaderAssignment"]["in"].setInput(s["plane"]["out"])
s["shaderAssignment"]["filter"].setInput(s["filter"]["out"])
s["shaderAssignment"]["shader"].setInput(s["shader"]["out"])
s["outputs"] = GafferScene.Outputs()
s["outputs"].addOutput(
"beauty",
IECoreScene.Output(self.temporaryDirectory() + "/test.tif", "tiff",
"rgba", {}))
s["outputs"]["in"].setInput(s["shaderAssignment"]["out"])
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["outputs"]["out"])
self.assertRaisesRegexp(RuntimeError, "Render aborted",
s["render"]["task"].execute)
def testOSLShaders(self):
swizzle = GafferOSL.OSLShader()
swizzle.loadShader("MaterialX/mx_swizzle_color_float")
swizzle["parameters"]["in"].setValue(imath.Color3f(0, 0, 1))
swizzle["parameters"]["channels"].setValue("b")
pack = GafferOSL.OSLShader()
pack.loadShader("MaterialX/mx_pack_color")
pack["parameters"]["in1"].setInput(swizzle["out"]["out"])
ball = GafferArnold.ArnoldShaderBall()
ball["shader"].setInput(pack["out"])
outputs = GafferScene.Outputs()
outputs.addOutput(
"beauty",
IECoreScene.Output("test", "ieDisplay", "rgba", {
"driverType": "ImageDisplayDriver",
"handle": "myLovelySphere",
}))
outputs["in"].setInput(ball["out"])
render = GafferArnold.ArnoldRender()
render["in"].setInput(outputs["out"])
render["task"].execute()
image = IECoreImage.ImageDisplayDriver.storedImage("myLovelySphere")
self.assertTrue(isinstance(image, IECoreImage.ImagePrimitive))
self.assertEqual(self.__color4fAtUV(image, imath.V2f(0.5)),
imath.Color4f(1, 0, 0, 1))
def testTwoRenders( self ) : sphere = GafferScene.Sphere() duplicate = GafferScene.Duplicate() duplicate["in"].setInput( sphere["out"] ) duplicate["target"].setValue( "/sphere" ) duplicate["copies"].setValue( 10000 ) render = GafferArnold.ArnoldRender() render["in"].setInput( duplicate["out"] ) render["mode"].setValue( render.Mode.SceneDescriptionMode ) render["fileName"].setValue( self.temporaryDirectory() + "/test.####.ass" ) errors = [] def executeFrame( frame ) : with Gaffer.Context() as c : c.setFrame( frame ) try : render["task"].execute() except Exception as e : errors.append( str( e ) ) threads = [] for i in range( 0, 2 ) : t = threading.Thread( target = executeFrame, args = ( i, ) ) t.start() threads.append( t ) for t in threads : t.join() self.assertEqual( len( errors ), 1 ) self.assertTrue( "Arnold is already in use" in errors[0] )
def testImageOutput( self ) :
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["outputs"] = GafferScene.Outputs()
s["outputs"].addOutput(
"beauty",
IECoreScene.Output(
self.temporaryDirectory() + "/test.####.tif",
"tiff",
"rgba",
{}
)
)
s["outputs"]["in"].setInput( s["plane"]["out"] )
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput( s["outputs"]["out"] )
c = Gaffer.Context()
for i in range( 1, 4 ) :
c.setFrame( i )
with c :
s["render"]["task"].execute()
for i in range( 1, 4 ) :
self.assertTrue( os.path.exists( self.temporaryDirectory() + "/test.%04d.tif" % i ) )
def testWaitForImage(self):
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["outputs"] = GafferScene.Outputs()
s["outputs"].addOutput(
"beauty",
IECore.Display(self.temporaryDirectory() + "/test.tif", "tiff",
"rgba", {}))
s["outputs"]["in"].setInput(s["plane"]["out"])
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["outputs"]["out"])
s["render"]["verbosity"].setValue(1)
s["render"]["fileName"].setValue(self.temporaryDirectory() +
"/test.ass")
s["fileName"].setValue(self.__scriptFileName)
s["render"].execute()
self.failUnless(os.path.exists(self.temporaryDirectory() +
"/test.tif"))
def testExecute( self ) : s = Gaffer.ScriptNode() s["plane"] = GafferScene.Plane() s["render"] = GafferArnold.ArnoldRender() s["render"]["mode"].setValue( s["render"].Mode.SceneDescriptionMode ) s["render"]["in"].setInput( s["plane"]["out"] ) s["expression"] = Gaffer.Expression() s["expression"].setExpression( "parent['render']['fileName'] = '" + self.temporaryDirectory() + "/test.%d.ass' % int( context['frame'] )" ) s["fileName"].setValue( self.__scriptFileName ) s.save() p = subprocess.Popen( "gaffer execute " + self.__scriptFileName + " -frames 1-3", shell=True, stderr = subprocess.PIPE, ) p.wait() self.assertFalse( p.returncode ) for i in range( 1, 4 ) : self.assertTrue( os.path.exists( self.temporaryDirectory() + "/test.%d.ass" % i ) )
def testExecute(self):
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["render"] = GafferArnold.ArnoldRender()
s["render"]["mode"].setValue("generate")
s["render"]["in"].setInput(s["plane"]["out"])
s["expression"] = Gaffer.Expression()
s["expression"]["engine"].setValue("python")
s["expression"]["expression"].setValue(
"parent['render']['fileName'] = '/tmp/test.%d.ass' % int( context['frame'] )"
)
s["fileName"].setValue(self.__scriptFileName)
s.save()
p = subprocess.Popen(
"gaffer execute " + self.__scriptFileName + " -frames 1-3",
shell=True,
stderr=subprocess.PIPE,
)
p.wait()
self.failIf(p.returncode)
for i in range(1, 4):
self.failUnless(os.path.exists("/tmp/test.%d.ass" % i))
def testImageOutput(self):
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["outputs"] = GafferScene.Outputs()
s["outputs"].addOutput(
"beauty",
IECore.Display(self.temporaryDirectory() + "/test.####.tif",
"tiff", "rgba", {}))
s["outputs"]["in"].setInput(s["plane"]["out"])
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["outputs"]["out"])
s["render"]["verbosity"].setValue(1)
s["render"]["fileName"].setValue(self.temporaryDirectory() +
"/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()
for i in range(1, 4):
self.failUnless(
os.path.exists(self.temporaryDirectory() +
"/test.%04d.tif" % i))
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 testFrameAndAASeed( self ) : options = GafferArnold.ArnoldOptions() render = GafferArnold.ArnoldRender() render["in"].setInput( options["out"] ) render["mode"].setValue( render.Mode.SceneDescriptionMode ) render["fileName"].setValue( self.temporaryDirectory() + "/test.ass" ) for frame in ( 1, 2, 2.8, 3.2 ) : for seed in ( None, 3, 4 ) : with Gaffer.Context() as c : c.setFrame( frame ) options["options"]["aaSeed"]["enabled"].setValue( seed is not None ) options["options"]["aaSeed"]["value"].setValue( seed or 1 ) render["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) self.assertEqual( arnold.AiNodeGetInt( arnold.AiUniverseGetOptions(), "AA_seed" ), seed or round( frame ) )
def testMissingCameraRaises(self):
s = Gaffer.ScriptNode()
s["options"] = GafferScene.StandardOptions()
s["options"]["options"]["renderCamera"]["enabled"].setValue(True)
s["options"]["options"]["renderCamera"]["value"].setValue(
"/i/dont/exist")
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["options"]["out"])
s["render"]["mode"].setValue(s["render"].Mode.SceneDescriptionMode)
s["render"]["fileName"].setValue(self.temporaryDirectory() +
"/test.ass")
# The requested camera doesn't exist - this should raise an exception.
self.assertRaisesRegexp(RuntimeError, "/i/dont/exist",
s["render"]["task"].execute)
# And even the existence of a different camera shouldn't change that.
s["camera"] = GafferScene.Camera()
s["options"]["in"].setInput(s["camera"]["out"])
self.assertRaisesRegexp(RuntimeError, "/i/dont/exist",
s["render"]["task"].execute)
def testLightFilters(self):
s = Gaffer.ScriptNode()
s["lightFilter"] = GafferArnold.ArnoldLightFilter()
s["lightFilter"].loadShader("light_blocker")
s["attributes"] = GafferScene.StandardAttributes()
s["attributes"]["in"].setInput(s["lightFilter"]["out"])
s["attributes"]["attributes"]["filteredLights"]["enabled"].setValue(
True)
s["attributes"]["attributes"]["filteredLights"]["value"].setValue(
"defaultLights")
s["light"] = GafferArnold.ArnoldLight()
s["light"].loadShader("point_light")
s["gobo"] = GafferArnold.ArnoldShader()
s["gobo"].loadShader("gobo")
s["assignment"] = GafferScene.ShaderAssignment()
s["assignment"]["in"].setInput(s["light"]["out"])
s["assignment"]["shader"].setInput(s["gobo"]["out"])
s["group"] = GafferScene.Group()
s["group"]["in"][0].setInput(s["attributes"]["out"])
s["group"]["in"][1].setInput(s["assignment"]["out"])
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["group"]["out"])
s["render"]["mode"].setValue(s["render"].Mode.SceneDescriptionMode)
s["render"]["fileName"].setValue(self.temporaryDirectory() +
"/test.ass")
s["render"]["task"].execute()
with IECoreArnold.UniverseBlock(writable=True):
arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass")
light = arnold.AiNodeLookUpByName("light:/group/light")
linkedFilters = arnold.AiNodeGetArray(light, "filters")
numFilters = arnold.AiArrayGetNumElements(linkedFilters.contents)
self.assertEqual(numFilters, 2)
linkedFilter = arnold.cast(arnold.AiArrayGetPtr(linkedFilters, 0),
arnold.POINTER(arnold.AtNode))
linkedGobo = arnold.cast(arnold.AiArrayGetPtr(linkedFilters, 1),
arnold.POINTER(arnold.AtNode))
self.assertEqual(arnold.AiNodeGetName(linkedFilter),
"lightFilter:/group/lightFilter")
self.assertEqual(
arnold.AiNodeEntryGetName(
arnold.AiNodeGetNodeEntry(linkedFilter)), "light_blocker")
self.assertEqual(
arnold.AiNodeEntryGetName(
arnold.AiNodeGetNodeEntry(linkedGobo)), "gobo")
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"] = GafferArnold.ArnoldRender()
s["render"]["fileName"].setValue("/tmp/test.####.ass")
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.assertTrue(hiddenStats["average"].getValue()[0] < 0.05)
self.assertTrue(visibleStats["average"].getValue()[0] > .35)
def testDirectoryCreation(self):
s = Gaffer.ScriptNode()
s["variables"].addChild(
Gaffer.NameValuePlug("renderDirectory",
self.temporaryDirectory() + "/renderTests"))
s["variables"].addChild(
Gaffer.NameValuePlug("assDirectory",
self.temporaryDirectory() + "/assTests"))
s["plane"] = GafferScene.Plane()
s["outputs"] = GafferScene.Outputs()
s["outputs"]["in"].setInput(s["plane"]["out"])
s["outputs"].addOutput(
"beauty",
IECoreScene.Output("$renderDirectory/test.####.exr", "exr", "rgba",
{}))
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["outputs"]["out"])
s["render"]["fileName"].setValue("$assDirectory/test.####.ass")
s["render"]["mode"].setValue(s["render"].Mode.SceneDescriptionMode)
self.assertFalse(
os.path.exists(self.temporaryDirectory() + "/renderTests"))
self.assertFalse(
os.path.exists(self.temporaryDirectory() + "/assTests"))
self.assertFalse(
os.path.exists(self.temporaryDirectory() +
"/assTests/test.0001.ass"))
s["fileName"].setValue(self.temporaryDirectory() + "/test.gfr")
with s.context():
s["render"]["task"].execute()
self.assertTrue(
os.path.exists(self.temporaryDirectory() + "/renderTests"))
self.assertTrue(os.path.exists(self.temporaryDirectory() +
"/assTests"))
self.assertTrue(
os.path.exists(self.temporaryDirectory() +
"/assTests/test.0001.ass"))
# check it can cope with everything already existing
with s.context():
s["render"]["task"].execute()
self.assertTrue(
os.path.exists(self.temporaryDirectory() + "/renderTests"))
self.assertTrue(os.path.exists(self.temporaryDirectory() +
"/assTests"))
self.assertTrue(
os.path.exists(self.temporaryDirectory() +
"/assTests/test.0001.ass"))
def testLightFiltersMany(self):
# \todo: this can easily be turned into a performance test
s = Gaffer.ScriptNode()
s["lightFilter"] = GafferArnold.ArnoldLightFilter()
s["lightFilter"].loadShader("light_blocker")
s["lightFilter"]["filteredLights"].setValue("defaultLights")
s["planeFilters"] = GafferScene.Plane("Plane")
s["planeFilters"]["divisions"].setValue(imath.V2i(9))
s["instancerFilters"] = GafferScene.Instancer("Instancer")
s["instancerFilters"]["in"].setInput(s["planeFilters"]["out"])
s["instancerFilters"]["instances"].setInput(s["lightFilter"]["out"])
s["instancerFilters"]["parent"].setValue("/plane")
s["light"] = GafferArnold.ArnoldLight()
s["light"].loadShader("point_light")
s["planeLights"] = GafferScene.Plane("Plane")
s["planeLights"]["divisions"].setValue(imath.V2i(9))
s["instancerLights"] = GafferScene.Instancer("Instancer")
s["instancerLights"]["in"].setInput(s["planeLights"]["out"])
s["instancerLights"]["instances"].setInput(s["light"]["out"])
s["instancerLights"]["parent"].setValue("/plane")
s["group"] = GafferScene.Group("Group")
s["group"]["in"][0].setInput(s["instancerFilters"]["out"])
s["group"]["in"][1].setInput(s["instancerLights"]["out"])
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["group"]["out"])
s["render"]["mode"].setValue(s["render"].Mode.SceneDescriptionMode)
s["render"]["fileName"].setValue(self.temporaryDirectory() +
"/testMany.ass")
s["render"]["task"].execute()
with IECoreArnold.UniverseBlock(writable=True):
foo = self.temporaryDirectory() + "/testMany.ass"
print foo
arnold.AiASSLoad(foo)
for i in range(100):
light = arnold.AiNodeLookUpByName(
"light:/group/plane1/instances/light/%s" % i)
linkedFilters = arnold.AiNodeGetArray(light, "filters")
numFilters = arnold.AiArrayGetNumElements(
linkedFilters.contents)
self.assertEqual(numFilters, 100)
def testPerformanceMonitorDoesntCrash( self ) : options = GafferScene.StandardOptions() options["options"]["performanceMonitor"]["value"].setValue( True ) options["options"]["performanceMonitor"]["enabled"].setValue( True ) render = GafferArnold.ArnoldRender() render["in"].setInput( options["out"] ) render["mode"].setValue( render.Mode.SceneDescriptionMode ) render["fileName"].setValue( self.temporaryDirectory() + "/test.ass" ) render["task"].execute()
def testTraceSets(self):
sphere = GafferScene.Sphere()
group = GafferScene.Group()
group["in"][0].setInput(sphere["out"])
group["in"][1].setInput(sphere["out"])
set1 = GafferScene.Set()
set1["name"].setValue("render:firstSphere")
set1["paths"].setValue(IECore.StringVectorData(["/group/sphere"]))
set1["in"].setInput(group["out"])
set2 = GafferScene.Set()
set2["name"].setValue("render:secondSphere")
set2["paths"].setValue(IECore.StringVectorData(["/group/sphere1"]))
set2["in"].setInput(set1["out"])
set3 = GafferScene.Set()
set3["name"].setValue("render:group")
set3["paths"].setValue(IECore.StringVectorData(["/group"]))
set3["in"].setInput(set2["out"])
set4 = GafferScene.Set()
set4["name"].setValue("render:bothSpheres")
set4["paths"].setValue(
IECore.StringVectorData(["/group/sphere", "/group/sphere1"]))
set4["in"].setInput(set3["out"])
render = GafferArnold.ArnoldRender()
render["in"].setInput(set4["out"])
render["mode"].setValue(render.Mode.SceneDescriptionMode)
render["fileName"].setValue(self.temporaryDirectory() + "/test.ass")
render["task"].execute()
with IECoreArnold.UniverseBlock(writable=True):
arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass")
firstSphere = arnold.AiNodeLookUpByName("/group/sphere")
secondSphere = arnold.AiNodeLookUpByName("/group/sphere1")
self.assertEqual(
self.__arrayToSet(
arnold.AiNodeGetArray(firstSphere, "trace_sets")),
{"firstSphere", "group", "bothSpheres"})
self.assertEqual(
self.__arrayToSet(
arnold.AiNodeGetArray(secondSphere, "trace_sets")),
{"secondSphere", "group", "bothSpheres"})
def testOSLShaders( self ) :
purple = GafferOSL.OSLShader()
purple.loadShader( "Maths/MixColor" )
purple["parameters"]["a"].setValue( imath.Color3f( 0.5, 0, 1 ) )
green = GafferOSL.OSLShader()
green.loadShader( "Maths/MixColor" )
green["parameters"]["a"].setValue( imath.Color3f( 0, 1, 0 ) )
mix = GafferOSL.OSLShader()
mix.loadShader( "Maths/MixColor" )
# test component connections
mix["parameters"]["a"][2].setInput( purple["out"]["out"][2] )
# test color connections
mix["parameters"]["b"].setInput( green["out"]["out"] )
mix["parameters"]["m"].setValue( 0.5 )
ball = GafferArnold.ArnoldShaderBall()
ball["shader"].setInput( mix["out"] )
catalogue = GafferImage.Catalogue()
outputs = GafferScene.Outputs()
outputs.addOutput(
"beauty",
IECoreScene.Output(
"test",
"ieDisplay",
"rgba",
{
"driverType" : "ClientDisplayDriver",
"displayHost" : "localhost",
"displayPort" : str( catalogue.displayDriverServer().portNumber() ),
"remoteDisplayType" : "GafferImage::GafferDisplayDriver",
}
)
)
outputs["in"].setInput( ball["out"] )
render = GafferArnold.ArnoldRender()
render["in"].setInput( outputs["out"] )
with GafferTest.ParallelAlgoTest.UIThreadCallHandler() as handler :
render["task"].execute()
handler.waitFor( 0.1 ) #Just need to let the catalogue update
self.assertEqual( self.__color4fAtUV( catalogue, imath.V2f( 0.5 ) ), imath.Color4f( 0, 0.5, 0.5, 1 ) )
def testManyCameras( self ) : camera = GafferScene.Camera() duplicate = GafferScene.Duplicate() duplicate["in"].setInput( camera["out"] ) duplicate["target"].setValue( "/camera" ) duplicate["copies"].setValue( 1000 ) render = GafferArnold.ArnoldRender() render["in"].setInput( duplicate["out"] ) render["mode"].setValue( render.Mode.SceneDescriptionMode ) render["fileName"].setValue( self.temporaryDirectory() + "/test.ass" ) render["task"].execute()
def testNoLinkedLightsOnLights(self):
sphere = GafferScene.Sphere()
meshLightShader = GafferArnold.ArnoldShader()
meshLightShader.loadShader("flat")
meshLightFilter = GafferScene.PathFilter()
meshLightFilter["paths"].setValue(IECore.StringVectorData(["/sphere"]))
meshLight = GafferArnold.ArnoldMeshLight()
meshLight["in"].setInput(sphere["out"])
meshLight["filter"].setInput(meshLightFilter["out"])
meshLight["parameters"]["color"].setInput(meshLightShader["out"])
light1 = GafferArnold.ArnoldLight()
light1.loadShader("point_light")
light2 = GafferArnold.ArnoldLight()
light2.loadShader("point_light")
# Trigger light linking by unlinking a light
light2["defaultLight"].setValue(False)
group = GafferScene.Group()
group["in"][0].setInput(meshLight["out"])
group["in"][1].setInput(light1["out"])
group["in"][2].setInput(light2["out"])
render = GafferArnold.ArnoldRender()
render["in"].setInput(group["out"])
render["mode"].setValue(render.Mode.SceneDescriptionMode)
render["fileName"].setValue(self.temporaryDirectory() + "/test.ass")
render["task"].execute()
with IECoreArnold.UniverseBlock(writable=True):
arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass")
sphere = arnold.AiNodeLookUpByName("/group/sphere")
self.assertIsNotNone(sphere)
self.assertEqual(
arnold.AiArrayGetNumElements(
arnold.AiNodeGetArray(sphere, "light_group")), 0)
self.assertFalse(arnold.AiNodeGetBool(sphere, "use_light_group"))
def testRendererContextVariable( self ) :
sphere = GafferScene.Sphere()
sphere["name"].setValue( "sphere${scene:renderer}" )
render = GafferArnold.ArnoldRender()
render["in"].setInput( sphere["out"] )
render["mode"].setValue( render.Mode.SceneDescriptionMode )
render["fileName"].setValue( self.temporaryDirectory() + "/test.ass" )
render["task"].execute()
with IECoreArnold.UniverseBlock( writable = True ) :
arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" )
self.assertTrue( arnold.AiNodeLookUpByName( "/sphereArnold" ) is not None )
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 testResolution(self):
s = Gaffer.ScriptNode()
s["camera"] = GafferScene.Camera()
s["options"] = GafferScene.StandardOptions()
s["options"]["in"].setInput(s["camera"]["out"])
s["options"]["options"]["renderResolution"]["enabled"].setValue(True)
s["options"]["options"]["renderResolution"]["value"].setValue(
imath.V2i(200, 100))
s["options"]["options"]["resolutionMultiplier"]["enabled"].setValue(
True)
s["options"]["options"]["resolutionMultiplier"]["value"].setValue(2)
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["options"]["out"])
s["render"]["mode"].setValue(s["render"].Mode.SceneDescriptionMode)
s["render"]["fileName"].setValue(self.temporaryDirectory() +
"/test.ass")
# Default camera should have the right resolution.
s["render"]["task"].execute()
with IECoreArnold.UniverseBlock(writable=True):
arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass")
options = arnold.AiUniverseGetOptions()
self.assertEqual(arnold.AiNodeGetInt(options, "xres"), 400)
self.assertEqual(arnold.AiNodeGetInt(options, "yres"), 200)
# As should a camera picked from the scene.
s["options"]["options"]["renderCamera"]["enabled"].setValue(True)
s["options"]["options"]["renderCamera"]["value"].setValue("/camera")
s["render"]["task"].execute()
with IECoreArnold.UniverseBlock(writable=True):
arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass")
options = arnold.AiUniverseGetOptions()
self.assertEqual(arnold.AiNodeGetInt(options, "xres"), 400)
self.assertEqual(arnold.AiNodeGetInt(options, "yres"), 200)
def testWaitForImage(self):
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["outputs"] = GafferScene.Outputs()
s["outputs"].addOutput(
"beauty",
IECoreScene.Output(self.temporaryDirectory() + "/test.tif", "tiff",
"rgba", {}))
s["outputs"]["in"].setInput(s["plane"]["out"])
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["outputs"]["out"])
s["render"]["task"].execute()
self.failUnless(os.path.exists(self.temporaryDirectory() +
"/test.tif"))
def testLightFiltersMany(self):
numLights = 10000
numLightFilters = 10000
s = Gaffer.ScriptNode()
s["lightFilter"] = GafferArnold.ArnoldLightFilter()
s["lightFilter"].loadShader("light_blocker")
s["lightFilter"]["filteredLights"].setValue("defaultLights")
s["planeFilters"] = GafferScene.Plane("Plane")
s["planeFilters"]["divisions"].setValue(
imath.V2i(1, numLightFilters / 2 - 1))
s["instancerFilters"] = GafferScene.Instancer("Instancer")
s["instancerFilters"]["in"].setInput(s["planeFilters"]["out"])
s["instancerFilters"]["instances"].setInput(s["lightFilter"]["out"])
s["instancerFilters"]["parent"].setValue("/plane")
s["light"] = GafferArnold.ArnoldLight()
s["light"].loadShader("point_light")
s["planeLights"] = GafferScene.Plane("Plane")
s["planeLights"]["divisions"].setValue(imath.V2i(1, numLights / 2 - 1))
s["instancerLights"] = GafferScene.Instancer("Instancer")
s["instancerLights"]["in"].setInput(s["planeLights"]["out"])
s["instancerLights"]["instances"].setInput(s["light"]["out"])
s["instancerLights"]["parent"].setValue("/plane")
s["group"] = GafferScene.Group("Group")
s["group"]["in"][0].setInput(s["instancerFilters"]["out"])
s["group"]["in"][1].setInput(s["instancerLights"]["out"])
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["group"]["out"])
with Gaffer.Context() as c:
c["scene:render:sceneTranslationOnly"] = IECore.BoolData(True)
s["render"]["task"].execute()
def testBounds(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(self.temporaryDirectory() + "/test.tif", "tiff",
"rgba", {}))
s["outputs"]["in"].setInput(s["plane"]["out"])
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["outputs"]["out"])
s["render"]["mode"].setValue("generate")
s["render"]["fileName"].setValue(self.temporaryDirectory() +
"/test.ass")
s["fileName"].setValue(self.temporaryDirectory() + "/test.gfr")
s.save()
s["render"]["task"].execute()
self.assertTrue(os.path.exists(self.temporaryDirectory() +
"/test.ass"))
p = subprocess.Popen("kick -dp -dw " + self.temporaryDirectory() +
"/test.ass",
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
p.wait()
output = "".join(p.stderr.readlines() + p.stdout.readlines())
self.failIf("incorrect bounds" in output)
self.failIf("user bounds could be" in output)
self.failIf("ignoring parameter min" in output)
self.failIf("ignoring parameter max" in output)
def testSetsNeedContextEntry( self ) : script = Gaffer.ScriptNode() script["light"] = GafferArnold.ArnoldLight() script["light"].loadShader( "point_light" ) script["expression"] = Gaffer.Expression() script["expression"].setExpression( """parent["light"]["name"] = context["lightName"]""" ) script["render"] = GafferArnold.ArnoldRender() script["render"]["in"].setInput( script["light"]["out"] ) script["render"]["mode"].setValue( script["render"].Mode.SceneDescriptionMode ) script["render"]["fileName"].setValue( self.temporaryDirectory() + "/test.ass" ) for i in range( 0, 100 ) : with Gaffer.Context() as context : context["lightName"] = "light%d" % i script["render"]["task"].execute()
def testDefaultLightsMistakesDontForceLinking(self):
light = GafferArnold.ArnoldLight()
light.loadShader("point_light")
sphere = GafferScene.Sphere()
# It doesn't make sense to add a non-light to the "defaultLights"
# set like this, but in the event of user error, we don't want to
# emit light links unnecessarily.
sphereSet = GafferScene.Set()
sphereSet["in"].setInput(sphere["out"])
sphereSet["name"].setValue("defaultLights")
sphereSet["paths"].setValue(IECore.StringVectorData(["/sphere"]))
group = GafferScene.Group()
group["in"][0].setInput(light["out"])
group["in"][1].setInput(sphereSet["out"])
render = GafferArnold.ArnoldRender()
render["in"].setInput(group["out"])
render["mode"].setValue(render.Mode.SceneDescriptionMode)
render["fileName"].setValue(self.temporaryDirectory() + "/test.ass")
render["task"].execute()
with IECoreArnold.UniverseBlock(writable=True):
arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass")
sphere = arnold.AiNodeLookUpByName("/group/sphere")
self.assertIsNotNone(sphere)
self.assertEqual(
arnold.AiArrayGetNumElements(
arnold.AiNodeGetArray(sphere, "light_group")), 0)
self.assertFalse(arnold.AiNodeGetBool(sphere, "use_light_group"))
