Lanierd/hydra 1054

lib/flowViewport/sceneIndex/fvpDefaultMaterialSceneIndex.cpp

@@ -22,13 +22,33 @@
 #include <pxr/imaging/hd/materialBindingsSchema.h>
 #include <pxr/imaging/hd/containerDataSourceEditor.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
+#include <pxr/usd/usdGeom/tokens.h>
 
 namespace FVP_NS_DEF {
 
 PXR_NAMESPACE_USING_DIRECTIVE
 
 namespace{
     static const TfToken purposes[] = { HdMaterialBindingsSchemaTokens->allPurpose };
+
+    // Support implicit surfaces from USD as well, not only meshes
+    bool _IsDefaultMaterialCompliantPrimitive(const TfToken& primType) 
+    { 
+        static VtArray<TfToken> const compliantPrimitives = { HdPrimTypeTokens->cone,
+                                                              HdPrimTypeTokens->cylinder,
+                                                              HdPrimTypeTokens->cylinder_1,
+                                                              HdPrimTypeTokens->cube,
+                                                              HdPrimTypeTokens->sphere,   
+                                                              HdPrimTypeTokens->capsule,
+                                                              HdPrimTypeTokens->capsule_1,
+                                                        #if HD_API_VERSION >= 67 // USD 24.05+
+                                                              UsdGeomTokens->TetMesh,
+                                                        #endif
+                                                              UsdGeomTokens->Plane,
+                                                              HdPrimTypeTokens->mesh};
+        return std::find(compliantPrimitives.cbegin(), compliantPrimitives.cend(), primType)
+            != compliantPrimitives.cend();
+    }
 }
 
 // static
@@ -68,7 +88,7 @@ HdSceneIndexPrim DefaultMaterialSceneIndex::GetPrim(const SdfPath& primPath) con
 bool DefaultMaterialSceneIndex::_ShouldWeApplyTheDefaultMaterial(const HdSceneIndexPrim& prim)const
 {
     // Only for meshes so far
-    if (HdPrimTypeTokens->mesh != prim.primType) {
+    if (! _IsDefaultMaterialCompliantPrimitive(prim.primType)) {
         return false;
     }
 

lib/mayaHydra/hydraExtensions/mixedUtils.cpp

@@ -78,6 +78,11 @@ SdfPath DagPathToSdfPath(
     const bool      stripNamespaces)
 {
     std::string name = dagPath.fullPathName().asChar();
+    if ( name.empty() ) {
+        MFnDependencyNode dep(dagPath.node());
+        TF_WARN("Empty fullpath name for DAG object : %s of type : %s", dep.name().asChar(), dep.typeName().asChar());
+        return SdfPath();
+    }
     SanitizeNameForSdfPath(name, stripNamespaces);
     SdfPath usdPath(name);
 

lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp

@@ -139,8 +139,9 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
         auto secondSegment = appPath.getSegments()[1];
         const auto lastComponentString = secondSegment.components().back().string();
         const bool lastComponentIsNumeric = lastComponentString.find_first_not_of(digits) == std::string::npos;
+        const size_t lastComponentIndex = secondSegment.size() - 1;
 
-        for (size_t iSecondSegment = 0; iSecondSegment < secondSegment.size(); iSecondSegment++) {
+        for (size_t iComponent = 0; iComponent < secondSegment.size(); iComponent++) {
             // Native instancing : if the current prim path points to a native instance, repath to the prototype
             // before appending the following UFE components
             HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
@@ -155,16 +156,20 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
                 instanceSelection = {instancerPath, prototypeIndex, {instanceSchema.GetInstanceIndex()->GetTypedValue(0)}};
             }
 
-            auto targetChildPath = primPath.AppendChild(TfToken(secondSegment.components()[iSecondSegment].string()));
+            auto targetChildPath = primPath.AppendChild(TfToken(secondSegment.components()[iComponent].string()));
             auto actualChildPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath);
             if (std::find(actualChildPaths.begin(), actualChildPaths.end(), targetChildPath) != actualChildPaths.end()) {
                 // Append if the new path is valid
-                primPath = primPath.AppendChild(TfToken(secondSegment.components()[iSecondSegment].string()));
+                primPath = targetChildPath;
             }
-            else if (iSecondSegment == secondSegment.size() - 1) {
-                // Point instancing : instance selection. The path should end with a number corresponding to the selected instance,
-                // and the remainder of the path points to the point instancer.
-                if (TF_VERIFY(lastComponentIsNumeric, "Expected number as final UFE path component but got an invalid path instead.")) {
+            else if (iComponent == lastComponentIndex) {
+                // If the last component is a number, we are dealing with an instance selection.
+                // But there are other cases like when you assign a USD Preview surface material to a usd prim, it has a shader prim in the material 
+                // which doesn't appear in the hydra hierarchy but is actually present and we end up in this case as well.
+                if (lastComponentIsNumeric) {
+                    // Point instancing : instance selection. The path should end with a number
+                    // corresponding to the selected instance,
+                    // and the remainder of the path points to the point instancer.
                     HdSceneIndexPrim instancerPrim = GetInputSceneIndex()->GetPrim(primPath);
                     HdInstancerTopologySchema instancerTopologySchema = HdInstancerTopologySchema::GetFromParent(instancerPrim.dataSource);
                     auto instanceIndicesByPrototype = instancerTopologySchema.GetInstanceIndices();

test/lib/mayaUsd/render/mayaToHydra/testMayaDefaultMaterial.py

@@ -44,6 +44,21 @@ def test_MayaDefaultMaterial(self):
             cmds.modelEditor(panel, edit=True, useDefaultMaterial=True)
             cmds.refresh()
             self.assertSnapshotClose("defaultMaterial" + ".png", self.IMAGE_DIFF_FAIL_THRESHOLD, self.IMAGE_DIFF_FAIL_PERCENT)        
+
+    def test_MayaDefaultMaterialUsdPrims(self):
+        # open a Maya scene with usd prims (sphere, capsule, cube, cylinder ...)
+        testFile = mayaUtils.openTestScene(
+                "testDefaultMaterial",
+                "testMayaDefaultMaterial_Usd_proceduralShapes.ma", useTestSettings=False)
+        cmds.refresh()
+
+        #Cone and cylinder_1 are not supported on OSX with USD 24.05 so they are not in our test scene
+
+        #Use Default Material
+        panel = mayaUtils.activeModelPanel()
+        cmds.modelEditor(panel, edit=True, useDefaultMaterial=True)
+        cmds.refresh()
+        self.assertSnapshotClose("defaultMaterialUsdPrims" + ".png", self.IMAGE_DIFF_FAIL_THRESHOLD, self.IMAGE_DIFF_FAIL_PERCENT)
 
 if __name__ == '__main__':
     fixturesUtils.runTests(globals())