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 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 testDirtyPropagation(self):
n = GafferArnold.ArnoldShader()
n.loadShader("noise")
d = GafferArnold.ArnoldDisplacement()
cs = GafferTest.CapturingSlot(d.plugDirtiedSignal())
d["height"].setValue(10)
self.assertTrue(d["out"] in [x[0] for x in cs])
del cs[:]
d["map"].setInput(n["out"])
self.assertTrue(d["out"] in [x[0] for x in cs])
def testOSLShaderInput(self):
n = GafferOSL.OSLShader()
n.loadShader("Pattern/Noise")
d = GafferArnold.ArnoldDisplacement()
d["map"].setInput(n["out"])
self.assertTrue(d["map"].getInput().isSame(n["out"]))
na = n.attributes()
da = d.attributes()
self.assertEqual(
da,
IECore.CompoundObject({
"ai:disp_map": na["osl:shader"],
"ai:disp_height": IECore.FloatData(1),
"ai:disp_padding": IECore.FloatData(0),
"ai:disp_zero_value": IECore.FloatData(0),
}))
def setup_materials(self):
"""
Creates Materials, Shaders and sets Input values
@return: None
"""
x = time.time()
shader_count = 0
# Creates Materials
for material in self.mtlx_doc.getMaterials():
material_name = fix_str(material.getName())
box_in = Gaffer.BoxIn()
box_out = Gaffer.BoxOut()
material_box = Gaffer.Box(material_name)
# Creates shader reference nodes
for shader_ref in material.getShaderRefs():
shader_name = fix_str(shader_ref.getName())
shader = GafferArnold.ArnoldShader(shader_name)
shader.loadShader(shader_ref.getNodeString())
shader_assignment = GafferScene.ShaderAssignment()
shader_assignment['shader'].setInput(shader["out"])
box_in.setup(shader_assignment["in"])
box_out.setup(shader_assignment["out"])
shader_assignment["in"].setInput(box_in["out"])
box_out["in"].setInput(shader_assignment["out"])
path_filter = GafferScene.PathFilter()
shader_assignment['filter'].setInput(path_filter["out"])
# Displacement Shader
if shader_ref.getAttribute("context") == "displacementshader":
dsp_shader = GafferArnold.ArnoldDisplacement()
shader_assignment['shader'].setInput(dsp_shader["out"])
dsp_shader['map'].setInput(shader["out"])
material_box.addChild(dsp_shader)
material_box.addChild(shader)
material_box.addChild(box_in)
material_box.addChild(box_out)
material_box.addChild(path_filter)
material_box.addChild(shader_assignment)
box_in.setupPromotedPlug()
box_out.setupPromotedPlug()
material_list = self.material_list()
if material_list:
if material_box != material_list[-1]:
material_box["in"].setInput(material_list[-1]["out"])
material_list[0]["in"].setInput(self["in"])
self["out"].setInput(material_box["out"])
self.addChild(material_box)
# Sets shader reference input values
for bind_input in shader_ref.getBindInputs():
value = bind_input.getValue()
if value is not None:
shader_parm = shader['parameters']
input_name = str(bind_input.getName())
if input_name in shader_parm:
self.set_input_value(shader_parm[input_name], value)
# Create shader nodes
for graph in shader_ref.traverseGraph(material):
node = graph.getUpstreamElement()
if node.isA(mx.Node):
shader_list = [i.getName() for i in material_box.children()
if isinstance(i, GafferArnold.ArnoldShader)]
node_name = fix_str(node.getName())
if node_name not in shader_list:
shader = GafferArnold.ArnoldShader(node_name)
shader.loadShader(node.getCategory())
material_box.addChild(shader)
shader_count += 1
# Sets shader input values
for input_parm in node.getInputs():
input_name = str(input_parm.getName())
if shader is not None:
shader_parm = shader['parameters']
if input_name in shader_parm:
value = input_parm.getValue()
if value is not None:
self.set_input_value(shader_parm[input_name], value)
# Sets Connections
for material in self.mtlx_doc.getMaterials():
material_box = self[fix_str(material.getName())]
for shader_ref in material.getShaderRefs():
shader_name = fix_str(shader_ref.getName())
shader = material_box[shader_name]
shader_parm = shader['parameters']
for bind_input in shader_ref.getBindInputs():
input_name = str(bind_input.getName())
output = bind_input.getConnectedOutput()
if output is not None:
node_name = fix_str(output.getNodeName())
if node_name:
if input_name in shader_parm:
self.set_input_connection(shader_parm[input_name],
material_box[node_name]["out"])
for graph in shader_ref.traverseGraph():
shader_node = graph.getUpstreamElement()
if shader_node.isA(mx.Node):
shader_name = fix_str(shader_node.getName())
shader = material_box[shader_name]
shader_parm = shader['parameters']
for input_parm in shader_node.getInputs():
input_name = str(input_parm.getName())
node_name = fix_str(input_parm.getNodeName())
if node_name:
if input_name in shader_parm:
channel_out = str(input_parm.getAttribute("channels"))
self.set_input_connection(shader_parm[input_name],
material_box[node_name]["out"],
channel_out)
logger.info("%s Loaded %d shaders in %.2f seconds" % (self.getName(), shader_count, time.time() - x))
def testNoInput(self):
d = GafferArnold.ArnoldDisplacement()
self.assertTrue("ai:disp_map" not in d.attributes())
