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 run(self):
# Convert sub layer paths to relative
has_sub_layer_paths = False
if getattr(self, 'sub_layer_paths', None) != None:
for i in xrange(len(self.sub_layer_paths)):
self.sub_layer_paths[i] = self.to_relative_path(
self.sub_layer_paths[i])
has_sub_layer_paths = True
# List actors in Unreal
self.unreal_prims = {}
actors = unreal.EditorLevelLibrary.get_all_level_actors()
for actor in actors:
print("actor: " + str(actor))
prim_path = self.get_usd_path_from_actor_labels(actor)
self.unreal_prims[prim_path] = actor
# Write USD file
with usd_unreal.utils.USDStageWrapper(
self, Usd.Stage.CreateNew(self.filename)) as stage_wrapper:
stage = self.stage
if has_sub_layer_paths:
for path in self.sub_layer_paths:
stage.GetRootLayer().subLayerPaths.append(path)
if self.stage_up_axis == 'y':
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y)
elif self.stage_up_axis == 'z':
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
self.current_frame = Usd.TimeCode.Default()
self.xform_cache = UsdGeom.XformCache(self.current_frame)
# Modify and add new objects
for prim_path, actor in self.unreal_prims.iteritems():
# Detect changes vs parent scenes
usd_node = None
original_prim = None
if has_sub_layer_paths:
original_prim = stage.GetPrimAtPath(prim_path)
if not original_prim.IsValid():
original_prim = None
usd_node = self.handle_object(original_prim, prim_path, actor)
# Delete level objects that do not exist in Unreal
self.detect_deleted(stage.GetPseudoRoot())
# Commit to disk
stage.Save()
def compute(self, **kwargs):
input_stage = self.get_input_link('Input', **kwargs)
if not input_stage or not self.name:
return None
if not self.object:
return input_stage
depsgraph = bpy.context.evaluated_depsgraph_get()
obj = self.object.evaluated_get(depsgraph)
path = f'/{Tf.MakeValidIdentifier(self.name)}'
stage = self.cached_stage.create()
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
root_xform = UsdGeom.Xform.Define(stage, path)
root_prim = root_xform.GetPrim()
for prim in input_stage.GetPseudoRoot().GetAllChildren():
override_prim = stage.OverridePrim(
root_xform.GetPath().AppendChild(prim.GetName()))
override_prim.GetReferences().AddReference(
input_stage.GetRootLayer().realPath, prim.GetPath())
if obj:
UsdGeom.Xform.Get(stage, root_xform.GetPath()).AddTransformOp()
root_prim.GetAttribute('xformOp:transform').Set(
Gf.Matrix4d(get_transform(obj)))
return stage
def compute(self, **kwargs):
input_stage = self.get_input_link('Input', **kwargs)
if not input_stage or not self.name:
return None
path = f'/{Tf.MakeValidIdentifier(self.name)}'
stage = self.cached_stage.create()
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
root_xform = UsdGeom.Xform.Define(stage, path)
root_prim = root_xform.GetPrim()
for prim in input_stage.GetPseudoRoot().GetAllChildren():
override_prim = stage.OverridePrim(
root_xform.GetPath().AppendChild(prim.GetName()))
override_prim.GetReferences().AddReference(
input_stage.GetRootLayer().realPath, prim.GetPath())
translation = Matrix.Translation((self.translation[:3]))
diagonal = Matrix.Diagonal((self.scale[:3])).to_4x4()
rotation_x = Matrix.Rotation(self.rotation[0], 4, 'X')
rotation_y = Matrix.Rotation(self.rotation[1], 4, 'Y')
rotation_z = Matrix.Rotation(self.rotation[2], 4, 'Z')
transform = translation @ rotation_x @ rotation_y @ rotation_z @ diagonal
UsdGeom.Xform.Get(stage, root_xform.GetPath()).AddTransformOp()
root_prim.GetAttribute('xformOp:transform').Set(
Gf.Matrix4d(transform.transposed()))
return stage
def compute(self, **kwargs):
from pxr import Usd, UsdGeom
ref_stages = []
for i in range(self.inputs_number):
stage = self.get_input_link(i, **kwargs)
if stage:
ref_stages.append(stage)
if not ref_stages:
return None
if len(ref_stages) == 1:
return ref_stages[0]
stage = self.cached_stage.create()
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
merge_prim = stage.DefinePrim(f"/merge")
stage.SetDefaultPrim(merge_prim)
for i, ref_stage in enumerate(ref_stages, 1):
ref = stage.DefinePrim(f"/merge/ref{i}", 'Xform')
default_prim = ref_stage.GetDefaultPrim()
override_prim = stage.OverridePrim(str(ref.GetPath()) + '/' + default_prim.GetName())
override_prim.GetReferences().AddReference(ref_stage.GetRootLayer().realPath)
return stage
def _sync(self, depsgraph):
stage = self.cached_stage.create()
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
root_prim = stage.GetPseudoRoot()
objects_len = sum(1 for _ in object.ObjectData.depsgraph_objects(
depsgraph, use_scene_cameras=False))
for i, obj_data in enumerate(
object.ObjectData.depsgraph_objects(depsgraph,
use_scene_cameras=False)):
if self.render_engine.test_break():
return
self.notify_status(
0.0,
f"Syncing object {i}/{objects_len}: {obj_data.object.name}")
object.sync(root_prim, obj_data)
if depsgraph.scene.world is not None:
world.sync(root_prim, depsgraph.scene.world)
object.sync(stage.GetPseudoRoot(),
object.ObjectData.from_object(depsgraph.scene.camera),
scene=depsgraph.scene)
def _export_depsgraph(self, stage, depsgraph, *,
sync_callback=None, test_break=None,
space_data=None, use_scene_lights=True, **kwargs):
log("sync", depsgraph)
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
root_prim = stage.DefinePrim(f"/{sdf_path(depsgraph.scene.name)}")
stage.SetDefaultPrim(root_prim)
objects_prim = stage.DefinePrim(f"{root_prim.GetPath()}/objects")
objects_len = len(depsgraph.objects)
for i, obj in enumerate(depsgraph_objects(depsgraph, space_data, use_scene_lights)):
if test_break and test_break():
return None
if sync_callback:
sync_callback(f"Syncing object {i}/{objects_len}: {obj.name}")
try:
object.sync(objects_prim, obj, **kwargs)
except Exception as e:
log.error(e)
world.sync(root_prim, depsgraph.scene.world, **kwargs)
def sync(self, depsgraph):
self.is_synced = False
stage = self.cached_stage.create()
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
root_prim = stage.GetPseudoRoot()
for obj_data in object.ObjectData.depsgraph_objects(
depsgraph, use_scene_cameras=False):
if self.render_engine.test_break():
return None
object.sync(root_prim, obj_data)
world.sync(root_prim, depsgraph.scene.world)
object.sync(stage.GetPseudoRoot(),
object.ObjectData.from_object(depsgraph.scene.camera),
scene=depsgraph.scene)
self.is_synced = True
log(f"Sync finished")
def _export_depsgraph(self,
stage,
depsgraph,
*,
sync_callback=None,
test_break=None,
space_data=None,
use_scene_lights=True,
**kwargs):
log("sync", depsgraph)
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
root_prim = stage.GetPseudoRoot()
objects_len = len(depsgraph.objects)
for i, obj in enumerate(
depsgraph_objects(depsgraph, space_data, use_scene_lights)):
if test_break and test_break():
return None
if sync_callback:
sync_callback(f"Syncing object {i}/{objects_len}: {obj.name}")
try:
object.sync(root_prim, obj, **kwargs)
except Exception as e:
log.error(e, 'EXCEPTION:', traceback.format_exc())
world.sync(root_prim, depsgraph.scene.world, **kwargs)
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 main():
parser = get_parser()
args = parser.parse_args()
kitchen_path = os.path.abspath(args.kitchen)
stage = Usd.Stage.CreateNew(EXPORT_NAME)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
ref = UsdGeom.Xform.Define(stage, '/ref')
for name, offset, color in LAYER_DATA:
fridge = UsdGeom.Xform.Define(stage, '/ref/{}'.format(name))
fridge_prim = fridge.GetPrim()
fridge_prim.GetReferences().AddReference(
assetPath=kitchen_path,
primPath=FRIDGE_PATH)
# Recolor
set_fridge_color(stage, fridge_prim, color)
# Translace
fridge.AddTranslateOp().Set(value=offset)
# Export Stage
stage.Save()
def compute(self, **kwargs):
input_stage = self.get_input_link('Input', **kwargs)
if not input_stage:
return None
if not self.name:
return input_stage
path = f'/{Tf.MakeValidIdentifier(self.name)}'
stage = self.cached_stage.create()
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
# create new root prim according to name and type
if self.type == 'Xform':
root_prim = UsdGeom.Xform.Define(stage, path)
elif self.type == 'Scope':
root_prim = UsdGeom.Scope.Define(stage, path)
elif self.type == 'SkelRoot':
root_prim = UsdSkel.Root.Define(stage, path)
else:
root_prim = stage.DefinePrim(path)
for prim in input_stage.GetPseudoRoot().GetAllChildren():
override_prim = stage.OverridePrim(root_prim.GetPath().AppendChild(prim.GetName()))
override_prim.GetReferences().AddReference(input_stage.GetRootLayer().realPath, prim.GetPath())
return stage
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 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 compute(self, **kwargs):
input_stage = self.get_input_link('Input', **kwargs)
if not input_stage:
return None
if not self.ignore_names:
return input_stage
ignore_names = [
name for name in self.ignore_names.replace(" ", ",").split(",")
if name
]
prog = re.compile('|'.join(ignore_names).replace('*', '\w*'))
prims = (child
for child in input_stage.GetPseudoRoot().GetAllChildren()
if not prog.fullmatch(child.GetName()))
stage = self.cached_stage.create()
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
if not prims:
return stage
root_prim = stage.GetPseudoRoot()
for i, prim in enumerate(prims, 1):
override_prim = stage.OverridePrim(root_prim.GetPath().AppendChild(
prim.GetName()))
override_prim.GetReferences().AddReference(
input_stage.GetRootLayer().realPath, prim.GetPath())
return stage
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 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 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 setup_scene(self, metersPerUnit=1.0, kilogramsPerUnit=1.0):
stage = Usd.Stage.CreateInMemory()
self.assertTrue(stage)
self.stage = stage
# setup stage units
UsdGeom.SetStageUpAxis(stage, "Z")
UsdGeom.SetStageMetersPerUnit(stage, metersPerUnit)
UsdPhysics.SetStageKilogramsPerUnit(stage, kilogramsPerUnit)
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 SetupStage(stage):
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y)
UsdGeom.SetStageMetersPerUnit(stage,
UsdGeom.LinearUnits.centimeters)
# Create this prim first, since it's the "entrypoint" to the
# layer, and we want it to appear at the top
rootPrim = stage.DefinePrim("/ModelShading")
stage.SetDefaultPrim(rootPrim)
return rootPrim
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)
self._export_depsgraph(stage, depsgraph)
return stage
def export_initial_scene(self):
stage = self.stage
for parent_usd_file in self.parent_usd_files:
stage.GetRootLayer().subLayerPaths.append(parent_usd_file)
if self.stage_up_axis == 'y':
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y)
elif self.stage_up_axis == 'z':
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
stage.SetFramesPerSecond(self.frame_rate)
for info in self.export_list:
usd_node = None
for handler in self.actor_export_handlers:
usd_node = handler(info)
if usd_node != None:
break
def set_up_axis(self, axis=UsdGeom.Tokens.z):
"""Change the up axis of the current stage
Args:
axis: valid values are `UsdGeom.Tokens.y`, or `UsdGeom.Tokens.z`
"""
stage = self.get_stage()
rootLayer = stage.GetRootLayer()
rootLayer.SetPermissionToEdit(True)
with Usd.EditContext(stage, rootLayer):
UsdGeom.SetStageUpAxis(stage, axis)
def test_Basic(self):
fileName = "test_base_material_specializes.usda"
stage = Usd.Stage.CreateNew(fileName)
rootPrimPath = Sdf.Path("/ModelShading")
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y)
UsdGeom.SetStageMetersPerUnit(stage, UsdGeom.LinearUnits.centimeters)
materialsPath = self._SetupShading(stage, rootPrimPath)
stage.SetDefaultPrim(stage.GetPrimAtPath(rootPrimPath))
self._TestShading(stage, materialsPath)
stage.Save()
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 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 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 __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 makeMatte(parentPath, imgHeight, imgWidth, upAxis, material, stage):
meshPath = os.path.join(parentPath, "Matte")
meshSchema = UsdGeom.Mesh.Define(stage, meshPath)
vertexCounts = [4]
meshSchema.CreateFaceVertexCountsAttr().Set(vertexCounts)
indices = [0, 1, 2, 3]
meshSchema.GetFaceVertexIndicesAttr().Set(indices)
meshSchema.GetSubdivisionSchemeAttr().Set("none")
# put comment here
offset = 0.3
newW = (imgWidth/ 2 + offset)
newH = imgHeight + offset
hDiff = -offset
# 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 = [(-newW, hDiff, -offset),
(newW, hDiff, -offset),
(newW, newH, -offset),
(-newW, newH, -offset)]
if upAxis == 'z' or upAxis == 'Z':
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
points = [(-halfW, -offset, hDiff),
(halfW, -offset, hDiff),
(halfW, -offset, height),
(-halfW, -offset, height)]
meshSchema.CreatePointsAttr().Set(points)
uvs = [(0, 0),
(1, 0),
(1, 1),
(0, 1)]
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)] )
meshSchema.CreateDoubleSidedAttr().Set(1)
