Support enums custom attributes as labels using a maya OptionVar

Author: lanierd-adsk

lib/mayaHydra/hydraExtensions/mixedUtils.cpp

@@ -78,6 +78,17 @@ PXR_NAMESPACE_USING_DIRECTIVE
 
 namespace MAYAHYDRA_NS_DEF {
 
+// OptionVar to emit enum primvars as label tokens instead of integer values.
+constexpr const char* kExtEnumUseLabelsOptionVar = "mayaHydraExtensionEnumUseLabels";
+
+bool UseEnumLabelsForExtensionAttrs()
+{
+    if (MGlobal::optionVarExists(kExtEnumUseLabelsOptionVar)) {
+        return MGlobal::optionVarIntValue(kExtEnumUseLabelsOptionVar) != 0;
+    }
+    return false;
+}
+
 // Store value only when it differs from the default.
 template<typename T> 
 void UpdateAttrs(const char* attrName, const T& val, const T& defaultVal, VtDictionary& attrs)
@@ -1057,12 +1068,32 @@ void GetExtensionAttributesFromNode(
                 short            value = attrPlug.asShort();
                 short            defaultVal = 0;
                 enumAttr.getDefault(defaultVal);
-                UpdateAttrsValue(
-                    attrName,
-                    VtValue(value),
-                    VtValue(defaultVal),
-                    !ignoreDefault,
-                    attrs);
+                if (UseEnumLabelsForExtensionAttrs()) {
+                    const MString label = enumAttr.fieldName(value);
+                    const MString defaultLabel = enumAttr.fieldName(defaultVal);
+                    if (!label.length() || !defaultLabel.length()) {
+                        UpdateAttrsValue(
+                            attrName,
+                            VtValue(value),
+                            VtValue(defaultVal),
+                            !ignoreDefault,
+                            attrs);
+                    } else {
+                        UpdateAttrsValue(
+                            attrName,
+                            VtValue(TfToken(label.asChar())),
+                            VtValue(TfToken(defaultLabel.asChar())),
+                            !ignoreDefault,
+                            attrs);
+                    }
+                } else {
+                    UpdateAttrsValue(
+                        attrName,
+                        VtValue(value),
+                        VtValue(defaultVal),
+                        !ignoreDefault,
+                        attrs);
+                }
             } break;
             case MFn::kTypedAttribute: {
                 MFnTypedAttribute typeAttr(attrObj);

test/lib/mayaUsd/render/mayaToHydra/cpp/testCustomAttributeTypes.cpp

@@ -75,6 +75,35 @@ using namespace MayaHydra;
 // Unit test: verifies custom Maya extension attributes are translated into Hydra primvars.
 namespace {
 
+// OptionVar to emit enum primvars as label tokens.
+const char* kEnumLabelOptionVar = "mayaHydraExtensionEnumUseLabels";
+
+class ScopedOptionVarInt
+{
+public:
+    ScopedOptionVarInt(const char* name, int value)
+        : _name(name)
+        , _hadValue(MGlobal::optionVarExists(name))
+        , _oldValue(_hadValue ? MGlobal::optionVarIntValue(name) : 0)
+    {
+        MGlobal::setOptionVarValue(name, value);
+    }
+
+    ~ScopedOptionVarInt()
+    {
+        if (_hadValue) {
+            MGlobal::setOptionVarValue(_name.c_str(), _oldValue);
+        } else {
+            MGlobal::removeOptionVar(_name.c_str());
+        }
+    }
+
+private:
+    std::string _name;
+    bool        _hadValue;
+    int         _oldValue;
+};
+
 // Build a predicate to find a prim by name and type.
 FindPrimPredicate getPrimPredicate(const std::string& primName, const TfToken& primType)
 {
@@ -264,6 +293,36 @@ TEST(CustomAttributes, extensionAttributeTypes)
     ExpectPrimvarValue(prim, TfToken("extMatrixAttr"), ToGfMatrix(matrixAttrValue));
 }
 
+// Validate enum primvars can emit labels when configured.
+TEST(CustomAttributes, extensionAttributeEnumLabels)
+{
+    ScopedOptionVarInt enumLabels(kEnumLabelOptionVar, 1);
+    MGlobal::executeCommand("setAttr \"pCubeShape1.extEnum\" 2");
+    MGlobal::executeCommand("dgdirty -a");
+    MGlobal::executeCommand("refresh");
+
+    const SceneIndicesVector& sceneIndices = GetTerminalSceneIndices();
+    ASSERT_GT(sceneIndices.size(), 0u);
+
+    HdSceneIndexPrim prim;
+    bool             testPassed = false;
+    for (const HdSceneIndexBaseRefPtr& sceneIndex : sceneIndices) {
+        SceneIndexInspector inspector(sceneIndex);
+        PrimEntriesVector foundPrims
+            = inspector.FindPrims(getPrimPredicate("pCube1", HdPrimTypeTokens->mesh));
+        if (foundPrims.size() == 1u) {
+            prim = foundPrims.front().prim;
+            ASSERT_EQ(prim.primType, HdPrimTypeTokens->mesh);
+            ASSERT_NE(prim.dataSource, nullptr);
+            testPassed = true;
+            break;
+        }
+    }
+    ASSERT_TRUE(testPassed);
+
+    ExpectPrimvarValue(prim, TfToken("extEnum"), TfToken("two"));
+}
+
 // Validate typed numeric attributes are translated into primvars.
 TEST(CustomAttributes, extensionAttributeTypedNumeric)
 {