def _ValidateAllAttributes(self, usdPrim, exportedAttrsDict):
"""
Validates that USD attributes, primvars, and UsdRi attributes exist,
have the correct value, and have the correct type for each attribute
prefix in exportedAttrsDict.
"""
self.assertTrue(usdPrim)
gprim = UsdGeom.Gprim(usdPrim)
self.assertTrue(gprim)
# Do a quick check to see whether we have the right number of attributes
# by counting the primvars and UsdRi attributes.
# Getting all primvars will also include the built-in displayColor,
# displayOpacity, and st, so we add 3 to the length of the
# exportedAttrsDict for that check.
primvars = gprim.GetPrimvars()
self.assertEqual(len(primvars), len(exportedAttrsDict) + 3)
riStatements = UsdRi.Statements(usdPrim)
self.assertTrue(riStatements)
riAttrs = riStatements.GetRiAttributes()
self.assertEqual(len(riAttrs), len(exportedAttrsDict))
# UsdRi attributes store vector and point array data as just arrays of
# three doubles/floats.
riAttrMapping = {
Sdf.ValueTypeNames.Vector3dArray: Sdf.ValueTypeNames.Double3Array,
Sdf.ValueTypeNames.Vector3fArray: Sdf.ValueTypeNames.Float3Array,
Sdf.ValueTypeNames.Point3dArray: Sdf.ValueTypeNames.Double3Array,
Sdf.ValueTypeNames.Point3fArray: Sdf.ValueTypeNames.Float3Array
}
for attrPrefix in exportedAttrsDict:
# Test regular USD attributes.
usdAttr = usdPrim.GetAttribute('userProperties:%sUsdAttr' % attrPrefix)
value = exportedAttrsDict[attrPrefix]['value']
self.assertTrue(usdAttr)
self.assertEqual(usdAttr.GetTypeName(),
exportedAttrsDict[attrPrefix]['typeName'])
self.assertTrue(usdAttr.IsCustom())
self._assertAlmostEqualWithFallback(usdAttr.Get(), value)
# Test primvars.
primvar = gprim.GetPrimvar('%sPrimvar' % attrPrefix)
self.assertTrue(primvar)
self.assertTrue(UsdGeom.Primvar.IsPrimvar(primvar))
self._assertAlmostEqualWithFallback(primvar.Get(), value)
self.assertEqual(primvar.GetTypeName(), exportedAttrsDict[attrPrefix]['typeName'])
# Test UsdRi attributes.
riAttr = usdPrim.GetAttribute('ri:attributes:user:%sUsdRiAttr' % attrPrefix)
self.assertTrue(riAttr)
self.assertTrue(UsdRi.Statements.IsRiAttribute(riAttr))
self._assertAlmostEqualWithFallback(riAttr.Get(), value)
riAttrType = exportedAttrsDict[attrPrefix]['typeName']
riAttrType = riAttrMapping.get(riAttrType, riAttrType)
self.assertEqual(riAttr.GetTypeName(), riAttrType)
def _AssertDisplayColorEqual(self, prim, expectedColor):
# expectedColor should be given as a list, so turn it into the type we'd
# expect to get out of the displayColor attribute, namely a VtVec3fArray.
expectedColor = Vt.Vec3fArray(1, expectedColor)
gprim = UsdGeom.Gprim(prim)
self.assertTrue(gprim)
displayColorPrimvar = gprim.GetDisplayColorPrimvar()
self.assertTrue(displayColorPrimvar)
self.assertEqual(displayColorPrimvar.ComputeFlattened(), expectedColor)
def _SetDisplayColor(mesh, color):
from pxr import UsdGeom
# DisplayColor is actually an array. Here, we just author one color which
# applies to the whole mesh.
UsdGeom.Gprim(mesh).CreateDisplayColorAttr([color])
def testExportAttributeTypes(self):
"""
Tests that attributes tagged to be exported as different attribute types
(Usd attributes, primvars, UsdRi attributes) are exported correctly.
"""
stage = self._GetExportedStage()
prim = stage.GetPrimAtPath('/UserExportedAttributesTest/Geom/CubeTypedAttrs')
self.assertTrue(prim)
# Validate Usd attributes.
attrName = 'userProperties:myIntArrayAttr'
attr = prim.GetAttribute(attrName)
self.assertTrue(attr)
expectedValue = Vt.IntArray([99, 98, 97, 96, 95, 94, 93, 92, 91, 90])
self.assertEqual(attr.Get(), expectedValue)
self.assertEqual(attr.GetTypeName(), Sdf.ValueTypeNames.IntArray)
self.assertTrue(attr.IsCustom())
# Validate UsdRi attributes.
expectedRiAttrs = {
'ri:attributes:user:myIntRiAttr':
{'value': 42,
'typeName': Sdf.ValueTypeNames.Int},
'ri:attributes:user:myNamespace:myAttr':
{'value': 'UsdRi string',
'typeName': Sdf.ValueTypeNames.String},
'ri:attributes:user:myStringArrayRiAttr':
{'value': Vt.StringArray(['the', 'quick', 'brown', 'fox']),
'typeName': Sdf.ValueTypeNames.StringArray},
}
expectedRiAttrNames = set(expectedRiAttrs.keys())
riStatements = UsdRi.Statements(prim)
self.assertTrue(riStatements)
riAttrs = riStatements.GetRiAttributes()
self.assertEqual(len(riAttrs), 3)
riAttrNames = {attr.GetName() for attr in riAttrs}
self.assertEqual(riAttrNames, expectedRiAttrNames)
for riAttrName in expectedRiAttrs:
riAttr = prim.GetAttribute(riAttrName)
self.assertTrue(riAttr)
self.assertTrue(UsdRi.Statements.IsRiAttribute(riAttr))
self.assertEqual(riAttr.Get(), expectedRiAttrs[riAttrName]['value'])
self.assertEqual(riAttr.GetTypeName(), expectedRiAttrs[riAttrName]['typeName'])
# Validate primvars.
expectedPrimvars = {
'myConstantIntPrimvar':
{'value': 123,
'typeName': Sdf.ValueTypeNames.Int,
'interpolation': UsdGeom.Tokens.constant},
'myFaceVaryingIntPrimvar':
{'value': 999,
'typeName': Sdf.ValueTypeNames.Int,
'interpolation': UsdGeom.Tokens.faceVarying},
'myFloatArrayPrimvar':
{'value': Vt.FloatArray([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8]),
'typeName': Sdf.ValueTypeNames.FloatArray,
'interpolation': UsdGeom.Tokens.vertex},
'myStringPrimvar':
{'value': 'no interp string',
'typeName': Sdf.ValueTypeNames.String,
'interpolation': None},
'myUniformDoublePrimvar':
{'value': 3.140,
'typeName': Sdf.ValueTypeNames.Double,
'interpolation': UsdGeom.Tokens.uniform},
'myVertexStringPrimvar':
{'value': 'a vertex string',
'typeName': Sdf.ValueTypeNames.String,
'interpolation': UsdGeom.Tokens.vertex},
}
expectedPrimvarNames = set(expectedPrimvars.keys())
# Getting all primvars will also include the built-in displayColor,
# displayOpacity, and st.
expectedPrimvarNames.update(['displayColor', 'displayOpacity', 'st'])
gprim = UsdGeom.Gprim(prim)
self.assertTrue(gprim)
primvars = gprim.GetPrimvars()
self.assertEqual(len(primvars), 9)
primvarNames = {primvar.GetPrimvarName() for primvar in primvars}
self.assertEqual(primvarNames, expectedPrimvarNames)
for primvarName in expectedPrimvars:
primvar = gprim.GetPrimvar(primvarName)
self.assertTrue(primvar)
self.assertTrue(UsdGeom.Primvar.IsPrimvar(primvar))
self._assertAlmostEqualWithFallback(
primvar.Get(),
expectedPrimvars[primvarName]['value'])
self.assertEqual(primvar.GetTypeName(), expectedPrimvars[primvarName]['typeName'])
expectedInterpolation = expectedPrimvars[primvarName]['interpolation']
if expectedInterpolation is None:
self.assertFalse(primvar.HasAuthoredInterpolation())
else:
self.assertTrue(primvar.HasAuthoredInterpolation())
self.assertEqual(primvar.GetInterpolation(), expectedInterpolation)
def Main():
s = Usd.Stage.CreateInMemory()
# Setup a quad mesh
gprim = s.DefinePrim("/Model/Geom/Mesh", "Mesh")
gprim.GetAttribute("faceVertexCounts").Set([4])
gprim.GetAttribute("faceVertexIndices").Set([0, 1, 3, 2])
gprim.GetAttribute("points").Set([(-2, -2, -2), (2, -2, -2), (-2, -2, 2),
(2, -2, 2)])
UsdGeom.Gprim(gprim).CreatePrimvar(
"somePrimvar", Sdf.ValueTypeNames.Color3fArray,
UsdGeom.Tokens.constant).Set([1.0, 1.0, 1.0])
UsdGeom.Gprim(gprim).CreatePrimvar("map1", Sdf.ValueTypeNames.Float2Array,
UsdGeom.Tokens.faceVarying).Set(
[1.0, 1.0])
lookPrim = UsdShade.Look.Define(s, "/Model/Looks/Pbs")
lookPrim.Bind(gprim)
# Add a Hydra shader and surface relationship from the look to the shader
hydraShader = UsdHydra.Shader(
UsdShade.Shader.Define(s, "/Model/Looks/Pbs/PolPbs"))
hydraShader.CreateIdAttr("PolPbs_1")
hydraLook = UsdHydra.LookAPI(lookPrim)
hydraLook.CreateBxdfRel().SetTargets([hydraShader.GetPath()])
uv = UsdHydra.Primvar(
UsdShade.Shader.Define(s, "/Model/Looks/Pbs/UvPrimvar"))
attr = uv.CreateVarnameAttr("map1")
faceIndex = UsdHydra.Primvar(
UsdShade.Shader.Define(s, "/Model/Looks/Pbs/FaceIndexPrimvar"))
attr = uv.CreateVarnameAttr("ptexFaceIndex")
faceOffset = UsdHydra.Primvar(
UsdShade.Shader.Define(s, "/Model/Looks/Pbs/FaceOffsetPrimvar"))
attr = uv.CreateVarnameAttr("ptexFaceOffset")
tex = UsdHydra.UvTexture(
UsdShade.Shader.Define(s, "/Model/Looks/Pbs/UvTex"))
tex.CreateIdAttr("HwUvTexture_1")
tex.CreateWrapSAttr(UsdHydra.Tokens.clamp)
tex.CreateWrapTAttr(UsdHydra.Tokens.repeat)
tex.CreateMinFilterAttr(UsdHydra.Tokens.linearMipmapLinear)
tex.CreateMagFilterAttr(UsdHydra.Tokens.linear)
tex.CreateTextureMemoryAttr(100.0)
tex.CreateFilenameAttr("/foo/bar.jpg")
tex.CreateParameter("outputs:color", Sdf.ValueTypeNames.Color3f)
param = UsdShade.Parameter(tex.CreateUvAttr())
param.ConnectToSource(uv, "result", False)
texturePath = Sdf.AssetPath("/foo.tex")
ptex = UsdHydra.PtexTexture(
UsdShade.Shader.Define(s, "/Model/Looks/Pbs/Ptex"))
ptex.CreateIdAttr("HwPtexTexture_1")
ptex.CreateTextureMemoryAttr(100.0)
ptex.CreateFilenameAttr("/foo/bar.ptex")
ptex.CreateParameter("outputs:color", Sdf.ValueTypeNames.Color3f)
param = UsdShade.Parameter(ptex.CreateFaceIndexAttr())
param.ConnectToSource(faceIndex, "result", False)
param = UsdShade.Parameter(ptex.CreateFaceOffsetAttr())
param.ConnectToSource(faceOffset, "result", False)
#
hydraShader.CreateFilenameAttr(Sdf.AssetPath("PbsSurface.glslfx"))
#
param = hydraShader.CreateParameter("colorFromUv",
Sdf.ValueTypeNames.Color3f)
param.ConnectToSource(tex, "color", False)
#
param = hydraShader.CreateParameter("colorFromPtex1",
Sdf.ValueTypeNames.Color3f)
param.ConnectToSource(ptex, "color", False)
#
color = UsdHydra.Primvar(
UsdShade.Shader.Define(s, "/Model/Looks/Pbs/ColorPrimvar"))
attr = uv.CreateVarnameAttr("displayColor")
param = hydraShader.CreateParameter("colorFromPrimvar",
Sdf.ValueTypeNames.Color3f)
param.ConnectToSource(color, "result", False)
print hydraShader.GetConnectedPrimvar(param.GetAttr())
print hydraShader.IsConnectedToPrimvar(param.GetAttr())
print s.GetRootLayer().ExportToString()
