def testInstancedGeom(self): """Tests that different shader bindings are correctly authored on instanced geometry.""" worldPath = "/World" # Where collections are authored redMat = "/World/Looks/blinn1SG" redPaths = ["/World/redCube", "/World/redSphere"] blueMat = "/World/Looks/phong1SG" bluePaths = [ "/World/blueCube", "/World/blueSphere", "/World/blueSphere2"] instanceMasters = [ "/InstanceSources/World_redSphere_blueSphereMultiAssignShape", "/InstanceSources/World_blueCube_blueCubeShape"] for path in redPaths: prim = self._simpleStage.GetPrimAtPath(path) self.assertTrue(prim.IsInstance()) bindingAPI = UsdShade.MaterialBindingAPI(prim) mat, rel = bindingAPI.ComputeBoundMaterial() self.assertEqual(mat.GetPath(), redMat) self.assertEqual(rel.GetPrim().GetPath(), worldPath) for path in bluePaths: prim = self._simpleStage.GetPrimAtPath(path) self.assertTrue(prim.IsInstance()) bindingAPI = UsdShade.MaterialBindingAPI(prim) mat, rel = bindingAPI.ComputeBoundMaterial() self.assertEqual(mat.GetPath(), blueMat) self.assertEqual(rel.GetPrim().GetPath(), worldPath) for path in instanceMasters: prim = self._simpleStage.GetPrimAtPath(path) self.assertTrue(prim) self.assertFalse( prim.HasRelationship(UsdShade.Tokens.materialBinding))
def test_BlockingOnOver(self): stage = Usd.Stage.CreateInMemory() over = stage.OverridePrim('/World/over') look = UsdShade.Material.Define(stage, "/World/Material") self.assertTrue(look) gprim = stage.DefinePrim("/World/gprim") UsdShade.MaterialBindingAPI(over).UnbindDirectBinding() UsdShade.MaterialBindingAPI.Apply(gprim).Bind(look) # This will compose in gprim's binding, but should still be blocked over.GetInherits().AddInherit("/World/gprim") self.assertFalse(UsdShade.MaterialBindingAPI(over).ComputeBoundMaterial()[0])
def testNestedInstancedGeom(self): """Tests that different shader bindings are correctly authored on instanced geometry within nested instances.""" worldPath = "/World" # Where collections are authored greenMat = "/World/Materials/blinn1SG" greenPaths = [ "/World/SimpleInstance1/Shape", "/World/ComplexA/NestedA/Base1/BaseShape1", "/World/ComplexA/NestedB/Base1/BaseShape1", "/World/Extra/Base3/Shape", "/World/ComplexB/NestedA/Base1/BaseShape1", "/World/ComplexB/NestedB/Base1/BaseShape1" ] blueMat = "/World/Materials/blinn2SG" bluePaths = [ "/World/SimpleInstance2/Shape", "/World/ComplexA/NestedA/Base2/BaseShape1", "/World/ComplexA/NestedB/Base2/BaseShape1", "/World/ComplexB/NestedA/Base2/BaseShape1", "/World/ComplexB/NestedB/Base2/BaseShape1" ] instanceMasters = [ "/InstanceSources/World_ComplexA_NestedA_Base1_BaseShape1" + "/Shape", "/InstanceSources/World_SimpleInstance1_SimpleInstanceShape1" + "/Shape" ] for path in greenPaths: prim = self._nestedStage.GetPrimAtPath(path) self.assertTrue(prim, msg=path) self.assertTrue(prim.IsInstanceProxy()) bindingAPI = UsdShade.MaterialBindingAPI(prim) mat, rel = bindingAPI.ComputeBoundMaterial() self.assertEqual(mat.GetPath(), greenMat) self.assertEqual(rel.GetPrim().GetPath(), worldPath) for path in bluePaths: prim = self._nestedStage.GetPrimAtPath(path) self.assertTrue(prim, msg=path) self.assertTrue(prim.IsInstanceProxy()) bindingAPI = UsdShade.MaterialBindingAPI(prim) mat, rel = bindingAPI.ComputeBoundMaterial() self.assertEqual(mat.GetPath(), blueMat) self.assertEqual(rel.GetPrim().GetPath(), worldPath) for path in instanceMasters: prim = self._nestedStage.GetPrimAtPath(path) self.assertTrue(prim) self.assertFalse( prim.HasRelationship(UsdShade.Tokens.materialBinding))
def test_Basic(self): s = Usd.Stage.CreateInMemory() rl = s.GetRootLayer() # set up so the weaker subtree binds gprim to look1, and # stronger subtree to look2 lw1 = UsdShade.Material.Define(s, "/weaker/look1") lw2 = UsdShade.Material.Define(s, "/weaker/look2") gpw = s.OverridePrim("/weaker/gprim") lw1.Bind(gpw) self.assertEqual( UsdShade.MaterialBindingAPI( gpw).GetDirectBindingRel().GetTargets(), [Sdf.Path("/weaker/look1")]) ls1 = UsdShade.Material.Define(s, "/stronger/look1") ls2 = UsdShade.Material.Define(s, "/stronger/look2") gps = s.OverridePrim("/stronger/gprim") ls2.Bind(gps) self.assertEqual( UsdShade.MaterialBindingAPI( gps).GetDirectBindingRel().GetTargets(), [Sdf.Path("/stronger/look2")]) cr = s.OverridePrim("/composed") cr.GetReferences().AddReference(rl.identifier, "/stronger") cr.GetReferences().AddReference(rl.identifier, "/weaker") gpc = s.GetPrimAtPath("/composed/gprim") lb = UsdShade.MaterialBindingAPI(gpc).GetDirectBindingRel() # validate we get look2, the stronger binding self.assertEqual(lb.GetTargets(), [Sdf.Path("/composed/look2")]) # upon unbinding *in* the stronger site (i.e. "/stronger/gprim"), # we should still be unbound in the fully composed view UsdShade.MaterialBindingAPI(gps).UnbindAllBindings() self.assertEqual(lb.GetTargets(), []) # but *clearing* the target on the referenced prim should allow # the weaker binding to shine through UsdShade.MaterialBindingAPI(gps).GetDirectBindingRel().ClearTargets( True) print rl.ExportToString() self.assertEqual(lb.GetTargets(), [Sdf.Path("/composed/look1")])
def bindMaterial(stage, geopath, matpath): geo = stage.GetPrimAtPath(geopath) if not geo: # if prim is not valid, let's create a new over prim geo = stage.OverridePrim(geopath) material = UsdShade.Material.Get(stage, matpath) UsdShade.MaterialBindingAPI(geo).Bind(material)
def _GetBoundMaterial(self, prim, materialPurpose=UsdShade.Tokens.allPurpose): (material, bindingRel) = UsdShade.MaterialBindingAPI(prim).ComputeBoundMaterial( materialPurpose) # Whenever we get a valid material, there must be a valid bindingRel. if material: self.assertTrue(bindingRel) return material
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 _assign_materials(obj_prim, obj, usd_mesh): usd_mat = None if obj.material_slots and obj.material_slots[0].material: usd_mat = material.sync(obj_prim, obj.material_slots[0].material, obj) if usd_mat: UsdShade.MaterialBindingAPI(usd_mesh).Bind(usd_mat)
def add_light(app, params, path_for_objects, stage, xsi_light, root_path): # here me add only basic parameters, all other will be defined in the material imp.reload(materials) # basic transform usd_xform, ref_stage, ref_stage_asset = add_xform(app, params, path_for_objects, True, stage, xsi_light, root_path) # get the type of the light xsi_light_type = xsi_light.Parameters("Type").Value usd_light = None xsi_geom_type = -1 if xsi_light_type == 0: # point (also area light) xsi_is_area = xsi_light.Parameters("LightArea").Value xsi_geom_type = xsi_light.Parameters("LightAreaGeom").Value if xsi_is_area: if xsi_geom_type == 1: # rectangular usd_light = UsdLux.RectLight.Define(ref_stage, str(usd_xform.GetPath()) + "/" + xsi_light.Name) elif xsi_geom_type == 2: # disc usd_light = UsdLux.DiskLight.Define(ref_stage, str(usd_xform.GetPath()) + "/" + xsi_light.Name) elif xsi_geom_type == 3: # sphere usd_light = UsdLux.SphereLight.Define(ref_stage, str(usd_xform.GetPath()) + "/" + xsi_light.Name) elif xsi_geom_type == 4: # cylinder usd_light = UsdLux.CylinderLight.Define(ref_stage, str(usd_xform.GetPath()) + "/" + xsi_light.Name) elif xsi_light_type == 1: # infinite usd_light = UsdLux.DistantLight.Define(ref_stage, str(usd_xform.GetPath()) + "/" + xsi_light.Name) elif xsi_light_type == 2: # spot usd_light = UsdLux.DistantLight.Define(ref_stage, str(usd_xform.GetPath()) + "/" + xsi_light.Name) # export light shader to material materials_opt = params.get("materials", None) if materials_opt is not None: is_materials = materials_opt.get("is_materials", True) if is_materials: usd_material = UsdShade.Material.Define(ref_stage, str(usd_xform.GetPath()) + "/Shader") xsi_root_shader = xsi_light.Parameters("LightShader") if xsi_root_shader is not None: materials.set_material_complete(xsi_root_shader, ref_stage, usd_material) # bind shader to the light UsdShade.MaterialBindingAPI(usd_light).Bind(usd_material) if usd_light is not None: # set neutral color usd_light.CreateColorAttr().Set((1.0, 1.0, 1.0)) # diffuse and specular coefficients xsi_is_diffuse = xsi_light.Parameters("DiffuseContribution").Value xsi_is_specular = xsi_light.Parameters("SpecularContribution").Value usd_light.CreateDiffuseAttr().Set(1.0 if xsi_is_diffuse else 0.0) usd_light.CreateSpecularAttr().Set(1.0 if xsi_is_specular else 0.0) # default intensity = 1.0 usd_light.CreateIntensityAttr().Set(1.0) # set animated parameters opt_animation = params["animation"] if opt_animation is None: set_light_at_frame(xsi_light, xsi_light_type, xsi_geom_type, usd_light) if opt_animation is not None: for frame in range(opt_animation[0], opt_animation[1] + 1): set_light_at_frame(xsi_light, xsi_light_type, xsi_geom_type, usd_light, frame) ref_stage.Save() return stage.GetPrimAtPath(root_path + str(usd_xform.GetPath()))
def _updateMeshBinding(path, appController): s = appController._dataModel.stage l = s.GetSessionLayer() s.SetEditTarget(l) mesh = s.GetPrimAtPath('/Scene/Geom/Plane') material = UsdShade.Material(s.GetPrimAtPath(path)) UsdShade.MaterialBindingAPI(mesh).Bind(material)
def _addModel(model, prototypesPrimPath, stage): # the name must be a full path without the . so just strip .usd from name name = model[0:model.find('.')] primPath = prototypesPrimPath.AppendChild(name) treeRefPrim = stage.DefinePrim(primPath) refs = treeRefPrim.GetReferences() refs.AddReference(model) path = treeRefPrim.GetPath() leaves = '/World/TreePointInstance/prototypes/{}/Leaves'.format(name) tree = UsdGeom.Mesh(stage.GetPrimAtPath(leaves)) tree.CreateDisplayColorAttr([(0.0, 0.8, 0.0)]) material = UsdShade.Material.Define(stage, '/World/Leaf{}Material'.format(name)) pbrShader = UsdShade.Shader.Define( stage, '/World/Leaf{}Material/LeafShader'.format(name)) pbrShader.CreateIdAttr("UsdPreviewSurface") pbrShader.CreateInput("diffuseColor", Sdf.ValueTypeNames.Color3f).Set( (0.0, 0.8, 0.0)) pbrShader.CreateInput("roughness", Sdf.ValueTypeNames.Float).Set(0.2) pbrShader.CreateInput("metallic", Sdf.ValueTypeNames.Float).Set(0.1) material.CreateSurfaceOutput().ConnectToSource(pbrShader, "surface") UsdShade.MaterialBindingAPI(tree).Bind(material) trunk = '/World/TreePointInstance/prototypes/{}/Trunk'.format(name) tree = UsdGeom.Mesh(stage.GetPrimAtPath(trunk)) tree.CreateDisplayColorAttr([(0.5, 0.2, 0.0)]) material = UsdShade.Material.Define(stage, '/World/Trunk{}Material'.format(name)) pbrShader = UsdShade.Shader.Define( stage, '/World/Trunk{}Material/TrunkShader'.format(name)) pbrShader.CreateIdAttr("UsdPreviewSurface") pbrShader.CreateInput("diffuseColor", Sdf.ValueTypeNames.Color3f).Set( (0.5, 0.2, 0.0)) pbrShader.CreateInput("roughness", Sdf.ValueTypeNames.Float).Set(0.2) pbrShader.CreateInput("metallic", Sdf.ValueTypeNames.Float).Set(0.1) material.CreateSurfaceOutput().ConnectToSource(pbrShader, "surface") UsdShade.MaterialBindingAPI(tree).Bind(material) # return the actual path to the model which will be added to the instancer return path
def computeBoundMaterial(self, prim, purpose): """Compute the material that the prim is bound to, for the given value of material purpose. """ if not isinstance(prim, Usd.Prim): raise ValueError("Expected Usd.Prim object, got: {}".format( repr(prim))) # We don't use the binding cache yet since it isn't exposed to python. return UsdShade.MaterialBindingAPI(prim).ComputeBoundMaterial(purpose)
def GetMtlxBoundPrims(usdStage, originalMtlxMaterialPath): prims = [] for prim in usdStage.Traverse(): for purpose in UsdShade.MaterialBindingAPI.GetMaterialPurposes(): (material, bindingRel) = UsdShade.MaterialBindingAPI(prim).\ ComputeBoundMaterial(purpose) if originalMtlxMaterialPath == material.GetPath(): prims.append((prim, bindingRel)) return prims
def testExportUVSetMappings(self): ''' Tests that exporting multiple Maya planes with varying UV mappings setups results in USD data with material specializations: ''' expected = [ ("/pPlane1", "/blinn1SG_map1_map1_map1", "map1", "map1", "map1"), ("/pPlane2", "/blinn1SG", "st1", "st1", "st1"), ("/pPlane3", "/blinn1SG", "st1", "st1", "st1"), ("/pPlane4", "/blinn1SG_st2_st2_st2", "st2", "st2", "st2"), ("/pPlane5", "/blinn1SG_p5a_p5b_p5c", "p5a", "p5b", "p5c"), ("/pPlane6", "/blinn1SG_p62_p63_p61", "p62", "p63", "p61"), ("/pPlane7", "/blinn1SG_p7r_p7p_p7q", "p7r", "p7p", "p7q"), ] if mayaUsdLib.WriteUtil.WriteMap1AsST(): # map1 renaming has almost no impact here. Getting better results # for that test would require something more radical, possibly # uvSet[0] is always renamed to "st" # Which would reuse a single material for the first four planes. # # As currently implemented, the renaming affects only one material: expected[0] = ("/pPlane1", "/blinn1SG_st_st_st", "st", "st", "st") for mesh_name, mat_name, f1_name, f2_name, f3_name in expected: plane_prim = self._stage.GetPrimAtPath(mesh_name) binding_api = UsdShade.MaterialBindingAPI(plane_prim) mat = binding_api.ComputeBoundMaterial()[0] self.assertEqual(mat.GetPath(), mat_name) self.assertEqual( mat.GetInput("file1:varname").GetAttr().Get(), f1_name) self.assertEqual( mat.GetInput("file2:varname").GetAttr().Get(), f2_name) self.assertEqual( mat.GetInput("file3:varname").GetAttr().Get(), f3_name) # Initial code had a bug where a material with no UV mappings would # specialize itself. Make sure it stays fixed: plane_prim = self._stage.GetPrimAtPath("/pPlane8") binding_api = UsdShade.MaterialBindingAPI(plane_prim) mat = binding_api.ComputeBoundMaterial()[0] self.assertEqual(mat.GetPath(), "/pPlane8/Materials/blinn2SG") self.assertFalse(mat.GetPrim().HasAuthoredSpecializes())
def generate_ticker_cube(index, stage, stock_name): stage.SetStartTimeCode(0) stage.SetEndTimeCode(192) TextureRoot = UsdGeom.Xform.Define(stage, '/TexModel' + stock_name) Usd.ModelAPI(TextureRoot).SetKind(Kind.Tokens.component) billboard = UsdGeom.Mesh.Define( stage, "/TexModel" + stock_name + "/card" + stock_name) billboard.CreatePointsAttr([(-5, -5, 5), (5, -5, 5), (5, 5, 5), (-5, 5, 5)]) billboard.CreateFaceVertexCountsAttr([4]) billboard.CreateFaceVertexIndicesAttr([0, 1, 2, 3]) billboard.CreateExtentAttr([(-5, -5, 5), (5, 5, 5)]) texCoords = billboard.CreatePrimvar("st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying) texCoords.Set([(0, 0), (1, 0), (1, 1), (0, 1)]) material = UsdShade.Material.Define( stage, '/TexModel' + stock_name + '/boardMat' + stock_name) stInput = material.CreateInput('frame:stPrimvarName', Sdf.ValueTypeNames.Token) stInput.Set('st') pbrShader = UsdShade.Shader.Define( stage, '/TexModel' + stock_name + '/boardMat/PBRShader' + stock_name) pbrShader.CreateIdAttr("UsdPreviewSurface") pbrShader.CreateInput("roughness", Sdf.ValueTypeNames.Float).Set(0.4) pbrShader.CreateInput("metallic", Sdf.ValueTypeNames.Float).Set(0.0) material.CreateSurfaceOutput().ConnectToSource(pbrShader, "surface") stReader = UsdShade.Shader.Define( stage, '/TexModel' + stock_name + '/boardMat/stReader' + stock_name) stReader.CreateIdAttr('UsdPrimvarReader_float2') stReader.CreateInput('varname', Sdf.ValueTypeNames.Token).ConnectToSource(stInput) print(stock_name) diffuseTextureSampler = UsdShade.Shader.Define( stage, '/TexModel' + stock_name + '/boardMat/diffuseTexture' + stock_name) diffuseTextureSampler.CreateIdAttr('UsdUVTexture') diffuseTextureSampler.CreateInput('file', Sdf.ValueTypeNames.Asset).Set( '/Users/Abhinav/Documents/USDZ/CNBC/textures/' + stock_name + '.png') diffuseTextureSampler.CreateInput( "st", Sdf.ValueTypeNames.Float2).ConnectToSource(stReader, 'result') diffuseTextureSampler.CreateOutput('rgb', Sdf.ValueTypeNames.Float3) pbrShader.CreateInput("diffuseColor", Sdf.ValueTypeNames.Color3f).ConnectToSource( diffuseTextureSampler, 'rgb') UsdShade.MaterialBindingAPI(billboard.GetPrim()).Bind(material) UsdGeom.XformCommonAPI(billboard).SetTranslate( (-20, 20 * index, -index * 20)) spin = billboard.AddRotateYOp(opSuffix='spin') spin.Set(time=0, value=0) spin.Set(time=192, value=1440) return stage
def testInstancedGeom_Subsets(self): """Tests that instanced geom with materials assigned to subsets are automatically de-instanced.""" multiAssignPrim = self._simpleStage.GetPrimAtPath( "/World/blueSphereMultiAssign") self.assertFalse(multiAssignPrim.IsInstanceable()) shape = multiAssignPrim.GetChild("Shape") self.assertFalse(shape.IsInstance()) subset1 = shape.GetChild("initialShadingGroup") self.assertTrue(subset1) mat, _ = UsdShade.MaterialBindingAPI(subset1).ComputeBoundMaterial() self.assertEqual(mat.GetPath(), "/World/Materials/initialShadingGroup") subset2 = shape.GetChild("blinn1SG") self.assertTrue(subset2) mat, _ = UsdShade.MaterialBindingAPI(subset2).ComputeBoundMaterial() self.assertEqual(mat.GetPath(), "/World/Materials/blinn1SG")
def add_material(materials_opt, xsi_mat, stage, stage_asset_path, usd_xform, usd_prim, is_bind=True): # do the same in prim_mesh material_asset_path = materials_opt.get("asset_path", None) if material_asset_path is not None: rel_material_path = utils.transform_path_to_relative(stage_asset_path, material_asset_path) mat_name = utils.buil_material_name(xsi_mat) mat_ref = stage.DefinePrim(str(usd_xform.GetPath()) + "/" + mat_name) mat_ref.GetReferences().AddReference(rel_material_path, "/" + xsi_mat.Library.Name + "/" + xsi_mat.Name) # bind the main material if is_bind: UsdShade.MaterialBindingAPI(usd_prim).Bind(UsdShade.Material(stage.GetPrimAtPath(mat_ref.GetPath())))
def sync(objects_prim, obj_data: ObjectData, **kwargs): """ sync the object and any data attached """ log("sync", obj_data.object, obj_data.instance_id) stage = objects_prim.GetStage() xform = UsdGeom.Xform.Define( stage, objects_prim.GetPath().AppendChild(obj_data.sdf_name)) obj_prim = xform.GetPrim() # setting transform xform.MakeMatrixXform().Set(Gf.Matrix4d(obj_data.transform)) obj = obj_data.object if obj_data.is_particle: orig_obj_path = objects_prim.GetPath().AppendChild( sdf_name(obj.original)) usd_mesh = UsdGeom.Mesh.Define( stage, obj_prim.GetPath().AppendChild(sdf_name(obj.original))) mesh_prim = stage.DefinePrim( orig_obj_path.AppendChild(sdf_name(obj.data)), 'Mesh') usd_mesh.GetPrim().GetReferences().AddInternalReference( mesh_prim.GetPath()) if obj.active_material: material_prim = stage.DefinePrim( orig_obj_path.AppendChild( material.sdf_name(obj.active_material)), 'Material') usd_material = UsdShade.Material.Get(stage, material_prim.GetPath()) UsdShade.MaterialBindingAPI(usd_mesh).Bind(usd_material) return if obj.type == 'MESH': if obj.mode == 'OBJECT': # if in edit mode use to_mesh mesh.sync(obj_prim, obj, **kwargs) else: to_mesh.sync(obj_prim, obj, **kwargs) elif obj.type == 'LIGHT': light.sync(obj_prim, obj, **kwargs) elif obj.type == 'CAMERA': camera.sync(obj_prim, obj, **kwargs) elif obj.type in ('EMPTY', 'ARMATURE'): pass else: to_mesh.sync(obj_prim, obj, **kwargs)
def generate_price_cube(price, stock_name, stage, position, index): path = create_image(price, stock_name, position) TextureRoot = UsdGeom.Xform.Define( stage, '/priceModel' + stock_name + str(position)) Usd.ModelAPI(TextureRoot).SetKind(Kind.Tokens.component) billboard = UsdGeom.Mesh.Define( stage, "/priceModel" + stock_name + str(position) + "/card" + stock_name + str(position)) billboard.CreatePointsAttr([(-5, -5, 5), (5, -5, 5), (5, 5, 5), (-5, 5, 5)]) billboard.CreateFaceVertexCountsAttr([4]) billboard.CreateFaceVertexIndicesAttr([0, 1, 2, 3]) billboard.CreateExtentAttr([(-5, -5, 5), (5, 5, 5)]) texCoords = billboard.CreatePrimvar("st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying) texCoords.Set([(0, 0), (1, 0), (1, 1), (0, 1)]) material = UsdShade.Material.Define( stage, '/priceModel' + stock_name + str(position) + '/boardMat' + stock_name + str(position)) stInput = material.CreateInput('frame:stPrimvarName', Sdf.ValueTypeNames.Token) stInput.Set('st') pbrShader = UsdShade.Shader.Define( stage, '/priceModel' + stock_name + str(position) + '/boardMat/PBRShader' + stock_name + str(position)) pbrShader.CreateIdAttr("UsdPreviewSurface") pbrShader.CreateInput("roughness", Sdf.ValueTypeNames.Float).Set(0.4) pbrShader.CreateInput("metallic", Sdf.ValueTypeNames.Float).Set(0.0) material.CreateSurfaceOutput().ConnectToSource(pbrShader, "surface") stReader = UsdShade.Shader.Define( stage, '/priceModel' + stock_name + str(position) + '/boardMat/stReader' + stock_name + str(position)) stReader.CreateIdAttr('UsdPrimvarReader_float2') stReader.CreateInput('varname', Sdf.ValueTypeNames.Token).ConnectToSource(stInput) diffuseTextureSampler = UsdShade.Shader.Define( stage, '/priceModel' + stock_name + str(position) + '/boardMat/diffuseTexture' + stock_name + str(position)) diffuseTextureSampler.CreateIdAttr('UsdUVTexture') diffuseTextureSampler.CreateInput('file', Sdf.ValueTypeNames.Asset).Set(path) diffuseTextureSampler.CreateInput( "st", Sdf.ValueTypeNames.Float2).ConnectToSource(stReader, 'result') diffuseTextureSampler.CreateOutput('rgb', Sdf.ValueTypeNames.Float3) pbrShader.CreateInput("diffuseColor", Sdf.ValueTypeNames.Color3f).ConnectToSource( diffuseTextureSampler, 'rgb') UsdShade.MaterialBindingAPI(billboard.GetPrim()).Bind(material) UsdGeom.XformCommonAPI(billboard).SetTranslate( (10 * position, (20 * index) + (price + 5), -index * 20))
def testUninstancedGeom(self): """Tests a basic case of non-instanced geometry with bindings.""" worldPath = "/World" # Where collections are authored redMat = self._simpleStage.GetPrimAtPath("/World/Looks/blinn1SG") uninstancedPrim = self._simpleStage.GetPrimAtPath("/World/notInstanced") self.assertFalse(uninstancedPrim.IsInstance()) bindingAPI = UsdShade.MaterialBindingAPI(uninstancedPrim) mat, rel = bindingAPI.ComputeBoundMaterial() self.assertEqual(mat.GetPrim(), redMat) self.assertEqual(rel.GetPrim().GetPath(), worldPath)
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 __init__(self, appController, item): PrimContextMenuItem.__init__(self, appController, item) from pxr import UsdShade self._boundFullMaterial = None self._bindingRel = None for p in self._selectionDataModel.getPrims(): (self._boundFullMaterial, self._bindingRel) = \ UsdShade.MaterialBindingAPI(p).ComputeBoundMaterial( UsdShade.Tokens.full) if self._boundFullMaterial: break
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 testExportPxrRisShading(self): """ Tests that exporting a Maya mesh with a simple Maya shading setup results in the correct shading on the USD mesh. """ cubePrim = self._stage.GetPrimAtPath('/MarbleCube/Geom/Cube') self.assertTrue(cubePrim) # Validate the Material prim bound to the Mesh prim. materialBindingAPI = UsdShade.MaterialBindingAPI(cubePrim) material = materialBindingAPI.ComputeBoundMaterial()[0] self.assertTrue(material) materialPath = material.GetPath().pathString self.assertEqual(materialPath, '/MarbleCube/Materials/MarbleCubeSG') if Usd.GetVersion() >= (0, 21, 5): # For USD 21.05 and later, GetInputs() and GetOutputs() take an # "onlyAuthored" argument that is True by default, so in that case # we expect only one output on the material for the "surface" # terminal in the "ri" renderContext that the export should have # authored. expectedNumOutputs = 1 else: # Otherwise prior to USD 21.05, GetInputs() and GetOutputs() did # not take any arguments and always included the built-in # terminals for the universal renderContext as well as any other # authored terminals. expectedNumOutputs = 4 # Validate the surface shader that is connected to the material. materialOutputs = material.GetOutputs() self.assertEqual(len(materialOutputs), expectedNumOutputs) print(self._stage.ExportToString()) materialOutput = material.GetOutput('ri:surface') (connectableAPI, outputName, outputType) = materialOutput.GetConnectedSource() self.assertEqual(outputName, 'out') shader = UsdShade.Shader(connectableAPI) self.assertTrue(shader) shaderId = shader.GetIdAttr().Get() self.assertEqual(shaderId, 'PxrMayaMarble') # Validate the connected input on the surface shader. shaderInput = shader.GetInput('placementMatrix') self.assertTrue(shaderInput) (connectableAPI, outputName, outputType) = shaderInput.GetConnectedSource() self.assertEqual(outputName, 'worldInverseMatrix') shader = UsdShade.Shader(connectableAPI) self.assertTrue(shader) shaderId = shader.GetIdAttr().Get() self.assertEqual(shaderId, 'PxrMayaPlacement3d')
def sync_update_all(root_prim, mat: bpy.types.Material): sdf_mat_name = sdf_name(mat) mat_prims = [] for obj_prim in root_prim.GetAllChildren(): mat_prim = obj_prim.GetChild(sdf_mat_name) if mat_prim: mat_prims.append(mat_prim) if not mat_prims: return None doc = mat.hdusd.export(None) if not doc: # removing rpr_materialx_node in all material_prims return None surfacematerial = next(node for node in doc.getNodes() if node.getCategory() == 'surfacematerial') stage = root_prim.GetStage() mx_file = utils.get_temp_file( ".mtlx", f'{mat.name}{mat.hdusd.mx_node_tree.name if mat.hdusd.mx_node_tree else ""}' ) mx.writeToXmlFile(doc, str(mx_file)) for mat_prim in mat_prims: mat_prim.GetReferences().ClearReferences() mat_prim.GetReferences().AddReference(f"./{mx_file.name}", "/MaterialX") # apply new bind if shader switched to MaterialX or vice versa mesh_prim = next((prim for prim in mat_prim.GetParent().GetChildren() if prim.GetTypeName() == 'Mesh'), None) if not mesh_prim: return None bindings = UsdShade.MaterialBindingAPI(mesh_prim) rel_bind = bindings.GetDirectBindingRel() sdf_path = mat_prim.GetPath().AppendChild('Materials').AppendChild( surfacematerial.getName()) sdf_path_old = next((target for target in rel_bind.GetTargets()), None) # check if bind path is changed if not sdf_path_old or sdf_path == sdf_path_old: return None usd_mat = UsdShade.Material.Define(stage, sdf_path) bindings.UnbindAllBindings() bindings.Bind(usd_mat)
def testExportRfMShaders(self): ''' Tests that exporting a Maya mesh with a simple Maya shading setup results in the correct shading on the USD mesh. ''' cubePrim = self._stage.GetPrimAtPath('/MarbleCube/Geom/Cube') self.assertTrue(cubePrim) # Validate the Material prim bound to the Mesh prim. self.assertTrue(cubePrim.HasAPI(UsdShade.MaterialBindingAPI)) materialBindingAPI = UsdShade.MaterialBindingAPI(cubePrim) material = materialBindingAPI.ComputeBoundMaterial()[0] self.assertTrue(material) materialPath = material.GetPath().pathString self.assertEqual(materialPath, '/MarbleCube/Materials/MarbleCubeSG') # We expect four outputs on the material, the three built-in terminals # for the universal renderContext, and a fourth for the "surface" # terminal in the "ri" renderContext that the export should have # authored. materialOutputs = material.GetOutputs() self.assertEqual(len(materialOutputs), 4) # Validate the lambert surface shader that is connected to the material. materialOutput = material.GetOutput('ri:surface') (connectableAPI, outputName, outputType) = materialOutput.GetConnectedSource() self.assertEqual(outputName, UsdShade.Tokens.surface) shader = UsdShade.Shader(connectableAPI) self.assertTrue(shader) shaderId = shader.GetIdAttr().Get() self.assertEqual(shaderId, 'PxrMayaLambert') # Validate the connected input on the lambert surface shader. shaderInput = shader.GetInput('color') self.assertTrue(shaderInput) (connectableAPI, outputName, outputType) = shaderInput.GetConnectedSource() self.assertEqual(outputName, 'outColor') shader = UsdShade.Shader(connectableAPI) self.assertTrue(shader) shaderId = shader.GetIdAttr().Get() self.assertEqual(shaderId, 'PxrMayaMarble') # Validate the connected input on the marble shader. shaderInput = shader.GetInput('placementMatrix') self.assertTrue(shaderInput) (connectableAPI, outputName, outputType) = shaderInput.GetConnectedSource() self.assertEqual(outputName, 'worldInverseMatrix') shader = UsdShade.Shader(connectableAPI) self.assertTrue(shader) shaderId = shader.GetIdAttr().Get() self.assertEqual(shaderId, 'PxrMayaPlacement3d')
def testExportDisplacementShaders(self): ''' Tests that exporting multiple Maya planes with varying displacement setups results in the expected USD data: ''' textures = ["RGBA", "RGB", "MonoA", "Mono"] channels = ["r", "g", "b", "a", "a"] for suffix in range(1, 21): image = textures[int((suffix - 1) / 5)] channel = channels[(suffix - 1) % 5] mesh_prim = self._stage.GetPrimAtPath('/pPlane%i' % suffix) self.assertTrue(mesh_prim) # Validate the Material prim bound to the Mesh prim. self.assertTrue(mesh_prim.HasAPI(UsdShade.MaterialBindingAPI)) mat_binding = UsdShade.MaterialBindingAPI(mesh_prim) material = mat_binding.ComputeBoundMaterial()[0] self.assertTrue(material) material_path = material.GetPath().pathString self.assertEqual( material_path, '/pPlane%i/Materials/blinn%iSG' % (suffix, suffix)) self.assertTrue(material.ComputeSurfaceSource()) self.assertTrue(material.ComputeDisplacementSource()) # Validate the shader that is connected to the material. mat_out = material.GetOutput(UsdShade.Tokens.displacement) (connect_api, out_name, _) = mat_out.GetConnectedSource() self.assertEqual(out_name, UsdShade.Tokens.displacement) shader = UsdShade.Shader(connect_api) self.assertTrue(shader) shader_id = shader.GetIdAttr().Get() self.assertEqual(shader_id, 'UsdPreviewSurface') # Validate the connected input on the displacement shader. in_displacement = shader.GetInput('displacement') self.assertTrue(in_displacement) (connect_api, out_name, _) = in_displacement.GetConnectedSource() self.assertEqual(out_name, channel) shader = UsdShade.Shader(connect_api) self.assertTrue(shader) shader_id = shader.GetIdAttr().Get() self.assertEqual(shader_id, 'UsdUVTexture') filename = shader.GetInput("file") self.assertTrue(filename.Get().path.endswith("/%s.png" % image))
def _bugStep1(s): # Make a Material that contains a UsdPreviewSurface material = UsdShade.Material.Define(s, '/Scene/Looks/NewMaterial') # Create the surface. pbrShader = UsdShade.Shader.Define(s, '/Scene/Looks/NewMaterial/PbrPreview') pbrShader.CreateIdAttr("UsdPreviewSurface") pbrShader.CreateInput("roughness", Sdf.ValueTypeNames.Float).Set(0.0) pbrShader.CreateInput("metallic", Sdf.ValueTypeNames.Float).Set(0.0) pbrShader.CreateInput("diffuseColor", Sdf.ValueTypeNames.Color3f).Set((0.0, 0.0, 1.0)) material.CreateSurfaceOutput().ConnectToSource(pbrShader, "surface") # Now bind the Material to the card mesh = s.GetPrimAtPath('/Scene/Geom/Plane') UsdShade.MaterialBindingAPI(mesh).Bind(material)
def _assign_materials(obj_prim, obj, usd_mesh): if not obj.material_slots: return mat = obj.material_slots[0].material if not mat: return stage = obj_prim.GetStage() root_prim = obj_prim.GetParent().GetParent() materials_prim = stage.DefinePrim(f"{root_prim.GetPath()}/materials") usd_mat = material.sync(materials_prim, mat, obj=obj) if usd_mat: UsdShade.MaterialBindingAPI(usd_mesh).Bind(usd_mat)
def test_GetBoundMaterial(self): stage = Usd.Stage.CreateInMemory() look = UsdShade.Material.Define(stage, "/World/Material") self.assertTrue(look) gprim = stage.OverridePrim("/World/Gprim") self.assertTrue(gprim) gprimBindingAPI = UsdShade.MaterialBindingAPI(gprim) self.assertFalse(gprimBindingAPI.ComputeBoundMaterial()[0]) gprimBindingAPI.Bind(look) (mat, rel) = gprimBindingAPI.ComputeBoundMaterial() self.assertTrue(mat and rel) # Now add one more target to mess things up rel = gprimBindingAPI.GetDirectBindingRel() rel.AddTarget(Sdf.Path("/World")) self.assertFalse(gprimBindingAPI.ComputeBoundMaterial()[0])