Fix dirtying attributes on non-meshes

Author: lanierd-adsk

lib/mayaHydra/hydraExtensions/adapters/cameraAdapter.cpp

@@ -22,6 +22,7 @@
 
 #include <pxr/base/gf/interval.h>
 #include <pxr/imaging/hd/camera.h>
+#include <pxr/imaging/hd/changeTracker.h>
 
 #include <maya/MDagMessage.h>
 #include <maya/MFnCamera.h>
@@ -79,7 +80,10 @@ void MayaHydraCameraAdapter::Populate()
 void MayaHydraCameraAdapter::MarkDirty(HdDirtyBits dirtyBits)
 {
     if (_isPopulated && dirtyBits != 0) {
-        dirtyBits = dirtyBits & HdCamera::AllDirty;
+        // We support extension-attribute primvars on cameras, so keep DirtyPrimvar even though
+        // cameras are sprims and normally only expose HdCamera dirty bits.
+        const HdDirtyBits primvarBits = dirtyBits & HdChangeTracker::DirtyPrimvar;
+        dirtyBits = (dirtyBits & HdCamera::AllDirty) | primvarBits;
         GetMayaHydraSceneIndex()->MarkSprimDirty(GetID(), dirtyBits);
     }
 }

lib/mayaHydra/hydraExtensions/adapters/lightAdapter.cpp

@@ -25,6 +25,7 @@
 #include <pxr/base/tf/diagnostic.h>
 #include <pxr/base/tf/type.h>
 #include <pxr/imaging/hd/light.h>
+#include <pxr/imaging/hd/changeTracker.h>
 #include <pxr/imaging/hdx/simpleLightTask.h>
 #include <pxr/usd/usdLux/tokens.h>
 
@@ -138,6 +139,10 @@ void MayaHydraLightAdapter::Populate()
 void MayaHydraLightAdapter::MarkDirty(HdDirtyBits dirtyBits)
 {
     if (_isPopulated && dirtyBits != 0) {
+        // We support extension-attribute primvars on lights, so keep DirtyPrimvar even though
+        // lights are sprims and normally only expose HdLight dirty bits.
+        const HdDirtyBits primvarBits = dirtyBits & HdChangeTracker::DirtyPrimvar;
+        dirtyBits = (dirtyBits & HdLight::AllDirty) | primvarBits;
         GetMayaHydraSceneIndex()->MarkSprimDirty(GetID(), dirtyBits);
     }
 }

lib/mayaHydra/hydraExtensions/adapters/materialAdapter.cpp

@@ -27,6 +27,7 @@
 #include <pxr/base/tf/token.h>
 #include <pxr/base/tf/type.h>
 #include <pxr/imaging/hd/material.h>
+#include <pxr/imaging/hd/changeTracker.h>
 #include <pxr/pxr.h>
 #include <pxr/usd/sdf/types.h>
 #include <pxr/usd/usd/prim.h>
@@ -85,6 +86,10 @@ bool MayaHydraMaterialAdapter::HasType(const TfToken& typeId) const
 
 void MayaHydraMaterialAdapter::MarkDirty(HdDirtyBits dirtyBits)
 {
+    // We support extension-attribute primvars on materials, so keep DirtyPrimvar even though
+    // materials are sprims and normally only expose HdMaterial dirty bits.
+    const HdDirtyBits primvarBits = dirtyBits & HdChangeTracker::DirtyPrimvar;
+    dirtyBits = (dirtyBits & HdMaterial::AllDirty) | primvarBits;
     GetMayaHydraSceneIndex()->MarkSprimDirty(GetID(), dirtyBits);
 }
 

lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp

@@ -27,6 +27,7 @@
 #include <mayaHydraLib/sceneIndex/mayaHydraDataSource.h>
 
 #include <pxr/base/tf/envSetting.h>
+#include <pxr/imaging/hd/primvarsSchema.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
 #include <pxr/imaging/hd/rprim.h>
 #include <pxr/usdImaging/usdImaging/tokens.h>
@@ -903,6 +904,9 @@ void MayaHydraSceneIndex::_MarkPrimDirty(
     HdSceneIndexPrim       prim = GetPrim(id);
     HdDataSourceLocatorSet locators;
     dirtyBitsToLocatorsFunc(prim.primType, dirtyBits, &locators);
+    if (dirtyBits & HdChangeTracker::DirtyPrimvar) {
+        locators.append(HdPrimvarsSchema::GetDefaultLocator());
+    }
     if (!locators.IsEmpty()) {
         DirtyPrims({ { id, locators } });
     }

test/lib/mayaUsd/render/mayaToHydra/CMakeLists.txt

@@ -100,6 +100,7 @@ set(INTERACTIVE_TEST_SCRIPT_FILES
     cpp/testGeomSubsetsPicking.py
     cpp/testSinglePicking.py
     cpp/testSceneIndexDirtying.py
+    cpp/testCustomAttributeDirtying.py
     cpp/testUsdStageInvalidate.py
     cpp/testCamera.py
     cpp/testCustomAttributes.py|depOnPlugins:mtoa

test/lib/mayaUsd/render/mayaToHydra/cpp/CMakeLists.txt

@@ -33,6 +33,7 @@ target_sources(${TARGET_NAME}
         testFlowViewportAPIAddPrims.cpp
         testUsdStageLayerMuting.cpp
         testMeshAdapterTransform.cpp
+        testCustomAttributeDirtying.cpp
         testFlowViewportAPIFilterPrims.cpp
         testSceneCorrectness.cpp
         testSelection.cpp

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

@@ -0,0 +1,127 @@
+// Copyright 2026 Autodesk
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "testUtils.h"
+
+#include <pxr/imaging/hd/primvarsSchema.h>
+#include <pxr/imaging/hd/tokens.h>
+
+#include <maya/MGlobal.h>
+
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <cmath>
+#include <string>
+
+PXR_NAMESPACE_USING_DIRECTIVE
+
+namespace {
+
+const char* kAttrName = "extDirty";
+const char* kMeshShapeName = "dirtyMeshShape";
+const char* kCameraShapeName = "dirtyCameraShape";
+const char* kLightShapeName = "dirtyLightShape";
+const char* kMaterialSgName = "dirtyMaterialSG";
+const char* kMeshShapeOptionVar = "mhDirtyMeshShape";
+const char* kCameraShapeOptionVar = "mhDirtyCameraShape";
+const char* kLightShapeOptionVar = "mhDirtyLightShape";
+const char* kMaterialSgOptionVar = "mhDirtyMaterialSg";
+
+std::string GetOptionVarOrDefault(const char* optionVar, const char* fallback)
+{
+    if (MGlobal::optionVarExists(optionVar)) {
+        return MGlobal::optionVarStringValue(optionVar).asChar();
+    }
+    return fallback;
+}
+
+bool AttrExists(const std::string& nodeName)
+{
+    int exists = 0;
+    const std::string cmd = std::string("attributeQuery -exists -node \"")
+        + nodeName + "\" " + kAttrName;
+    MGlobal::executeCommand(cmd.c_str(), exists);
+    return exists != 0;
+}
+
+void SetAttrAndRefresh(const std::string& nodeName, double value)
+{
+    const std::string cmd = std::string("setAttr \"")
+        + nodeName + "." + kAttrName + "\" " + std::to_string(value);
+    MGlobal::executeCommand(cmd.c_str());
+    MGlobal::executeCommand("refresh");
+}
+
+bool FindDirtyPrimWithPrimvarValueSince(
+    SceneIndexNotificationsAccumulator& accumulator,
+    size_t startIndex,
+    double expectedValue)
+{
+    const auto& entries = accumulator.GetDirtiedPrimEntries();
+    auto sceneIndex = accumulator.GetObservedSceneIndex();
+    const TfToken primvarName(kAttrName);
+
+    for (size_t i = startIndex; i < entries.size(); ++i) {
+        if (!entries[i].dirtyLocators.Contains(HdPrimvarsSchema::GetDefaultLocator())) {
+            continue;
+        }
+
+        HdSceneIndexPrim prim = sceneIndex->GetPrim(entries[i].primPath);
+        if (!prim.dataSource) {
+            continue;
+        }
+
+        HdSampledDataSourceHandle valueDs
+            = HdPrimvarsSchema::GetFromParent(prim.dataSource)
+                  .GetPrimvar(primvarName)
+                  .GetPrimvarValue();
+        if (!valueDs) {
+            continue;
+        }
+
+        VtValue value = valueDs->GetValue(0.0f);
+        if (!value.IsHolding<double>()) {
+            continue;
+        }
+
+        const double actual = value.UncheckedGet<double>();
+        if (std::abs(actual - expectedValue) <= 1e-6) {
+            return true;
+        }
+    }
+    return false;
+}
+
+} // namespace
+
+// Unit test: ensure extension-attribute primvars dirty for mesh, camera, light, material.
+TEST(CustomAttributeDirtying, testDirtyPrimvars)
+{
+    const SceneIndicesVector& sceneIndices = GetTerminalSceneIndices();
+    ASSERT_GT(sceneIndices.size(), 0u);
+    SceneIndexNotificationsAccumulator notifsAccumulator(sceneIndices.front());
+
+    auto checkDirty = [&](const std::string& nodeName, double value) {
+        const size_t startIndex = notifsAccumulator.GetDirtiedPrimEntries().size();
+        SetAttrAndRefresh(nodeName, value);
+        EXPECT_TRUE(FindDirtyPrimWithPrimvarValueSince(notifsAccumulator, startIndex, value));
+    };
+
+    checkDirty(GetOptionVarOrDefault(kMeshShapeOptionVar, kMeshShapeName), 1.0);
+    checkDirty(GetOptionVarOrDefault(kCameraShapeOptionVar, kCameraShapeName), 2.0);
+    checkDirty(GetOptionVarOrDefault(kLightShapeOptionVar, kLightShapeName), 3.0);
+    checkDirty(GetOptionVarOrDefault(kMaterialSgOptionVar, kMaterialSgName), 4.0);
+}

test/lib/mayaUsd/render/mayaToHydra/cpp/testCustomAttributeDirtying.py

@@ -0,0 +1,72 @@
+# Copyright 2026 Autodesk
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import maya.cmds as cmds
+import fixturesUtils
+import mtohUtils
+from testUtils import PluginLoaded
+
+
+class TestCustomAttributeDirtying(mtohUtils.MayaHydraBaseTestCase):
+    # MayaHydraBaseTestCase.setUpClass requirement.
+    _file = __file__
+
+    def setupScene(self):
+        cmds.file(new=True, force=True)
+        mesh_transform, mesh_shape = cmds.polyCube(name="dirtyMesh")
+        cam_transform, cam_shape = cmds.camera(name="dirtyCamera")
+        light_shape = cmds.pointLight(name="dirtyLight")
+
+        material = cmds.shadingNode("lambert", asShader=True, name="dirtyMaterial")
+        material_sg = cmds.sets(
+            renderable=True,
+            noSurfaceShader=True,
+            empty=True,
+            name="dirtyMaterialSG")
+        cmds.connectAttr(material + ".outColor", material_sg + ".surfaceShader", force=True)
+        cmds.sets(mesh_transform, edit=True, forceElement=material_sg)
+
+        mesh_transform = cmds.ls(mesh_transform, long=True)[0]
+        mesh_shape = cmds.listRelatives(mesh_transform, shapes=True, fullPath=True)[0]
+        cam_shape = cmds.listRelatives(cam_transform, shapes=True, fullPath=True)[0]
+        light_shape = cmds.ls(light_shape, long=True)[0]
+        material_sg = cmds.ls(material_sg, long=True)[0]
+
+        def _ensure_ext_dirty(node):
+            if not cmds.attributeQuery("extDirty", node=node, exists=True):
+                cmds.addAttr(node, longName="extDirty", attributeType="double", defaultValue=0.0)
+            try:
+                cmds.setAttr(node + ".extDirty", edit=True, keyable=True)
+            except RuntimeError:
+                cmds.setAttr(node + ".extDirty", edit=True, channelBox=True)
+
+        for node in (mesh_shape, cam_shape, light_shape, material_sg):
+            _ensure_ext_dirty(node)
+
+        self.setHdStormRenderer()
+        cmds.optionVar(stringValue=("mhDirtyMeshShape", mesh_shape))
+        cmds.optionVar(stringValue=("mhDirtyCameraShape", cam_shape))
+        cmds.optionVar(stringValue=("mhDirtyLightShape", light_shape))
+        cmds.optionVar(stringValue=("mhDirtyMaterialSg", material_sg))
+
+        cmds.refresh()
+
+    def test_customAttributeDirtying(self):
+        self.setupScene()
+        with PluginLoaded('mayaHydraCppTests'):
+            cmds.mayaHydraCppTest(f="CustomAttributeDirtying.testDirtyPrimvars")
+
+
+if __name__ == '__main__':
+    fixturesUtils.runTests(globals())