Merge branch 'sdf12' into ahcorde/usd_to_sdf_transforms

Author: ahcorde

usd/src/CMakeLists.txt

@@ -94,4 +94,9 @@ if (TARGET UNIT_Light_Sdf2Usd_TEST)
     ${sdf2usd_test_sources})
 endif()
 
+if (TARGET UNIT_Material_Sdf2Usd_TEST)
+  target_sources(UNIT_Material_Sdf2Usd_TEST PRIVATE
+    ${sdf2usd_test_sources})
+endif()
+
 add_subdirectory(cmd)

usd/src/Conversions.cc

@@ -43,7 +43,14 @@ namespace sdf
       out.SetNormalMap(pbr->NormalMap());
       sdf::Pbr pbrOut;
       sdf::PbrWorkflow pbrWorkflow;
-      pbrWorkflow.SetAlbedoMap(pbr->AlbedoMap());
+      if (!pbr->AlbedoMap().empty())
+      {
+        pbrWorkflow.SetAlbedoMap(pbr->AlbedoMap());
+      }
+      else
+      {
+        pbrWorkflow.SetAlbedoMap(_in->TextureImage());
+      }
       pbrWorkflow.SetMetalnessMap(pbr->MetalnessMap());
       pbrWorkflow.SetEmissiveMap(pbr->EmissiveMap());
       pbrWorkflow.SetRoughnessMap(pbr->RoughnessMap());
@@ -66,13 +73,15 @@ namespace sdf
           pbr->NormalMap(), sdf::NormalMapSpace::OBJECT);
       }
 
-      if (pbr->Type() == ignition::common::PbrType::METAL)
+      if (pbr->Type() == ignition::common::PbrType::SPECULAR)
       {
-        pbrOut.SetWorkflow(sdf::PbrWorkflowType::METAL, pbrWorkflow);
+        pbrWorkflow.SetType(sdf::PbrWorkflowType::SPECULAR);
+        pbrOut.SetWorkflow(sdf::PbrWorkflowType::SPECULAR, pbrWorkflow);
       }
-      else if (pbr->Type() == ignition::common::PbrType::SPECULAR)
+      else
       {
-        pbrOut.SetWorkflow(sdf::PbrWorkflowType::SPECULAR, pbrWorkflow);
+        pbrWorkflow.SetType(sdf::PbrWorkflowType::METAL);
+        pbrOut.SetWorkflow(sdf::PbrWorkflowType::METAL, pbrWorkflow);
       }
       out.SetPbrMaterial(pbrOut);
     }

usd/src/sdf_parser/Material.cc

@@ -192,6 +192,7 @@ namespace usd
         sdf::usd::UsdErrorCode::INVALID_PRIM_PATH,
         "Not able to cast the UsdShadeShader at path [" + shaderPath.GetString()
         + "] to a Prim"));
+      return errors;
     }
 
     auto shaderOut = pxr::UsdShadeConnectableAPI(shaderPrim).CreateOutput(

usd/src/sdf_parser/Material_Sdf2Usd_TEST.cc

@@ -17,6 +17,7 @@
 
 #include <gtest/gtest.h>
 
+#include <ignition/common/Material.hh>
 #include <ignition/common/Util.hh>
 
 // TODO(ahcorde) this is to remove deprecated "warnings" in usd, these warnings
@@ -29,11 +30,16 @@
 #include <pxr/usd/usd/stage.h>
 #pragma pop_macro ("__DEPRECATED")
 
+#include "Material.hh"
+
+#include "sdf/usd/UsdError.hh"
 #include "sdf/usd/sdf_parser/World.hh"
+#include "sdf/Material.hh"
 #include "sdf/Root.hh"
 #include "test_config.h"
 #include "test_utils.hh"
 #include "../UsdTestUtils.hh"
+#include "../Conversions.hh"
 
 void CheckMaterial(
   const pxr::UsdPrim &_prim,
@@ -183,6 +189,64 @@ class UsdStageFixture : public::testing::Test
   public: pxr::UsdStageRefPtr stage;
 };
 
+TEST_F(UsdStageFixture, MaterialTextureName)
+{
+  sdf::testing::ScopeExit removeCopiedMaterials(
+      []
+      {
+        ignition::common::removeAll(
+          ignition::common::joinPaths(ignition::common::cwd(), "materials"));
+      });
+
+  sdf::setFindCallback(sdf::usd::testing::findFileCb);
+  ignition::common::addFindFileURICallback(
+    std::bind(&sdf::usd::testing::FindResourceUri, std::placeholders::_1));
+  const auto path = sdf::testing::TestFile("sdf", "basic_shapes.sdf");
+
+  ignition::common::Material materialCommon;
+  materialCommon.SetTextureImage("materials/textures/albedo_map.png");
+
+  const sdf::Material materialSdf = sdf::usd::convert(&materialCommon);
+
+  const auto materialPathStr = std::string("/Looks/Material_0");
+  auto materialPath = pxr::SdfPath(materialPathStr);
+
+  sdf::usd::UsdErrors errors = sdf::usd::ParseSdfMaterial(&materialSdf,
+      stage, materialPath);
+  EXPECT_TRUE(errors.empty());
+
+  {
+    ASSERT_TRUE(this->stage->GetPrimAtPath(materialPath));
+
+    const std::string materialshaderPath = materialPathStr + "/Shader";
+    const auto materialShaderPrim = this->stage->GetPrimAtPath(
+      pxr::SdfPath(materialshaderPath));
+    ASSERT_TRUE(materialShaderPrim);
+
+    auto variantshader = pxr::UsdShadeShader(materialShaderPrim);
+    ASSERT_TRUE(variantshader);
+
+    std::vector<pxr::UsdShadeInput> inputs = variantshader.GetInputs();
+
+    bool checkedTextureInput = false;
+    for (const auto &input : inputs)
+    {
+      if (input.GetBaseName() == "diffuse_texture")
+      {
+        pxr::SdfAssetPath materialPathUSD;
+        pxr::UsdShadeInput diffuseTextureShaderInput =
+          variantshader.GetInput(pxr::TfToken("diffuse_texture"));
+        diffuseTextureShaderInput.Get(&materialPathUSD);
+        EXPECT_EQ("materials/textures/albedo_map.png",
+          materialPathUSD.GetAssetPath());
+        checkedTextureInput = true;
+        break;
+      }
+    }
+    EXPECT_TRUE(checkedTextureInput);
+  }
+}
+
 /////////////////////////////////////////////////
 TEST_F(UsdStageFixture, Material)
 {