def SetupShading(stage):
# First create the shading prims
UsdGeom.Scope.Define(stage, shadersPath)
UsdGeom.Scope.Define(stage, materialsPath)
# .. and as we create each surface, bind the associated material's variant to it
allMaterials = []
for material in materialBases:
materialPrim = UsdShade.Material.Define(
stage, MakeMaterialPath(material))
allMaterials.append(materialPrim.GetPrim())
for variant in shadeVariations:
surface = UsdShade.Shader.Define(
stage, MakeSurfacePath(material, variant))
colorOut = surface.CreateOutput("out",
Sdf.ValueTypeNames.Color3f)
disp = UsdShade.Shader.Define(
stage, MakeDisplacementPath(material, variant))
dispOut = disp.CreateOutput('out',
Sdf.ValueTypeNames.Vector3f)
pattern = UsdShade.Shader.Define(
stage, MakePatternPath(material, variant))
patternOut = pattern.CreateOutput(
"out", Sdf.ValueTypeNames.FloatArray)
with materialPrim.GetEditContextForVariant(variant):
surfaceOutput = materialPrim.CreateOutput(
"surf", colorOut.GetTypeName())
surfaceOutput.ConnectToSource(
UsdShade.ConnectionSourceInfo(
UsdShade.ConnectableAPI(colorOut.GetPrim()),
colorOut.GetBaseName(),
UsdShade.AttributeType.Output))
displacementOutput = materialPrim.CreateOutput(
"disp", dispOut.GetTypeName())
displacementOutput.ConnectToSource(dispOut)
patternOutput = materialPrim.CreateOutput(
"pattern", patternOut.GetTypeName())
patternOutput.ConnectToSource(patternOut)
return allMaterials
def test_InputOutputConnections(self):
stage = self._SetupStage()
################################
print('Test Input/Output connections')
################################
pale = UsdShade.Shader.Get(stage, palePath)
self.assertTrue(pale)
whiterPale = UsdShade.Shader.Get(stage, whiterPalePath)
self.assertTrue(whiterPale)
shaderClass = UsdShade.Shader.Get(stage, classPalePath)
print('Test RenderType')
chords = pale.CreateInput("chords", Sdf.ValueTypeNames.String)
self.assertTrue(chords)
self.assertTrue(not chords.HasRenderType())
self.assertEqual(chords.GetRenderType(), "")
chords.SetRenderType("notes")
self.assertTrue(chords.HasRenderType())
self.assertEqual(chords.GetRenderType(), "notes")
################################
print('Test scalar connections')
################################
usdShadeInput = pale.CreateInput('myFloatInput',
Sdf.ValueTypeNames.Float)
# test set/get documentation.
doc = "My shade input"
usdShadeInput.SetDocumentation(doc)
self.assertEqual(usdShadeInput.GetDocumentation(), doc)
# test set/get dislayGroup
displayGroup = "floats"
usdShadeInput.SetDisplayGroup(displayGroup)
self.assertEqual(usdShadeInput.GetDisplayGroup(), displayGroup)
self.assertEqual(usdShadeInput.GetBaseName(), 'myFloatInput')
self.assertEqual(usdShadeInput.GetTypeName(), Sdf.ValueTypeNames.Float)
usdShadeInput.Set(1.0)
self.assertTrue(not usdShadeInput.HasConnectedSource())
usdShadeInput.ConnectToSource(
UsdShade.ConnectionSourceInfo(whiterPale.ConnectableAPI(), 'Fout',
Output))
self.assertTrue(usdShadeInput.HasConnectedSource())
self.assertEqual(usdShadeInput.GetAttr().GetConnections(),
[whiterPale.GetPath().AppendProperty("outputs:Fout")])
self.assertEqual(usdShadeInput.GetConnectedSources()[0], [
UsdShade.ConnectionSourceInfo(whiterPale.ConnectableAPI(), 'Fout',
Output)
])
usdShadeInput.ClearSources()
self.assertTrue(not usdShadeInput.HasConnectedSource())
self.assertEqual(usdShadeInput.GetConnectedSources()[0], [])
# Now make the connection in the class
inheritedInput = shaderClass.CreateInput('myFloatInput',
Sdf.ValueTypeNames.Float)
inheritedInput.ConnectToSource(
UsdShade.ConnectionSourceInfo(whiterPale.ConnectableAPI(), 'Fout',
Output))
# note we're now testing the inheritING prim's parameter
self.assertTrue(usdShadeInput.HasConnectedSource())
self.assertTrue(usdShadeInput.GetConnectedSources()[0], [
UsdShade.ConnectionSourceInfo(whiterPale.ConnectableAPI(), 'Fout',
Output)
])
# clearing no longer changes anything
usdShadeInput.ClearSources()
self.assertTrue(usdShadeInput.HasConnectedSource())
self.assertTrue(usdShadeInput.GetConnectedSources()[0], [
UsdShade.ConnectionSourceInfo(whiterPale.ConnectableAPI(), 'Fout',
Output)
])
# but disconnecting should
usdShadeInput.DisconnectSource()
self.assertTrue(not usdShadeInput.HasConnectedSource())
self.assertEqual(usdShadeInput.GetConnectedSources()[0], [])
################################
print('Test asset id')
################################
self.assertEqual(pale.GetImplementationSource(), UsdShade.Tokens.id)
self.assertEqual(whiterPale.GetImplementationSource(),
UsdShade.Tokens.id)
self.assertTrue(pale.SetShaderId('SharedFloat_1'))
self.assertEqual(pale.GetShaderId(), 'SharedFloat_1')
self.assertTrue(whiterPale.CreateIdAttr('SharedColor_1'))
self.assertEqual(whiterPale.GetIdAttr().Get(), 'SharedColor_1')
self.assertTrue(pale.GetSourceAsset() is None)
self.assertTrue(whiterPale.GetSourceCode() is None)
# Test boundaries of parameter type-testing when connecting
print("Test Typed Input Connections")
colInput = pale.CreateInput("col1", Sdf.ValueTypeNames.Color3f)
self.assertTrue(colInput)
self.assertTrue(
colInput.ConnectToSource(
UsdShade.ConnectionSourceInfo(whiterPale.ConnectableAPI(),
'colorOut', Output)))
outputAttr = whiterPale.GetPrim().GetAttribute("outputs:colorOut")
self.assertTrue(outputAttr)
self.assertEqual(outputAttr.GetTypeName(), Sdf.ValueTypeNames.Color3f)
v3fInput = pale.CreateInput("v3f1", Sdf.ValueTypeNames.Float3)
self.assertTrue(v3fInput)
self.assertTrue(
v3fInput.ConnectToSource(
UsdShade.ConnectionSourceInfo(whiterPale.ConnectableAPI(),
"colorOut", Output)))
pointInput = pale.CreateInput("point1", Sdf.ValueTypeNames.Point3f)
self.assertTrue(pointInput)
self.assertTrue(
pointInput.ConnectToSource(
UsdShade.ConnectionSourceInfo(whiterPale.ConnectableAPI(),
"colorOut", Output)))
floatInput = pale.CreateInput("float1", Sdf.ValueTypeNames.Float)
self.assertTrue(floatInput)
# XXX The following test must be disabled until we re-enable strict
# type-checking for input / output connections. See bug/113600
# can't connect float to color!
#with RequiredException(Tf.ErrorException):
# floatInput.ConnectToSource(
# UsdShade.ConnectionSourceInfo(whiterPale, "colorOut", Output))
self.assertTrue(
floatInput.ConnectToSource(
UsdShade.ConnectionSourceInfo(whiterPale.ConnectableAPI(),
"floatInput", Input)))
outputAttr = whiterPale.GetPrim().GetAttribute("outputs:floatInput")
self.assertFalse(outputAttr)
outputAttr = whiterPale.GetPrim().GetAttribute("inputs:floatInput")
self.assertTrue(outputAttr)
print("Test Input Fetching")
# test against single input fetches
vecInput = pale.CreateInput('vec', Sdf.ValueTypeNames.Color3f)
self.assertTrue(vecInput)
self.assertTrue(pale.GetInput('vec'))
self.assertEqual(pale.GetInput('vec').GetBaseName(), 'vec')
self.assertEqual(
pale.GetInput('vec').GetTypeName(), Sdf.ValueTypeNames.Color3f)
self.assertTrue(pale.GetInput('vec').SetRenderType('foo'))
self.assertEqual(pale.GetInput('vec').GetRenderType(), 'foo')
# test against multiple input parameters.
inputs = pale.GetInputs()
# assure new item in collection
self.assertEqual(
len([pr for pr in inputs if pr.GetRenderType() == 'foo']), 1)
# ensure the input count increments properly
oldlen = len(pale.GetInputs())
newparam = pale.CreateInput('struct', Sdf.ValueTypeNames.Color3f)
# assure new item in collection
self.assertEqual(len(pale.GetInputs()), (oldlen + 1))
# ensure by-value capture in 'inputs'
self.assertNotEqual(len(pale.GetInputs()), len(inputs))
def test_Basic(self):
MaterialPath = Sdf.Path("/Material")
ShaderPath = Sdf.Path("/Material/Shader")
NodeGraphPath = Sdf.Path("/Material/NodeGraph")
NestedShaderPath = Sdf.Path("/Material/NodeGraph/NestedShader")
usdStage = Usd.Stage.CreateInMemory()
self.assertTrue(usdStage)
material = UsdShade.Material.Define(usdStage, MaterialPath)
self.assertTrue(material)
self.assertTrue(UsdShade.ConnectableAPI(material).IsContainer())
nodeGraph = UsdShade.NodeGraph.Define(usdStage, NodeGraphPath)
self.assertTrue(nodeGraph)
self.assertTrue(UsdShade.ConnectableAPI(nodeGraph).IsContainer())
self.assertTrue(UsdShade.ConnectableAPI(nodeGraph).IsNodeGraph())
shader = UsdShade.Shader.Define(usdStage, ShaderPath)
self.assertTrue(shader)
self.assertFalse(UsdShade.ConnectableAPI(shader).IsContainer())
self.assertTrue(UsdShade.ConnectableAPI(shader).IsShader())
nestedShader = UsdShade.Shader.Define(usdStage, NestedShaderPath)
self.assertTrue(nestedShader)
# Create all inputs and connections.
# Create a float interface input on the material.
matConnectable = material.ConnectableAPI()
floatInterfaceInput = matConnectable.CreateInput(
"floatInput", Sdf.ValueTypeNames.Float)
# default connectability of an interface-input is 'full'
self.assertEqual(floatInterfaceInput.GetConnectability(),
UsdShade.Tokens.full)
# inputs on a material are not connectable
xAttr = material.GetPrim().CreateAttribute("x",
Sdf.ValueTypeNames.Double,
True)
self._CanConnect(floatInterfaceInput, xAttr)
self.assertTrue(
floatInterfaceInput.SetConnectability(
UsdShade.Tokens.interfaceOnly))
self.assertEqual(floatInterfaceInput.GetConnectability(),
UsdShade.Tokens.interfaceOnly)
self.assertTrue(floatInterfaceInput.ClearConnectability())
self.assertEqual(floatInterfaceInput.GetConnectability(),
UsdShade.Tokens.full)
# Create a color valued interface input on the material.
colorInterfaceInput = material.CreateInput("colorInput",
Sdf.ValueTypeNames.Color3f)
self.assertEqual(colorInterfaceInput.GetConnectability(),
UsdShade.Tokens.full)
self.assertTrue(
colorInterfaceInput.SetConnectability(
UsdShade.Tokens.interfaceOnly))
colorMaterialOutput = material.CreateOutput("colorOutput",
Sdf.ValueTypeNames.Color3f)
# Create shader inputs.
shaderConnectable = shader.ConnectableAPI()
shaderInputFloat = shaderConnectable.CreateInput(
"shaderFloat", Sdf.ValueTypeNames.Float)
shaderInputColor = shader.CreateInput("shaderColor",
Sdf.ValueTypeNames.Color3f)
self.assertEqual(shaderInputFloat.GetConnectability(),
UsdShade.Tokens.full)
self.assertEqual(shaderInputColor.GetConnectability(),
UsdShade.Tokens.full)
# The shader inputs have full connectability by default and can be
# connected to any input or output.
self._CanConnect(shaderInputColor, colorInterfaceInput)
# Make the connection.
self.assertTrue(
shaderInputColor.ConnectToSource(
UsdShade.ConnectionSourceInfo(
material, colorInterfaceInput.GetBaseName(),
UsdShade.AttributeType.Input)))
self.assertEqual(shaderInputColor.GetAttr().GetConnections(),
[colorInterfaceInput.GetAttr().GetPath()])
self._CanConnect(shaderInputFloat, floatInterfaceInput)
self.assertTrue(shaderInputFloat.ConnectToSource(floatInterfaceInput))
self.assertEqual(shaderInputFloat.GetAttr().GetConnections(),
[floatInterfaceInput.GetAttr().GetPath()])
shaderOutputColor = shader.CreateOutput("color",
Sdf.ValueTypeNames.Color3f)
shaderOutputFloat = shader.CreateOutput("fOut",
Sdf.ValueTypeNames.Float)
nodeGraphInputFloat = nodeGraph.CreateInput("nodeGraphFlIn",
Sdf.ValueTypeNames.Float)
self.assertEqual(nodeGraphInputFloat.GetConnectability(),
UsdShade.Tokens.full)
# NodeGraph Input with "interfaceOnly" connectability cannot be
# connected to an output.
self.assertTrue(
nodeGraphInputFloat.SetConnectability(
UsdShade.Tokens.interfaceOnly))
self._CannotConnect(nodeGraphInputFloat, shaderOutputFloat)
# NodeGraph Input with full connectability can be connected to an output.
self.assertTrue(
nodeGraphInputFloat.SetConnectability(UsdShade.Tokens.full))
self._CanConnect(nodeGraphInputFloat, shaderOutputFloat)
self.assertTrue(
nodeGraphInputFloat.ConnectToSource(
UsdShade.ConnectionSourceInfo(shaderOutputFloat)))
nodeGraphInputColor = nodeGraph.CreateInput("nodeGraphColor",
Sdf.ValueTypeNames.Color3f)
self.assertTrue(
nodeGraphInputColor.SetConnectability(
UsdShade.Tokens.interfaceOnly))
# Can't connect an "interfaceOnly" input to an output on a shader or node-graph.
self._CannotConnect(nodeGraphInputColor, shaderOutputColor)
self._CannotConnect(nodeGraphInputColor, colorMaterialOutput)
# Can't connect an "interfaceOnly" input to a "full" input on a shader.
self._CannotConnect(nodeGraphInputColor, shaderInputColor)
# Change connectability of input on shader to "interfaceOnly" to allow the
# previously attempted connection.
self.assertTrue(
shaderInputColor.SetConnectability(UsdShade.Tokens.interfaceOnly))
self._CanConnect(nodeGraphInputColor, shaderInputColor)
self.assertTrue(
nodeGraphInputColor.SetConnectedSources(
[UsdShade.ConnectionSourceInfo(shaderInputColor)]))
# Change connectability of an interface input to full, to test connection
# from an "interfaceOnly" to a "full" input on a nodegraph.
self.assertTrue(
floatInterfaceInput.SetConnectability(UsdShade.Tokens.full))
self.assertEqual(floatInterfaceInput.GetConnectability(),
UsdShade.Tokens.full)
nestedShaderInputFloat = nestedShader.CreateInput(
"nestedShaderFloat", Sdf.ValueTypeNames.Float)
self.assertTrue(
nestedShaderInputFloat.SetConnectability(
UsdShade.Tokens.interfaceOnly))
self._CannotConnect(nestedShaderInputFloat, floatInterfaceInput)
# Change connectability of interface input to "interfaceOnly". This will
# allow the previously attempted connection.
self.assertTrue(
floatInterfaceInput.SetConnectability(
UsdShade.Tokens.interfaceOnly))
self._CanConnect(nestedShaderInputFloat, floatInterfaceInput)
self.assertTrue(
nestedShaderInputFloat.ConnectToSource(floatInterfaceInput))
# Test the ability to connect to multiple sources
floatInterfaceInput2 = matConnectable.CreateInput(
"floatInput2", Sdf.ValueTypeNames.Float)
self.assertTrue(
shaderInputFloat.ConnectToSource(
UsdShade.ConnectionSourceInfo(floatInterfaceInput2),
UsdShade.ConnectionModification.Append))
self.assertEqual(shaderInputFloat.GetAttr().GetConnections(), [
floatInterfaceInput.GetAttr().GetPath(),
floatInterfaceInput2.GetAttr().GetPath()
])
floatInterfaceInput3 = matConnectable.CreateInput(
"floatInput3", Sdf.ValueTypeNames.Float)
self.assertTrue(
shaderInputFloat.ConnectToSource(
UsdShade.ConnectionSourceInfo(floatInterfaceInput3),
UsdShade.ConnectionModification.Prepend))
self.assertEqual(shaderInputFloat.GetAttr().GetConnections(), [
floatInterfaceInput3.GetAttr().GetPath(),
floatInterfaceInput.GetAttr().GetPath(),
floatInterfaceInput2.GetAttr().GetPath()
])
sourceInfos, invalidPaths = shaderInputFloat.GetConnectedSources()
self.assertEqual(sourceInfos, [
UsdShade.ConnectionSourceInfo(floatInterfaceInput3),
UsdShade.ConnectionSourceInfo(floatInterfaceInput),
UsdShade.ConnectionSourceInfo(floatInterfaceInput2)
])
self.assertEqual(invalidPaths, [])
# Test the targeted disconnection of a single source
shaderInputFloat.DisconnectSource(floatInterfaceInput.GetAttr())
sourceInfos, invalidPaths = shaderInputFloat.GetConnectedSources()
self.assertEqual(sourceInfos, [
UsdShade.ConnectionSourceInfo(floatInterfaceInput3),
UsdShade.ConnectionSourceInfo(floatInterfaceInput2)
])
self.assertEqual(invalidPaths, [])
# Calling DisconnectSource without a specific source attribute will
# remove all remaining connections
shaderInputFloat.DisconnectSource()
sourceInfos, invalidPaths = shaderInputFloat.GetConnectedSources()
self.assertEqual(sourceInfos, [])
self.assertEqual(invalidPaths, [])
# Clear sources is another way to remove all connections
shaderInputColor.ClearSources()
sourceInfos, invalidPaths = shaderInputColor.GetConnectedSources()
self.assertEqual(sourceInfos, [])
self.assertEqual(invalidPaths, [])
