def main():
# Make the stage
stage = Usd.Stage.CreateNew(STAGENAME)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y)
modelRoot = UsdGeom.Xform.Define(stage, '/TexModel')
Usd.ModelAPI(modelRoot).SetKind(Kind.Tokens.component)
# A simple card with same proportions as the texture we will map
billboard = UsdGeom.Mesh.Define(stage, '/TexModel/card')
billboard.CreatePointsAttr([(-430, -145, 0), (430, -145, 0), (430, 145, 0),
(-430, 145, 0)])
billboard.CreateFaceVertexCountsAttr([4])
billboard.CreateFaceVertexIndicesAttr([0, 1, 2, 3])
billboard.CreateExtentAttr([(-430, -145, 0), (430, 145, 0)])
texCoords = billboard.CreatePrimvar('st',
Sdf.ValueTypeNames.TexCoord2fArray,
UsdGeom.Tokens.varying)
texCoords.Set([(0, 0), (1, 0), (1, 1), (0, 1)])
# Create material
material = UsdShade.Material.Define(stage, '/TexModel/material')
stInput = material.CreateInput('frame:stPrimvarName',
Sdf.ValueTypeNames.Token)
stInput.Set('st')
pbrShader = UsdShade.Shader.Define(stage, '/TexModel/material/PBRShader')
pbrShader.CreateIdAttr('UsdPreviewSurface')
pbrShader.CreateInput('roughness', Sdf.ValueTypeNames.Float).Set(0.4)
pbrShader.CreateInput('metallic', Sdf.ValueTypeNames.Float).Set(0.0)
material.CreateSurfaceOutput().ConnectToSource(pbrShader, 'surface')
stReader = UsdShade.Shader.Define(stage, '/TexModel/material/stReader')
stReader.CreateIdAttr('UsdPrimvarReader_float2')
stReader.CreateInput('varname',
Sdf.ValueTypeNames.Token).ConnectToSource(stInput)
diffuseTextureSampler = UsdShade.Shader.Define(
stage, '/TexModel/material/diffuseTexture')
diffuseTextureSampler.CreateIdAttr('UsdUVTexture')
diffuseTextureSampler.CreateInput(
'file', Sdf.ValueTypeNames.Asset).Set(TEXTURE_FILE)
diffuseTextureSampler.CreateInput(
'st', Sdf.ValueTypeNames.Float2).ConnectToSource(stReader, 'result')
diffuseTextureSampler.CreateOutput('rgb', Sdf.ValueTypeNames.Float3)
pbrShader.CreateInput('diffuseColor',
Sdf.ValueTypeNames.Color3f).ConnectToSource(
diffuseTextureSampler, 'rgb')
UsdShade.MaterialBindingAPI(billboard).Bind(material)
# Save stage
stage.Save()
def TestUnloadedExtentsHints():
stage = Usd.Stage.Open(
"unloadedCubeModel.usda",
load = Usd.Stage.LoadNone)
bboxCacheNo = UsdGeom.BBoxCache(Usd.TimeCode(0.0),
includedPurposes=[UsdGeom.Tokens.default_], useExtentsHint=False)
bboxCacheYes = UsdGeom.BBoxCache(Usd.TimeCode(0.0),
includedPurposes=[UsdGeom.Tokens.default_], useExtentsHint=True)
print "-"*80
print "Testing aggregate bounds with unloaded child prims"
print "-"*80
print
prim = stage.GetPseudoRoot()
bboxNo = bboxCacheNo.ComputeWorldBound(prim)
bboxYes = bboxCacheYes.ComputeWorldBound(prim)
assert bboxNo.GetRange().IsEmpty()
assert not bboxYes.GetRange().IsEmpty()
def sync_from_prim(self, root_obj, prim):
prim_obj = self.id_data
self.sdf_path = str(prim.GetPath())
self.cached_stage.assign(prim.GetStage())
prim_obj.name = prim.GetName()
prim_obj.parent = root_obj
prim_obj.matrix_local = usd_utils.get_xform_transform(
UsdGeom.Xform(prim))
prim_obj.hide_viewport = prim.GetTypeName() not in GEOM_TYPES
def draw_item(self, context, layout, data, item, icon, active_data,
active_propname, index):
if self.layout_type not in {'DEFAULT', 'COMPACT'}:
return
for i in range(item.indent):
layout.split(factor=0.1)
items = data.items
prim = data.get_prim(item)
if not prim:
return
visible = UsdGeom.Imageable(prim).ComputeVisibility() != 'invisible'
col = layout.column()
if not prim.GetChildren():
icon = 'DOT'
col.enabled = False
elif len(items) > index + 1 and items[index + 1].indent > item.indent:
icon = 'TRIA_DOWN'
else:
icon = 'TRIA_RIGHT'
expand_op = col.operator(HDUSD_OP_usd_list_item_expand.bl_idname,
text="",
icon=icon,
emboss=False,
depress=False)
expand_op.index = index
col = layout.column()
col.label(text=prim.GetName())
col.enabled = visible
col = layout.column()
col.alignment = 'RIGHT'
col.label(text=prim.GetTypeName())
col.enabled = visible
col = layout.column()
col.alignment = 'RIGHT'
if prim.GetTypeName() == 'Xform':
icon = 'HIDE_OFF' if visible else 'HIDE_ON'
else:
col.enabled = False
icon = 'NONE'
visible_op = col.operator(HDUSD_OP_usd_list_item_show_hide.bl_idname,
text="",
icon=icon,
emboss=False,
depress=False)
visible_op.index = index
def _MoveCamera(stage):
from pxr import UsdGeom, Gf
cam = UsdGeom.Camera.Get(stage, '/World/main_cam')
# the camera derives from UsdGeom.Xformable so we can
# use the XformCommonAPI on it, too, and see how rotations are handled
xformAPI = UsdGeom.XformCommonAPI(cam)
xformAPI.SetTranslate((8, 120, 8))
# -86 degree rotation around X axis. Can specify rotation order as
# optional parameter
xformAPI.SetRotate((-86, 0, 0))
def _ValidateXformPrim(self, stage, xformPrimPath,
expectedTranslation=None):
xformPrim = stage.GetPrimAtPath(xformPrimPath)
self.assertTrue(xformPrim)
xformSchema = UsdGeom.Xform(xformPrim)
self.assertTrue(xformSchema)
self._ValidateXformOps(xformPrim, expectedTranslation)
return xformSchema
def _AssertDisplayColorEqual(self, prim, expectedColor):
# expectedColor should be given as a list, so turn it into the type we'd
# expect to get out of the displayColor attribute, namely a VtVec3fArray.
expectedColor = Vt.Vec3fArray(1, expectedColor)
gprim = UsdGeom.Gprim(prim)
self.assertTrue(gprim)
displayColorPrimvar = gprim.GetDisplayColorPrimvar()
self.assertTrue(displayColorPrimvar)
self.assertEqual(displayColorPrimvar.ComputeFlattened(), expectedColor)
def __init__(self, appController, item):
PrimContextMenuItem.__init__(self, appController, item)
self._nonActiveCameraPrim = None
if len(self._selectionDataModel.getPrims()) is 1:
prim = self._selectionDataModel.getPrims()[0]
from pxr import UsdGeom
cam = UsdGeom.Camera(prim)
if cam:
if prim != appController.getActiveCamera():
self._nonActiveCameraPrim = prim
def test_import_st_no_indices_uniform(self, out_dir, mesh):
out_path = os.path.join(out_dir, 'st_no_indices_face_uniform.usda')
uvs = torch.rand((mesh.faces.size(0), 2))
scene_path = '/World/mesh_0'
usd.export_mesh(out_path, scene_path=scene_path, vertices=mesh.vertices,
faces=mesh.faces, uvs=uvs)
# check that interpolation was set correctly to 'uniform'
stage = Usd.Stage.Open(out_path)
pv = UsdGeom.Mesh(stage.GetPrimAtPath(scene_path)).GetPrimvar('st')
assert pv.GetInterpolation() == 'uniform'
def createCommonAPI(testCase, sphereXformable):
sphereXformable.AddTranslateOp(UsdGeom.XformOp.PrecisionFloat,
"pivot")
sphereXformable.AddTranslateOp(UsdGeom.XformOp.PrecisionFloat,
"pivot", True)
self.assertEqual(
sphereXformable.GetXformOpOrderAttr().Get(),
Vt.TokenArray(("xformOp:translate:pivot",
"!invert!xformOp:translate:pivot")))
self.assertTrue(UsdGeom.XformCommonAPI(sphereXformable))
def makeBackSq(parentPath, imgHeight, imgWidth, upAxis, frameW, materialBackSq, stage):
meshPath = os.path.join(parentPath, "BackSq")
meshSchema = UsdGeom.Mesh.Define(stage, meshPath)
vertexCounts = [4]
meshSchema.CreateFaceVertexCountsAttr().Set(vertexCounts)
indices = [2, 3, 0, 1]
meshSchema.GetFaceVertexIndicesAttr().Set(indices)
meshSchema.GetSubdivisionSchemeAttr().Set("none")
# put comment here
offset = -0.6
sqSide = min(imgHeight, imgWidth)
# we want to put the origin of the card in the center 'bottom'
# this is course depends on what the up axis is:
if upAxis == 'y' or upAxis == 'Y':
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y)
points = [(-sqSide /2, sqSide + frameW, offset),
(sqSide /2, sqSide + frameW, offset),
(sqSide/2, frameW, offset),
(-sqSide /2, frameW, offset)]
if upAxis == 'z' or upAxis == 'Z':
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
points =[(-sqSide /2, offset, sqSide + frameW),
(sqSide /2, offset, sqSide + frameW),
(sqSide/2, offset, frameW),
(-sqSide /2, offset, frameW)]
meshSchema.CreatePointsAttr().Set(points)
uvs = [(1, 1),
(0, 1),
(0, 0),
(1, 0)]
st = meshSchema.CreatePrimvar("st", Sdf.ValueTypeNames.Float2Array)
st.Set(uvs)
st.SetInterpolation(UsdGeom.Tokens.vertex)
extent = meshSchema.ComputeExtent(points)
meshSchema.CreateExtentAttr().Set(extent)
meshSchema.GetDisplayColorAttr().Set( [(1, 1, 1)] )
if materialBackSq != None:
prim = meshSchema.GetPrim()
relName = "material:binding"
rel = prim.CreateRelationship(relName)
rel.AddTarget(materialBackSq)
def compute(self, **kwargs):
depsgraph = bpy.context.evaluated_depsgraph_get()
stage = self.cached_stage.create()
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
root_prim = stage.GetPseudoRoot()
kwargs = {'scene': depsgraph.scene,
'is_use_animation': self.is_use_animation,
'is_restrict_frames': self.is_restrict_frames,
'frame_start': self.frame_start,
'frame_end': self.frame_end}
if self.data == 'SCENE':
for obj_data in ObjectData.depsgraph_objects(depsgraph):
object.sync(root_prim, obj_data, **kwargs)
if depsgraph.scene.world is not None:
world.sync(root_prim, depsgraph.scene.world)
elif self.data == 'COLLECTION':
if not self.collection:
return
for obj_col in self.collection.objects:
if obj_col.hdusd.is_usd or (obj_col.type == 'CAMERA' and obj_col.name == USD_CAMERA ):
continue
object.sync(root_prim, ObjectData.from_object(
obj_col.evaluated_get(depsgraph)), **kwargs)
elif self.data == 'OBJECT':
if not self.object or self.object.hdusd.is_usd:
return
object.sync(root_prim, ObjectData.from_object(self.object.evaluated_get(depsgraph)),
**kwargs)
return stage
def test_XformOpOperators(self):
s = Usd.Stage.CreateInMemory()
rootXform = UsdGeom.Xform.Define(s, "/Root")
translateOp = rootXform.AddTranslateOp()
scaleOp = rootXform.AddScaleOp()
self.assertFalse(UsdGeom.XformOp())
self.assertTrue(translateOp)
self.assertTrue(scaleOp)
xformOps = rootXform.GetOrderedXformOps()
self.assertEqual(xformOps, [translateOp, scaleOp])
xformOps.remove(translateOp)
self.assertEqual(xformOps, [scaleOp])
def test_InvalidXformable(self):
xf = UsdGeom.Xformable()
# This used to crash before the SchemaBase __getattribute__ method
# was overridden to test the validity of the underlying prim.
with self.assertRaises(RuntimeError):
xf.ClearXformOpOrder()
# It should still be safe to get the prim, but the prim will be invalid.
p = xf.GetPrim()
with self.assertRaises(RuntimeError):
p.IsActive()
# It should still be safe to get the path, but the path will be empty.
self.assertEqual(xf.GetPath(), Sdf.Path())
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 __init__(self, appController, item):
PrimContextMenuItem.__init__(self, appController, item)
from pxr import UsdGeom
self._imageable = False
self._isVisible = False
for prim in self._selectionDataModel.getPrims():
imgbl = UsdGeom.Imageable(prim)
if imgbl:
self._imageable = True
self._isVisible = (imgbl.ComputeVisibility(self._currentFrame)
== UsdGeom.Tokens.inherited)
break
def _sync(self, context, depsgraph):
super()._sync(context, depsgraph)
stage = self.cached_stage.create()
log("sync", depsgraph)
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
root_prim = stage.GetPseudoRoot()
for obj_data in object.ObjectData.depsgraph_objects(
depsgraph,
space_data=self.space_data,
use_scene_cameras=False,
use_scene_lights=self.shading_data.use_scene_lights):
object.sync(root_prim, obj_data)
world.sync(root_prim, depsgraph.scene.world, self.shading_data)
self.render_params.clearColor = world.get_clear_color(root_prim)
def main():
# Make the stage
stage = Usd.Stage.CreateNew(STAGENAME)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y)
# Set transform and create primitive
xformPrim = UsdGeom.Xform.Define(stage, '/hello')
Usd.ModelAPI(xformPrim).SetKind(Kind.Tokens.component)
spherePrim = UsdGeom.Sphere.Define(stage, '/hello/world')
# Create texture coords
texCoords = spherePrim.CreatePrimvar('st',
Sdf.ValueTypeNames.TexCoord2fArray,
UsdGeom.Tokens.varying)
# This line makes USD complain that there aren't enough texture coordinates.
#texCoords.Set([(0, 0), (1, 0), (1,1), (0, 1)])
# Create material
material = UsdShade.Material.Define(stage, '/hello/material')
stInput = material.CreateInput('frame:stPrimvarName',
Sdf.ValueTypeNames.Token)
stInput.Set('st')
pbrShader = UsdShade.Shader.Define(stage, '/hello/material/PBRShader')
pbrShader.CreateIdAttr('UsdPreviewSurface')
pbrShader.CreateInput('roughness', Sdf.ValueTypeNames.Float).Set(0.4)
pbrShader.CreateInput('metallic', Sdf.ValueTypeNames.Float).Set(0.0)
material.CreateSurfaceOutput().ConnectToSource(pbrShader, 'surface')
stReader = UsdShade.Shader.Define(stage, '/hello/material/stReader')
stReader.CreateIdAttr('UsdPrimvarReader_float2')
stReader.CreateInput('varname',
Sdf.ValueTypeNames.Token).ConnectToSource(stInput)
diffuseTextureSampler = UsdShade.Shader.Define(
stage, '/hello/material/diffuseTexture')
diffuseTextureSampler.CreateIdAttr('UsdUVTexture')
diffuseTextureSampler.CreateInput(
'file', Sdf.ValueTypeNames.Asset).Set(TEXTURE_FILE)
diffuseTextureSampler.CreateInput(
'st', Sdf.ValueTypeNames.Float2).ConnectToSource(stReader, 'result')
diffuseTextureSampler.CreateOutput('rgb', Sdf.ValueTypeNames.Float3)
pbrShader.CreateInput('diffuseColor',
Sdf.ValueTypeNames.Color3f).ConnectToSource(
diffuseTextureSampler, 'rgb')
UsdShade.MaterialBindingAPI(spherePrim).Bind(material)
# Save stage
stage.Save()
def test_Extent(self):
stage = Usd.Stage.Open("test.usda")
pi = UsdGeom.PointInstancer(
stage.GetPrimAtPath("/MultiInstanceForExtents"))
times = [0, 1, 2]
expectedExtents = [[(-1, -1, -1), (1, 1, 1)],
[(-3.7600734, 1.2399265, -1),
(3.7600734, 6.2600737, 3.5)],
[(-6.3968024, 3.6031978, -1),
(6.3968024, 11.396802, 6)]]
self.compareExtents(pi, times, 0, expectedExtents)
def _create_basic_scene():
stage = Usd.Stage.CreateInMemory()
sphere = UsdGeom.Sphere.Define(stage, "/Some/Prim")
sphere.GetRadiusAttr().Set(10.0)
another = Usd.Stage.CreateInMemory()
another.GetRootLayer().subLayerPaths.append(
stage.GetRootLayer().identifier)
override = UsdGeom.Sphere(another.OverridePrim("/Some/Prim"))
override.GetRadiusAttr().Set(20.0)
return another
def testMashPrototypes_NoIdsArray(self):
"""
MASH instancers might not have an ids array if using dynamics.
Make sure they still export OK.
"""
instancerPrim = self.stage.GetPrimAtPath(
"/InstancerTest/MASH2_Instancer")
self.assertTrue(instancerPrim)
instancer = UsdGeom.PointInstancer(instancerPrim)
protoIndices = instancer.GetProtoIndicesAttr().Get()
self.assertEqual(len(protoIndices), 10)
def testTransforms(self):
"""
Check that the point transforms are correct.
"""
mayaInstancer = OMFX.MFnInstancer(self._GetDagPath("instancer1"))
usdInstancer = UsdGeom.PointInstancer(
self.stage.GetPrimAtPath("/InstancerTest/instancer1"))
time = self.START_TIMECODE
while time <= self.END_TIMECODE:
cmds.currentTime(time, edit=True)
# Need to do this because MFnInstancer will give instance matrices
# as offsets from prototypes' original world space positions.
worldPositions = [
self._GetWorldSpacePosition("|dummyGroup|pCube1"),
self._GetWorldSpacePosition(
"|InstancerTest|instancer1|prototypeUnderInstancer"),
self._GetWorldSpacePosition("|referencePrototype")
]
paths = OM.MDagPathArray()
matrices = OM.MMatrixArray()
particlePathStartIndices = OM.MIntArray()
pathIndices = OM.MIntArray()
mayaInstancer.allInstances(paths, matrices,
particlePathStartIndices, pathIndices)
usdInstanceTransforms = \
usdInstancer.ComputeInstanceTransformsAtTime(time, time)
usdProtoIndices = usdInstancer.GetProtoIndicesAttr().Get(time)
self.assertEqual(matrices.length(), len(usdInstanceTransforms))
# Compute the instancer-space position of instances in Maya
# (including the protos' transforms). By default, this is what
# UsdGeomPointInstancer::ComputeInstanceTransformsAtTime already
# gives us.
mayaWorldPositions = [
worldPositions[protoIndex] for protoIndex in usdProtoIndices
]
mayaGfMatrices = [
mayaWorldPositions[i] * self._MayaToGfMatrix(matrices[i])
for i in xrange(matrices.length())
]
usdGfMatrices = [
usdInstanceTransforms[i]
for i in xrange(len(usdInstanceTransforms))
]
for i in xrange(len(usdGfMatrices)):
self._AssertXformMatrices(mayaGfMatrices[i], usdGfMatrices[i])
time += 1.0
def createXformOps(ufeObject):
selDag, selPrim = getDagAndPrimFromUfe(ufeObject)
stage = mayaUsdLib.GetPrim(selDag).GetStage()
primPath = Sdf.Path(selPrim)
prim = stage.GetPrimAtPath(primPath)
xformAPI = UsdGeom.XformCommonAPI(prim)
xformAPI.CreateXformOps(
UsdGeom.XformCommonAPI.OpTranslate,
UsdGeom.XformCommonAPI.OpRotate,
UsdGeom.XformCommonAPI.OpScale)
def testExportUvVersusUvIndexFromIterator(self):
"""
Tests that UVs export properly on a mesh where the UV returned by
MItMeshFaceVertex::getUV is known to be different from that
returned by MItMeshFaceVertex::getUVIndex and indexed into the UV array.
(The latter should return the desired result from the outMesh and is the
method currently used by usdMaya.)
"""
brokenBoxMesh = UsdGeom.Mesh(self._stage.GetPrimAtPath(
"/UsdExportUVSetsTest/Geom/BrokenUVs/box"))
stPrimvar = brokenBoxMesh.GetPrimvar("st").ComputeFlattened()
self.assertEqual(stPrimvar[0], Gf.Vec2f(1.0, 1.0))
def relocateWorldCenter(self,in_dagnode_path="|assets", out_dagnode_path="|assets|scn"):
'''
Try to define static prim xform information.
'''
if not cmds.objExists(in_dagnode_path) or not cmds.objExists(out_dagnode_path):
return
if not self.isDAGNodeBeMoved(in_dagnode_path):
return
scenegraph_path = self.fetchNameSceneGraphPrim(out_dagnode_path)
scenegraph_data = self.fetchDataStaticMayaXform(in_dagnode_path)
prim = self.__stage__.GetPrimAtPath( scenegraph_path )
if scenegraph_data["visibility"]:
UsdGeom.Imageable(prim).MakeVisible()
else:
UsdGeom.Imageable(prim).MakeInvisible()
rotateXYZ = scenegraph_data["rotateXYZ"]
UsdGeom.XformCommonAPI(prim).SetRotate(tuple(rotateXYZ),UsdGeom.XformCommonAPI.RotationOrderXYZ)
scale = scenegraph_data["scale"]
UsdGeom.XformCommonAPI(prim).SetScale(tuple(scale))
translate = scenegraph_data["translate"]
UsdGeom.XformCommonAPI(prim).SetTranslate(tuple(translate))
def GetInstanceIndicesForIds(prim, instanceIds, time):
'''Attempt to find the instance indices of a list of authored instance IDs
for prim 'prim' at time 'time'. If the prim is not a PointInstancer or does
not have authored IDs, returns None. If any ID from 'instanceIds' does not
exist at the given time, its index is not added to the list (because it does
not have an index).'''
ids = UsdGeom.PointInstancer(prim).GetIdsAttr().Get(time)
if ids:
return [instanceIndex for instanceIndex, instanceId in enumerate(ids)
if instanceId in instanceIds]
else:
return None
def __init__(self, mainWindow, item):
NodeContextMenuItem.__init__(self, mainWindow, item)
from pxr import UsdGeom
self._imageable = False
self._isVisible = False
for prim in self._currentNodes:
imgbl = UsdGeom.Imageable(prim)
if imgbl:
self._imageable = True
self._isVisible = (imgbl.ComputeVisibility(
self._currentFrame) == UsdGeom.Tokens.inherited)
break
def __defineUSDDefaultSetting__(self, dagnode_path, rangeTimeCode=None):
'''
Set the default of USD such as TimeCode, DefaultPrim and UpAxis.
'''
# set USD default setting
if rangeTimeCode:
self.__stage__.SetStartTimeCode(rangeTimeCode[0])
self.__stage__.SetEndTimeCode(rangeTimeCode[1])
scenegraph_path = self.fetchNameSceneGraphPrim(dagnode_path)
root_prim = self.__stage__.GetPrimAtPath( self.fetchNameUsdRoot(scenegraph_path))
self.__stage__.SetDefaultPrim(root_prim)
UsdGeom.SetStageUpAxis(self.__stage__, UsdGeom.Tokens.y)
def TestUsd4957():
""" Tests the case in which a prim has an xform directly on it and its
bounding box relative to one of its ancestors is computed using
ComputeRelativeBound().
"""
s = Usd.Stage.Open("testUSD4957.usda")
b = s.GetPrimAtPath("/A/B")
c = s.GetPrimAtPath("/A/B/C")
bc = UsdGeom.BBoxCache(Usd.TimeCode.Default(), ['default', 'render'])
# Call the function being tested
relativeBbox = bc.ComputeRelativeBound(c, b)
# Compare the result with the bbox of C in its local space
cExtent = UsdGeom.Boundable(c).GetExtentAttr().Get()
cRange = Gf.Range3d(Gf.Vec3d(cExtent[0]), Gf.Vec3d(cExtent[1]))
cLocalXform = UsdGeom.Xformable(c).GetLocalTransformation()
cBbox = Gf.BBox3d(cRange, cLocalXform)
AssertBBoxesClose(relativeBbox, cBbox,
"ComputeRelativeBound produced a wrong bbox.")
def exportDynamicAssmblyRefUSD(self, location, destination, rangeTimeCode, motionSample):
scenegraph_path = self.fetchNameSceneGraphPrim(dagnode_path)
scenegraph_tree = self.fetchListUSDPrim(dagnode_path)
scenegraph_data = self.fetchDataDynamicMayaXform(dagnode_path,rangeTimeCode,motionSample)
# create a UsdStage
if os.path.isfile(destination):
stage = Usd.Stage.Open(destination)
else:
stage = Usd.Stage.CreateNew(destination)
for prim_node in scenegraph_tree:
gprim = Usd.ModelAPI(UsdGeom.Xform.Define(stage, prim_node))
prim = stage.GetPrimAtPath( scenegraph_path )
root_prim = stage.GetPrimAtPath( self.fetchNameUsdRoot(scenegraph_path))
# set USD default setting
stage.SetStartTimeCode(rangeTimeCode[0])
stage.SetEndTimeCode(rangeTimeCode[1])
stage.SetDefaultPrim(root_prim)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y)
# set visibility rotateXYZ scale translate sampleTime data into specific prim
for frameData in sorted(scenegraph_data.keys()):
if scenegraph_data[frameData]["visibility"]:
UsdGeom.Imageable(prim).MakeVisible(frameData)
else:
UsdGeom.Imageable(prim).MakeInvisible(frameData)
rotateXYZ = scenegraph_data[frameData]["rotateXYZ"]
UsdGeom.XformCommonAPI(prim).SetRotate(tuple(rotateXYZ),UsdGeom.XformCommonAPI.RotationOrderXYZ,frameData)
scale = scenegraph_data[frameData]["scale"]
UsdGeom.XformCommonAPI(prim).SetScale(tuple(scale),frameData)
translate = scenegraph_data[frameData]["translate"]
UsdGeom.XformCommonAPI(prim).SetTranslate(tuple(translate), frameData)
# save UsdStage
stage.GetRootLayer().Save()
