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)