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)