def test_RoundTrip(self):
for fmt in allFormats:
stage = Usd.Stage.CreateInMemory('TestRoundTrip.'+fmt)
prims = map(stage.DefinePrim, ['/foo', '/bar', '/baz'])
treeRange = Usd.PrimRange(stage.GetPseudoRoot())
tripped = Usd._TestPrimRangeRoundTrip(treeRange)
self.assertEqual(treeRange, tripped)
self.assertEqual(list(treeRange), list(tripped))
treeRange = Usd.PrimRange.PreAndPostVisit(stage.GetPseudoRoot())
tripped = Usd._TestPrimRangeRoundTrip(treeRange)
self.assertEqual(treeRange, tripped)
self.assertEqual(list(treeRange), list(tripped))
def _MakeFlattenedRegistryLayer(filePath):
# We flatten the schema classes to 'eliminate' composition when querying
# the schema registry.
stage = Usd.Stage.Open(filePath)
# Certain qualities on builtin properties are not overridable in scene
# description. For example, builtin attributes' types always come from the
# definition registry, never from scene description. That's problematic in
# this case where we're trying to *establish* the definition registry.
# Since the classes in schema.usda use the real prim type names
# (e.g. 'Mesh') Usd will pick up these built-in qualities from the existing
# prim definition. To side-step this, we temporarily override the prim type
# names in the session layer so they do not pick up these special
# nonoverridable qualities when we flatten. Then after the fact we repair
# all the type names.
def mangle(typeName):
return '__MANGLED_TO_AVOID_BUILTINS__' + typeName
def demangle(typeName):
return typeName.replace('__MANGLED_TO_AVOID_BUILTINS__', '')
# Mangle the typeNames.
with Usd.EditContext(stage, editTarget=stage.GetSessionLayer()):
for cls in stage.GetPseudoRoot().GetAllChildren():
if cls.GetTypeName():
cls.SetTypeName(mangle(cls.GetTypeName()))
flatLayer = stage.Flatten(addSourceFileComment=False)
# Demangle the typeNames.
for cls in flatLayer.rootPrims:
if cls.typeName:
cls.typeName = demangle(cls.typeName)
# In order to prevent derived classes from inheriting base class
# documentation metadata, we must manually replace docs here.
for layer in stage.GetLayerStack():
for cls in layer.rootPrims:
flatCls = flatLayer.GetPrimAtPath(cls.path)
if cls.HasInfo('documentation'):
flatCls.SetInfo('documentation', cls.documentation)
else:
flatCls.ClearInfo('documentation')
return flatLayer
def _set_blendshape_weights(self, skel_anim, usd_node, gltf_node):
animations = self.gltf_loader.get_animations()
if (len(animations) > 0): # only support first animation group
animation = animations[0]
animation_channels = animation.get_animation_channels_for_node(gltf_node)
for animation_channel in animation_channels:
if animation_channel.target.path == 'weights':
output_data = animation_channel.sampler.get_output_data()
input_data = animation_channel.sampler.get_input_data()
output_data_entries = []
for index in range(0, len(output_data)/2):
output_data_entries.append([output_data[index * 2], output_data[index * 2 + 1]])
usd_blend_shape_weights = skel_anim.CreateBlendShapeWeightsAttr()
for entry in zip(output_data_entries, input_data):
usd_blend_shape_weights.Set(Vt.FloatArray(entry[0]), Usd.TimeCode(entry[1] * self.fps))
def TestBug113044():
stage = Usd.Stage.Open("animVis.usda")
bboxCache = UsdGeom.BBoxCache(Usd.TimeCode(0.0),
includedPurposes=[UsdGeom.Tokens.default_])
pseudoRoot = stage.GetPrimAtPath("/")
assert bboxCache.ComputeWorldBound(pseudoRoot).GetRange().IsEmpty()
# The cube is visible at frame 1. This should invalidate the bounds at '/'
# and cause the bbox to be non-empty.
bboxCache.SetTime(1.0)
assert not bboxCache.ComputeWorldBound(pseudoRoot).GetRange().IsEmpty()
bboxCache.SetTime(2.0)
assert bboxCache.ComputeWorldBound(pseudoRoot).GetRange().IsEmpty()
bboxCache.SetTime(3.0)
assert not bboxCache.ComputeWorldBound(pseudoRoot).GetRange().IsEmpty()
def ResetPrim(self, prim):
self.beginResetModel()
if prim is None:
self.__valid = False
self.__prim = Usd.Prim()
else:
self.__valid = True
self.__prim = prim
self.__listener = Tf.Notice.Register(Usd.Notice.ObjectsChanged,
self.__OnObjectsChanged,
self.__prim.GetStage())
if self.__prim:
self.__primTree = self._GetPrimTree(prim)
else:
self.__primTree = []
self.endResetModel()
def test_TimeSamplesMetadata(self):
'''Test timeSamples composition, with layer offsets'''
for fmt in allFormats:
s = Usd.Stage.CreateInMemory(
'TestTimeSamplesMetadata.'+fmt)
# Create two prims, 'weaker' and 'stronger', 'stronger' references
# 'weaker'.
weaker = s.OverridePrim('/weaker')
stronger = s.OverridePrim('/stronger')
# Use a layer offset on the reference arc to shift timeSamples
# later in time by 10.
if Usd.UsesInverseLayerOffset():
refOffset = Sdf.LayerOffset(scale=1.0, offset=-10.0)
else:
refOffset = Sdf.LayerOffset(scale=1.0, offset=10.0)
stronger.GetReferences().AddReference(
s.GetRootLayer().identifier, weaker.GetPath(), refOffset)
# Set some time samples on the reference.
weaker_attr = \
weaker.CreateAttribute("attr", Sdf.ValueTypeNames.String)
# We write directly to the weaker_attr, as opposed to
# writing to stronger_attr with an edit target (which
# would give the same result).
weaker_attr.Set("abc_0", 0.0)
weaker_attr.Set("def_10", 10.0)
stronger_attr = stronger.GetAttribute('attr')
# Confirm resolved metadata.
weaker_expectedTimeSamples = {0.0: 'abc_0', 10.0: 'def_10'}
self.assertEqual(
weaker_attr.GetTimeSamples(),
sorted(weaker_expectedTimeSamples.keys()))
self.assertEqual(
weaker_attr.GetMetadata('timeSamples'),
weaker_expectedTimeSamples)
# Stronger attribute will be affected by the offset.
stronger_expectedTimeSamples = {10.0: 'abc_0', 20.0: 'def_10'}
self.assertEqual(
stronger_attr.GetTimeSamples(),
sorted(stronger_expectedTimeSamples.keys()))
self.assertEqual(
stronger_attr.GetMetadata('timeSamples'),
stronger_expectedTimeSamples)
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 __init__(self, mainWindow, item):
NodeContextMenuItem.__init__(self, mainWindow, item)
self._assetName = None
if len(self._currentNodes) == 1:
from pxr import Usd
model = Usd.ModelAPI(self._currentNodes[0])
name = model.GetAssetName()
identifier = model.GetAssetIdentifier()
if name and identifier:
# Ar API is still settling out...
# from pxr import Ar
# identifier = Ar.GetResolver().Resolve("", identifier.path)
from pxr import Sdf
layer = Sdf.Layer.Find(identifier.path)
if layer:
self._assetName = name
self._filePath = layer.realPath
def __init__(self, appController, item):
PrimContextMenuItem.__init__(self, appController, item)
self._assetName = None
if len(self._selectionDataModel.getPrims()) == 1:
from pxr import Usd
model = Usd.ModelAPI(self._selectionDataModel.getFocusPrim())
name = model.GetAssetName()
identifier = model.GetAssetIdentifier()
if name and identifier:
# Ar API is still settling out...
# from pxr import Ar
# identifier = Ar.GetResolver().Resolve("", identifier.path)
from pxr import Sdf
layer = Sdf.Layer.Find(identifier.path)
if layer:
self._assetName = name
self._filePath = layer.realPath
def main():
"""Run the main execution of this module."""
stage = Usd.Stage.CreateInMemory()
stage.SetStartTimeCode(0)
stage.SetEndTimeCode(12)
prim = stage.DefinePrim("/Prim")
model = Usd.ClipsAPI(prim)
model.SetClipActive([(0, 0), (2, 1)])
model.SetClipAssetPaths(
[Sdf.AssetPath("./clip_1.usda"),
Sdf.AssetPath("./clip_2.usda")])
model.SetClipPrimPath("/Clip")
model.SetClipTimes([(0, 0), (1, 1), (2, 0), (3, 1)])
model.SetClipManifestAssetPath("./clip_manifest.usda")
prim.GetReferences().AddReference(assetPath="./ref.usda", primPath="/Ref")
print(stage.GetRootLayer().ExportToString())
def defineParentXforms(stage, primPath):
'''
Ensure parent group prims are built.
Parameters
----------
stage : Sdf.Stage
primPath : str
'''
# this is from the usd tutorial...
from pxr import UsdGeom
path = ''
parentPrims = primPath.strip('/').split('/')[:-1]
for nextPrim in parentPrims:
path += ('/' + nextPrim)
# Make sure the model-parents we need are well-specified
Usd.ModelAPI(UsdGeom.Xform.Define(stage,
path)).SetKind(Kind.Tokens.group)
def FromUsdFile(cls, usdFile, role=None, parent=None):
# type: (str, Optional[Union[Type[OutlinerRole], OutlinerRole]], Optional[QtGui.QWidget]) -> UsdOutliner
"""
Parameters
----------
usdFile : str
role : Optional[Union[Type[OutlinerRole], OutlinerRole]]
parent : Optional[QtGui.QWidget]
Returns
-------
UsdOutliner
"""
with Usd.StageCacheContext(Usd.BlockStageCaches):
stage = Usd.Stage.Open(usdFile, Usd.Stage.LoadNone)
assert stage, 'Failed to open stage'
stage.SetEditTarget(stage.GetSessionLayer())
return cls(stage, role=role, parent=parent)
def _SetDefaultWithEditTarget(editTarget, attr, resolvedValue,
expectedAuthoredValue):
# Set the edit target on the stage.
stage.SetEditTarget(editTarget)
# Set the value at time to the resolved value and verify we get the
# same resolved value back from both the attr and a
# UsdAttributeQuery
attr.Set(resolvedValue)
self.assertEqual(attr.Get(), resolvedValue)
# Note that we create the attribute query in this function for the
# same attribute because we're making changes that affect value
# resolution
attrQuery = Usd.AttributeQuery(attr)
self.assertEqual(attrQuery.Get(), resolvedValue)
# Verify that the default value authored on the edit target's layer
# matches the expected authored value.
self._VerifyAuthoredValue(editTarget, attr.GetPath(), "default",
expectedAuthoredValue)
def ValidateExpectedInstances(stage, expectedInstances):
"""
Validate the expected instances and prototypes on the given stage.
expectedInstances is a mapping from:
prototype prim path -> list of expected instance prim paths
"""
for (prototypePath, instancePaths) in expectedInstances.items():
# Validate that all prims expected to be instances of the same prototype
# are associated with the same prototype prim.
prototype = stage.GetPrimAtPath(prototypePath)
assert prototype, "Expected prototype <%s> does not exist" % prototypePath
for p in instancePaths:
prim = stage.GetPrimAtPath(p)
assert prim, "Prim <%s> does not exist" % p
assert prim.IsInstance(), "Prim <%s> is not an instance" % p
assert prim.GetPrototype() == prototype, \
"Instance <%s> does not have expected prototype <%s>" % \
(p, prototype.GetPath())
# Validate that the prototype prim's source prim index is one of
# the instance's prim indexes.
prototypePrimIndexPath = prototype._GetSourcePrimIndex().rootNode.path
instancePrimIndexPaths = [
stage.GetPrimAtPath(p)._GetSourcePrimIndex().rootNode.path
for p in instancePaths
]
assert prototypePrimIndexPath in instancePrimIndexPaths, \
"Prototype <%s> using unexpected prim index <%s>, expected " \
"one of %s" % (prototype.GetPath(), prototypePrimIndexPath,
instancePrimIndexPaths)
# Validate that we don't have any unexpected prototypes or instances.
for prototype in stage.GetPrototypes():
assert str(prototype.GetPath()) in expectedInstances
for root in [stage.GetPseudoRoot()] + stage.GetPrototypes():
for prim in Usd.PrimRange(root):
if prim.IsInstance():
assert str(prim.GetPath()) in \
expectedInstances.get(
str(prim.GetPrototype().GetPath()), []), \
"Found unexpected instance prim <%s> with prototype <%s>" %\
(prim.GetPath(), prim.GetPrototype().GetPath())
def test_SetFromCamera(self):
camera = Gf.Camera()
usdStage = Usd.Stage.CreateInMemory()
usdCamera = UsdGeom.Camera.Define(usdStage, '/camera')
usdCameraProj = usdCamera.GetProjectionAttr()
# test fall-back values
self._CheckValues(camera, usdCamera, 1.0)
self.assertEqual(usdCameraProj.GetResolveInfo().GetSource(),
Usd.ResolveInfoSourceFallback)
camera.transform = (
Gf.Matrix4d().SetRotate(Gf.Rotation(Gf.Vec3d(1.0, 2.0, 3.0), 10.0))
* Gf.Matrix4d().SetTranslate(Gf.Vec3d(4.0, 5.0, 6.0)))
camera.projection = Gf.Camera.Orthographic
camera.horizontalAperture = 5.1
camera.verticalAperture = 2.0
camera.horizontalApertureOffset = 0.13
camera.verticalApertureOffset = -0.14
camera.focalLength = 28
camera.clippingRange = Gf.Range1f(5, 15)
camera.clippingPlanes = [[1, 2, 3, 4], [8, 7, 6, 5]]
camera.fStop = 1.2
camera.focusDistance = 300
usdCamera.SetFromCamera(camera, 1.0)
# test assigned values
self._CheckValues(camera, usdCamera, 1.0)
self.assertEqual(usdCameraProj.GetResolveInfo().GetSource(),
Usd.ResolveInfoSourceTimeSamples)
usdCamera.SetFromCamera(camera, 1.0)
actual = usdCamera.GetLocalTransformation(Usd.TimeCode(1.0))
expected = Gf.Matrix4d(0.9858929135, 0.14139860385, -0.089563373740,
0.0, -0.1370579618, 0.98914839500,
0.052920390613, 0.0, 0.0960743367,
-0.03989846462, 0.994574197504, 0.0, 4.0, 5.0,
6.0, 1.0)
for a, e in zip(actual, expected):
self.assertTrue(Gf.IsClose(a, e, 1e-2))
def traverse_instanced_children(prim):
"""Get every Prim child beneath `prim`, even if `prim` is instanced.
Important:
If `prim` is instanced, any child that this function yields will
be an instance proxy.
Args:
prim (`pxr.Usd.Prim`): Some Prim to check for children.
Yields:
`pxr.Usd.Prim`: The children of `prim`.
"""
for child in prim.GetFilteredChildren(Usd.TraverseInstanceProxies()):
yield child
for subchild in traverse_instanced_children(child):
yield subchild
def test_VariantSelectionPathAbstraction(self):
for fmt in allFormats:
s = Usd.Stage.CreateInMemory(
'TestVariantSelectionPathAbstraction.' + fmt)
p = s.OverridePrim("/Foo")
vss = p.GetVariantSets()
self.assertFalse(p.HasVariantSets())
vs = vss.AddVariantSet("LOD")
self.assertTrue(p.HasVariantSets())
self.assertTrue(vs)
self.assertTrue(vs.AddVariant("High"))
self.assertTrue(p.HasVariantSets())
# This call triggers the bug. This happens because it triggers the
# computation of a PcpPrimIndex for the variant prim, which then causes
# the prim with a variant selection to be included in the UsdStage's
# scene graph later when the next round of change processing occurs.
#
# XXX: WBN to indicate the bug # above. This code changed when the
# variant API changed during the switch to using EditTargets instead of
# UsdPrimVariant. It's unclear whether or not the mystery bug is still
# reproduced. Leaving the test in place as much as possible..
self.assertFalse(p.GetAttribute("bar").IsDefined())
# This triggers change processing which will include the prim with the
# variant selection and put it on the stage.
vs.SetVariantSelection('High')
editTarget = vs.GetVariantEditTarget()
self.assertTrue(editTarget)
with Usd.EditContext(s, editTarget):
s.DefinePrim(p.GetPath().AppendChild('Foobar'), 'Scope')
self.assertTrue(s.GetPrimAtPath(p.GetPath().AppendChild('Foobar')))
# Here's the actual manifestation of the bug: We should still not have
# this prim on the stage, but when the bug is present, we do. Paths
# containing variant selections can never identify objects on a stage.
# Verify that the stage does not contain a prim for the variant prim
# spec we just created at </Foo{LOD=High}Foobar>
testPath = p.GetPath().AppendVariantSelection(
'LOD', 'High').AppendChild('Foobar')
self.assertFalse(s.GetPrimAtPath(testPath))
def main():
stage = Usd.Stage.CreateInMemory()
# Method A: Set using methods
some_sphere = UsdGeom.Sphere.Define(stage, "/SomeSphere")
model = Usd.ModelAPI(some_sphere.GetPrim())
model.SetAssetName("some_asset")
model.SetAssetVersion("v1")
model.SetAssetIdentifier("some/path/to/file.usda")
model.SetPayloadAssetDependencies(
Sdf.AssetPathArray(
[Sdf.AssetPath("something.usd"), Sdf.AssetPath("another/thing.usd")]
)
)
# Method B: Set-by-key
another_sphere = UsdGeom.Sphere.Define(stage, "/AnotherSphere")
another_prim = another_sphere.GetPrim()
another_prim.SetAssetInfoByKey("version", "v1")
another_prim.SetAssetInfoByKey("name", "some_asset")
another_prim.SetAssetInfoByKey("identifier", "some/path/to/file.usda")
another_prim.SetAssetInfoByKey(
"payloadAssetDependencies",
Sdf.AssetPathArray(
[Sdf.AssetPath("something.usd"), Sdf.AssetPath("another/thing.usd")]
),
)
# Method C: Set-by-dict
last_sphere = UsdGeom.Sphere.Define(stage, "/LastSphere")
last_sphere.GetPrim().SetAssetInfo(
{
"identifier": "some/path/to/file.usda",
"name": "some_asset",
"version": "v1",
"payloadAssetDependencies": Sdf.AssetPathArray(
[Sdf.AssetPath("something.usd"), Sdf.AssetPath("another/thing.usd")]
),
}
)
print(stage.GetRootLayer().ExportToString())
def createPrimAndAttributes(stage, primPath, mayaReferencePath, mayaNamespace,
mayaAutoEdit):
try:
prim = stage.DefinePrim(primPath.path, 'MayaReference')
except (Tf.ErrorException):
return Usd.Prim()
mayaReferenceAttr = prim.CreateAttribute('mayaReference',
Sdf.ValueTypeNames.Asset)
mayaReferenceAttr.Set(mayaReferencePath)
mayaNamespaceAttr = prim.CreateAttribute('mayaNamespace',
Sdf.ValueTypeNames.String)
mayaNamespaceAttr.Set(mayaNamespace)
mayaAutoEditAttr = prim.CreateAttribute('mayaAutoEdit',
Sdf.ValueTypeNames.Bool)
mayaAutoEditAttr.Set(mayaAutoEdit)
return prim
def export_mesh_to_usd(full_name,smc, directory):
task = unreal.AssetExportTask()
task.object = smc.static_mesh
task.filename = get_usd_asset_filename(full_name, directory)
task.selected = False
task.replace_identical = True
task.prompt = False
task.automated = True
unreal.Exporter.run_asset_export_task(task)
#let's add the asset information
unreal.log_warning("adding asset information for :" + full_name)
stage = Usd.Stage.Open(task.filename)
usd_prim = stage.GetDefaultPrim()
model = Usd.ModelAPI(usd_prim)
model.SetAssetIdentifier(task.filename)
model.SetAssetName(full_name.rsplit('.')[1])
stage.Save()
return task.filename
def test_ResolveAssetPathFn(self):
src_stage = Usd.Stage.Open('emptyAssetPaths.usda')
def replaceWithFoo(layer, s):
return 'foo'
src_layer_stack = src_stage._GetPcpCache().layerStack
layer = Usd.FlattenLayerStack(src_layer_stack,
resolveAssetPathFn=replaceWithFoo,
tag='resolveAssetPathFn')
result_stage = Usd.Stage.Open(layer)
# verify that we replaced asset paths with "foo"
prim = result_stage.GetPrimAtPath('/Test')
assetAttr = prim.GetAttribute('a')
self.assertEqual(assetAttr.Get(), Sdf.AssetPath('foo'))
assetArrayAttr = prim.GetAttribute('b')
self.assertEqual(list(assetArrayAttr.Get()),
[Sdf.AssetPath('foo'), Sdf.AssetPath('foo')])
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 export(name):
global file_path
global relative_directory
global root_name
global USDExportLevel
global selection_only
set_file_path()
filename = file_path + '/'+name
root_name = '/' + unreal.EditorLevelLibrary.get_editor_world().get_name()
#first we export all the different assets that we will reference after
if export_assets == True :
export_all_meshes_as_usd_assets(file_path)
#onto the usda layer that will reference those assets
stagecache = UsdUtils.StageCache.Get()
stagecachecontext = Usd.StageCacheContext(stagecache)
stage = Usd.Stage.CreateNew(filename)
nf = stage.DefinePrim(root_name, 'Xform')
stage.SetDefaultPrim(nf)
UsdGeom.SetStageUpAxis(stage,'Z')
#now we add the actors to the usd stage, referencing the usd asset files we exported above.
if selection_only == False :
listActors = unreal.EditorLevelLibrary.get_all_level_actors()
else :
listActors = unreal.EditorLevelLibrary.get_selected_level_actors()
for actor in listActors :
if isinstance(actor,unreal.StaticMeshActor):
add_actor_to_stage(actor, stage)
elif isinstance(actor, unreal.CineCameraActor):
add_camera_to_stage(actor, stage)
elif USDExportLevel.should_export_actor(actor):
sm_array = actor.get_components_by_class(unreal.StaticMeshComponent.static_class())
for smc in sm_array:
add_static_mesh_component_to_stage(smc,stage)
stage.GetRootLayer().Save()
def __init__(self, stage=None, columns=None, parent=None):
# type: (Optional[Usd.Stage], Optional[Union[List[str], Tuple[str]]], Optional[QtCore.QObject]) -> None
"""
Parameters
----------
stage : Optional[Usd.Stage]
columns : Optional[List[str]]
parent : Optional[QtCore.QObject]
"""
super(HierarchyStandardModel, self).__init__(
stage,
Usd.TraverseInstanceProxies(Usd.PrimIsDefined
| ~Usd.PrimIsDefined), parent)
if not columns:
# By default show all possible columns.
self.columns = [
HierarchyStandardModel.Name, HierarchyStandardModel.Type,
HierarchyStandardModel.Kind
]
else:
self.columns = columns
def GetPrimLoadability(prim):
"""Return a tuple of (isLoadable, isLoaded) for 'prim', according to
the following rules:
A prim is loadable if it is active, and either of the following are true:
* prim has a payload
* prim is a model group
The latter is useful because loading is recursive on a UsdStage, and it
is convenient to be able to (e.g.) load everything loadable in a set.
A prim 'isLoaded' only if there are no unloaded prims beneath it, i.e.
it is stating whether the prim is "fully loaded". This
is a debatable definition, but seems useful for usdview's purposes."""
if not (prim.IsActive() and (prim.IsGroup() or prim.HasPayload())):
return (False, True)
# XXX Note that we are potentially traversing the entire stage here.
# If this becomes a performance issue, we can cast this query into C++,
# cache results, etc.
for p in Usd.PrimRange(prim, Usd.PrimIsActive):
if not p.IsLoaded():
return (True, False)
return (True, True)
def test_InvalidXformOps(self):
s = Usd.Stage.CreateInMemory()
p = s.DefinePrim('/World', 'Xform')
x = UsdGeom.Xformable(p)
# Create an attribute that is not in the xformOp namespace.
attr1 = p.CreateAttribute("myXformOp:transform", Sdf.ValueTypeNames.Matrix4d)
self._TestInvalidXformOp(attr1)
# Create an xform op with an invalid optype.
attr2 = p.CreateAttribute("xformOp:translateXYZ", Sdf.ValueTypeNames.Double3)
self._TestInvalidXformOp(attr2)
# Create an xform op with opType=transform and typeName=Matrix4f.
with self.assertRaises(RuntimeError):
xformOp = x.AddTransformOp(precision=UsdGeom.XformOp.PrecisionFloat)
# Test Validity of XformOp with no attr
xformOp = UsdGeom.XformOp(Usd.Attribute())
self.assertFalse(xformOp.IsDefined())
self.assertFalse(bool(xformOp))
def test_TimeSampled(self):
extents = {
'/capsule' : Vt.Vec3fArray(2, (Gf.Vec3f(-4.0, -4.0, -6.0),
Gf.Vec3f(4.0, 4.0, 6.0))),
'/cone' : Vt.Vec3fArray(2, (Gf.Vec3f(-4.0, -4.0, -3.0),
Gf.Vec3f(4.0, 4.0, 3.0))),
'/cube' : Vt.Vec3fArray(2, (Gf.Vec3f(-3.0, -3.0, -3.0),
Gf.Vec3f(3.0, 3.0, 3.0))),
'/cylinder' : Vt.Vec3fArray(2, (Gf.Vec3f(-4.0, -4.0, -3.0),
Gf.Vec3f(4.0, 4.0, 3.0))),
'/sphere' : Vt.Vec3fArray(2, (Gf.Vec3f(-4.0, -4.0, -4.0),
Gf.Vec3f(4.0, 4.0, 4.0)))
}
testFile = "test.usda"
s = Usd.Stage.Open(testFile)
for primpath in self.primpaths:
p = s.GetPrimAtPath(primpath)
b = UsdGeom.Boundable(p)
tc = Usd.TimeCode(2.0)
e = UsdGeom.Boundable.ComputeExtentFromPlugins(b, tc)
self.assertEqual(extents[primpath], e)
def buildUI(self):
usdSch = Usd.SchemaRegistry()
self.suppressArrayAttribute()
# We use UFE for the ancestor node types since it caches the
# results by node type.
for schemaType in self.item.ancestorNodeTypes():
schemaType = usdSch.GetTypeFromName(schemaType)
schemaTypeName = schemaType.typeName
sectionName = self.sectionNameFromSchema(schemaTypeName)
if schemaType.pythonClass:
attrsToAdd = schemaType.pythonClass.GetSchemaAttributeNames(
False)
# We have a special case when building the Xformable section.
if schemaTypeName == 'UsdGeomXformable':
self.createTransformAttributesSection(
sectionName, attrsToAdd)
else:
self.createSection(sectionName, attrsToAdd)
def test_Bug145873(self):
# The payload inclusion predicate wasn't being invoked on ancestors of
# requested index paths in pcp.
payload = Usd.Stage.CreateInMemory()
for n in ('One', 'Two', 'Three'):
payload.DefinePrim('/CubesModel/Geom/Cube' + n)
root = Usd.Stage.CreateInMemory()
cubes = root.DefinePrim('/Cubes')
cubes.SetPayload(payload.GetRootLayer().identifier, '/CubesModel')
testStage = Usd.Stage.OpenMasked(
root.GetRootLayer(),
Usd.StagePopulationMask(['/Cubes/Geom/CubeTwo']))
# Only /Cubes/Geom/CubeTwo (and ancestors) should be present.
assert testStage.GetPrimAtPath('/Cubes')
assert testStage.GetPrimAtPath('/Cubes/Geom')
assert not testStage.GetPrimAtPath('/Cubes/Geom/CubeOne')
assert testStage.GetPrimAtPath('/Cubes/Geom/CubeTwo')
assert not testStage.GetPrimAtPath('/Cubes/Geom/CubeThree')
def test_FlattenWithOffsets(self):
"""Tests that layer offsets are taken into account when flattening
attribute time samples."""
srcAttr = self.srcStage.GetPrimAtPath("/OffsetTimeSamples") \
.GetAttribute("a")
self.assertEqual(self._GetTimeSamples(srcAttr), {10: 100, 20: 1000})
for dstStage in [self.srcStage, self.stage2]:
dstAttr = srcAttr.FlattenTo(
dstStage.OverridePrim("/OffsetTimeSamplesRoot"))
self.assertEqual(self._GetTimeSamples(dstAttr), {
10: 100,
20: 1000
})
self.assertEqual(
self._GetTimeSamplesInLayer(dstStage.GetRootLayer(),
dstAttr.GetPath()), {
10: 100,
20: 1000
})
dstSubLayer = dstStage.GetLayerStack()[-1]
with Usd.EditContext(
dstStage,
dstStage.GetEditTargetForLocalLayer(dstSubLayer)):
dstAttr = srcAttr.FlattenTo(
dstStage.OverridePrim("/OffsetTimeSamplesSublayer"))
# flattened time samples
self.assertEqual(self._GetTimeSamples(dstAttr), {
10: 100,
20: 1000
})
# time samples from the offset sublayer
self.assertEqual(
self._GetTimeSamplesInLayer(dstSubLayer,
dstAttr.GetPath()),
self.expectedTimeSampleOffsetSublayer[dstStage])
def reportModelInfo(stage):
_resolveAr = Ar.GetResolver().Resolve
@lru_cache
def resolve(identifier):
return _resolveAr(str(Path(identifier)))
missing_info = set()
incomplete_info = defaultdict(set)
unresolved_ids = defaultdict(set)
with Ar.ResolverContextBinder(stage.GetPathResolverContext()):
for prim in stage.Traverse(predicate=Usd.PrimIsModel):
model = Usd.ModelAPI(prim)
if not (model.IsKind("component") or model.IsKind("assembly")):
continue # only check for "important" kinds
elif (info := model.GetAssetInfo()):
if (missing := frozenset({"name", "identifier"} - set(info))):
incomplete_info[missing].add(prim)
elif not resolve(info['identifier'].path):
unresolved_ids[info['identifier']].add(prim)
continue
