def _AddCueRigAndCacheVariants(stage):
from pxr import Kind, Sdf, Usd, UsdGeom
from AL.usd import schemas
# Make sure the model-parents we need are well-specified
Usd.ModelAPI(UsdGeom.Xform.Define(stage,
'/World')).SetKind(Kind.Tokens.group)
animModel = Usd.ModelAPI(UsdGeom.Xform.Define(stage, '/World/anim'))
animModel.SetKind(Kind.Tokens.group)
animVariant = animModel.GetPrim().GetVariantSets().AddVariantSet(
'animVariant')
animVariant.AddVariant('rig')
animVariant.SetVariantSelection('rig')
with animVariant.GetVariantEditContext():
# Creating maya rig for CueBall
cueBallRig = schemas.MayaReference.Define(stage, '/World/anim/CueBall')
cueBallRig.CreateMayaNamespaceAttr().Set('cueball_rig')
cueBallRig.CreateMayaReferenceAttr().Set(
os.path.join(ASSET_BASE, 'Ball/Ball_rig.ma'))
animVariant.AddVariant('cache')
animVariant.SetVariantSelection('cache')
with animVariant.GetVariantEditContext():
# Creating cache layer and bring in as payload
cueCacheLayerPath = 'shots/s00_01/s00_01_animcue.usd'
if not os.path.exists(cueCacheLayerPath):
payload = Usd.Stage.CreateNew(cueCacheLayerPath)
payload.DefinePrim("/Ball")
payload.Save()
cueBallCache = UsdGeom.Xform.Define(stage, '/World/anim/CueBall')
cueBallCache.GetPrim().SetPayload(cueCacheLayerPath, '/Ball')
def main():
sequenceFilePath = 'shots/s00/s00.usd'
setsLayoutLayerFilePath = 'shots/s00/s00_sets.usd'
from pxr import Kind, Usd, UsdGeom, Sdf
stage = Usd.Stage.Open(sequenceFilePath)
# we use Sdf, a lower level library, to obtain the 'sets' layer.
workingLayer = Sdf.Layer.FindOrOpen(setsLayoutLayerFilePath)
assert stage.HasLocalLayer(workingLayer)
# this makes the workingLayer the target for authoring operations by the
# stage.
stage.SetEditTarget(workingLayer)
# Make sure the model-parents we need are well-specified
Usd.ModelAPI(UsdGeom.Xform.Define(stage,
'/World')).SetKind(Kind.Tokens.group)
Usd.ModelAPI(UsdGeom.Xform.Define(stage, '/World/sets')).SetKind(
Kind.Tokens.group)
# in previous examples, we've been using GetReferences().AppendReference(...). The
# following uses .SetItems() instead which lets us explicitly set (replace)
# the references at once instead of adding.
stage.DefinePrim('/World/sets/Room_set').GetReferences().SetReferences(
[Sdf.Reference(os.path.join(ASSET_BASE, 'Room_set/Room_set.usd'))])
stage.GetEditTarget().GetLayer().Save()
print '==='
print 'usdview %s' % sequenceFilePath
print 'usdcat %s' % setsLayoutLayerFilePath
def testExportWithKindAttrAndKindFlag(self):
"""
Tests exporting a Maya file with both USD_kind custom attributes and
using the usdExport -kind flag; there should be an error if the USD_kind
is not derived from the kind specified in the -kind flag.
"""
cmds.file(os.path.abspath('KindTestUsdKindAttr.ma'),
open=True,
force=True)
cmds.loadPlugin('pxrUsd')
usdFilePath = os.path.abspath('KindTestUsdKindAttr.usda')
with self.assertRaises(RuntimeError):
cmds.usdExport(mergeTransformAndShape=True,
file=usdFilePath,
kind='assembly')
cmds.usdExport(mergeTransformAndShape=True,
file=usdFilePath,
kind='model')
stage = Usd.Stage.Open(usdFilePath)
self.assertTrue(stage)
rootPrim = stage.GetPrimAtPath('/KindTest')
self.assertTrue(Kind.Registry().IsA(
Usd.ModelAPI(rootPrim).GetKind(), 'component'))
rootPrim2 = stage.GetPrimAtPath('/KindTest2')
self.assertTrue(Kind.Registry().IsA(
Usd.ModelAPI(rootPrim2).GetKind(), 'assembly'))
def test_PrimIsModelOrGroup(self):
for fmt in allFormats:
s = Usd.Stage.CreateInMemory('TestPrimIsModelOrGroup.' + fmt)
group = s.DefinePrim("/Group", "Xform")
Usd.ModelAPI(group).SetKind('group')
model = s.DefinePrim("/Group/Model", "Model")
Usd.ModelAPI(model).SetKind('model')
mesh = s.DefinePrim("/Group/Model/Sbdv", "Mesh")
x1 = list(Usd.PrimRange(group, Usd.PrimIsModel))
self.assertEqual(x1, [group, model])
x2 = list(Usd.PrimRange(group, Usd.PrimIsGroup))
self.assertEqual(x2, [group])
x3 = list(Usd.PrimRange(group, ~Usd.PrimIsModel))
self.assertEqual(x3, [])
x4 = list(Usd.PrimRange(mesh, ~Usd.PrimIsModel))
self.assertEqual(x4, [mesh])
x5 = list(Usd.PrimRange(group, Usd.PrimIsModel | Usd.PrimIsGroup))
self.assertEqual(x5, [group, model])
x6 = list(Usd.PrimRange(group, Usd.PrimIsModel & Usd.PrimIsGroup))
self.assertEqual(x6, [group])
def testExport(self):
"""
Tests that the built-in metadata attribute converters can export
USD_hidden, USD_instanceable, and USD_kind attributes by setting
the correct metadata in the output USD file.
"""
newUsdFilePath = os.path.abspath('UsdAttrsNew.usda')
cmds.usdExport(file=newUsdFilePath, shadingMode='none')
newUsdStage = Usd.Stage.Open(newUsdFilePath)
# pCube1 and pCube2 have USD_kind.
prim1 = newUsdStage.GetPrimAtPath('/World/pCube1')
self.assertEqual(Usd.ModelAPI(prim1).GetKind(), 'potato')
prim2 = newUsdStage.GetPrimAtPath('/World/pCube2')
self.assertEqual(Usd.ModelAPI(prim2).GetKind(), 'bakedpotato')
# pCube2 and pCube4 have USD_hidden.
self.assertTrue(newUsdStage.GetPrimAtPath('/World/pCube2').IsHidden())
self.assertTrue(newUsdStage.GetPrimAtPath('/World/pCube4').IsHidden())
# pCube3 and pCube4 have USD_instanceable.
self.assertTrue(
newUsdStage.GetPrimAtPath('/World/pCube3').IsInstanceable())
self.assertTrue(
newUsdStage.GetPrimAtPath('/World/pCube4').IsInstanceable())
def createDefalut():
try:
chrStage = Usd.Stage.CreateNew(FILEBASE + 'chr.usda')
except:
chrStage = Usd.Stage.Open(FILEBASE + 'chr.usda')
setChrPrim = UsdGeom.Xform.Define(chrStage, '/chr').GetPrim()
chrStage.SetDefaultPrim(setChrPrim)
UsdGeom.SetStageUpAxis(chrStage, UsdGeom.Tokens.y)
Usd.ModelAPI(setChrPrim).SetKind(Kind.Tokens.assembly)
chrStage.GetRootLayer().Save()
try:
prpStage = Usd.Stage.CreateNew(FILEBASE + 'prp.usda')
except:
prpStage = Usd.Stage.Open(FILEBASE + 'prp.usda')
setPrpPrim = UsdGeom.Xform.Define(prpStage, '/prp').GetPrim()
prpStage.SetDefaultPrim(setPrpPrim)
UsdGeom.SetStageUpAxis(prpStage, UsdGeom.Tokens.y)
Usd.ModelAPI(setPrpPrim).SetKind(Kind.Tokens.assembly)
prpStage.GetRootLayer().Save()
try:
scnStage = Usd.Stage.CreateNew(FILEBASE + 'scn.usda')
except:
scnStage = Usd.Stage.Open(FILEBASE + 'scn.usda')
setScnPrim = UsdGeom.Xform.Define(scnStage, '/scn').GetPrim()
scnStage.SetDefaultPrim(setScnPrim)
UsdGeom.SetStageUpAxis(scnStage, UsdGeom.Tokens.y)
Usd.ModelAPI(setScnPrim).SetKind(Kind.Tokens.assembly)
scnStage.GetRootLayer().Save()
def _TestPrototypes(self, instancerName):
"""
Tests that all of the instancer prototypes made it to USD.
"""
self.assertTrue(self.stage)
instancer = OMFX.MFnInstancer(self._GetDagPath(instancerName))
# Move to the last frame so that we can ensure all of the prototypes
# are in use.
cmds.currentTime(self.END_TIMECODE, edit=True)
paths = OM.MDagPathArray()
matrices = OM.MMatrixArray()
particlePathStartIndices = OM.MIntArray()
pathIndices = OM.MIntArray()
instancer.allInstances(paths, matrices, particlePathStartIndices,
pathIndices)
# Check that the Maya instanced objects are what we think they are.
pathStrings = [paths[i].fullPathName() for i in range(paths.length())]
self.assertEqual(
pathStrings,
[
# 0 (logical 0) - Cube
"|dummyGroup|pCube1|pCubeShape1",
"|dummyGroup|pCube1|pSphere1|pSphereShape1",
# 1 (logical 2) - Sphere
"|InstancerTest|%s|prototypeUnderInstancer|prototypeUnderInstancerShape"
% instancerName,
# 2 (logical 3) - Reference
"|referencePrototype|NS_referencePrototype:Geom|NS_referencePrototype:Cone|NS_referencePrototype:ConeShape"
])
# Check that the USD prims have correct type name, references, kinds,
# kinds, instancerTranslate xformOps.
instancerPrim = self.stage.GetPrimAtPath("/InstancerTest/%s" %
instancerName)
self.assertEqual(
Usd.ModelAPI(instancerPrim).GetKind(), Kind.Tokens.subcomponent)
prototypesPrim = instancerPrim.GetChild("Prototypes")
self.assertEqual(len(prototypesPrim.GetChildren()), 3)
self.assertEqual(
Usd.ModelAPI(prototypesPrim).GetKind(), Kind.Tokens.subcomponent)
# Note that pCube1_0 is a special case where instancerTranslate
# isn't the opposite of translate, so both have to be left in.
prototype0 = prototypesPrim.GetChild("pCube1_0")
self._AssertPrototype(prototype0, "Xform", 2, True)
prototype1 = prototypesPrim.GetChild("prototypeUnderInstancer_1")
self._AssertPrototype(prototype1, "Mesh", 0, False)
prototype2 = prototypesPrim.GetChild("referencePrototype_2")
self._AssertPrototype(prototype2, "Xform", 1, False)
self.assertEqual(
Usd.ModelAPI(prototype2).GetAssetName(), "ConeAssetName")
def test_ModelAPI(self):
for fmt in allFormats:
s = Usd.Stage.CreateInMemory('TestModelAPI.' + fmt)
p = s.DefinePrim('/World', 'Xform')
model = Usd.ModelAPI(p)
self.assertEqual(model.GetKind(), '')
self.assertFalse(model.IsModel())
self.assertFalse(model.IsGroup())
model.SetKind(Kind.Tokens.group)
# Testing that initializing a schema from another schema works
newSchema = Usd.ModelAPI(model)
self.assertEqual(newSchema.GetKind(), model.GetKind())
def addReference(stage, path, fileName, targetPrim):
'''
Add a reference to the given USD stage at the given path.
If defaultPrim is not None, the the referencee contains a default prim and
we can contruct the reference to use it.
Otherwise, create the reference to point to the first found rootPrim.
(We are assume these files will only have one root prim)
'''
prim = stage.GetPrimAtPath(path)
if not prim:
# Create groups (xforms) for all the intermediate scopes in the namespace
for ancestor in Sdf.Path(path).GetParentPath().GetPrefixes():
p = UsdGeom.Xform.Define(stage, ancestor)
Usd.ModelAPI(p).SetKind(Kind.Tokens.group)
# Create an over to hold the actual reference. This is so that
# the composited prim is named what we see in the referencing file.
prim = stage.OverridePrim(path)
else:
prim = stage.GetPrimAtPath(path)
refList = prim.GetReferences()
if targetPrim:
refList.AddReference(Sdf.Reference(fileName, targetPrim))
else:
refList.AddReference(Sdf.Reference(fileName))
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()
def _CreateAsset(assetName, assetDir, assetKind, addShadingVariantLayer):
assetFilePath = os.path.join(assetDir, '%s.usd' % assetName)
print "Creating asset at %s" % assetFilePath
# Make the layer ascii - good for readability, plus the file is small
rootLayer = Sdf.Layer.CreateNew(assetFilePath, args={'format': 'usda'})
assetStage = Usd.Stage.Open(rootLayer)
# Define a prim for the asset and make it the default for the stage.
assetPrim = UsdGeom.Xform.Define(assetStage, '/%s' % assetName).GetPrim()
assetStage.SetDefaultPrim(assetPrim)
# Lets viewing applications know how to orient a free camera properly
UsdGeom.SetStageUpAxis(assetStage, UsdGeom.Tokens.y)
# Usually we will "loft up" the kind authored into the exported geometry
# layer rather than re-stamping here; we'll leave that for a later
# tutorial, and just be explicit here.
model = Usd.ModelAPI(assetPrim)
if assetKind:
model.SetKind(assetKind)
model.SetAssetName(assetName)
model.SetAssetIdentifier('%s/%s.usd' % (assetName, assetName))
refs = []
if addShadingVariantLayer:
# if we're going to add it, then shading is stronger than geom and needs
# to be added first
refs.append('./%s.shadingVariants.usda' % assetName)
refs.append('./%s.maya.usd' % assetName)
_CreateAndReferenceLayers(assetPrim, assetDir, refs)
assetStage.GetRootLayer().Save()
def testExportWithKindFlag(self):
"""
Tests exporting a Maya file with no USD_kind custom attributes
and using the usdExport -kind flag.
"""
cmds.file(os.path.abspath('KindTest.ma'), open=True, force=True)
cmds.loadPlugin('pxrUsd')
usdFilePath = os.path.abspath('KindTest.usda')
# Check the error mark; this ensures that we actually got a Tf error
# (that was eventually converted into a Maya error, which Maya raises
# in Python as a RuntimeError).
mark = Tf.Error.Mark()
mark.SetMark()
with self.assertRaises(RuntimeError):
cmds.usdExport(mergeTransformAndShape=True,
file=usdFilePath,
kind='assembly')
errors = mark.GetErrors()
self.assertEqual(len(errors), 1)
self.assertIn(
"</KindTest> has kind 'assembly', which is derived from 'assembly'",
str(errors[0]))
cmds.usdExport(mergeTransformAndShape=True,
file=usdFilePath,
kind='fakeKind')
stage = Usd.Stage.Open(usdFilePath)
self.assertTrue(stage)
rootPrim = stage.GetPrimAtPath('/KindTest')
self.assertTrue(Kind.Registry().IsA(
Usd.ModelAPI(rootPrim).GetKind(), 'fakeKind'))
def testExportWithAssemblyAndMesh(self):
"""
Tests exporting a Maya file with a root prim containing an assembly
and a mesh.
"""
cmds.file(os.path.abspath('KindTestAssemblyAndMesh.ma'),
open=True,
force=True)
cmds.loadPlugin('pxrUsd')
# Should fail due to the mesh.
usdFilePath = os.path.abspath('KindTestAssemblyAndMesh.usda')
with self.assertRaises(RuntimeError):
cmds.usdExport(mergeTransformAndShape=True,
file=usdFilePath,
kind='assembly')
# Should be 'component' because of the mesh
usdFilePath = os.path.abspath('KindTestAssemblyAndMesh.usda')
cmds.usdExport(mergeTransformAndShape=True, file=usdFilePath)
stage = Usd.Stage.Open(usdFilePath)
self.assertTrue(stage)
rootPrim = stage.GetPrimAtPath('/KindTest')
self.assertTrue(Kind.Registry().IsA(
Usd.ModelAPI(rootPrim).GetKind(), 'component'))
def testExportWithAssemblies(self):
"""
Tests exporting a Maya file with a root prim containing an assembly.
"""
cmds.file(os.path.abspath('KindTestAssembly.ma'),
open=True,
force=True)
cmds.loadPlugin('pxrUsd')
usdFilePath = os.path.abspath('KindTestAssembly.usda')
cmds.usdExport(mergeTransformAndShape=True,
file=usdFilePath,
kind='assembly')
stage = Usd.Stage.Open(usdFilePath)
self.assertTrue(stage)
# Default kind without setting kind=assembly should still be assembly.
usdFilePath = os.path.abspath('KindTestAssembly2.usda')
cmds.usdExport(mergeTransformAndShape=True, file=usdFilePath)
stage = Usd.Stage.Open(usdFilePath)
self.assertTrue(stage)
rootPrim = stage.GetPrimAtPath('/KindTest')
self.assertTrue(Kind.Registry().IsA(
Usd.ModelAPI(rootPrim).GetKind(), 'assembly'))
def main():
"""Run the main execution of the current script."""
stage = Usd.Stage.CreateInMemory()
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y)
root = UsdGeom.Xform.Define(stage, "/TexModel")
Usd.ModelAPI(root).SetKind(Kind.Tokens.component)
billboard = attach_billboard(stage, root)
material = UsdShade.Material.Define(
stage,
str(billboard.GetPath()) + "/" + "boardMat")
shader = attach_surface_shader(stage, material,
str(material.GetPath()) + "/" + "PBRShader")
reader = attach_texture(stage, shader, str(material.GetPath()))
st_input = material.CreateInput("frame:stPrimvarName",
Sdf.ValueTypeNames.Token)
st_input.Set("st")
reader.CreateInput("varname",
Sdf.ValueTypeNames.Token).ConnectToSource(st_input)
UsdShade.MaterialBindingAPI(billboard).Bind(material)
print(stage.GetRootLayer().ExportToString())
def _AddModel(stage, path, refPath):
'''
Adds a reference to refPath at the given path in the stage. This will make
sure the model hierarchy is maintained by ensuring that all ancestors of
the path have "kind" set to "group".
returns the referenced model.
'''
from pxr import Kind, Sdf, Usd, UsdGeom
# convert path to an Sdf.Path which has several methods that are useful
# when working with paths. We use GetPrefixes() here which returns a list
# of all the prim prefixes for a given path.
path = Sdf.Path(path)
for prefixPath in path.GetPrefixes()[1:-1]:
parentPrim = stage.GetPrimAtPath(prefixPath)
if not parentPrim:
parentPrim = UsdGeom.Xform.Define(stage, prefixPath).GetPrim()
Usd.ModelAPI(parentPrim).SetKind(Kind.Tokens.group)
# typeless def here because we'll be getting the type from the prim that
# we're referencing.
m = stage.DefinePrim(path)
m.GetReferences().AddReference(os.path.join(ASSET_BASE, refPath))
return m
def refresh(self):
# PrimPath
cmds.textFieldGrp(self.primPath,
edit=True,
text=str(self.prim.GetPath()))
# Kind
model = Usd.ModelAPI(self.prim)
primKind = model.GetKind()
if not primKind:
# Special case to handle the empty string (for meta data value empty).
cmds.optionMenuGrp(self.kind, edit=True, select=1)
else:
cmds.optionMenuGrp(self.kind, edit=True, value=primKind)
# Active
cmds.checkBoxGrp(self.active, edit=True, value1=self.prim.IsActive())
# Instanceable
cmds.checkBoxGrp(self.instan,
edit=True,
value1=self.prim.IsInstanceable())
# All other metadata types
for k in self.extraMetadata:
v = self.prim.GetMetadata(
k) if k != 'customData' else self.prim.GetCustomData()
cmds.textFieldGrp(self.extraMetadata[k], edit=True, text=str(v))
def main():
from pxr import Kind, Usd, UsdGeom
setFilePath = os.path.join(ASSET_BASE, 'Room_set/Room_set.usd')
# Create the model stage, the model prim, and also make the modelPrim the
# default prim so that the layer can be referenced without specifying a
# root path.
stage = Usd.Stage.CreateNew(setFilePath)
setModelPrim = UsdGeom.Xform.Define(stage, '/Room_set').GetPrim()
stage.SetDefaultPrim(setModelPrim)
# Lets viewing applications know how to orient a free camera properly
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y)
# Models can have a "kind" which can be used to categorize models into
# different types. This is useful for other applications to reason about
# the model hierarchy.
Usd.ModelAPI(setModelPrim).SetKind(Kind.Tokens.assembly)
# add child models to our set.
_AddModel(stage, '/Room_set/Furniture/Table', 'Table/Table.usd')
ballNumber = 0
import math
for row in range(5):
tableX = 10 + row * 2 * BALL_RADIUS * math.cos(math.pi / 6)
tableRowZ = -row * BALL_RADIUS
numBallsInRow = row + 1
for i in range(numBallsInRow):
ballNumber += 1
b = _AddModel(stage, '/Room_set/Props/Ball_%d' % ballNumber,
'Ball/Ball.usd')
# tableX and tableZ will arrange the balls into a triangle.
tableZ = tableRowZ + i * 2 * BALL_RADIUS
ballXlate = (tableX, TABLE_HEIGHT + BALL_RADIUS, tableZ)
# Apply the UsdGeom.Xformable schema to the model, and then set the
# transformation.
# We are only going to translate the balls, but we still use
# the helper XformCommonAPI schema to instantiate a translate op.
# XformCommonAPI helps ensure transform ops are interchangeable
# between applications, when you can make do with SRT + pivot
UsdGeom.XformCommonAPI(b).SetTranslate(ballXlate)
# we conveniently named the shadingVariant the same as the name of
# the ball.
shadingVariantName = b.GetName()
# get the variantSet "shadingVariant" and then set it accordingly.
vs = b.GetVariantSets().GetVariantSet('shadingVariant')
vs.SetVariantSelection(shadingVariantName)
stage.GetRootLayer().Save()
def createPrims(stage, variants):
'''Create a testing asset prim and populate its variants.'''
for path, pathVariants in variants.iteritems():
prim = stage.DefinePrim(path)
model = Usd.ModelAPI(prim)
model.SetAssetName('test_asset') # needs a name or it will be skipped
createVariants(prim, pathVariants)
stage.GetRootLayer().Save()
def _SetupBilliards(stage):
from pxr import Kind, Sdf, Usd, UsdGeom
# Make sure the model-parents we need are well-specified
Usd.ModelAPI(UsdGeom.Xform.Define(stage,
'/World')).SetKind(Kind.Tokens.group)
Usd.ModelAPI(UsdGeom.Xform.Define(stage, '/World/anim')).SetKind(
Kind.Tokens.group)
# in previous examples, we've been using GetReferences().Add(...). The
# following uses .SetItems() instead which lets us explicitly set (replace)
# the references at once instead of adding.
cueBall = stage.DefinePrim('/World/anim/CueBall')
cueBall.GetReferences().SetItems(
[Sdf.Reference(os.path.join(ASSET_BASE, 'Ball/Ball.usd'))])
# deactivate everything that isn't 8, 9, 1, 4. We accumulate the prims we
# want to deactivate so that we don't delete while iterating.
roomProps = stage.GetPrimAtPath('/World/sets/Room_set/Props')
keepers = set(['Ball_%d' % i for i in [1, 9, 8, 4]])
toDeactivate = []
for child in roomProps.GetChildren():
if child.GetName() not in keepers:
toDeactivate.append(child)
for prim in toDeactivate:
prim.SetActive(False)
# the offset values are relative to the radius of the ball
def _MoveBall(ballPrim, offset):
translation = (offset[0] * BALL_RADIUS, TABLE_HEIGHT + BALL_RADIUS,
offset[1] * BALL_RADIUS)
# Apply the UsdGeom.Xformable schema to the model, and then set the
# transformation. Note we can use ordinary python tuples
from pxr import UsdGeom
UsdGeom.XformCommonAPI(ballPrim).SetTranslate(translation)
# all these values are just eye-balled and are relative to Ball_1.
_MoveBall(cueBall, (1.831, 4.331))
_MoveBall(stage.GetPrimAtPath('/World/sets/Room_set/Props/Ball_2'),
(0.000, 0.000))
_MoveBall(stage.GetPrimAtPath('/World/sets/Room_set/Props/Ball_10'),
(2.221, 1.119))
_MoveBall(stage.GetPrimAtPath('/World/sets/Room_set/Props/Ball_1'),
(3.776, 0.089))
_MoveBall(stage.GetPrimAtPath('/World/sets/Room_set/Props/Ball_4'),
(5.453, -0.543))
def make_defalt_prim(self, location, stage, kind):
default_path = Sdf.Path('/{}'.format(location))
print 'default_path', default_path
default_prim = stage.DefinePrim(default_path)
stage.SetDefaultPrim(default_prim)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y)
UsdGeom.SetStageMetersPerUnit(stage, UsdGeom.LinearUnits.centimeters)
Usd.ModelAPI(default_prim).SetKind(kind)
def make_default_prim(stage):
default_path = Sdf.Path(DEFAULT_PATH)
default_prim = stage.DefinePrim(default_path)
stage.SetDefaultPrim(default_prim)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y)
UsdGeom.SetStageMetersPerUnit(stage, UsdGeom.LinearUnits.centimeters)
Usd.ModelAPI(default_prim).SetKind(Kind.Tokens.component)
return default_prim
def __defineUSDXformPrimByLoops__(self, dagnode_path):
'''
Create the UsdPrim that type as Xform,
and have a loop to create every prim one by one.
'''
scenegraph_path = self.fetchNameSceneGraphPrim(dagnode_path)
scenegraph_tree = self.fetchListUSDPrim(dagnode_path)
for prim_node in scenegraph_tree:
Usd.ModelAPI(UsdGeom.Xform.Define(self.__stage__, prim_node))
def generate_ticker_cube(index, stage, stock_name):
stage.SetStartTimeCode(0)
stage.SetEndTimeCode(192)
TextureRoot = UsdGeom.Xform.Define(stage, '/TexModel' + stock_name)
Usd.ModelAPI(TextureRoot).SetKind(Kind.Tokens.component)
billboard = UsdGeom.Mesh.Define(
stage, "/TexModel" + stock_name + "/card" + stock_name)
billboard.CreatePointsAttr([(-5, -5, 5), (5, -5, 5), (5, 5, 5),
(-5, 5, 5)])
billboard.CreateFaceVertexCountsAttr([4])
billboard.CreateFaceVertexIndicesAttr([0, 1, 2, 3])
billboard.CreateExtentAttr([(-5, -5, 5), (5, 5, 5)])
texCoords = billboard.CreatePrimvar("st",
Sdf.ValueTypeNames.TexCoord2fArray,
UsdGeom.Tokens.varying)
texCoords.Set([(0, 0), (1, 0), (1, 1), (0, 1)])
material = UsdShade.Material.Define(
stage, '/TexModel' + stock_name + '/boardMat' + stock_name)
stInput = material.CreateInput('frame:stPrimvarName',
Sdf.ValueTypeNames.Token)
stInput.Set('st')
pbrShader = UsdShade.Shader.Define(
stage, '/TexModel' + stock_name + '/boardMat/PBRShader' + stock_name)
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' + stock_name + '/boardMat/stReader' + stock_name)
stReader.CreateIdAttr('UsdPrimvarReader_float2')
stReader.CreateInput('varname',
Sdf.ValueTypeNames.Token).ConnectToSource(stInput)
print(stock_name)
diffuseTextureSampler = UsdShade.Shader.Define(
stage,
'/TexModel' + stock_name + '/boardMat/diffuseTexture' + stock_name)
diffuseTextureSampler.CreateIdAttr('UsdUVTexture')
diffuseTextureSampler.CreateInput('file', Sdf.ValueTypeNames.Asset).Set(
'/Users/Abhinav/Documents/USDZ/CNBC/textures/' + stock_name + '.png')
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.GetPrim()).Bind(material)
UsdGeom.XformCommonAPI(billboard).SetTranslate(
(-20, 20 * index, -index * 20))
spin = billboard.AddRotateYOp(opSuffix='spin')
spin.Set(time=0, value=0)
spin.Set(time=192, value=1440)
return stage
def testExport(self):
"""
Tests that the adaptor mechanism can export
USD_hidden, USD_instanceable, and USD_kind attributes by setting
the correct metadata in the output USD file.
"""
cmds.file(new=True, force=True)
cmds.usdImport(file=self.inputUsdFile,
shadingMode=[
["none", "default"],
])
newUsdFilePath = os.path.abspath('UsdAttrsNew.usda')
cmds.usdExport(file=newUsdFilePath, shadingMode='none')
newUsdStage = Usd.Stage.Open(newUsdFilePath)
# pCube1 and pCube2 have USD_kind.
prim1 = newUsdStage.GetPrimAtPath('/World/pCube1')
self.assertEqual(Usd.ModelAPI(prim1).GetKind(), 'potato')
prim2 = newUsdStage.GetPrimAtPath('/World/pCube2')
self.assertEqual(Usd.ModelAPI(prim2).GetKind(), 'bakedpotato')
# pCube2, pCube4, and pCube5 have USD_hidden. pCube1 and pCube3 do not.
self.assertTrue(
newUsdStage.GetPrimAtPath('/World/pCube2').HasAuthoredHidden())
self.assertTrue(
newUsdStage.GetPrimAtPath('/World/pCube4').HasAuthoredHidden())
self.assertTrue(
newUsdStage.GetPrimAtPath('/World/pCube5').HasAuthoredHidden())
self.assertFalse(
newUsdStage.GetPrimAtPath('/World/pCube1').HasAuthoredHidden())
self.assertFalse(
newUsdStage.GetPrimAtPath('/World/pCube3').HasAuthoredHidden())
self.assertTrue(newUsdStage.GetPrimAtPath('/World/pCube2').IsHidden())
self.assertTrue(newUsdStage.GetPrimAtPath('/World/pCube4').IsHidden())
self.assertFalse(newUsdStage.GetPrimAtPath('/World/pCube5').IsHidden())
# pCube3 and pCube4 have USD_instanceable.
self.assertTrue(
newUsdStage.GetPrimAtPath('/World/pCube3').IsInstanceable())
self.assertTrue(
newUsdStage.GetPrimAtPath('/World/pCube4').IsInstanceable())
def _set_assembly(prim_path):
model = Usd.ModelAPI(prim_path)
model.SetKind(Kind.Tokens.assembly)
parent = prim_path.GetParent()
if parent:
_set_assembly(parent)
return
def main():
"""Run the main execution of the current script."""
stage = Usd.Stage.CreateInMemory()
stage.GetRootLayer().documentation = (
"This is an example of setting a Model Prim kind")
sphere1 = UsdGeom.Sphere.Define(stage, "/SomeSphere")
Usd.ModelAPI(sphere1).SetKind(Kind.Tokens.component)
sphere2 = UsdGeom.Sphere.Define(stage, "/SomeSphere/SphereChild")
Usd.ModelAPI(sphere2).SetKind(Kind.Tokens.subcomponent)
sphere3 = UsdGeom.Sphere.Define(stage, "/SomeSphere/Foo")
Usd.ModelAPI(sphere3).SetKind("does_not_exist")
sphere3.GetPrim().SetMetadata(
"comment",
"XXX: This kind is made up. But it could be real if we added to the KindRegistry\n"
"https://graphics.pixar.com/usd/docs/api/class_kind_registry.html",
)
print(stage.GetRootLayer().ExportToString())
def generate_price_cube(price, stock_name, stage, position, index):
path = create_image(price, stock_name, position)
TextureRoot = UsdGeom.Xform.Define(
stage, '/priceModel' + stock_name + str(position))
Usd.ModelAPI(TextureRoot).SetKind(Kind.Tokens.component)
billboard = UsdGeom.Mesh.Define(
stage, "/priceModel" + stock_name + str(position) + "/card" +
stock_name + str(position))
billboard.CreatePointsAttr([(-5, -5, 5), (5, -5, 5), (5, 5, 5),
(-5, 5, 5)])
billboard.CreateFaceVertexCountsAttr([4])
billboard.CreateFaceVertexIndicesAttr([0, 1, 2, 3])
billboard.CreateExtentAttr([(-5, -5, 5), (5, 5, 5)])
texCoords = billboard.CreatePrimvar("st",
Sdf.ValueTypeNames.TexCoord2fArray,
UsdGeom.Tokens.varying)
texCoords.Set([(0, 0), (1, 0), (1, 1), (0, 1)])
material = UsdShade.Material.Define(
stage, '/priceModel' + stock_name + str(position) + '/boardMat' +
stock_name + str(position))
stInput = material.CreateInput('frame:stPrimvarName',
Sdf.ValueTypeNames.Token)
stInput.Set('st')
pbrShader = UsdShade.Shader.Define(
stage, '/priceModel' + stock_name + str(position) +
'/boardMat/PBRShader' + stock_name + str(position))
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, '/priceModel' + stock_name + str(position) +
'/boardMat/stReader' + stock_name + str(position))
stReader.CreateIdAttr('UsdPrimvarReader_float2')
stReader.CreateInput('varname',
Sdf.ValueTypeNames.Token).ConnectToSource(stInput)
diffuseTextureSampler = UsdShade.Shader.Define(
stage, '/priceModel' + stock_name + str(position) +
'/boardMat/diffuseTexture' + stock_name + str(position))
diffuseTextureSampler.CreateIdAttr('UsdUVTexture')
diffuseTextureSampler.CreateInput('file',
Sdf.ValueTypeNames.Asset).Set(path)
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.GetPrim()).Bind(material)
UsdGeom.XformCommonAPI(billboard).SetTranslate(
(10 * position, (20 * index) + (price + 5), -index * 20))
def test_ModelHierarchy(self):
for fmt in allFormats:
s = Usd.Stage.CreateInMemory('TestModelHierarchy.' + fmt)
x = s.DefinePrim('/X', 'Scope')
y = s.DefinePrim('/X/Y', 'Scope')
z = s.DefinePrim('/X/Y/Z', 'Scope')
self.assertFalse(x.IsModel())
self.assertFalse(y.IsModel())
self.assertFalse(z.IsModel())
xm = Usd.ModelAPI(x)
ym = Usd.ModelAPI(y)
zm = Usd.ModelAPI(z)
# X is not a model. Hence, Y can't be a model, even if it has kind set
# to 'component'.
ym.SetKind(Kind.Tokens.component)
self.assertFalse(ym.IsModel())
# Setting X's kind to component, causes it to be a model, but Y still
# remains a non-model as component below another component violates the
# model hierarchy.
xm.SetKind(Kind.Tokens.component)
self.assertTrue(xm.IsModel())
self.assertFalse(ym.IsModel())
# Setting X's kind to assembly fixes the model hierarchy and causes
# X to be a model group and Y to be a model.
xm.SetKind(Kind.Tokens.assembly)
self.assertTrue(xm.IsModel())
self.assertTrue(xm.IsGroup())
self.assertTrue(ym.IsModel())
self.assertFalse(ym.IsGroup())
# A component below a component violates model hierarchy.
zm.SetKind(Kind.Tokens.component)
self.assertFalse(zm.IsModel())
# A subcomponent also isn't considered to be a model.
zm.SetKind(Kind.Tokens.subcomponent)
self.assertFalse(zm.IsModel())
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()
