def test_metersPerUnit(self):
stage = Usd.Stage.CreateInMemory()
self.assertTrue(stage)
self.assertEqual(UsdGeom.GetStageMetersPerUnit(stage),
UsdGeom.LinearUnits.centimeters)
self.assertFalse(UsdGeom.StageHasAuthoredMetersPerUnit(stage))
self.assertTrue(
UsdGeom.SetStageMetersPerUnit(stage, UsdGeom.LinearUnits.feet))
self.assertTrue(UsdGeom.StageHasAuthoredMetersPerUnit(stage))
# test that common alternate representations that are not
# numerically identical compare equal using LinearUnitsAre
authored = UsdGeom.GetStageMetersPerUnit(stage)
fromInches = 12 * UsdGeom.LinearUnits.inches
self.assertNotEqual(authored, fromInches)
self.assertTrue(UsdGeom.LinearUnitsAre(authored, fromInches))
# similar test for feet to yards
self.assertTrue(
UsdGeom.SetStageMetersPerUnit(stage, UsdGeom.LinearUnits.yards))
authored = UsdGeom.GetStageMetersPerUnit(stage)
fromFeet = 3 * UsdGeom.LinearUnits.feet
self.assertNotEqual(authored, fromFeet)
self.assertTrue(UsdGeom.LinearUnitsAre(authored, fromFeet))
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 _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 _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 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 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 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):
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.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 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 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 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 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 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 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.DefinePrim(f"/{sdf_path(depsgraph.scene.name)}")
stage.SetDefaultPrim(root_prim)
objects_prim = stage.DefinePrim(f"{root_prim.GetPath()}/objects")
self._export_depsgraph(objects_prim, depsgraph)
return stage
def compute(self, **kwargs):
if not self.filename:
return None
file_path = bpy.path.abspath(self.filename)
if not os.path.isfile(file_path):
log.warn("Couldn't find USD file", self.filename, self)
return None
input_stage = Usd.Stage.Open(file_path)
if self.filter_path == '/*':
self.cached_stage.insert(input_stage)
return input_stage
# creating search regex pattern and getting filtered rpims
prog = re.compile(
self.filter_path.replace('*',
'#') # temporary replacing '*' to '#'
.replace('/', '\/') # for correct regex pattern
.replace('##', '[\w\/]*') # creation
.replace('#', '\w*'))
def get_child_prims(prim):
if not prim.IsPseudoRoot() and prog.fullmatch(str(prim.GetPath())):
yield prim
return
for child in prim.GetAllChildren():
yield from get_child_prims(child)
prims = tuple(get_child_prims(input_stage.GetPseudoRoot()))
if not prims:
return None
stage = self.cached_stage.create()
stage.SetInterpolationType(Usd.InterpolationTypeHeld)
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
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 _sync(self, context, depsgraph):
super()._sync(context, depsgraph)
self.data_source = self.get_settings(depsgraph.scene).data_source
stage = self.cached_stage.create()
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
nodetree = bpy.data.node_groups[self.data_source]
output_node = nodetree.get_output_node()
self.nodetree_stage_changed(
output_node.cached_stage() if output_node else None)
world_data = world.WorldData.init_from_stage(self.stage)
self.render_params.clearColor = world_data.clear_color
def compute(self, **kwargs):
input_stage = self.get_input_link('Input', **kwargs)
if not input_stage:
return None
if not self.filter_path:
return input_stage
filter_path = [
name for name in self.filter_path.replace(" ", ",").split(",")
if name
]
# creating search regex pattern and getting filtered rpims
prog = re.compile('|'.join(filter_path).replace(
'*', '#') # temporary replacing '*' to '#'
.replace('/', '\/') # for correct regex pattern
.replace('##', '[\w\/]*') # creation
.replace('#', '\w*'))
def get_child_prims(prim):
if not prim.IsPseudoRoot() and prog.fullmatch(str(prim.GetPath())):
yield prim
return
for child in prim.GetAllChildren():
yield from get_child_prims(child)
prims = tuple(get_child_prims(input_stage.GetPseudoRoot()))
if not prims:
return None
stage = self.cached_stage.create()
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
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 compute(self, **kwargs):
if not self.object:
return None
input_stage = self.get_input_link('Input', **kwargs)
if not input_stage:
return None
if not input_stage.GetPseudoRoot().GetAllChildren():
return None
depsgraph = bpy.context.evaluated_depsgraph_get()
obj = self.object.evaluated_get(depsgraph)
distribute_items = obj.data.vertices if self.method == 'VERTICES' else obj.data.polygons
if not distribute_items:
return None
stage = self.cached_stage.create()
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
for i, item in enumerate(distribute_items):
root_xform = UsdGeom.Xform.Define(
stage, f'/{Tf.MakeValidIdentifier(f"{self.name}_{i}")}')
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())
trans = Matrix.Translation(item.co if self.method ==
'VERTICES' else item.center)
rot = item.normal.to_track_quat().to_matrix().to_4x4()
transform = trans @ rot
if self.object_transform:
transform = obj.matrix_world @ transform
UsdGeom.Xform.Get(stage, root_xform.GetPath()).MakeMatrixXform()
root_xform.GetPrim().GetAttribute('xformOp:transform').Set(
Gf.Matrix4d(transform.transposed()))
return stage
def __init__(self, render_engine):
super().__init__(render_engine)
cls = self.__class__
if cls.timer:
cls.timer.cancel()
if not cls.renderer:
log("Creating renderer")
cls.renderer = UsdImagingLite.Engine()
cls.renderer.SetRendererPlugin('HdRprPlugin')
cls.cached_stage = CachedStage()
stage = cls.cached_stage.create()
UsdGeom.SetStageMetersPerUnit(stage, 1)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
self.renderer = cls.renderer
self.cached_stage = cls.cached_stage
self.is_synced = False
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 _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 _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))
objects_stage = Usd.Stage.CreateNew(str(get_temp_file(".usda")))
object_root_prim = objects_stage.GetPseudoRoot()
for i, obj_data in enumerate(object.ObjectData.depsgraph_objects_obj(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(object_root_prim, obj_data)
for prim in objects_stage.GetPseudoRoot().GetAllChildren():
override_prim = stage.OverridePrim(root_prim.GetPath().AppendChild(prim.GetName()))
override_prim.GetReferences().AddReference(objects_stage.GetRootLayer().realPath, prim.GetPath())
instance_len = sum(1 for _ in object.ObjectData.depsgraph_objects_inst(depsgraph, use_scene_cameras=False))
chunks = math.ceil(instance_len / CHUNK_COUNT)
chunks_data = {}
for i in range(chunks):
chunk_stage = Usd.Stage.CreateNew(str(get_temp_file(".usda")))
chunk_prim = stage.OverridePrim(f'/chunk_{i}')
chunks_data[i] = {'stage': chunk_stage, 'prim': chunk_prim}
objects_processed = 0
threadLock = threading.Lock()
def sync_chunk(idx, stage, prim):
nonlocal objects_processed
xform = UsdGeom.Xform.Define(stage, stage.GetPseudoRoot().GetPath().AppendChild(f'chunk_{idx}'))
obj_prim = xform.GetPrim()
for i, obj_data in enumerate(object.ObjectData.depsgraph_objects_inst(depsgraph, use_scene_cameras=False)):
if i >= (idx) * CHUNK_COUNT and i < (idx + 1) * CHUNK_COUNT:
with threadLock:
objects_processed += 1
self.notify_status(0.0, f"Syncing instances: {objects_processed} / {instance_len}")
object.sync(obj_prim, obj_data, objects_stage)
stage.SetDefaultPrim(obj_prim)
with futures.ThreadPoolExecutor() as executor:
chunk_sync = []
for idx in chunks_data:
chunk_sync.append(executor.submit(sync_chunk, idx,
chunks_data[idx]['stage'],
chunks_data[idx]["prim"]))
for idx, future in enumerate(futures.wait(chunk_sync)):
if idx == 0:
for i in chunks_data:
chunk_prim = stage.GetPrimAtPath(chunks_data[i]["prim"].GetPath())
chunk_prim.GetReferences().AddReference(chunks_data[i]['stage'].GetRootLayer().realPath)
pass
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)
