def _GetEditTargets(self, prim):
primIndex = prim.GetPrimIndex()
rootNode = primIndex.rootNode
refNode = rootNode.children[0]
rootLayer = Sdf.Find('timeCodes/root.usda')
rootSubLayer = Sdf.Find('timeCodes/root_sub.usda')
refLayer = Sdf.Find('timeCodes/ref.usda')
refSubLayer = Sdf.Find('timeCodes/ref_sub.usda')
self.assertTrue(rootLayer)
self.assertTrue(rootSubLayer)
self.assertTrue(refLayer)
self.assertTrue(refSubLayer)
# No mapping
rootEditTarget = Usd.EditTarget(rootLayer)
# Composed layer offset: scale = 0.5
rootSubEditTarget = Usd.EditTarget(rootSubLayer, rootNode)
# Composed layer offset: scale = 2, offset = -3.0
refEditTarget = Usd.EditTarget(refLayer, refNode)
# Composed layer offset: scale = 2, offset = +3.0
refSubEditTarget = Usd.EditTarget(refSubLayer, refNode)
self.assertEqual(rootEditTarget.GetLayer(), rootLayer)
self.assertEqual(rootSubEditTarget.GetLayer(), rootSubLayer)
self.assertEqual(refEditTarget.GetLayer(), refLayer)
self.assertEqual(refSubEditTarget.GetLayer(), refSubLayer)
# Edit targets returned as a tuple with the layers from strongest to
# weakest.
return (rootEditTarget, rootSubEditTarget, refEditTarget,
refSubEditTarget)
def _GetEditTargets(self, prim):
primIndex = prim.GetPrimIndex()
rootNode = primIndex.rootNode
refNode = rootNode.children[0]
rootLayer = Sdf.Find('timeCodes/root.usda')
rootSubLayer = Sdf.Find('timeCodes/root_sub.usda')
refLayer = Sdf.Find('timeCodes/ref.usda')
refSubLayer = Sdf.Find('timeCodes/ref_sub.usda')
self.assertTrue(rootLayer)
self.assertTrue(rootSubLayer)
self.assertTrue(refLayer)
self.assertTrue(refSubLayer)
# No mapping
rootEditTarget = Usd.EditTarget(rootLayer)
# Composed layer offset: scale = 0.5 (note that this from a tcps change
# from 24 to 48 from the root layer to its sub layer)
rootSubEditTarget = Usd.EditTarget(rootSubLayer, rootNode)
# Composed layer offset: scale = 2, offset = -3.0 (note that this
# includes another tcps change back to 24 across the reference)
refEditTarget = Usd.EditTarget(refLayer, refNode)
# Composed layer offset: scale = 2, offset = +3.0
refSubEditTarget = Usd.EditTarget(refSubLayer, refNode)
self.assertEqual(rootEditTarget.GetLayer(), rootLayer)
self.assertEqual(rootSubEditTarget.GetLayer(), rootSubLayer)
self.assertEqual(refEditTarget.GetLayer(), refLayer)
self.assertEqual(refSubEditTarget.GetLayer(), refSubLayer)
# Edit targets returned as a tuple with the layers from strongest to
# weakest.
return (rootEditTarget, rootSubEditTarget, refEditTarget,
refSubEditTarget)
def main():
"""Run the main execution of the current script."""
inner_stage = _make_target()
main_stage = Usd.Stage.CreateInMemory()
# XXX : In order to use `inner_stage` in an EditContext, it must be
# in `main_stage`'s local LayerStack (e.g. it must be a sublayer)
#
main_stage.GetRootLayer().subLayerPaths.append(
inner_stage.GetRootLayer().identifier)
print(main_stage.GetRootLayer().ExportToString())
print('Inner stage before context')
print(inner_stage.GetRootLayer().ExportToString())
with Usd.EditContext(main_stage, inner_stage.GetRootLayer()):
sphere = UsdGeom.Sphere(main_stage.GetPrimAtPath("/root/sphere"))
sphere.GetRadiusAttr().Set(10)
print('Inner stage after context')
print(inner_stage.GetRootLayer().ExportToString())
main_stage.SetEditTarget(Usd.EditTarget(inner_stage.GetRootLayer()))
sphere = UsdGeom.Sphere(main_stage.GetPrimAtPath("/root/sphere"))
sphere.GetRadiusAttr().Set(5)
print('Inner stage after setting')
print(inner_stage.GetRootLayer().ExportToString())
def test_OffsetsAuthoring(self):
for fmt in allFormats:
# Create a simple structure one rootLayer with one subLayer, a prim
# 'Foo' in the rootLayer that references 'Bar' defined in refLayer.
# Then we assign a layer offset to the reference and to the sublayer,
# and we test authoring a time sample into the reference via an
# EditTarget, as well as to the subLayer. In both cases we check that
# the time value was correctly transformed.
rootLayer = Sdf.Layer.CreateAnonymous('root.'+fmt)
subLayer = Sdf.Layer.CreateAnonymous('sub.'+fmt)
refLayer = Sdf.Layer.CreateAnonymous('ref.'+fmt)
# add subLayer to rootLayer and give it a layer offset.
subOffset = Sdf.LayerOffset(scale=3.0, offset=4.0)
rootLayer.subLayerPaths.append(subLayer.identifier)
rootLayer.subLayerOffsets[0] = subOffset
# add Foo root prim.
fooRoot = Sdf.PrimSpec(rootLayer, 'Foo', Sdf.SpecifierDef)
# add Bar target prim in refLayer.
barRef = Sdf.PrimSpec(refLayer, 'Bar', Sdf.SpecifierDef)
# make Foo reference Bar.
refOffset = Sdf.LayerOffset(scale=2.0, offset=1.0)
fooRoot.referenceList.Add(Sdf.Reference(refLayer.identifier,
barRef.path, refOffset))
# Create a UsdStage, get 'Foo'.
stage = Usd.Stage.Open(rootLayer)
foo = stage.GetPrimAtPath('/Foo')
# Make an EditTarget to author into the referenced Bar.
editTarget = Usd.EditTarget(refLayer,
foo.GetPrimIndex().rootNode.children[0])
with Usd.EditContext(stage, editTarget):
attr = foo.CreateAttribute('attr', Sdf.ValueTypeNames.Double)
attr.Set(1.0, time=2.0)
self.assertEqual(attr.Get(time=2.0), 1.0, (
'expected value 1.0 at time=2.0, got %s' % attr.Get(time=2.0)))
# Check that the time value in the reference is correctly
# transformed.
authoredTime = barRef.attributes[
'attr'].GetInfo('timeSamples').keys()[0]
self.assertEqual(refOffset.GetInverse() * 2.0, authoredTime)
# Make an EditTarget to author into the sublayer.
editTarget = stage.GetEditTargetForLocalLayer(subLayer)
with Usd.EditContext(stage, editTarget):
attr = foo.GetAttribute('attr')
attr.Set(1.0, time=2.0)
self.assertEqual(attr.Get(time=2.0), 1.0, (
'expected value 1.0 at time=2.0, got %s' % attr.Get(time=2.0)))
# Check that the time value in the sublayer is correctly
# transformed.
authoredTime = subLayer.GetAttributeAtPath(
'/Foo.attr').GetInfo('timeSamples').keys()[0]
self.assertEqual(subOffset.GetInverse() * 2.0, authoredTime)
def test_AppliedSchemas(self):
for fmt in allFormats:
sessionLayer = Sdf.Layer.CreateNew("SessionLayer.%s" % fmt)
s = Usd.Stage.CreateInMemory('AppliedSchemas.%s' % fmt,
sessionLayer)
s.SetEditTarget(Usd.EditTarget(s.GetRootLayer()))
root = s.OverridePrim('/hello')
self.assertEqual([], root.GetAppliedSchemas())
rootModelAPI = Usd.ModelAPI.Apply(root)
self.assertTrue(rootModelAPI)
root = rootModelAPI.GetPrim()
self.assertTrue(root)
self.assertTrue(root.HasAPI(Usd.ModelAPI))
self.assertEqual(['ModelAPI'], root.GetAppliedSchemas())
# Switch the edit target to the session layer and test bug 156929
s.SetEditTarget(Usd.EditTarget(s.GetSessionLayer()))
sessionClipsAPI = Usd.ClipsAPI.Apply(root)
self.assertTrue(sessionClipsAPI)
self.assertEqual(['ClipsAPI', 'ModelAPI'],
root.GetAppliedSchemas())
self.assertTrue(root.HasAPI(Usd.ClipsAPI))
# Ensure duplicates aren't picked up
anotherSessionClipsAPI = Usd.ClipsAPI.Apply(root)
self.assertTrue(anotherSessionClipsAPI)
self.assertEqual(['ClipsAPI', 'ModelAPI'],
root.GetAppliedSchemas())
# Add a duplicate in the root layer and ensure that there are no
# duplicates in the composed result.
s.SetEditTarget(Usd.EditTarget(s.GetRootLayer()))
rootClipsAPI = Usd.ClipsAPI.Apply(root)
self.assertTrue(rootClipsAPI)
self.assertEqual(['ClipsAPI', 'ModelAPI'],
root.GetAppliedSchemas())
def test_GetDirtyLayers(self):
"""Validates that we get all modified layers from a UsdStage"""
layer1 = Sdf.Layer.FindOrOpen("dirtyLayer1.usda")
layer2 = Sdf.Layer.FindOrOpen("dirtyLayer2.usda")
layer3 = Sdf.Layer.FindOrOpen("dirtyLayer3.usda")
fakeLayer = Sdf.Layer.FindOrOpen("123fake.usda")
self.assertIsNotNone(layer1)
self.assertIsNotNone(layer2)
self.assertIsNotNone(layer3)
self.assertIsNone(fakeLayer)
stage = Usd.Stage.Open(layer1)
sessionLayer = stage.GetSessionLayer()
prim = stage.GetPrimAtPath('/Root')
hello = prim.GetAttribute('hello')
dirtyLayers = UsdUtils.GetDirtyLayers(stage)
self.assertEqual(len(dirtyLayers), 0)
stage.SetEditTarget(Usd.EditTarget(layer3))
hello.Set('edit')
dirtyLayers = UsdUtils.GetDirtyLayers(stage)
self.assertEqual(len(dirtyLayers), 1)
self.assertIn(layer3, dirtyLayers)
stage.SetEditTarget(Usd.EditTarget(layer1))
hello.Set('edit')
dirtyLayers = UsdUtils.GetDirtyLayers(stage)
self.assertEqual(len(dirtyLayers), 2)
self.assertIn(layer1, dirtyLayers)
self.assertIn(layer3, dirtyLayers)
stage.SetEditTarget(Usd.EditTarget(sessionLayer))
hello.Set('edit')
dirtyLayers = UsdUtils.GetDirtyLayers(stage)
self.assertEqual(len(dirtyLayers), 3)
self.assertIn(layer1, dirtyLayers)
self.assertIn(layer3, dirtyLayers)
self.assertIn(sessionLayer, dirtyLayers)
def test_upAxis(self):
stage = Usd.Stage.CreateInMemory()
self.assertTrue(stage)
self.assertEqual(UsdGeom.GetStageUpAxis(stage),
UsdGeom.GetFallbackUpAxis())
self.assertTrue(UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y))
self.assertEqual(UsdGeom.GetStageUpAxis(stage), UsdGeom.Tokens.y)
with Usd.EditContext(stage, Usd.EditTarget(stage.GetSessionLayer())):
self.assertTrue(UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z))
self.assertEqual(UsdGeom.GetStageUpAxis(stage), UsdGeom.Tokens.z)
# Setting illegal value should raise
with self.assertRaises(Tf.ErrorException):
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.x)
def testCopySpecToLayer(self):
destStage = Usd.Stage.CreateInMemory()
destLayer = Sdf.Layer.CreateAnonymous()
destStage.GetSessionLayer().subLayerPaths.append(destLayer.identifier)
destStage.SetEditTarget(Usd.EditTarget(destLayer))
destPrim = destStage.DefinePrim("/primsState/root", "Xform")
primPath = Sdf.Path("/root")
self.usdPrimDisplayManager.swapPrimPurposes(primPath)
self.usdPrimDisplayManager.copySpecToLayer(primPath, destLayer, destPrim.GetPath())
self.assertEqual(destStage.GetAttributeAtPath("/primsState/root/Sphere/PROXY.purpose").Get(), "default")
self.assertEqual(destStage.GetAttributeAtPath("/primsState/root/Cone/PROXY.purpose").Get(), "default")
self.assertFalse(destStage.GetPrimAtPath("/primsState/root/Sphere/HIGH").IsActive())
self.assertFalse(destStage.GetPrimAtPath("/primsState/root/Cone/HIGH").IsActive())
self.assertFalse(destStage.GetPrimAtPath("/primsState/root/Cylinder/HIGH").IsValid())
def setUp(self):
# DefineStage
self.stage = Usd.Stage.CreateInMemory()
self.stage.DefinePrim("/root", "Xform")
sphere = UsdGeom.Xform.Define(self.stage, "/root/Sphere")
sphere.AddTranslateOp().Set(value=(8, 0, 0))
self.sphereRender = self.stage.DefinePrim("/root/Sphere/HIGH", "Sphere")
self.sphereProxy = self.stage.DefinePrim("/root/Sphere/PROXY", "Sphere")
self.sphereRender.GetAttribute("purpose").Set("render")
self.sphereProxy.GetAttribute("purpose").Set("proxy")
cone = UsdGeom.Xform.Define(self.stage, "/root/Cone")
cone.AddTranslateOp().Set(value=(4, 0, 0))
self.coneRender = self.stage.DefinePrim("/root/Cone/HIGH", "Cone")
self.coneProxy = self.stage.DefinePrim("/root/Cone/PROXY", "Cone")
self.coneRender.GetAttribute("purpose").Set("render")
self.coneProxy.GetAttribute("purpose").Set("proxy")
cylinder = UsdGeom.Xform.Define(self.stage, "/root/Cylinder")
self.cylinderRender = self.stage.DefinePrim("/root/Cylinder/HIGH", "Cylinder")
self.cylinderRender.GetAttribute("purpose").Set("render")
self.usdPrimDisplayManager = UsdPrimsDisplayManager(self.stage)
# Add payload
self.assetPrim = self.stage.DefinePrim("/root/Asset", "Xform")
assetPath = "{}/data/simple_asset.usda".format(os.path.dirname(os.path.realpath(__file__)))
self.assetPrim.GetPayloads().AddPayload(assetPath)
self.assetRender = self.stage.GetPrimAtPath("/root/Asset/assetCube/HIGH")
self.assetProxy = self.stage.GetPrimAtPath("/root/Asset/assetCube/PROXY")
self.assetPrim2 = self.stage.DefinePrim("/root/Asset2", "Xform")
assetPath = "{}/data/simple_asset.usda".format(os.path.dirname(os.path.realpath(__file__)))
self.assetPrim2.GetPayloads().AddPayload(assetPath)
self.asset2Render = self.stage.GetPrimAtPath("/root/Asset2/assetCube/HIGH")
self.asset2Proxy = self.stage.GetPrimAtPath("/root/Asset2/assetCube/PROXY")
sessLayer = self.stage.GetSessionLayer()
self.stage.SetEditTarget(Usd.EditTarget(sessLayer))
self.usdPrimDisplayManager.setLayerMuted(False)
def test_AppliedSchemas(self):
self.assertTrue(Usd.ModelAPI.IsAPISchema())
self.assertTrue(Usd.ClipsAPI.IsAPISchema())
self.assertTrue(Usd.CollectionAPI.IsAPISchema())
self.assertFalse(Usd.ModelAPI.IsApplied())
self.assertFalse(Usd.ClipsAPI.IsApplied())
self.assertTrue(Usd.CollectionAPI.IsApplied())
self.assertTrue(Usd.CollectionAPI.IsMultipleApply())
for fmt in allFormats:
sessionLayer = Sdf.Layer.CreateNew("SessionLayer.%s" % fmt)
s = Usd.Stage.CreateInMemory('AppliedSchemas.%s' % fmt,
sessionLayer)
s.SetEditTarget(Usd.EditTarget(s.GetRootLayer()))
world = s.OverridePrim('/world')
self.assertEqual([], world.GetAppliedSchemas())
rootCollAPI = Usd.CollectionAPI.ApplyCollection(world, "root")
self.assertTrue(rootCollAPI)
world = rootCollAPI.GetPrim()
self.assertTrue(world)
self.assertTrue(world.HasAPI(Usd.CollectionAPI))
# The schemaType that's passed into HasAPI must derive from
# UsdAPISchemaBase and must not be UsdAPISchemaBase.
with self.assertRaises(RuntimeError):
world.HasAPI(Usd.Typed)
with self.assertRaises(RuntimeError):
world.HasAPI(Usd.APISchemaBase)
with self.assertRaises(RuntimeError):
world.HasAPI(Usd.ModelAPI)
# Try calling HasAPI a random TfType that isn't a derivative of
# SchemaBase.
with self.assertRaises(RuntimeError):
world.HasAPI(Sdf.ListOpType)
self.assertEqual(['CollectionAPI:root'], world.GetAppliedSchemas())
# Switch the edit target to the session layer and test bug 156929
s.SetEditTarget(Usd.EditTarget(s.GetSessionLayer()))
sessionCollAPI = Usd.CollectionAPI.ApplyCollection(
world, "session")
self.assertTrue(sessionCollAPI)
self.assertEqual(['CollectionAPI:session', 'CollectionAPI:root'],
world.GetAppliedSchemas())
self.assertTrue(world.HasAPI(Usd.CollectionAPI))
# Ensure duplicates aren't picked up
anotherSessionCollAPI = Usd.CollectionAPI.ApplyCollection(
world, "session")
self.assertTrue(anotherSessionCollAPI)
self.assertEqual(['CollectionAPI:session', 'CollectionAPI:root'],
world.GetAppliedSchemas())
# Add a duplicate in the root layer and ensure that there are no
# duplicates in the composed result.
s.SetEditTarget(Usd.EditTarget(s.GetRootLayer()))
rootLayerSessionCollAPI = Usd.CollectionAPI.ApplyCollection(
world, "session")
self.assertTrue(rootLayerSessionCollAPI)
self.assertEqual(['CollectionAPI:session', 'CollectionAPI:root'],
world.GetAppliedSchemas())
def test_InheritPathMapping(self):
for fmt in allFormats:
stage = Usd.Stage.CreateInMemory("x." + fmt, sessionLayer=None)
# Create test scenegraph
stage.DefinePrim("/Ref")
stage.DefinePrim("/Ref/Class")
stage.DefinePrim("/Ref/Instance")
stage.DefinePrim("/Ref2")
stage.DefinePrim("/Ref2/Class")
stage.DefinePrim("/Class")
prim = stage.DefinePrim("/Model")
prim.GetReferences().AddInternalReference("/Ref")
classPrim = stage.GetPrimAtPath("/Model/Class")
instancePrim = stage.GetPrimAtPath("/Model/Instance")
self.assertEqual(prim.GetChildren(), [classPrim, instancePrim])
# Set the edit target to point to the referenced prim.
refNode = prim.GetPrimIndex().rootNode.children[0]
self.assertEqual(refNode.arcType, Pcp.ArcTypeReference)
stage.SetEditTarget(
Usd.EditTarget(refNode.layerStack.layers[0], refNode))
# Add an inherit path to the instance prim pointing to the
# class prim.
instancePrim.GetInherits() \
.AddInherit("/Model/Class", Usd.ListPositionFrontOfPrependList)
expectedInheritPaths = Sdf.PathListOp()
expectedInheritPaths.prependedItems = [Sdf.Path("/Ref/Class")]
instancePrimSpec = \
stage.GetRootLayer().GetPrimAtPath("/Ref/Instance")
self.assertEqual(instancePrimSpec.GetInfo("inheritPaths"),
expectedInheritPaths)
# Remove the inherit path.
instancePrim.GetInherits().RemoveInherit(classPrim.GetPath())
expectedInheritPaths = Sdf.PathListOp()
expectedInheritPaths.deletedItems = [Sdf.Path("/Ref/Class")]
self.assertEqual(instancePrimSpec.GetInfo("inheritPaths"),
expectedInheritPaths)
# Add a global inherit path.
instancePrim.GetInherits() \
.AddInherit("/Class", Usd.ListPositionFrontOfPrependList)
expectedInheritPaths = Sdf.PathListOp()
expectedInheritPaths.prependedItems = [Sdf.Path("/Class")]
expectedInheritPaths.deletedItems = [Sdf.Path("/Ref/Class")]
self.assertEqual(instancePrimSpec.GetInfo("inheritPaths"),
expectedInheritPaths)
# Remove the global inherit path.
instancePrim.GetInherits().RemoveInherit("/Class")
expectedInheritPaths = Sdf.PathListOp()
expectedInheritPaths.deletedItems = ["/Ref/Class", "/Class"]
self.assertEqual(instancePrimSpec.GetInfo("inheritPaths"),
expectedInheritPaths)
# Try to add a local inherit path pointing to a prim outside the
# scope of reference. This should fail because that path will not
# map across the reference edit target.
with self.assertRaises(Tf.ErrorException):
instancePrim.GetInherits() \
.AddInherit("/Ref2/Class", Usd.ListPositionFrontOfPrependList)
self.assertEqual(instancePrimSpec.GetInfo("inheritPaths"),
expectedInheritPaths)
# Remove the local inherit path. This should fail and raise an
# error again because the path will not map across the reference.
with self.assertRaises(Tf.ErrorException):
instancePrim.GetInherits().RemoveInherit("/Ref2/Class")
self.assertEqual(instancePrimSpec.GetInfo("inheritPaths"),
expectedInheritPaths)
# Set inherit paths using the SetInherits API
instancePrim.GetInherits().SetInherits(["/Model/Class", "/Class"])
expectedInheritPaths = Sdf.PathListOp()
expectedInheritPaths.explicitItems = ["/Ref/Class", "/Class"]
self.assertEqual(instancePrimSpec.GetInfo("inheritPaths"),
expectedInheritPaths)
# Try to set unmappable inherit paths using the SetInherits API,
# which should fail.
with self.assertRaises(Tf.ErrorException):
instancePrim.GetInherits().SetInherits(["/Ref2/Class"])
self.assertEqual(instancePrimSpec.GetInfo("inheritPaths"),
expectedInheritPaths)
def MakeEditTarget(node):
return Usd.EditTarget(stage.GetRootLayer(), node)
def test_InternalReferenceMapping(self):
for fmt in allFormats:
# Create test scenegraph
refLayer = Sdf.Layer.CreateAnonymous('InternalRefMapping_ref.' +
fmt)
refSpec = Sdf.PrimSpec(refLayer, 'Ref', Sdf.SpecifierDef)
subRefSpec = Sdf.PrimSpec(refSpec, 'SubrootRef', Sdf.SpecifierDef)
childRefSpec = Sdf.PrimSpec(refSpec, 'Child', Sdf.SpecifierDef)
refSpec2 = Sdf.PrimSpec(refLayer, 'Ref2', Sdf.SpecifierDef)
childRefSpec2 = Sdf.PrimSpec(refSpec2, 'Child', Sdf.SpecifierDef)
stage = Usd.Stage.CreateInMemory('InternalRefMapping.' + fmt)
prim = stage.DefinePrim('/Root')
prim.GetReferences().AddReference(refLayer.identifier,
refSpec.path)
prim = stage.GetPrimAtPath('/Root')
# Set the edit target to point to the referenced prim
refNode = prim.GetPrimIndex().rootNode.children[0]
self.assertEqual(refNode.arcType, Pcp.ArcTypeReference)
stage.SetEditTarget(Usd.EditTarget(refLayer, refNode))
# Add an internal sub-root reference to the child of the
# referenced prim.
childPrim = stage.GetPrimAtPath('/Root/Child')
childPrim.GetReferences().AddInternalReference(
'/Root/SubrootRef', position=Usd.ListPositionFront)
expectedRefs = Sdf.ReferenceListOp()
expectedRefs.prependedItems = [
Sdf.Reference(primPath='/Ref/SubrootRef')
]
self.assertEqual(childRefSpec.GetInfo('references'), expectedRefs)
# Remove the internal sub-root reference.
childPrim.GetReferences().RemoveReference(
Sdf.Reference(primPath='/Root/SubrootRef'))
expectedRefs = Sdf.ReferenceListOp()
expectedRefs.deletedItems = [
Sdf.Reference(primPath='/Ref/SubrootRef')
]
self.assertEqual(childRefSpec.GetInfo('references'), expectedRefs)
# Add an internal reference.
childPrim.GetReferences().AddInternalReference(
'/Ref2', position=Usd.ListPositionFront)
expectedRefs = Sdf.ReferenceListOp()
expectedRefs.deletedItems = [
Sdf.Reference(primPath='/Ref/SubrootRef')
]
expectedRefs.prependedItems = [Sdf.Reference(primPath='/Ref2')]
self.assertEqual(childRefSpec.GetInfo('references'), expectedRefs)
# Remove internal reference.
childPrim.GetReferences().RemoveReference(
Sdf.Reference(primPath='/Ref2'))
expectedRefs = Sdf.ReferenceListOp()
expectedRefs.deletedItems = [
Sdf.Reference(primPath='/Ref/SubrootRef'),
Sdf.Reference(primPath='/Ref2')
]
self.assertEqual(childRefSpec.GetInfo('references'), expectedRefs)
# Try to set an unmappable sub-root reference.
with self.assertRaises(Tf.ErrorException):
childPrim.GetReferences().AddInternalReference('/Ref2/Child')
self.assertEqual(childRefSpec.GetInfo('references'), expectedRefs)
def __enter__(self):
self._primStateLayer.stage.SetEditTarget(
Usd.EditTarget(self._primStateLayer.layer))
def test_OffsetsAuthoring(self):
for fmt in allFormats:
# Create a simple structure one rootLayer with one subLayer, a prim
# 'Foo' in the rootLayer that references 'Bar' defined in refLayer.
# Then we assign a layer offset to the reference and to the sublayer,
# and we test authoring a time sample into the reference via an
# EditTarget, as well as to the subLayer. In both cases we check that
# the time value was correctly transformed.
rootLayer = Sdf.Layer.CreateAnonymous('root.' + fmt)
subLayer = Sdf.Layer.CreateAnonymous('sub.' + fmt)
refLayer = Sdf.Layer.CreateAnonymous('ref.' + fmt)
payloadLayer = Sdf.Layer.CreateAnonymous('payload.' + fmt)
# add subLayer to rootLayer and give it a layer offset.
subOffset = Sdf.LayerOffset(scale=3.0, offset=4.0)
rootLayer.subLayerPaths.append(subLayer.identifier)
rootLayer.subLayerOffsets[0] = subOffset
# add Foo root prim.
fooRoot = Sdf.PrimSpec(rootLayer, 'Foo', Sdf.SpecifierDef)
# add Bar target prim in refLayer.
barRef = Sdf.PrimSpec(refLayer, 'Bar', Sdf.SpecifierDef)
# make Foo reference Bar.
refOffset = Sdf.LayerOffset(scale=2.0, offset=1.0)
fooRoot.referenceList.Add(
Sdf.Reference(refLayer.identifier, barRef.path, refOffset))
# add Baz target prim in payloadLayer.
bazPayload = Sdf.PrimSpec(payloadLayer, 'Baz', Sdf.SpecifierDef)
# make Foo reference Baz.
payloadOffset = Sdf.LayerOffset(offset=-1.0)
fooRoot.payloadList.Add(
Sdf.Payload(payloadLayer.identifier, bazPayload.path,
payloadOffset))
# Set the payload layer to have a different tcps. The effective
# payloadOffset for verification below will have the effective scale
# from the tcps difference between layers.
payloadLayer.timeCodesPerSecond = 48.0
payloadOffset = payloadOffset * Sdf.LayerOffset(scale=24.0 / 48.0)
# Create a UsdStage, get 'Foo'.
stage = Usd.Stage.Open(rootLayer)
foo = stage.GetPrimAtPath('/Foo')
# Make an EditTarget to author into the referenced Bar.
refNode = foo.GetPrimIndex().rootNode.children[0]
self.assertEqual(refNode.path, Sdf.Path('/Bar'))
editTarget = Usd.EditTarget(refLayer, refNode)
with Usd.EditContext(stage, editTarget):
attr = foo.CreateAttribute('attr', Sdf.ValueTypeNames.Double)
attr.Set(1.0, time=2.0)
self.assertEqual(attr.Get(time=2.0), 1.0,
('expected value 1.0 at time=2.0, got %s' %
attr.Get(time=2.0)))
# Check that the time value in the reference is correctly
# transformed.
authoredTime = list(
barRef.attributes['attr'].GetInfo('timeSamples').keys())[0]
self.assertEqual(refOffset.GetInverse() * 2.0, authoredTime)
# Make an EditTarget to author into the payloaded Baz.
payloadNode = foo.GetPrimIndex().rootNode.children[1]
self.assertEqual(payloadNode.path, Sdf.Path('/Baz'))
editTarget = Usd.EditTarget(payloadLayer, payloadNode)
with Usd.EditContext(stage, editTarget):
attr = foo.CreateAttribute('attrFromBaz',
Sdf.ValueTypeNames.Double)
attr.Set(1.0, time=2.0)
self.assertEqual(attr.Get(time=2.0), 1.0,
('expected value 1.0 at time=2.0, got %s' %
attr.Get(time=2.0)))
# Check that the time value in the payload is correctly
# transformed.
authoredTime = list(
bazPayload.attributes['attrFromBaz'].GetInfo(
'timeSamples').keys())[0]
self.assertEqual(payloadOffset.GetInverse() * 2.0,
authoredTime)
# Make an EditTarget to author into the sublayer.
editTarget = stage.GetEditTargetForLocalLayer(subLayer)
with Usd.EditContext(stage, editTarget):
attr = foo.GetAttribute('attr')
attr.Set(1.0, time=2.0)
self.assertEqual(attr.Get(time=2.0), 1.0,
('expected value 1.0 at time=2.0, got %s' %
attr.Get(time=2.0)))
# Check that the time value in the sublayer is correctly
# transformed.
authoredTime = list(
subLayer.GetAttributeAtPath('/Foo.attr').GetInfo(
'timeSamples').keys())[0]
self.assertEqual(subOffset.GetInverse() * 2.0, authoredTime)
