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")),
])
