Material: Material interface

Author: ft-lab

tests/util/ConverterTestCase.py

@@ -25,33 +25,39 @@ def check_material_binding(self, prim: Usd.Prim, material: UsdShade.Material):
         bound_material = material_binding.GetDirectBindingRel().GetTargets()[0]
         self.assertEqual(bound_material, material.GetPrim().GetPath())
 
-    def get_material_diffuse_color(self, material: UsdShade.Material) -> Gf.Vec3f | None:
+    def _get_input_value(self, shader: UsdShade.Shader, input_name: str):
+        value_attrs = UsdShade.Utils.GetValueProducingAttributes(shader.GetInput(input_name))
+
+        # If no value is set, returns None.
+        if not value_attrs or len(value_attrs) == 0:
+            return None
+
+        return value_attrs[0].Get()
+
+    def _get_material_input_value(self, material: UsdShade.Material, input_name: str):
         shader: UsdShade.Shader = usdex.core.computeEffectivePreviewSurfaceShader(material)
-        return shader.GetInput("diffuseColor").Get()
+        return self._get_input_value(shader, input_name)
+
+    def get_material_diffuse_color(self, material: UsdShade.Material) -> Gf.Vec3f | None:
+        return self._get_material_input_value(material, "diffuseColor")
 
     def get_material_specular_color(self, material: UsdShade.Material) -> Gf.Vec3f | None:
-        shader: UsdShade.Shader = usdex.core.computeEffectivePreviewSurfaceShader(material)
-        return shader.GetInput("specularColor").Get()
+        return self._get_material_input_value(material, "specularColor")
 
     def get_material_specular_workflow(self, material: UsdShade.Material) -> bool:
-        shader: UsdShade.Shader = usdex.core.computeEffectivePreviewSurfaceShader(material)
-        return shader.GetInput("useSpecularWorkflow").Get() == 1
+        return self._get_material_input_value(material, "useSpecularWorkflow") == 1
 
     def get_material_opacity(self, material: UsdShade.Material) -> float:
-        shader: UsdShade.Shader = usdex.core.computeEffectivePreviewSurfaceShader(material)
-        return shader.GetInput("opacity").Get()
+        return self._get_material_input_value(material, "opacity")
 
     def get_material_roughness(self, material: UsdShade.Material) -> float:
-        shader: UsdShade.Shader = usdex.core.computeEffectivePreviewSurfaceShader(material)
-        return shader.GetInput("roughness").Get()
+        return self._get_material_input_value(material, "roughness")
 
     def get_material_metallic(self, material: UsdShade.Material) -> float:
-        shader: UsdShade.Shader = usdex.core.computeEffectivePreviewSurfaceShader(material)
-        return shader.GetInput("metallic").Get()
+        return self._get_material_input_value(material, "metallic")
 
     def get_material_ior(self, material: UsdShade.Material) -> float:
-        shader: UsdShade.Shader = usdex.core.computeEffectivePreviewSurfaceShader(material)
-        return shader.GetInput("ior").Get()
+        return self._get_material_input_value(material, "ior")
 
     def get_material_texture_path(self, material: UsdShade.Material, texture_type: str = "diffuseColor") -> pathlib.Path:
         """
@@ -69,9 +75,9 @@ def get_material_texture_path(self, material: UsdShade.Material, texture_type: s
         self.assertTrue(texture_input.HasConnectedSource())
 
         connected_source = texture_input.GetConnectedSource()
-        texture_prim = connected_source[0].GetPrim()
-        texture_file_attr = texture_prim.GetAttribute("inputs:file")
-        return pathlib.Path(texture_file_attr.Get().path)
+        texture_shader = UsdShade.Shader(connected_source[0].GetPrim())
+        texture_file_value = self._get_input_value(texture_shader, "file")
+        return pathlib.Path(texture_file_value.path)
 
     def get_material_diffuse_color_texture_fallback(self, material: UsdShade.Material) -> Gf.Vec4f | None:
         shader: UsdShade.Shader = usdex.core.computeEffectivePreviewSurfaceShader(material)
@@ -80,5 +86,5 @@ def get_material_diffuse_color_texture_fallback(self, material: UsdShade.Materia
             source = diffuse_color_input.GetConnectedSource()
             if len(source) > 0 and isinstance(source[0], UsdShade.ConnectableAPI) and source[0].GetPrim().IsA(UsdShade.Shader):
                 diffuse_texture_shader = UsdShade.Shader(source[0].GetPrim())
-                return diffuse_texture_shader.GetInput("fallback").Get()
+                return self._get_input_value(diffuse_texture_shader, "fallback")
         return None

urdf_usd_converter/_impl/_flatten.py

@@ -17,18 +17,18 @@ def export_flattened(asset_stage: Usd.Stage, output_dir: str, asset_dir: str, as
     asset_identifier = f"{output_path.absolute().as_posix()}/{asset_stem}.{asset_format}"
     usdex.core.exportLayer(layer, asset_identifier, get_authoring_metadata(), comment)
 
-    # fix all PreviewMaterial inputs:file to ./Textures/xxx
+    # fix all PreviewMaterial material interface asset inputs from abs to rel paths (./Textures/xxx)
     stage = Usd.Stage.Open(asset_identifier)
     for prim in stage.Traverse():
-        if prim.IsA(UsdShade.Shader):
-            shader = UsdShade.Shader(prim)
-            file_input = shader.GetInput("file")
-            if file_input and file_input.Get() is not None:
-                file_path = pathlib.Path(file_input.Get().path if hasattr(file_input.Get(), "path") else file_input.Get())
-                tmpdir = pathlib.Path(tempfile.gettempdir())
-                if file_path.is_relative_to(tmpdir):
-                    new_path = f"./{Tokens.Textures}/{file_path.name}"
-                    file_input.Set(Sdf.AssetPath(new_path))
+        if prim.IsA(UsdShade.Material):
+            material = UsdShade.Material(prim)
+            for input in material.GetInputs(onlyAuthored=True):
+                if input.GetTypeName() == Sdf.ValueTypeNames.Asset:
+                    file_path = pathlib.Path(input.Get().path)
+                    tmpdir = pathlib.Path(tempfile.gettempdir())
+                    if file_path.is_relative_to(tmpdir):
+                        new_path = f"./{Tokens.Textures}/{file_path.name}"
+                        input.Set(Sdf.AssetPath(new_path))
     stage.Save()
     # copy texture to output dir
     temp_textures_dir = pathlib.Path(asset_dir) / Tokens.Payload / Tokens.Textures

urdf_usd_converter/_impl/material.py

@@ -180,6 +180,12 @@ def _convert_material(
         if specular_texture_path:
             _add_specular_texture_to_preview_material(material_prim, _get_texture_asset_path(specular_texture_path, texture_paths, data))
 
+    result = usdex.core.addPreviewMaterialInterface(material_prim)
+    if not result:
+        Tf.RaiseRuntimeError(f'Failed to add material instance to material prim "{material_prim.GetPath()}"')
+
+    material_prim.GetPrim().SetInstanceable(True)
+
     return material_prim
 
 
@@ -209,7 +215,7 @@ def _add_specular_texture_to_preview_material(material_prim: UsdShade.Material,
         material_prim, "SpecularTexture", specular_texture_path, usdex.core.ColorSpace.eAuto, fallback
     )
 
-    # Connect the PreviewSurface shader "roughness" to the roughness tex shader output
+    # Connect the PreviewSurface shader "specularColor" to the specular texture shader output
     specular_color_input.ConnectToSource(texture_reader.CreateOutput("rgb", Sdf.ValueTypeNames.Float3))