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)