Merge fix-7.4.1 to master (#2273)

* ARNOLD-16217: Re-process conncetions after sync in update (#2266)

* Add changelog (#2270)

* Fix sampling of instancer matrices after a change of shutter value  (#2272)

* resample the instancer matrices if the shutter has changed

* fix incorrect initialization of the node indices array

* add test

* add changelog

* add note

* protect reading the sampled primvars with a lock

---------

Co-authored-by: Ashley Handscomb Retallack <[email protected]>
Co-authored-by: cpichard <[email protected]>

Author: 3 people

CHANGELOG.md

@@ -1,7 +1,14 @@
 <!-- SPDX-License-Identifier: Apache-2.0 -->
 # Changelog
 
-## Next Feature release
+## Next Bugfix release
+
+### Bug fixes
+
+- [usd#2269](https://github.com/Autodesk/arnold-usd/issues/2269) - Connections are not processed correctly during hydra procedural updates
+- [usd#2268](https://github.com/Autodesk/arnold-usd/issues/2268) - Reenable instancer motion blur on the first rendered frame by recomputing the transform matrices when the shutter is updated.
+
+## [7.4.1.0] - 2025-03-26
 
 ### Bug fixes
 - [usd#2254](https://github.com/Autodesk/arnold-usd/issues/2254) - Fix bug happening when the number of normal keys is less than the number of point keys.

libs/render_delegate/instancer.cpp

@@ -93,6 +93,17 @@ void HdArnoldInstancer::Sync(HdSceneDelegate* sceneDelegate, HdRenderParam* rend
     }
 }
 
+// Sample a primvar, check that the keys have the correct number of instances otherwise get only the sample at the keyframe
+// We have to do this because hydra SamplePrimvar
+template <typename VectorT>
+static void SamplePrimvar(
+    HdSceneDelegate* delegate, const SdfPath& id, const TfToken& key, const GfVec2f& shutterRange, VectorT& out)
+{
+    HdArnoldSampledPrimvarType sample;
+    delegate->SamplePrimvar(id, key, &sample);
+    HdArnoldUnboxResample(sample, shutterRange, out);
+}
+
 void HdArnoldInstancer::_SyncPrimvars(HdDirtyBits dirtyBits, HdArnoldRenderParam* renderParam)
 {
     auto& changeTracker = GetDelegate()->GetRenderIndex().GetChangeTracker();
@@ -120,21 +131,13 @@ void HdArnoldInstancer::_SyncPrimvars(HdDirtyBits dirtyBits, HdArnoldRenderParam
                 continue;
             }
             if (primvar.name == GetInstanceTransformsToken()) {
-                HdArnoldSampledPrimvarType sample;
-                GetDelegate()->SamplePrimvar(id, GetInstanceTransformsToken(), &sample);
-                HdArnoldUnboxResample(sample, renderParam->GetShutterRange(), _transforms);
+                SamplePrimvar(GetDelegate(), id, primvar.name, renderParam->GetShutterRange(), _transforms);
             } else if (primvar.name == GetRotateToken()) {
-                HdArnoldSampledPrimvarType sample;
-                GetDelegate()->SamplePrimvar(id, GetRotateToken(), &sample);
-                HdArnoldUnboxResample(sample, renderParam->GetShutterRange(), _rotates);
+                SamplePrimvar(GetDelegate(), id, primvar.name, renderParam->GetShutterRange(), _rotates);
             } else if (primvar.name == GetScaleToken()) {
-                HdArnoldSampledPrimvarType sample;
-                GetDelegate()->SamplePrimvar(id, GetScaleToken(), &sample);
-                HdArnoldUnboxResample(sample, renderParam->GetShutterRange(), _scales);
+                SamplePrimvar(GetDelegate(), id, primvar.name, renderParam->GetShutterRange(), _scales);
             } else if (primvar.name == GetTranslateToken()) {
-                HdArnoldSampledPrimvarType sample;
-                GetDelegate()->SamplePrimvar(id, GetTranslateToken(), &sample);
-                HdArnoldUnboxResample(sample, renderParam->GetShutterRange(), _translates);
+                SamplePrimvar(GetDelegate(), id, primvar.name, renderParam->GetShutterRange(), _translates);
             } else {
                 HdArnoldInsertPrimvar(
                     _primvars, primvar.name, primvar.role, primvar.interpolation, GetDelegate()->Get(id, primvar.name),
@@ -143,13 +146,39 @@ void HdArnoldInstancer::_SyncPrimvars(HdDirtyBits dirtyBits, HdArnoldRenderParam
         }
     }
 
+    // NOTE: it shouldn't be necessary to mark the instancer clean as it is done later on by hydra
     changeTracker.MarkInstancerClean(id);
 }
 
+void HdArnoldInstancer::ResampleInstancePrimvars()
+{
+    const auto& id = GetId();
+    std::lock_guard<std::mutex> lock(_mutex);
+    // Recompute the sampled primvars only if they were previously sampled
+    if (_transforms.count) {
+        SamplePrimvar(GetDelegate(), id, GetInstanceTransformsToken(), _samplingInterval, _transforms);
+    }
+    if (_rotates.count) {
+        SamplePrimvar(GetDelegate(), id, GetRotateToken(), _samplingInterval, _rotates);
+    }
+    if (_scales.count) {
+        SamplePrimvar(GetDelegate(), id, GetScaleToken(), _samplingInterval, _scales);
+    }
+    if (_translates.count) {
+        SamplePrimvar(GetDelegate(), id, GetTranslateToken(), _samplingInterval, _translates);
+    }
+}
+
 void HdArnoldInstancer::CalculateInstanceMatrices(HdArnoldRenderDelegate* renderDelegate, 
     const SdfPath& prototypeId, std::vector<AtNode *> &instancers)
 {
     const SdfPath& instancerId = GetId();
+    HdArnoldRenderParam * renderParam = reinterpret_cast<HdArnoldRenderParam*>(renderDelegate->GetRenderParam());
+    
+    // If the sampling interval has changed we need to resample the translate, orientations and scales
+    if (UpdateSamplingInterval(renderParam->GetShutterRange())){
+        ResampleInstancePrimvars();
+    }
 
     const auto instanceIndices = GetDelegate()->GetInstanceIndices(instancerId, prototypeId);
     if (instanceIndices.empty()) {
@@ -166,10 +195,15 @@ void HdArnoldInstancer::CalculateInstanceMatrices(HdArnoldRenderDelegate* render
     // most samples and use its time range.
     // TODO(pal): Improve this further by using the widest time range and calculate sample count based on that.
     _AccumulateSampleTimes(instancerTransforms, sampleArray);
-    _AccumulateSampleTimes(_transforms, sampleArray);
-    _AccumulateSampleTimes(_translates, sampleArray);
-    _AccumulateSampleTimes(_rotates, sampleArray);
-    _AccumulateSampleTimes(_scales, sampleArray);
+    {
+        // Another mesh can be resampling the instances primvars, we need to lock 
+        std::lock_guard<std::mutex> lock(_mutex);
+        _AccumulateSampleTimes(_transforms, sampleArray);
+        _AccumulateSampleTimes(_translates, sampleArray);
+        _AccumulateSampleTimes(_rotates, sampleArray);
+        _AccumulateSampleTimes(_scales, sampleArray);
+    }
+
 
     // By default _deformKeys will take over sample counts
     if (sampleArray.count <= 2 && _deformKeys < 2 && _deformKeys > -1 ) { 
@@ -274,7 +308,7 @@ void HdArnoldInstancer::CalculateInstanceMatrices(HdArnoldRenderDelegate* render
         auto* nodeIdxsArray = AiArrayAllocate(instanceCount, sampleCount, AI_TYPE_UINT);
         auto* matrices = static_cast<AtMatrix*>(AiArrayMap(matrixArray));
         auto* nodeIdxs = static_cast<uint32_t*>(AiArrayMap(nodeIdxsArray));
-        std::fill(nodeIdxs, nodeIdxs + instanceCount, 0);
+        std::fill(nodeIdxs, nodeIdxs + instanceCount*sampleCount, 0);
         AiArrayUnmap(nodeIdxsArray);
         auto convertMatrices = [&](size_t sample) {
             std::transform(

libs/render_delegate/instancer.h

@@ -83,6 +83,18 @@ class HdArnoldInstancer : public HdInstancer {
     /// Safe to call on multiple threads.
     HDARNOLD_API
     void _SyncPrimvars(HdDirtyBits dirtyBits, HdArnoldRenderParam* renderParam);
+
+    /// Saves the sampling interval used for sampling the primvars related to the transform
+    /// Returns true if the value has changed
+    inline bool UpdateSamplingInterval(GfVec2f samplingInterval)
+    {
+        bool hasChanged = samplingInterval != _samplingInterval;
+        _samplingInterval = samplingInterval;
+        return hasChanged;
+    }
+    /// @brief Resamples the stored sampled primvars. This is necessary when the sampling interval has changed
+    void ResampleInstancePrimvars();
+
     HdArnoldRenderDelegate* _delegate = nullptr;
     std::mutex _mutex;                                ///< Mutex to safe-guard calls to _SyncPrimvars.
     HdArnoldPrimvarMap _primvars;                     ///< Unordered map to store all the primvars.
@@ -91,8 +103,8 @@ class HdArnoldInstancer : public HdInstancer {
     // Newer versions use GfQuatH arrays instead of GfVec4f arrays.
     HdArnoldSampledType<VtQuathArray> _rotates; ///< Sampled instance rotate values.
     HdArnoldSampledType<VtVec3fArray> _scales; ///< Sampled instance scale values.
-
     int _deformKeys = -1; ///< Number of samples to consider, -1 means deactivated
+    GfVec2f _samplingInterval = {0.f, 0.f}; //< Keep track of the primvar sampling interval used 
 };
 
 PXR_NAMESPACE_CLOSE_SCOPE

libs/render_delegate/reader.cpp

@@ -326,7 +326,6 @@ void HydraArnoldReader::ReadStage(UsdStageRefPtr stage,
     // root.push_back(SdfPath("/"));
     // collection.SetRootPaths(root);
     _renderIndex->SyncAll(&_tasks, &_taskContext);
-
     arnoldRenderDelegate->ProcessConnections();
 
     // We want to render the purpose that this reader was assigned to.
@@ -342,6 +341,7 @@ void HydraArnoldReader::ReadStage(UsdStageRefPtr stage,
     // HasPendingChanges updates the dirtybits for a resync, this is how it works in our hydra render pass.
     while (arnoldRenderDelegate->HasPendingChanges(_renderIndex, _shutter)) {
         _renderIndex->SyncAll(&_tasks, &_taskContext);
+        arnoldRenderDelegate->ProcessConnections();
     }
 
 #ifndef ENABLE_SHARED_ARRAYS
@@ -398,6 +398,9 @@ void HydraArnoldReader::Update()
 
     arnoldRenderDelegate->HasPendingChanges(_renderIndex, _shutter);
     _renderIndex->SyncAll(&_tasks, &_taskContext);
+    // Connections may have been made as part of the sync pass, so we need to process them
+    // again to make sure that the nodes are up to date. (#2269)
+    arnoldRenderDelegate->ProcessConnections();
 }
 
 void HydraArnoldReader::WriteDebugScene() const

testsuite/test_2268/README

@@ -0,0 +1,7 @@
+Instancer motion blur
+
+see #2268
+
+author: [email protected] 
+
+PARAMS: {'scene': 'test.usda', 'kick_params': '-frame 3'}