def testLoadDifferentShader( self ) : standard = GafferArnold.ArnoldShader() standard.loadShader( "standard" ) lambert = GafferArnold.ArnoldShader() lambert.loadShader( "lambert" ) shader = GafferArnold.ArnoldShader() shader.loadShader( "lambert" ) def assertParametersEqual( s1, s2, ignore = [] ) : self.assertEqual( set( s1["parameters"].keys() ), set( s2["parameters"].keys() ) ) for k in s1["parameters"].keys() : if k in ignore : continue self.assertEqual( s1["parameters"][k].getValue(), s2["parameters"][k].getValue() ) assertParametersEqual( shader, lambert ) shader["parameters"]["Kd"].setValue( 0.25 ) shader.loadShader( "standard", keepExistingValues = True ) assertParametersEqual( shader, standard, ignore = [ "Kd" ] ) self.assertEqual( shader["parameters"]["Kd"].getValue(), 0.25 ) shader.loadShader( "lambert", keepExistingValues = False ) assertParametersEqual( shader, lambert )
def testRecoverFromIncorrectSerialisedDefaultValue( self ) : s = Gaffer.ScriptNode() s["n1"] = GafferArnold.ArnoldShader() s["n1"].loadShader( "flat" ) s["n2"] = GafferArnold.ArnoldShader() s["n2"].loadShader( "flat" ) # Emulate the incorrect loading of # default value for output plugs - # bug introduced in 0.28.2.0. s["n1"]["out"] = Gaffer.Color3fPlug( direction = Gaffer.Plug.Direction.Out, defaultValue = IECore.Color3f( -1 ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["n2"]["out"] = Gaffer.Color3fPlug( direction = Gaffer.Plug.Direction.Out, defaultValue = IECore.Color3f( -1 ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["a"] = GafferScene.ShaderAssignment() s["a"]["shader"].setInput( s["n2"]["out"] ) s["n2"]["parameters"]["color"].setInput( s["n1"]["out"] ) s2 = Gaffer.ScriptNode() s2.execute( s.serialise() ) self.assertEqual( s2["n1"]["out"].defaultValue(), IECore.Color3f( 0 ) ) self.assertTrue( s2["n2"]["parameters"]["color"].getInput().isSame( s2["n1"]["out"] ) ) self.assertTrue( s2["a"]["shader"].getInput().isSame( s2["n2"]["out"] ) )
def testDisablingInNetwork(self):
s = GafferArnold.ArnoldShader()
s.loadShader("standard")
f = GafferArnold.ArnoldShader()
f.loadShader("flat")
s["parameters"]["Ks_color"].setInput(f["out"])
stateHash = s.stateHash()
state = s.state()
self.assertEqual(len(state), 2)
self.assertEqual(state[1].name, "standard")
self.assertEqual(state[0].name, "flat")
self.assertTrue(s["enabled"].isSame(s.enabledPlug()))
f["enabled"].setValue(False)
stateHash2 = s.stateHash()
self.assertNotEqual(stateHash2, stateHash)
state2 = s.state()
self.assertEqual(len(state2), 1)
for key in state[1].parameters.keys():
if key != "Ks_color":
self.assertEqual(state[1].parameters[key],
state2[0].parameters[key])
def testMixAndMatchWithOSLShadersThroughSwitch(self):
arnoldIn = GafferArnold.ArnoldShader()
arnoldIn.loadShader("flat")
oslIn = GafferOSL.OSLShader()
oslIn.loadShader("Pattern/ColorSpline")
switch1 = GafferScene.ShaderSwitch()
switch2 = GafferScene.ShaderSwitch()
switch1.setup(arnoldIn["out"])
switch2.setup(oslIn["out"]["c"])
switch1["in"][0].setInput(arnoldIn["out"])
switch1["in"][1].setInput(oslIn["out"]["c"])
switch2["in"][0].setInput(arnoldIn["out"])
switch2["in"][1].setInput(oslIn["out"]["c"])
arnoldOut = GafferArnold.ArnoldShader()
arnoldOut.loadShader("flat")
oslOut = GafferOSL.OSLShader()
oslOut.loadShader("Utility/SplitColor")
arnoldOut["parameters"]["color"].setInput(switch1["out"])
oslOut["parameters"]["c"].setInput(switch2["out"])
for i in range(0, 2):
switch1["index"].setValue(i)
switch2["index"].setValue(i)
network1 = arnoldOut.attributes()["ai:surface"]
network2 = oslOut.attributes()["osl:shader"]
self.assertEqual(len(network1), 2)
self.assertEqual(len(network2), 2)
self.assertEqual(network1[1].name, "flat")
self.assertEqual(network2[1].name, "Utility/SplitColor")
if i == 0:
self.assertEqual(
network1[1].parameters["color"].value,
"link:" + network1[0].parameters["__handle"].value)
self.assertEqual(
network2[1].parameters["c"].value,
"link:" + network1[0].parameters["__handle"].value)
else:
self.assertEqual(
network1[1].parameters["color"].value,
"link:" + network1[0].parameters["__handle"].value + ".c")
self.assertEqual(
network2[1].parameters["c"].value,
"link:" + network1[0].parameters["__handle"].value + ".c")
def testColorParameterMetadata(self):
self.__forceArnoldRestart()
n = GafferArnold.ArnoldShader()
n.loadShader("ray_switch")
for p in n["parameters"]:
self.assertTrue(isinstance(p, Gaffer.Color4fPlug))
self.addCleanup(os.environ.__setitem__, "ARNOLD_PLUGIN_PATH",
os.environ["ARNOLD_PLUGIN_PATH"])
os.environ["ARNOLD_PLUGIN_PATH"] = os.environ[
"ARNOLD_PLUGIN_PATH"] + ":" + os.path.join(
os.path.dirname(__file__), "metadata")
self.__forceArnoldRestart()
n = GafferArnold.ArnoldShader()
n.loadShader("ray_switch")
for name in ["camera", "shadow", "diffuse_transmission"]:
self.assertTrue(
isinstance(n["parameters"][name], Gaffer.Color3fPlug))
for name in [
"diffuse_reflection", "specular_transmission",
"specular_reflection", "volume"
]:
self.assertTrue(
isinstance(n["parameters"][name], Gaffer.Color4fPlug))
def testDisabledShaderPassesThroughExternalValue(self):
s = GafferArnold.ArnoldShader()
s.loadShader("standard")
f = GafferArnold.ArnoldShader()
f.loadShader("flat")
f["parameters"]["color"].setValue(IECore.Color3f(1, 2, 3))
s["parameters"]["Ks_color"].setInput(f["out"])
attributesHash = s.attributesHash()
attributes = s.attributes()
self.assertEqual(len(attributes), 1)
self.assertEqual(attributes["ai:surface"][1].name, "standard")
self.assertEqual(attributes["ai:surface"][0].name, "flat")
self.assertTrue(s["enabled"].isSame(s.enabledPlug()))
f["enabled"].setValue(False)
attributesHash2 = s.attributesHash()
self.assertNotEqual(attributesHash2, attributesHash)
attributes2 = s.attributes()
self.assertEqual(len(attributes2), 1)
for key in attributes["ai:surface"][1].parameters.keys():
if key != "Ks_color":
self.assertEqual(attributes["ai:surface"][1].parameters[key],
attributes2["ai:surface"][0].parameters[key])
else:
self.assertEqual(
attributes["ai:surface"][0].parameters["color"],
attributes2["ai:surface"][0].parameters[key])
def testShaderInputs(self):
s = GafferArnold.ArnoldShader()
s.loadShader("physical_sky")
s["parameters"]["intensity"].setValue(2)
# Test setting up a matte closure connected to "shader"
# Note that this doesn't currently render correctly, but SolidAngle assures me that they are fixing
# it and is the preferred way
s2 = GafferArnold.ArnoldShader()
s2.loadShader("matte")
s2["parameters"]["color"].setValue(imath.Color4f(0, 1, 0, 0.5))
l = GafferArnold.ArnoldLight()
l.loadShader("skydome_light")
l["parameters"]["color"].setInput(s["out"])
l["parameters"]["shader"].setInput(s2["out"])
network = l["out"].attributes("/light")["ai:light"]
self.assertEqual(len(network), 3)
self.assertEqual(network[0].name, "physical_sky")
self.assertEqual(network[0].parameters["intensity"].value, 2)
self.assertEqual(network[1].name, "matte")
self.assertEqual(network[1].parameters["color"].value,
imath.Color4f(0, 1, 0, 0.5))
self.assertEqual(network[2].parameters["color"].value,
"link:" + network[0].parameters["__handle"].value)
self.assertEqual(network[2].parameters["shader"].value,
"link:" + network[1].parameters["__handle"].value)
s["parameters"]["intensity"].setValue(4)
network = l["out"].attributes("/light")["ai:light"]
self.assertEqual(network[0].parameters["intensity"].value, 4)
def testDisablingInNetwork( self ) : s = GafferArnold.ArnoldShader() s.loadShader( "standard_surface" ) f = GafferArnold.ArnoldShader() f.loadShader( "flat" ) s["parameters"]["specular_color"].setInput( f["out"] ) attributesHash = s.attributesHash() attributes = s.attributes() self.assertEqual( len( attributes ), 1 ) self.assertEqual( attributes["ai:surface"][1].name, "standard_surface" ) self.assertEqual( attributes["ai:surface"][0].name, "flat" ) self.assertTrue( s["enabled"].isSame( s.enabledPlug() ) ) f["enabled"].setValue( False ) attributesHash2 = s.attributesHash() self.assertNotEqual( attributesHash2, attributesHash ) attributes2 = s.attributes() self.assertEqual( len( attributes2 ), 1 ) for key in attributes["ai:surface"][1].parameters.keys() : if key != "specular_color" : self.assertEqual( attributes["ai:surface"][1].parameters[key], attributes2["ai:surface"][0].parameters[key] )
def testShaderNetwork( self ) : s = GafferArnold.ArnoldShader() s.loadShader( "standard_surface" ) n = GafferArnold.ArnoldShader() n.loadShader( "noise" ) s["parameters"]["base_color"].setInput( n["out"] ) s["parameters"]["specular_color"].setInput( n["out"] ) st = s.attributes()["ai:surface"] self.assertEqual( len( st ), 2 ) self.assertEqual( st[0].type, "ai:shader" ) self.assertEqual( st[0].name, "noise" ) self.failUnless( "__handle" in st[0].parameters ) self.assertEqual( st[1].type, "ai:surface" ) self.assertEqual( st[1].name, "standard_surface" ) self.failIf( "__handle" in st[1].parameters ) self.assertEqual( st[1].parameters["base_color"].value, "link:" + st[0].parameters["__handle"].value ) self.assertEqual( st[1].parameters["specular_color"].value, "link:" + st[0].parameters["__handle"].value )
def testLoadDifferentShader( self ) : mix = GafferArnold.ArnoldShader() mix.loadShader( "mix" ) switch = GafferArnold.ArnoldShader() switch.loadShader( "switch_rgba" ) shader = GafferArnold.ArnoldShader() shader.loadShader( "switch_rgba" ) def assertParametersEqual( s1, s2, ignore = [] ) : self.assertEqual( set( s1["parameters"].keys() ), set( s2["parameters"].keys() ) ) for k in s1["parameters"].keys() : if k in ignore : continue self.assertEqual( s1["parameters"][k].getValue(), s2["parameters"][k].getValue() ) assertParametersEqual( shader, switch ) shader["parameters"]["input1"].setValue( IECore.Color4f( 0.25 ) ) shader.loadShader( "mix", keepExistingValues = True ) assertParametersEqual( shader, mix, ignore = [ "input1" ] ) self.assertEqual( shader["parameters"]["input1"].getValue(), IECore.Color4f( 0.25 ) ) shader.loadShader( "switch_rgba", keepExistingValues = False ) assertParametersEqual( shader, switch )
def testShaderNetworkRender( self ) :
f = GafferArnold.ArnoldShader()
f.loadShader( "flat" )
f["parameters"]["color"].setValue( IECore.Color3f( 1, 1, 0 ) )
s = GafferArnold.ArnoldShader()
s.loadShader( "utility" )
s["parameters"]["color"].setInput( f["parameters"]["color"] )
r = IECoreArnold.Renderer()
r.display( "test", "ieDisplay", "rgba", { "driverType" : "ImageDisplayDriver", "handle" : "test" } )
with IECore.WorldBlock( r ) :
for ss in s.state() :
ss.render( r )
r.concatTransform( IECore.M44f.createTranslated( IECore.V3f( 0, 0, -5 ) ) )
mesh = IECore.MeshPrimitive.createPlane( IECore.Box2f( IECore.V2f( -1 ), IECore.V2f( 1 ) ) )
mesh.render( r )
image = IECore.ImageDisplayDriver.removeStoredImage( "test" )
e = IECore.PrimitiveEvaluator.create( image )
result = e.createResult()
e.pointAtUV( IECore.V2f( 0.5 ), result )
self.assertAlmostEqual( result.floatPrimVar( e.R() ), 1, 5 )
self.assertAlmostEqual( result.floatPrimVar( e.G() ), 1, 5 )
self.assertEqual( result.floatPrimVar( e.B() ), 0 )
def testShaderNetwork(self):
s = GafferArnold.ArnoldShader()
s.loadShader("standard")
n = GafferArnold.ArnoldShader()
n.loadShader("noise")
s["parameters"]["Kd"].setInput(n["out"])
s["parameters"]["Ks"].setInput(n["out"])
st = s.state()
self.assertEqual(len(st), 2)
self.assertEqual(st[0].type, "shader")
self.assertEqual(st[0].name, "noise")
self.failUnless("__handle" in st[0].parameters)
self.assertEqual(st[1].type, "ai:surface")
self.assertEqual(st[1].name, "standard")
self.failIf("__handle" in st[1].parameters)
self.assertEqual(st[1].parameters["Kd"].value,
"link:" + st[0].parameters["__handle"].value)
self.assertEqual(st[1].parameters["Ks"].value,
"link:" + st[0].parameters["__handle"].value)
def testShaderNetwork( self ) : s = GafferArnold.ArnoldShader( "surface" ) s.loadShader( "standard_surface" ) n = GafferArnold.ArnoldShader( "noise" ) n.loadShader( "noise" ) s["parameters"]["base_color"].setInput( n["out"] ) s["parameters"]["specular_color"].setInput( n["out"] ) network = s.attributes()["ai:surface"] self.assertEqual( len( network ), 2 ) self.assertEqual( network.getShader( "noise" ).type, "ai:shader" ) self.assertEqual( network.getShader( "noise" ).name, "noise" ) self.assertEqual( network.getShader( "surface" ).type, "ai:surface" ) self.assertEqual( network.getShader( "surface" ).name, "standard_surface" ) self.assertEqual( network.inputConnections( "surface" ), [ network.Connection( ( "noise", "" ), ( "surface", "base_color" ) ), network.Connection( ( "noise", "" ), ( "surface", "specular_color" ) ), ] )
def testReload( self ) : image = GafferArnold.ArnoldShader() image.loadShader( "image" ) image["parameters"]["swap_st"].setValue( True ) image["parameters"]["uvcoords"].setValue( IECore.V2f( 0.5, 1 ) ) image["parameters"]["missing_tile_color"].setValue( IECore.Color4f( 0.25, 0.5, 0.75, 1 ) ) image["parameters"]["start_channel"].setValue( 1 ) image["parameters"]["swrap"].setValue( "black" ) lambert = GafferArnold.ArnoldShader() lambert.loadShader( "lambert" ) lambert["parameters"]["Kd"].setValue( 0.25 ) lambert["parameters"]["Kd_color"].setInput( image["out"] ) lambert["parameters"]["opacity"].setValue( IECore.Color3f( 0.1 ) ) lambert["parameters"]["aov_direct_diffuse"].setValue( "test" ) originalImagePlugs = image.children() originalImageParameterPlugs = image["parameters"].children() originalLambertPlugs = lambert.children() originalLambertParameterPlugs = lambert["parameters"].children() lambert.loadShader( "lambert", keepExistingValues = True ) def assertValuesWereKept() : self.assertEqual( image["parameters"]["swap_st"].getValue(), True ) self.assertEqual( image["parameters"]["uvcoords"].getValue(), IECore.V2f( 0.5, 1 ) ) self.assertEqual( image["parameters"]["missing_tile_color"].getValue(), IECore.Color4f( 0.25, 0.5, 0.75, 1 ) ) self.assertEqual( image["parameters"]["start_channel"].getValue(), 1 ) self.assertEqual( image["parameters"]["swrap"].getValue(), "black" ) self.assertEqual( image.children(), originalImagePlugs ) self.assertEqual( image["parameters"].children(), originalImageParameterPlugs ) self.assertEqual( lambert["parameters"]["Kd"].getValue(), 0.25 ) self.assertTrue( lambert["parameters"]["Kd_color"].getInput().isSame( image["out"] ) ) self.assertEqual( lambert["parameters"]["opacity"].getValue(), IECore.Color3f( 0.1 ) ) self.assertEqual( lambert["parameters"]["aov_direct_diffuse"].getValue(), "test" ) self.assertEqual( lambert.children(), originalLambertPlugs ) self.assertEqual( lambert["parameters"].children(), originalLambertParameterPlugs ) assertValuesWereKept() image.loadShader( "image", keepExistingValues = True ) assertValuesWereKept() image.loadShader( "image", keepExistingValues = False ) for p in image["parameters"].children() : self.assertTrue( p.isSetToDefault() ) self.assertTrue( lambert["parameters"]["Kd_color"].getInput() is None )
def _testEmptyPlugTypeMetadata(self):
n = GafferArnold.ArnoldShader()
n.loadShader("standard_surface")
self.assertTrue("diffuse_roughness" not in n["parameters"])
n = GafferArnold.ArnoldShader()
n.loadShader("standard_surface")
self.assertTrue("diffuse_roughness" not in n["parameters"])
def test(self):
sphere = GafferScene.Sphere()
camera = GafferScene.Camera()
group = GafferScene.Group()
group["in"][0].setInput(sphere["out"])
group["in"][1].setInput(camera["out"])
noise = GafferArnold.ArnoldShader()
noise.loadShader("noise")
flat = GafferArnold.ArnoldShader()
flat.loadShader("flat")
cameraShaders = GafferArnold.ArnoldCameraShaders()
cameraShaders["filterMap"].setInput(flat["out"])
cameraShaders["uvRemap"].setInput(noise["out"])
sphereFilter = GafferScene.PathFilter()
sphereFilter["paths"].setValue(
IECore.StringVectorData(["/group/sphere"]))
cameraFilter = GafferScene.PathFilter()
cameraFilter["paths"].setValue(
IECore.StringVectorData(["/group/camera"]))
assignment = GafferScene.ShaderAssignment()
assignment["in"].setInput(group["out"])
assignment["shader"].setInput(flat["out"])
assignment["filter"].setInput(sphereFilter["out"])
cameraShadersAssignment = GafferScene.ShaderAssignment()
cameraShadersAssignment["in"].setInput(group["out"])
cameraShadersAssignment["shader"].setInput(cameraShaders["out"])
cameraShadersAssignment["filter"].setInput(cameraFilter["out"])
self.assertEqual(
cameraShadersAssignment["out"].attributes("/group/camera")
["ai:filtermap"],
assignment["out"].attributes("/group/sphere")["ai:surface"],
)
self.assertEqual(
cameraShadersAssignment["out"].attributes("/group/camera")
["ai:uv_remap"].outputShader().name, "noise")
cameraShaders["enabled"].setValue(False)
self.assertNotIn(
"ai:filtermap",
cameraShadersAssignment["out"].attributes("/group/camera"))
self.assertNotIn(
"ai:uv_remap",
cameraShadersAssignment["out"].attributes("/group/camera"))
def testStandardShaderAcceptsImageInputs( self ) : s = GafferArnold.ArnoldShader() s.loadShader( "standard_surface" ) t = GafferArnold.ArnoldShader() t.loadShader( "image" ) s["parameters"]["emission_color"].setInput( t["out"] ) self.failUnless( s["parameters"]["emission_color"].getInput().isSame( t["out"] ) ) self.failUnless( s["parameters"]["emission_color"][0].getInput().isSame( t["out"][0] ) ) self.failUnless( s["parameters"]["emission_color"][1].getInput().isSame( t["out"][1] ) ) self.failUnless( s["parameters"]["emission_color"][2].getInput().isSame( t["out"][2] ) )
def testAssignment(self):
s = GafferScene.Sphere()
n = GafferArnold.ArnoldShader()
n.loadShader("noise")
d = GafferArnold.ArnoldDisplacement()
d["map"].setInput(n["out"])
d["height"].setValue(2.5)
f = GafferScene.PathFilter()
f["paths"].setValue(IECore.StringVectorData(["/sphere"]))
a = GafferScene.ShaderAssignment()
a["in"].setInput(s["out"])
a["shader"].setInput(d["out"])
a["filter"].setInput(f["out"])
self.assertEqual(a["out"].attributes("/sphere")["ai:disp_height"],
IECore.FloatData(2.5))
d["height"].setValue(5)
self.assertEqual(a["out"].attributes("/sphere")["ai:disp_height"],
IECore.FloatData(5))
def testDefaultValuesForOutput( self ) : for i in range( 0, 100 ) : n = GafferArnold.ArnoldShader() n.loadShader( "flat" ) self.assertEqual( n["out"].defaultValue(), IECore.Color3f( 0 ) )
def testLoadShaderInSerialisation( self ) : s = Gaffer.ScriptNode() s["s"] = GafferArnold.ArnoldShader() s["s"].loadShader( "lambert" ) self.assertTrue( """loadShader( "lambert", keepExistingValues=True )""" in s.serialise() )
def _testFloatParameterMetadata(self):
n = GafferArnold.ArnoldShader()
n.loadShader("gobo")
self.assertTrue(
isinstance(n["parameters"]["slidemap"], Gaffer.FloatPlug))
def testMixAndMatchWithOSLShaders( self ) : utility = GafferArnold.ArnoldShader() utility.loadShader( "utility" ) splitColor = GafferOSL.OSLShader() splitColor.loadShader( "Utility/SplitColor" ) splitColor["parameters"]["c"].setInput( utility["out"] ) colorSpline = GafferOSL.OSLShader() colorSpline.loadShader( "Pattern/ColorSpline" ) colorSpline["parameters"]["x"].setInput( splitColor["out"]["r"] ) flat = GafferArnold.ArnoldShader() flat.loadShader( "flat" ) flat["parameters"]["color"].setInput( colorSpline["out"]["c"] )
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 testMetadata(self):
shader = GafferArnold.ArnoldShader()
shader.loadShader("noise")
self.assertEqual(
Gaffer.Metadata.value(shader["parameters"]["octaves"],
"nodule:type"), "")
self.assertEqual(
Gaffer.Metadata.value(shader["parameters"]["amplitude"],
"nodule:type"), "GafferUI::StandardNodule")
self.assertEqual(
Gaffer.Metadata.value(shader["parameters"]["octaves"],
"plugValueWidget:type"), None)
self.assertEqual(
Gaffer.Metadata.value(shader["parameters"]["coord_space"],
"plugValueWidget:type"),
"GafferUI.PresetsPlugValueWidget")
self.assertEqual(
Gaffer.Metadata.value(shader["parameters"]["coord_space"],
"presetNames"),
IECore.StringVectorData(["world", "object", "Pref"]),
)
self.assertEqual(
Gaffer.Metadata.value(shader["parameters"]["coord_space"],
"presetValues"),
Gaffer.Metadata.value(shader["parameters"]["coord_space"],
"presetNames"),
)
def test(self):
n = GafferArnold.ArnoldShader()
n.loadShader("noise")
d = GafferArnold.ArnoldDisplacement()
d["map"].setInput(n["out"])
d["height"].setValue(2.5)
d["padding"].setValue(25)
d["zeroValue"].setValue(.25)
d["autoBump"].setValue(True)
na = n.attributes()
da = d.attributes()
self.assertEqual(
da,
IECore.CompoundObject({
"ai:disp_map": na["ai:surface"],
"ai:disp_height": IECore.FloatData(2.5),
"ai:disp_padding": IECore.FloatData(25),
"ai:disp_zero_value": IECore.FloatData(.25),
"ai:disp_autobump": IECore.BoolData(True),
}))
d["enabled"].setValue(False)
self.assertEqual(d.attributes(), IECore.CompoundObject())
def test(self):
a = GafferArnold.ArnoldBackground()
self.assertNotIn("option:ai:background",
a["out"]["globals"].getValue())
s = GafferArnold.ArnoldShader()
s.loadShader("flat")
cs = GafferTest.CapturingSlot(a.plugDirtiedSignal())
a["shader"].setInput(s["out"])
self.assertIn(a["out"]["globals"], {x[0] for x in cs})
backgroundOption = a["out"]["globals"].getValue(
)["option:ai:background"]
self.assertIsInstance(backgroundOption, IECoreScene.ShaderNetwork)
self.assertEqual(backgroundOption.outputShader().name, "flat")
self.assertEqual(
backgroundOption.outputShader().parameters["color"].value,
imath.Color3f(1))
del cs[:]
s["parameters"]["color"]["r"].setValue(0.25)
self.assertIn(a["out"]["globals"], {x[0] for x in cs})
backgroundOption = a["out"]["globals"].getValue(
)["option:ai:background"]
self.assertIsInstance(backgroundOption, IECoreScene.ShaderNetwork)
self.assertEqual(backgroundOption.outputShader().name, "flat")
self.assertEqual(
backgroundOption.outputShader().parameters["color"].value,
imath.Color3f(0.25, 1, 1))
def __init__( self, name = "ArnoldShaderBall" ) :
GafferScene.ShaderBall.__init__( self, name )
self["environment"] = Gaffer.StringPlug( defaultValue = "${GAFFER_ROOT}/resources/hdri/studio.exr" )
self["__envMap"] = GafferArnold.ArnoldShader()
self["__envMap"].loadShader( "image" )
self["__envMap"]["parameters"]["filename"].setInput( self["environment"] )
self["__skyDome"] = GafferArnold.ArnoldLight()
self["__skyDome"].loadShader( "skydome_light" )
self["__skyDome"]["parameters"]["color"].setInput( self["__envMap"]["out"] )
self["__skyDome"]["parameters"]["format"].setValue( "latlong" )
self["__skyDome"]["parameters"]["camera"].setValue( 0 )
self["__parentLights"] = GafferScene.Parent()
self["__parentLights"]["in"].setInput( self._outPlug().getInput() )
self["__parentLights"]["children"][0].setInput( self["__skyDome"]["out"] )
self["__parentLights"]["parent"].setValue( "/" )
self["__arnoldOptions"] = GafferArnold.ArnoldOptions()
self["__arnoldOptions"]["in"].setInput( self["__parentLights"]["out"] )
self["__arnoldOptions"]["options"]["aaSamples"]["enabled"].setValue( True )
self["__arnoldOptions"]["options"]["aaSamples"]["value"].setValue( 3 )
self.addChild(
self["__arnoldOptions"]["options"]["threads"].createCounterpart( "threads", Gaffer.Plug.Direction.In )
)
self["__arnoldOptions"]["options"]["threads"].setInput( self["threads"] )
self._outPlug().setInput( self["__arnoldOptions"]["out"] )
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 testShaderInputs(self):
# Test setting up a checkerboard connected to the lightfilter's "shader" input.
s = GafferArnold.ArnoldShader("Checkerboard")
s.loadShader("checkerboard")
l = GafferArnold.ArnoldLightFilter()
l.loadShader("light_blocker")
l["parameters"]["shader"].setInput(s["out"])
network = l["out"].attributes("/lightFilter")["ai:lightFilter:filter"]
self.assertEqual(len(network), 2)
self.assertEqual(network.getShader("__shader").name, "light_blocker")
self.assertEqual(
network.getShader("Checkerboard").name, "checkerboard")
self.assertEqual(
network.getShader("Checkerboard").parameters["color1"].value,
imath.Color3f(1, 1, 1))
self.assertEqual(network.inputConnections(network.getOutput().shader),
[
network.Connection(
("Checkerboard", ""),
(network.getOutput().shader, "shader")),
])
def test(self):
a = GafferArnold.ArnoldAtmosphere()
self.assertNotIn("option:ai:atmosphere",
a["out"]["globals"].getValue())
s = GafferArnold.ArnoldShader()
s.loadShader("atmosphere_volume")
cs = GafferTest.CapturingSlot(a.plugDirtiedSignal())
a["shader"].setInput(s["out"])
self.assertIn(a["out"]["globals"], {x[0] for x in cs})
atmosphereOption = a["out"]["globals"].getValue(
)["option:ai:atmosphere"]
self.assertIsInstance(atmosphereOption, IECoreScene.ShaderNetwork)
self.assertEqual(atmosphereOption.outputShader().name,
"atmosphere_volume")
self.assertEqual(
atmosphereOption.outputShader().parameters["density"].value, 0.0)
del cs[:]
s["parameters"]["density"].setValue(0.25)
self.assertIn(a["out"]["globals"], {x[0] for x in cs})
atmosphereOption = a["out"]["globals"].getValue(
)["option:ai:atmosphere"]
self.assertIsInstance(atmosphereOption, IECoreScene.ShaderNetwork)
self.assertEqual(atmosphereOption.outputShader().name,
"atmosphere_volume")
self.assertEqual(
atmosphereOption.outputShader().parameters["density"].value, 0.25)
