def testEmptyPlugTypeMetadata(self): self.__forceArnoldRestart() n = GafferArnold.ArnoldShader() n.loadShader("standard") self.assertTrue("aov_direct_diffuse" in n["parameters"]) 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.loadShader("standard") self.assertTrue("aov_direct_diffuse" not in n["parameters"]) n = GafferArnold.ArnoldShader() n.loadShader("standard") self.assertTrue("aov_direct_diffuse" not in n["parameters"])
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 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 testParameterRepresentation(self): n = GafferArnold.ArnoldShader() n.loadShader("wireframe") self.assertIsInstance(n["parameters"]["line_width"], Gaffer.FloatPlug) self.assertIsInstance(n["parameters"]["fill_color"], Gaffer.Color3fPlug) self.assertIsInstance(n["parameters"]["line_color"], Gaffer.Color3fPlug) self.assertIsInstance(n["parameters"]["raster_space"], Gaffer.BoolPlug) self.assertIsInstance(n["parameters"]["edge_type"], Gaffer.StringPlug) self.assertNotIn("name", n["parameters"])
def _createTraceSetShader(self): # It's currently pretty ugly how we need to disable the trace set when it is left empty, # to match the behaviour expected by GafferSceneTest.InteractiveRenderTest. # Would be somewhat cleaner if we had the primaryInput metadata on trace_set # available, so we could just put an expression on it to disable it when no trace set is given, # but it doesn't seem very safe to do a metadata load in the middle of the tests shaderBox = Gaffer.Box() shader = GafferArnold.ArnoldShader("shader") shader.loadShader("standard_surface") shader["parameters"]["base"].setValue(1) shader["parameters"]["specular_roughness"].setValue(0) shader["parameters"]["metalness"].setValue(1) shader["parameters"]["specular_IOR"].setValue(100) #return shader, Gaffer.StringPlug( "unused" ) traceSetShader = GafferArnold.ArnoldShader("traceSetShader") traceSetShader.loadShader("trace_set") traceSetShader["parameters"]["passthrough"].setInput(shader["out"]) switchShader = GafferArnold.ArnoldShader("switchShader") switchShader.loadShader("switch_shader") switchShader["parameters"]["input0"].setInput(shader["out"]) switchShader["parameters"]["input1"].setInput(traceSetShader["out"]) shaderBox.addChild(shader) shaderBox.addChild(traceSetShader) shaderBox.addChild(switchShader) shaderBox["enableExpression"] = Gaffer.Expression() shaderBox["enableExpression"].setExpression( 'parent.switchShader.parameters.index = parent.traceSetShader.parameters.trace_set != ""', "OSL") Gaffer.PlugAlgo.promote(switchShader["out"]) return shaderBox, traceSetShader["parameters"]["trace_set"]
def testLightFilterAssignmentAttributeName( self ) : p = GafferScene.Plane() s = GafferArnold.ArnoldShader( "light_blocker" ) s.loadShader( "light_blocker" ) # metadata sets type to ai:lightFilter a = GafferScene.ShaderAssignment() a["in"].setInput( p["out"] ) a["shader"].setInput( s["out"] ) self.assertEqual( s["attributeSuffix"].getValue(), "light_blocker" ) self.assertEqual( a["out"].attributes( "/plane" ).keys(), [ "ai:lightFilter:light_blocker"] )
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 = GafferScene.Private.IECoreScenePreview.Renderer.create( "IECoreArnold::Renderer", GafferScene.Private.IECoreScenePreview.Renderer.RenderType.Batch) r.output( "test", IECore.Display("test", "ieDisplay", "rgba", { "driverType": "ImageDisplayDriver", "handle": "test" })) mesh = r.object( "mesh", IECore.MeshPrimitive.createPlane( IECore.Box2f(IECore.V2f(-1), IECore.V2f(1))), r.attributes(s.attributes())) mesh.transform(IECore.M44f().translate(IECore.V3f(0, 0, -5))) r.render() 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 testShaderSwitch(self): l = GafferArnold.ArnoldShader() l.loadShader("lambert") f1 = GafferArnold.ArnoldShader("f1") f1.loadShader("flat") f1["parameters"]["color"].setValue(imath.Color3f(0)) f2 = GafferArnold.ArnoldShader("f2") f2.loadShader("flat") f2["parameters"]["color"].setValue(imath.Color3f(1)) f3 = GafferArnold.ArnoldShader("f3") f3.loadShader("flat") f3["parameters"]["color"].setValue(imath.Color3f(2)) for switchType in (Gaffer.SwitchComputeNode, GafferScene.ShaderSwitch): s = switchType() s.setup(f1["out"]) s["in"][0].setInput(f1["out"]) s["in"][1].setInput(f2["out"]) s["in"][2].setInput(f3["out"]) l["parameters"]["Kd_color"].setInput(s["out"]) def assertIndex(index): network = l.attributes()["ai:surface"] self.assertEqual(len(network), 2) self.assertEqual(network[0].parameters["color"].value, imath.Color3f(index)) for i in range(0, 3): s["index"].setValue(i) assertIndex(i)
def testShaderNetworkRender(self): f = GafferArnold.ArnoldShader() f.loadShader("flat") f["parameters"]["color"].setValue(imath.Color3f(1, 1, 0)) s = GafferArnold.ArnoldShader() s.loadShader("utility") s["parameters"]["color"].setInput(f["parameters"]["color"]) r = GafferScene.Private.IECoreScenePreview.Renderer.create( "Arnold", GafferScene.Private.IECoreScenePreview.Renderer.RenderType.Batch) r.output( "test", IECoreScene.Output("test", "ieDisplay", "rgba", { "driverType": "ImageDisplayDriver", "handle": "test" })) mesh = r.object( "mesh", IECoreScene.MeshPrimitive.createPlane( imath.Box2f(imath.V2f(-1), imath.V2f(1))), r.attributes(s.attributes())) mesh.transform(imath.M44f().translate(imath.V3f(0, 0, -5))) r.render() imagePrimitive = IECoreImage.ImageDisplayDriver.removeStoredImage( "test") pixelPos = 320 + 240 * 640 self.assertAlmostEqual(imagePrimitive["R"][pixelPos], 1, 5) self.assertAlmostEqual(imagePrimitive["G"][pixelPos], 1, 5) self.assertEqual(imagePrimitive["B"][pixelPos], 0)
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"))
def testDisabledShaderPassesThroughExternalValue( self ) : s = GafferArnold.ArnoldShader() s.loadShader( "standard_surface" ) f = GafferArnold.ArnoldShader() f.loadShader( "flat" ) f["parameters"]["color"].setValue( IECore.Color3f( 1, 2, 3 ) ) 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] ) else : self.assertEqual( attributes["ai:surface"][0].parameters["color"], attributes2["ai:surface"][0].parameters[key] )
def _createPointLight(self): light = GafferArnold.ArnoldLight() with IECore.CapturingMessageHandler() as mh: light.loadShader("point_light") self.assertEqual(len(mh.messages), 4) for m in mh.messages: ## \todo Remove once we've figured out what to do # with these parameters. self.assertTrue("of type \"ARRAY\"" in m.message) return light, light["parameters"]["color"]
def testSerialisation(self): s = Gaffer.ScriptNode() s["o"] = GafferArnold.ArnoldOptions() s["o"]["options"]["aaSamples"]["value"].setValue(1) names = s["o"]["options"].keys() s2 = Gaffer.ScriptNode() s2.execute(s.serialise()) self.assertEqual(s2["o"]["options"].keys(), names) self.assertTrue("options1" not in s2["o"]) self.assertEqual(s2["o"]["options"]["aaSamples"]["value"].getValue(), 1)
def testHash( self ) : n = GafferArnold.ArnoldShader() h = n.attributesHash() n.loadShader( "noise" ) h2 = n.attributesHash() self.assertNotEqual( h, h2 ) n["parameters"]["octaves"].setValue( 10 ) h3 = n.attributesHash() self.assertNotEqual( h2, h3 )
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 testConnectionsBetweenParameters(self): s = GafferArnold.ArnoldShader() s.loadShader("add") s["parameters"]["input1"].setValue(imath.Color3f(0.1, 0.2, 0.3)) s["parameters"]["input2"].setInput(s["parameters"]["input1"]) shader = s.attributes()["ai:surface"][0] self.assertEqual(shader.parameters["input1"].value, imath.Color3f(0.1, 0.2, 0.3)) self.assertEqual(shader.parameters["input2"].value, imath.Color3f(0.1, 0.2, 0.3))
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 testConnectionsBetweenParameters(self): s = GafferArnold.ArnoldShader() s.loadShader("flat") s["parameters"]["color"].setValue(IECore.Color3f(0.1, 0.2, 0.3)) s["parameters"]["opacity"].setInput(s["parameters"]["color"]) shader = s.state()[0] self.assertEqual(shader.parameters["color"].value, IECore.Color3f(0.1, 0.2, 0.3)) self.assertEqual(shader.parameters["opacity"].value, IECore.Color3f(0.1, 0.2, 0.3))
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.assertEqual( backgroundOption[0].name, "flat" ) self.assertEqual( backgroundOption[0].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.assertEqual( backgroundOption[0].name, "flat" ) self.assertEqual( backgroundOption[0].parameters["color"].value, imath.Color3f( 0.25, 1, 1 ) )
def testFloatParameterMetadata(self): self.__forceArnoldRestart() n = GafferArnold.ArnoldShader() n.loadShader("gobo") self.assertTrue( isinstance(n["parameters"]["slidemap"], Gaffer.Color3fPlug)) 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("gobo") self.assertTrue( isinstance(n["parameters"]["slidemap"], Gaffer.FloatPlug))
def __init__(self, name="ArnoldLDTShaderBall"): GafferSceneLDT.LDTShaderBall.__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.addChild( self["__skyDome"]["parameters"]["exposure"].createCounterpart( "exposure", Gaffer.Plug.Direction.In)) self["__skyDome"]["parameters"]["exposure"].setInput(self["exposure"]) self["__parentLights"] = GafferScene.Parent() self["__parentLights"]["in"].setInput(self._outPlug().getInput()) self["__parentLights"]["child"].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 testDefaultOverrideMetadata(self): self.__forceArnoldRestart() n = GafferArnold.ArnoldShader() n.loadShader("image") self.assertEqual(n["parameters"]["single_channel"].defaultValue(), False) self.assertEqual(n["parameters"]["mipmap_bias"].defaultValue(), 0) self.assertEqual(n["parameters"]["start_channel"].defaultValue(), 0) self.assertEqual(n["parameters"]["sscale"].defaultValue(), 1.0) self.assertEqual(n["parameters"]["multiply"].defaultValue(), imath.Color3f(1.0)) self.assertEqual( n["parameters"]["missing_texture_color"].defaultValue(), imath.Color4f(0.0)) self.assertEqual(n["parameters"]["uvcoords"].defaultValue(), imath.V2f(0.0)) self.assertEqual(n["parameters"]["filename"].defaultValue(), "") self.assertEqual(n["parameters"]["filter"].defaultValue(), "smart_bicubic") 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.loadShader("image") self.assertEqual(n["parameters"]["single_channel"].defaultValue(), True) self.assertEqual(n["parameters"]["mipmap_bias"].defaultValue(), 42) self.assertEqual(n["parameters"]["start_channel"].defaultValue(), 42) self.assertAlmostEqual(n["parameters"]["sscale"].defaultValue(), 42.42, places=5) self.assertEqual(n["parameters"]["multiply"].defaultValue(), imath.Color3f(1.2, 3.4, 5.6)) # RGBA metadata support added in Arnold 5.3. Need to wait until we standardise on that # to add this declaration to the test metadata #self.assertEqual( n["parameters"]["missing_texture_color"].defaultValue(), imath.Color4f( 1.2, 3.4, 5.6, 7.8 ) ) self.assertEqual(n["parameters"]["uvcoords"].defaultValue(), imath.V2f(1.2, 3.4)) self.assertEqual(n["parameters"]["filename"].defaultValue(), "overrideDefault") self.assertEqual(n["parameters"]["filter"].defaultValue(), "closest")
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"] ) six.assertRaisesRegex( self, RuntimeError, "Render aborted", s["render"]["task"].execute )
def _testColorParameterMetadata(self): 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 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 testShaderInputs( self ) : s = GafferArnold.ArnoldShader( "sky" ) 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( "matte" ) 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.getShader( "sky" ).name, "physical_sky" ) self.assertEqual( network.getShader( "sky" ).parameters["intensity"].value, 2 ) self.assertEqual( network.getShader( "matte" ).name, "matte" ) self.assertEqual( network.getShader( "matte" ).parameters["color"].value, imath.Color4f( 0, 1, 0, 0.5 ) ) self.assertEqual( network.inputConnections( network.getOutput().shader ), [ network.Connection( ( "sky", "" ), ( network.getOutput().shader, "color" ) ), network.Connection( ( "matte", "" ), ( network.getOutput().shader, "shader" ) ), ] ) s["parameters"]["intensity"].setValue( 4 ) network = l["out"].attributes( "/light" )["ai:light"] self.assertEqual( network.getShader( "sky" ).parameters["intensity"].value, 4 )
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 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 testSerialisation(self): s = Gaffer.ScriptNode() s["a"] = GafferArnold.ArnoldAttributes() s["a"]["attributes"]["cameraVisibility"]["value"].setValue(False) names = s["a"]["attributes"].keys() s2 = Gaffer.ScriptNode() s2.execute(s.serialise()) self.assertEqual(s2["a"]["attributes"].keys(), names) self.assertTrue("attributes1" not in s2["a"]) self.assertEqual( s2["a"]["attributes"]["cameraVisibility"]["value"].getValue(), False)
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")), ])