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)