def test_InvalidPrimvar(self):
p = UsdGeom.Primvar()
# We can always call GetAttr, but it will return a null attribute
# if we don't have a prim.
self.assertEqual(p.GetAttr(), Usd.Attribute())
# This used to crash before the Primvar __getattribute__ method
# was overridden to test the validity of the underlying prim.
with self.assertRaises(RuntimeError):
p.BlockIndices()
# We can't even call GetName, because there is no attribute.
with self.assertRaises(RuntimeError):
p.BlockIndices()
# Now do some tests with a valid prim, but invalid attribute.
stage = Usd.Stage.CreateInMemory('myTest.usda')
gp = UsdGeom.Mesh.Define(stage, '/myMesh').GetPrim()
u1 = UsdGeom.Primvar(gp.GetAttribute('primvars:u1'))
# The attribute isn't valid, and the primvar isn't defined.
self.assertFalse(u1.GetAttr().IsValid())
self.assertFalse(u1.IsDefined())
# But we can still get back to the source primitive.
self.assertEqual(u1.GetAttr().GetPrim(), gp)
# And we can still access name information.
self.assertEqual(u1.GetName(), 'primvars:u1')
self.assertEqual(u1.GetBaseName(), 'u1')
# But attempting to access any real primvar information will raise
# a RuntimeError exception.
with self.assertRaises(RuntimeError):
u1.GetElementSize()
def test_PrimvarAPI(self):
# We'll put all our Primvar on a single mesh gprim
stage = Usd.Stage.CreateInMemory('myTest.usda')
gp = UsdGeom.Mesh.Define(stage, '/myMesh')
nPasses = 3
# Add three Primvars
u1 = gp.CreatePrimvar('u_1', Sdf.ValueTypeNames.FloatArray)
# Make sure it's OK to manually specify the classifier namespace
v1 = gp.CreatePrimvar('primvars:v_1', Sdf.ValueTypeNames.FloatArray)
_3dpmats = gp.CreatePrimvar('projMats',
Sdf.ValueTypeNames.Matrix4dArray,
"constant", nPasses)
# ensure we can't create a primvar that contains namespaces.
with self.assertRaises(Tf.ErrorException):
gp.CreatePrimvar('no:can:do', Sdf.ValueTypeNames.FloatArray)
self.assertEqual(len(gp.GetAuthoredPrimvars()), 3)
self.assertEqual(len(gp.GetPrimvars()), 5)
# Now add some random properties, and reverify
p = gp.GetPrim()
p.CreateRelationship("myBinding")
p.CreateAttribute("myColor", Sdf.ValueTypeNames.Color3f)
p.CreateAttribute("primvars:my:overly:namespaced:Color",
Sdf.ValueTypeNames.Color3f)
datas = gp.GetAuthoredPrimvars()
IsPrimvar = UsdGeom.Primvar.IsPrimvar
self.assertEqual(len(datas), 3)
self.assertTrue(IsPrimvar(datas[0]))
self.assertTrue(IsPrimvar(datas[1]))
# For variety, test the explicit Attribute extractor
self.assertTrue(IsPrimvar(datas[2].GetAttr()))
self.assertFalse(IsPrimvar(p.GetAttribute("myColor")))
# Here we're testing that the speculative constructor fails properly
self.assertFalse(IsPrimvar(UsdGeom.Primvar(p.GetAttribute("myColor"))))
# And here that the speculative constructor succeeds properly
self.assertTrue(
IsPrimvar(UsdGeom.Primvar(p.GetAttribute(v1.GetName()))))
# Some of the same tests, exercising the bool-type operator
# for UsdGeomPrimvar; Primvar provides the easiest way to get INvalid attrs!
self.assertTrue(datas[0])
self.assertTrue(datas[1])
self.assertTrue(datas[2])
self.assertFalse(UsdGeom.Primvar(p.GetAttribute("myColor")))
self.assertFalse(UsdGeom.Primvar(p.GetAttribute("myBinding")))
self.assertTrue(UsdGeom.Primvar(p.GetAttribute(v1.GetName())))
# Same classification test through GprimSchema API
self.assertTrue(gp.HasPrimvar('u_1'))
self.assertTrue(gp.HasPrimvar('v_1'))
self.assertTrue(gp.HasPrimvar('projMats'))
self.assertFalse(gp.HasPrimvar('myColor'))
self.assertFalse(gp.HasPrimvar('myBinding'))
# Test that the gpv's returned by GetPrimvars are REALLY valid,
# and that the UsdAttribute metadata wrappers work
self.assertEqual(datas[0].GetTypeName(),
Sdf.ValueTypeNames.Matrix4dArray)
self.assertEqual(datas[1].GetTypeName(), Sdf.ValueTypeNames.FloatArray)
self.assertEqual(datas[2].GetBaseName(), "v_1")
# Now we'll add some extra configuration and verify that the
# interrogative API works properly
self.assertEqual(u1.GetInterpolation(),
UsdGeom.Tokens.constant) # fallback
self.assertFalse(u1.HasAuthoredInterpolation())
self.assertFalse(u1.HasAuthoredElementSize())
self.assertTrue(u1.SetInterpolation(UsdGeom.Tokens.vertex))
self.assertTrue(u1.HasAuthoredInterpolation())
self.assertEqual(u1.GetInterpolation(), UsdGeom.Tokens.vertex)
self.assertFalse(v1.HasAuthoredInterpolation())
self.assertFalse(v1.HasAuthoredElementSize())
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.uniform))
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.varying))
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.constant))
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.faceVarying))
with self.assertRaises(Tf.ErrorException):
v1.SetInterpolation("frobosity")
# Should be the last good value set
self.assertEqual(v1.GetInterpolation(), "faceVarying")
self.assertTrue(_3dpmats.HasAuthoredInterpolation())
self.assertTrue(_3dpmats.HasAuthoredElementSize())
with self.assertRaises(Tf.ErrorException):
_3dpmats.SetElementSize(0)
# Failure to set shouldn't change the state...
self.assertTrue(_3dpmats.HasAuthoredElementSize())
self.assertTrue(_3dpmats.SetElementSize(nPasses))
self.assertTrue(_3dpmats.HasAuthoredElementSize())
# Make sure value Get/Set work
self.assertEqual(u1.Get(), None)
self.assertFalse(u1.IsIndexed())
self.assertEqual(u1.ComputeFlattened(), None)
uVal = Vt.FloatArray([1.1, 2.1, 3.1])
self.assertTrue(u1.Set(uVal))
self.assertEqual(u1.Get(), uVal)
# Make sure indexed primvars work
self.assertFalse(u1.IsIndexed())
indices = Vt.IntArray([0, 1, 2, 2, 1, 0])
self.assertTrue(u1.SetIndices(indices))
self.assertTrue(u1.IsIndexed())
self.assertEqual(u1.GetIndices(), indices)
for a, b in zip(u1.ComputeFlattened(), [1.1, 2.1, 3.1, 3.1, 2.1, 1.1]):
self.assertTrue(Gf.IsClose(a, b, 1e-5))
self.assertNotEqual(u1.ComputeFlattened(), u1.Get())
self.assertEqual(u1.GetUnauthoredValuesIndex(), -1)
self.assertTrue(u1.SetUnauthoredValuesIndex(2))
self.assertEqual(u1.GetUnauthoredValuesIndex(), 2)
self.assertEqual(u1.GetTimeSamples(), [])
self.assertFalse(u1.ValueMightBeTimeVarying())
indicesAt1 = Vt.IntArray([1, 2, 0])
indicesAt2 = Vt.IntArray([])
self.assertTrue(u1.SetIndices(indicesAt1, 1.0))
self.assertEqual(u1.GetIndices(1.0), indicesAt1)
uValAt1 = Vt.FloatArray([2.1, 3.1, 4.1])
self.assertTrue(u1.Set(uValAt1, 1.0))
self.assertEqual(u1.Get(1.0), uValAt1)
self.assertEqual(u1.GetTimeSamples(), [1.0])
self.assertFalse(u1.ValueMightBeTimeVarying())
self.assertTrue(u1.SetIndices(indicesAt2, 2.0))
self.assertEqual(u1.GetIndices(2.0), indicesAt2)
uValAt2 = Vt.FloatArray([3.1, 4.1, 5.1])
self.assertTrue(u1.Set(uValAt2, 2.0))
self.assertEqual(u1.Get(2.0), uValAt2)
self.assertEqual(u1.GetTimeSamples(), [1.0, 2.0])
self.assertEqual(u1.GetTimeSamplesInInterval(Gf.Interval(0.5, 1.5)),
[1.0])
self.assertTrue(u1.ValueMightBeTimeVarying())
for a, b in zip(u1.ComputeFlattened(1.0), [3.1, 4.1, 2.1]):
self.assertTrue(Gf.IsClose(a, b, 1e-5))
self.assertNotEqual(u1.ComputeFlattened(1.0), u1.Get(1.0))
self.assertTrue(len(u1.ComputeFlattened(2.0)) == 0)
self.assertNotEqual(u1.ComputeFlattened(2.0), u1.Get(2.0))
# Ensure that primvars with indices only authored at timeSamples
# (i.e. no default) are recognized as such. Manual name-munging
# necessitated by UsdGeomPrimvar's lack of API for accessing
# the indices attribute directly!
u1Indices = p.GetAttribute(u1.GetName() + ":indices")
self.assertTrue(u1Indices)
u1Indices.ClearDefault()
self.assertTrue(u1.IsIndexed())
# Finally, ensure the values returned by GetDeclarationInfo
# (on new Primvar objects, to test the GprimSchema API)
# is identical to the individual queries, and matches what we set above
nu1 = gp.GetPrimvar("u_1")
(name, typeName, interpolation, elementSize) = nu1.GetDeclarationInfo()
self.assertEqual(name, u1.GetBaseName())
self.assertEqual(typeName, u1.GetTypeName())
self.assertEqual(interpolation, u1.GetInterpolation())
self.assertEqual(elementSize, u1.GetElementSize())
self.assertEqual(name, "u_1")
self.assertEqual(typeName, Sdf.ValueTypeNames.FloatArray)
self.assertEqual(interpolation, UsdGeom.Tokens.vertex)
self.assertEqual(elementSize, 1)
nv1 = gp.GetPrimvar("v_1")
(name, typeName, interpolation, elementSize) = nv1.GetDeclarationInfo()
self.assertEqual(name, v1.GetBaseName())
self.assertEqual(typeName, v1.GetTypeName())
self.assertEqual(interpolation, v1.GetInterpolation())
self.assertEqual(elementSize, v1.GetElementSize())
self.assertEqual(name, "v_1")
self.assertEqual(typeName, Sdf.ValueTypeNames.FloatArray)
self.assertEqual(interpolation, UsdGeom.Tokens.faceVarying)
self.assertEqual(elementSize, 1)
nmats = gp.GetPrimvar('projMats')
(name, typeName, interpolation,
elementSize) = nmats.GetDeclarationInfo()
self.assertEqual(name, _3dpmats.GetBaseName())
self.assertEqual(typeName, _3dpmats.GetTypeName())
self.assertEqual(interpolation, _3dpmats.GetInterpolation())
self.assertEqual(elementSize, _3dpmats.GetElementSize())
self.assertEqual(name, 'projMats')
self.assertEqual(typeName, Sdf.ValueTypeNames.Matrix4dArray)
self.assertEqual(interpolation, UsdGeom.Tokens.constant)
self.assertEqual(elementSize, nPasses)
# Id primvar
notId = gp.CreatePrimvar('notId', Sdf.ValueTypeNames.FloatArray)
self.assertFalse(notId.IsIdTarget())
with self.assertRaises(Tf.ErrorException):
notId.SetIdTarget(gp.GetPath())
handleid = gp.CreatePrimvar('handleid', Sdf.ValueTypeNames.String)
# make sure we can still just set a string
v = "handleid_value"
self.assertTrue(handleid.Set(v))
self.assertEqual(handleid.Get(), v)
self.assertEqual(handleid.ComputeFlattened(), v)
numPrimvars = len(gp.GetPrimvars())
# This check below ensures that the "indices" attributes belonging to
# indexed primvars aren't considered to be primvars themselves.
self.assertEqual(numPrimvars, 7)
self.assertTrue(handleid.SetIdTarget(gp.GetPath()))
# make sure we didn't increase the number of primvars (also that
# GetPrimvars doesn't break when we have relationships)
self.assertEqual(len(gp.GetPrimvars()), numPrimvars)
self.assertEqual(handleid.Get(), gp.GetPath())
stringPath = '/my/string/path'
self.assertTrue(handleid.SetIdTarget(stringPath))
self.assertEqual(handleid.Get(), Sdf.Path(stringPath))
p = Sdf.Path('/does/not/exist')
self.assertTrue(handleid.SetIdTarget(p))
self.assertEqual(handleid.Get(), p)
handleid_array = gp.CreatePrimvar('handleid_array',
Sdf.ValueTypeNames.StringArray)
self.assertTrue(handleid_array.SetIdTarget(gp.GetPath()))
def test_PrimvarsAPI(self):
IsPrimvar = UsdGeom.Primvar.IsPrimvar
# We'll put all our Primvar on a single mesh gprim
stage = Usd.Stage.CreateInMemory('myTest.usda')
gp = UsdGeom.Mesh.Define(stage, '/myMesh')
gp_pv = UsdGeom.PrimvarsAPI(gp)
nPasses = 3
# Add three Primvars
u1 = gp_pv.CreatePrimvar('u_1', Sdf.ValueTypeNames.FloatArray)
self.assertFalse(u1.NameContainsNamespaces())
self.assertEqual(UsdGeom.Primvar.StripPrimvarsName(u1.GetName()),
"u_1")
# Make sure it's OK to manually specify the classifier namespace
v1 = gp_pv.CreatePrimvar('primvars:v_1', Sdf.ValueTypeNames.FloatArray)
self.assertEqual(UsdGeom.Primvar.StripPrimvarsName(v1.GetName()),
"v_1")
noPrimvarsPrefixName = "noPrimvarPrefixName"
self.assertEqual(
UsdGeom.Primvar.StripPrimvarsName(noPrimvarsPrefixName),
noPrimvarsPrefixName)
self.assertFalse(v1.NameContainsNamespaces())
_3dpmats = gp_pv.CreatePrimvar('projMats',
Sdf.ValueTypeNames.Matrix4dArray,
"constant", nPasses)
# ensure we can create a primvar that contains namespaces!
primvarName = 'skel:jointWeights'
jointWeights = gp_pv.CreatePrimvar(primvarName,
Sdf.ValueTypeNames.FloatArray)
self.assertTrue(IsPrimvar(jointWeights))
self.assertTrue(
UsdGeom.Primvar.IsValidPrimvarName(jointWeights.GetName()))
self.assertTrue(jointWeights.NameContainsNamespaces())
self.assertEqual(primvarName, jointWeights.GetPrimvarName())
# Ensure we cannot create a primvar named indices or any namespace
# ending in indices
with self.assertRaises(Tf.ErrorException):
gp_pv.CreatePrimvar("indices", Sdf.ValueTypeNames.IntArray)
with self.assertRaises(Tf.ErrorException):
gp_pv.CreatePrimvar("multi:aggregate:indices",
Sdf.ValueTypeNames.IntArray)
self.assertEqual(len(gp_pv.GetAuthoredPrimvars()), 4)
# displayColor and displayOpacity are builtins, not authored
self.assertEqual(len(gp_pv.GetPrimvars()), 6)
# Now add some random properties, plus a "manually" created, namespaced
# primvar, and reverify
p = gp.GetPrim()
p.CreateRelationship("myBinding")
p.CreateAttribute("myColor", Sdf.ValueTypeNames.Color3f)
p.CreateAttribute("primvars:some:overly:namespaced:Color",
Sdf.ValueTypeNames.Color3f)
datas = gp_pv.GetAuthoredPrimvars()
self.assertEqual(len(datas), 5)
self.assertTrue(IsPrimvar(datas[0]))
self.assertTrue(UsdGeom.Primvar.IsValidPrimvarName(datas[0].GetName()))
self.assertTrue(
UsdGeom.Primvar.IsPrimvarRelatedPropertyName(datas[0].GetName()))
self.assertTrue(IsPrimvar(datas[1]))
self.assertTrue(UsdGeom.Primvar.IsValidPrimvarName(datas[1].GetName()))
self.assertTrue(
UsdGeom.Primvar.IsPrimvarRelatedPropertyName(datas[1].GetName()))
# For variety, test the explicit Attribute extractor
self.assertTrue(IsPrimvar(datas[2].GetAttr()))
self.assertTrue(
UsdGeom.Primvar.IsValidPrimvarName(datas[2].GetAttr().GetName()))
self.assertTrue(
UsdGeom.Primvar.IsPrimvarRelatedPropertyName(
datas[2].GetAttr().GetName()))
self.assertFalse(IsPrimvar(p.GetAttribute("myColor")))
self.assertFalse(UsdGeom.Primvar.IsValidPrimvarName("myColor"))
self.assertFalse(
UsdGeom.Primvar.IsPrimvarRelatedPropertyName("myColor"))
# Here we're testing that the speculative constructor fails properly
self.assertFalse(IsPrimvar(UsdGeom.Primvar(p.GetAttribute("myColor"))))
self.assertFalse(
UsdGeom.Primvar.IsValidPrimvarName(
datas[0].GetIndicesAttr().GetName()))
self.assertTrue(
UsdGeom.Primvar.IsPrimvarRelatedPropertyName(
datas[0].GetIndicesAttr().GetName()))
# And here that the speculative constructor succeeds properly
self.assertTrue(
IsPrimvar(UsdGeom.Primvar(p.GetAttribute(v1.GetName()))))
# Some of the same tests, exercising the bool-type operator
# for UsdGeomPrimvar; Primvar provides the easiest way to get INvalid attrs!
self.assertTrue(datas[0])
self.assertTrue(datas[1])
self.assertTrue(datas[2])
self.assertFalse(UsdGeom.Primvar(p.GetAttribute("myColor")))
self.assertFalse(UsdGeom.Primvar(p.GetAttribute("myBinding")))
self.assertTrue(UsdGeom.Primvar(p.GetAttribute(v1.GetName())))
# Same classification test through GprimSchema API
self.assertTrue(gp_pv.HasPrimvar('u_1'))
self.assertTrue(gp_pv.HasPrimvar('v_1'))
self.assertTrue(gp_pv.HasPrimvar('projMats'))
self.assertTrue(gp_pv.HasPrimvar('skel:jointWeights'))
self.assertFalse(gp_pv.HasPrimvar('myColor'))
self.assertFalse(gp_pv.HasPrimvar('myBinding'))
# Test that the gpv's returned by GetPrimvars are REALLY valid,
# and that the UsdAttribute metadata wrappers work
self.assertEqual(datas[0].GetTypeName(),
Sdf.ValueTypeNames.Matrix4dArray)
self.assertEqual(datas[3].GetTypeName(), Sdf.ValueTypeNames.FloatArray)
self.assertEqual(datas[4].GetBaseName(), "v_1")
# Now we'll add some extra configuration and verify that the
# interrogative API works properly
self.assertEqual(u1.GetInterpolation(),
UsdGeom.Tokens.constant) # fallback
self.assertFalse(u1.HasAuthoredInterpolation())
self.assertFalse(u1.HasAuthoredElementSize())
self.assertTrue(u1.SetInterpolation(UsdGeom.Tokens.vertex))
self.assertTrue(u1.HasAuthoredInterpolation())
self.assertEqual(u1.GetInterpolation(), UsdGeom.Tokens.vertex)
self.assertFalse(v1.HasAuthoredInterpolation())
self.assertFalse(v1.HasAuthoredElementSize())
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.uniform))
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.varying))
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.constant))
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.faceVarying))
with self.assertRaises(Tf.ErrorException):
v1.SetInterpolation("frobosity")
# Should be the last good value set
self.assertEqual(v1.GetInterpolation(), "faceVarying")
self.assertTrue(_3dpmats.HasAuthoredInterpolation())
self.assertTrue(_3dpmats.HasAuthoredElementSize())
with self.assertRaises(Tf.ErrorException):
_3dpmats.SetElementSize(0)
# Failure to set shouldn't change the state...
self.assertTrue(_3dpmats.HasAuthoredElementSize())
self.assertTrue(_3dpmats.SetElementSize(nPasses))
self.assertTrue(_3dpmats.HasAuthoredElementSize())
# Make sure value Get/Set work
self.assertEqual(u1.Get(), None)
self.assertFalse(u1.IsIndexed())
self.assertFalse(u1.GetIndicesAttr())
self.assertEqual(u1.ComputeFlattened(), None)
uVal = Vt.FloatArray([1.1, 2.1, 3.1])
self.assertTrue(u1.Set(uVal))
self.assertEqual(u1.Get(), uVal)
# Make sure indexed primvars work
self.assertFalse(u1.IsIndexed())
indices = Vt.IntArray([0, 1, 2, 2, 1, 0])
self.assertTrue(u1.SetIndices(indices))
self.assertTrue(u1.IsIndexed())
self.assertTrue(u1.GetIndicesAttr())
self.assertEqual(u1.GetIndices(), indices)
for a, b in zip(u1.ComputeFlattened(), [1.1, 2.1, 3.1, 3.1, 2.1, 1.1]):
self.assertTrue(Gf.IsClose(a, b, 1e-5))
self.assertNotEqual(u1.ComputeFlattened(), u1.Get())
indicesWithInvalid = Vt.IntArray([0, 3, 2, 2, -1, 0])
self.assertTrue(u1.SetIndices(indicesWithInvalid))
self.assertTrue(u1.ComputeFlattened() is None)
indicesWithInvalid = Vt.IntArray([4, 5, 6, 7, -1, 8])
self.assertTrue(u1.SetIndices(indicesWithInvalid))
self.assertTrue(u1.ComputeFlattened() is None)
self.assertEqual(u1.GetUnauthoredValuesIndex(), -1)
self.assertTrue(u1.SetUnauthoredValuesIndex(2))
self.assertEqual(u1.GetUnauthoredValuesIndex(), 2)
self.assertEqual(u1.GetTimeSamples(), [])
self.assertFalse(u1.ValueMightBeTimeVarying())
indicesAt1 = Vt.IntArray([1, 2, 0])
indicesAt2 = Vt.IntArray([])
uValAt1 = Vt.FloatArray([2.1, 3.1, 4.1])
uValAt2 = Vt.FloatArray([3.1, 4.1, 5.1])
self.assertTrue(u1.SetIndices(indicesAt1, 1.0))
self.assertEqual(u1.GetIndices(1.0), indicesAt1)
self.assertTrue(u1.Set(uValAt1, 1.0))
self.assertEqual(u1.Get(1.0), uValAt1)
self.assertEqual(u1.GetTimeSamples(), [1.0])
self.assertFalse(u1.ValueMightBeTimeVarying())
self.assertTrue(u1.SetIndices(indicesAt2, 2.0))
self.assertEqual(u1.GetIndices(2.0), indicesAt2)
self.assertTrue(u1.Set(uValAt2, 2.0))
self.assertEqual(u1.Get(2.0), uValAt2)
self.assertEqual(u1.GetTimeSamples(), [1.0, 2.0])
self.assertEqual(u1.GetTimeSamplesInInterval(Gf.Interval(0.5, 1.5)),
[1.0])
self.assertTrue(u1.ValueMightBeTimeVarying())
# Add more time-samples to u1
indicesAt0 = Vt.IntArray([])
uValAt3 = Vt.FloatArray([4.1, 5.1, 6.1])
self.assertTrue(u1.SetIndices(indicesAt0, 0.0))
self.assertEqual(u1.GetTimeSamples(), [0.0, 1.0, 2.0])
self.assertTrue(u1.Set(uValAt3, 3.0))
self.assertEqual(u1.GetTimeSamples(), [0.0, 1.0, 2.0, 3.0])
self.assertEqual(u1.GetTimeSamplesInInterval(Gf.Interval(1.5, 3.5)),
[2.0, 3.0])
for a, b in zip(u1.ComputeFlattened(1.0), [3.1, 4.1, 2.1]):
self.assertTrue(Gf.IsClose(a, b, 1e-5))
self.assertNotEqual(u1.ComputeFlattened(1.0), u1.Get(1.0))
self.assertTrue(len(u1.ComputeFlattened(2.0)) == 0)
self.assertNotEqual(u1.ComputeFlattened(2.0), u1.Get(2.0))
# Ensure that primvars with indices only authored at timeSamples
# (i.e. no default) are recognized as such.
u1Indices = u1.GetIndicesAttr()
self.assertTrue(u1Indices)
u1Indices.ClearDefault()
self.assertTrue(u1.IsIndexed())
# Finally, ensure the values returned by GetDeclarationInfo
# (on new Primvar objects, to test the GprimSchema API)
# is identical to the individual queries, and matches what we set above
nu1 = gp_pv.GetPrimvar("u_1")
(name, typeName, interpolation, elementSize) = nu1.GetDeclarationInfo()
self.assertEqual(name, u1.GetBaseName())
self.assertEqual(typeName, u1.GetTypeName())
self.assertEqual(interpolation, u1.GetInterpolation())
self.assertEqual(elementSize, u1.GetElementSize())
self.assertEqual(name, "u_1")
self.assertEqual(typeName, Sdf.ValueTypeNames.FloatArray)
self.assertEqual(interpolation, UsdGeom.Tokens.vertex)
self.assertEqual(elementSize, 1)
nv1 = gp_pv.GetPrimvar("v_1")
(name, typeName, interpolation, elementSize) = nv1.GetDeclarationInfo()
self.assertEqual(name, v1.GetBaseName())
self.assertEqual(typeName, v1.GetTypeName())
self.assertEqual(interpolation, v1.GetInterpolation())
self.assertEqual(elementSize, v1.GetElementSize())
self.assertEqual(name, "v_1")
self.assertEqual(typeName, Sdf.ValueTypeNames.FloatArray)
self.assertEqual(interpolation, UsdGeom.Tokens.faceVarying)
self.assertEqual(elementSize, 1)
nmats = gp_pv.GetPrimvar('projMats')
(name, typeName, interpolation,
elementSize) = nmats.GetDeclarationInfo()
self.assertEqual(name, _3dpmats.GetBaseName())
self.assertEqual(typeName, _3dpmats.GetTypeName())
self.assertEqual(interpolation, _3dpmats.GetInterpolation())
self.assertEqual(elementSize, _3dpmats.GetElementSize())
self.assertEqual(name, 'projMats')
self.assertEqual(typeName, Sdf.ValueTypeNames.Matrix4dArray)
self.assertEqual(interpolation, UsdGeom.Tokens.constant)
self.assertEqual(elementSize, nPasses)
# Custom builtins for gprim display primvars
displayColor = gp.CreateDisplayColorPrimvar(UsdGeom.Tokens.vertex, 3)
self.assertTrue(displayColor)
declInfo = displayColor.GetDeclarationInfo()
self.assertEqual(declInfo,
('displayColor', Sdf.ValueTypeNames.Color3fArray,
UsdGeom.Tokens.vertex, 3))
displayOpacity = gp.CreateDisplayOpacityPrimvar(
UsdGeom.Tokens.constant)
self.assertTrue(displayOpacity)
declInfo = displayOpacity.GetDeclarationInfo()
self.assertEqual(declInfo,
('displayOpacity', Sdf.ValueTypeNames.FloatArray,
UsdGeom.Tokens.constant, 1))
# Id primvar
notId = gp_pv.CreatePrimvar('notId', Sdf.ValueTypeNames.FloatArray)
self.assertFalse(notId.IsIdTarget())
with self.assertRaises(Tf.ErrorException):
notId.SetIdTarget(gp.GetPath())
handleid = gp_pv.CreatePrimvar('handleid', Sdf.ValueTypeNames.String)
# make sure we can still just set a string
v = "handleid_value"
self.assertTrue(handleid.Set(v))
self.assertEqual(handleid.Get(), v)
self.assertEqual(handleid.ComputeFlattened(), v)
numPrimvars = len(gp_pv.GetPrimvars())
# This check below ensures that the "indices" attributes belonging to
# indexed primvars aren't considered to be primvars themselves.
self.assertEqual(numPrimvars, 9)
self.assertTrue(handleid.SetIdTarget(gp.GetPath()))
# make sure we didn't increase the number of primvars (also that
# GetPrimvars doesn't break when we have relationships)
self.assertEqual(len(gp_pv.GetPrimvars()), numPrimvars)
self.assertEqual(handleid.Get(), gp.GetPath())
stringPath = '/my/string/path'
self.assertTrue(handleid.SetIdTarget(stringPath))
self.assertEqual(handleid.Get(), Sdf.Path(stringPath))
p = Sdf.Path('/does/not/exist')
self.assertTrue(handleid.SetIdTarget(p))
self.assertEqual(handleid.Get(), p)
handleid_array = gp_pv.CreatePrimvar('handleid_array',
Sdf.ValueTypeNames.StringArray)
self.assertTrue(handleid_array.SetIdTarget(gp.GetPath()))
# Test BlockPrimvar API
pv_blocking = gp_pv.CreatePrimvar('pvb', Sdf.ValueTypeNames.FloatArray)
pvName = pv_blocking.GetName()
pv_blocking.SetInterpolation(UsdGeom.Tokens.vertex)
pv_val = Vt.FloatArray([1.1, 2.1, 3.1])
pv_blocking.Set(pv_val)
# Block a non-indexed primvar should also construct and block indices attr
self.assertFalse(pv_blocking.IsIndexed())
self.assertTrue(pv_blocking.HasAuthoredValue())
self.assertTrue(pv_blocking.HasAuthoredInterpolation())
gp_pv.BlockPrimvar(pvName)
self.assertFalse(pv_blocking.HasAuthoredValue())
self.assertTrue(pv_blocking.HasAuthoredInterpolation())
self.assertFalse(pv_blocking.IsIndexed())
self.assertTrue(
pv_blocking.GetIndicesAttr().GetResolveInfo().ValueIsBlocked())
# re-set pv_blocking
pv_blocking.Set(pv_val)
pv_indices = Vt.IntArray([0, 1, 2, 2, 1, 0])
pv_blocking.SetIndices(pv_indices)
self.assertTrue(pv_blocking.HasAuthoredValue())
self.assertTrue(pv_blocking.HasAuthoredInterpolation())
self.assertTrue(pv_blocking.IsIndexed())
# Block primvar as well as indices Attr
gp_pv.BlockPrimvar(pvName)
self.assertFalse(pv_blocking.HasAuthoredValue())
self.assertTrue(pv_blocking.HasAuthoredInterpolation())
self.assertFalse(pv_blocking.IsIndexed())
# re-set pv_blocking for further testing
pv_blocking.Set(pv_val)
pv_indices = Vt.IntArray([0, 1, 2, 2, 1, 0])
pv_blocking.SetIndices(pv_indices)
# test BlockPrimvar on a referenced prim
weakLayer = Sdf.Layer.CreateAnonymous()
stageWeak = Usd.Stage.Open(weakLayer)
ovrMesh = stageWeak.OverridePrim('/myMesh')
ovrMesh.GetReferences().AddReference(stage.GetRootLayer().identifier,
'/myMesh')
gp_pv_ovr = UsdGeom.PrimvarsAPI(ovrMesh)
pv_blocking_ovr = gp_pv_ovr.GetPrimvar(pvName)
self.assertTrue(pv_blocking_ovr.HasAuthoredValue())
self.assertTrue(pv_blocking_ovr.HasAuthoredInterpolation())
self.assertTrue(pv_blocking_ovr.IsIndexed())
# should only block primvar and indices attr in the referenced prim
gp_pv_ovr.BlockPrimvar(pvName)
# ovr primvar will be blocked!
self.assertFalse(pv_blocking_ovr.HasAuthoredValue())
self.assertTrue(pv_blocking_ovr.HasAuthoredInterpolation())
self.assertFalse(pv_blocking_ovr.IsIndexed())
# stronger layer wont get affected and original prim should not be blocked
self.assertTrue(pv_blocking.HasAuthoredValue())
self.assertTrue(pv_blocking.HasAuthoredInterpolation())
self.assertTrue(pv_blocking.IsIndexed())
# Remove a few valid primvar names
# without namespace
p = gp.GetPrim()
self.assertTrue(u1.IsIndexed())
u1Name = u1.GetName()
u1IndicesAttrName = u1.GetIndicesAttr().GetName()
# can not remove a primvar across a reference arc
weakLayer = Sdf.Layer.CreateAnonymous()
stageWeak = Usd.Stage.Open(weakLayer)
ovrMesh = stageWeak.OverridePrim('/myMesh')
ovrMesh.GetReferences().AddReference(stage.GetRootLayer().identifier,
'/myMesh')
gp_pv_ovr = UsdGeom.PrimvarsAPI(ovrMesh)
self.assertTrue(gp_pv_ovr.HasPrimvar(u1Name))
self.assertFalse(gp_pv_ovr.RemovePrimvar(u1Name))
self.assertTrue(gp_pv_ovr.GetPrim().HasAttribute(u1Name))
# remove indexed primvar
self.assertTrue(gp_pv.RemovePrimvar(u1Name))
self.assertFalse(p.HasAttribute(u1Name))
self.assertFalse(p.HasAttribute(u1IndicesAttrName))
# with primvars namespace
v1Name = v1.GetName()
self.assertTrue(gp_pv.RemovePrimvar(v1Name))
self.assertFalse(p.HasAttribute(v1Name))
# primvar does not exists
self.assertFalse(gp_pv.RemovePrimvar('does_not_exist'))
self.assertFalse(gp_pv.RemovePrimvar('does_not_exist:does_not_exist'))
# try to remove an invalid primvar with restricted tokens, "indices"
with self.assertRaises(Tf.ErrorException):
gp_pv.RemovePrimvar('indices')
with self.assertRaises(Tf.ErrorException):
gp_pv.RemovePrimvar('multi:aggregate:indices')
# create Indices primvar using CreateIndexedPrimvar API
uVal = Vt.FloatArray([1.1, 2.1, 3.1])
indices = Vt.IntArray([0, 1, 2, 2, 1, 0])
indexedPrimvar = gp_pv.CreateIndexedPrimvar(
'indexedPrimvar', Sdf.ValueTypeNames.FloatArray, uVal, indices,
UsdGeom.Tokens.vertex)
self.assertTrue(indexedPrimvar.IsIndexed())
self.assertTrue(indexedPrimvar.HasAuthoredValue())
self.assertTrue(indexedPrimvar.HasAuthoredInterpolation())
# mimic a Pixar production workflow of creating primvars
# 1. show usage with CreatePrimvar
# 2. show usage with CreateNonIndexedPrimvar
# - create a primvar in base layer
# - override this primvar in a stronger layer
# - update primvar in base layer to use indices
# - test if primvar has indices blocked in strong layer or not!
# Create primvar in base layer using CreatePrimvar api and set value
basePrimvar1 = gp_pv.CreatePrimvar('pv1',
Sdf.ValueTypeNames.FloatArray)
basePrimvar1.Set(uVal)
# Create primvar in base layer using CreatePrimvar api and set value
basePrimvar2 = gp_pv.CreatePrimvar('pv2',
Sdf.ValueTypeNames.FloatArray)
basePrimvar2.Set(uVal)
# stronger layer
strongLayer = Sdf.Layer.CreateAnonymous()
strongStage = Usd.Stage.Open(strongLayer)
# over Mesh prim and add reference
oMesh = strongStage.OverridePrim('/myMesh')
oMesh.GetReferences().AddReference(stage.GetRootLayer().identifier,
'/myMesh')
# over primvarsApi instance
gp_pv_ovr = UsdGeom.PrimvarsAPI(oMesh)
# override value for primvar
oVal = Vt.FloatArray([2.2, 3.2, 4.2])
# override pv1 using CreatePrimvar api
oBasePrimvar1 = gp_pv_ovr.CreatePrimvar('pv1',
Sdf.ValueTypeNames.FloatArray)
oBasePrimvar1.Set(oVal)
# override pv2 using CreateNonIndexedPrimvar api
oBasePrimvar2 = gp_pv_ovr.CreateNonIndexedPrimvar(
'pv2', Sdf.ValueTypeNames.FloatArray, oVal)
# test indices attr missing on oBasePrimvar1
self.assertFalse(oBasePrimvar1.GetIndicesAttr().IsValid())
# test oBasePrimvar2's indices attribute has a block authored
self.assertFalse(oBasePrimvar2.IsIndexed())
self.assertTrue(
oBasePrimvar2.GetIndicesAttr().GetResolveInfo().ValueIsBlocked())
# update base (weaker) layer primvars to have an indices
basePrimvar1.SetIndices(indices)
basePrimvar2.SetIndices(indices)
# ovr pv1 should now get indices
self.assertTrue(oBasePrimvar1.IsIndexed())
# ovr pv2 should still have the block for indices
self.assertFalse(oBasePrimvar2.IsIndexed())
self.assertTrue(
oBasePrimvar2.GetIndicesAttr().GetResolveInfo().ValueIsBlocked())
