From 8f0d000845ba9836d53a1a29c8eeed63a4f5e71d Mon Sep 17 00:00:00 2001
From: tgvarik <tgvarik@users.noreply.github.com>
Date: Mon, 27 Nov 2023 15:12:15 -0800
Subject: [PATCH] [hdPrman] Consolidate and improve motion blur handling

Rewrites the velocity motion blur scene index plugin to handle all types of motion blur processing for hdPrman. The plugin is renamed to HdPrman_MotionBlurSceneIndexPlugin, and redundant motion blur processing code previously scattered throughout hdPrman is removed.

The revised motion blur scene index plugin is exclusively responsible for reshaping data sources for motion blur in hdPrman. No other part of hdPrman needs to concern itself with questions of whether and how to apply motion blur. Downstream consumers need only sample data sources to receive the correct number of samples. Tests are added to explicitly test transform blur (and blurScale, which was not previously applied to transform blur) on geometry and cameras.

The velocity blur handling portions of the plugin have been expanded to support velocity blur on point instancers. However, since hdPrman currently does not support constant primvars on point instancers, the plugin is unable to see authored velocities or angularVelocities and so cannot apply velocity blur to point instancers yet. Accordingly, no test of this functionality has been added. This will be rectified in follow-up work.

Note that in 2294852, we introduced a change that affected all non-points primvars with authored time samples. With that change, such primvars were sampled once at the midpoint of the requested interval. That behavior has been reverted. Non-blurable primvars are sampled at offset 0 regardless of interval to conform to the USDMotionAPI specification.

Support for USD versions < 22.05 and Prman versions < 25.0 is removed from the affected files. Likewise, gating on the presence of the motion blur scene index plugin is also removed, since it is always loaded for USD versions >= 22.05.

(Internal change: 2305710)
(Internal change: 2305831)
---
 .../plugin/hdPrman/CMakeLists.txt             |    2 +-
 .../plugin/hdPrman/basisCurves.cpp            |   23 +-
 .../plugin/hdPrman/debugCodes.cpp             |    1 +
 .../renderman-25/plugin/hdPrman/debugCodes.h  |    3 +-
 .../renderman-25/plugin/hdPrman/gprim.h       |   15 -
 .../renderman-25/plugin/hdPrman/mesh.cpp      |   29 +-
 .../hdPrman/motionBlurSceneIndexPlugin.cpp    | 1460 +++++++++++++++++
 ...xPlugin.h => motionBlurSceneIndexPlugin.h} |   39 +-
 .../renderman-25/plugin/hdPrman/plugInfo.json |    4 +-
 .../renderman-25/plugin/hdPrman/points.cpp    |   50 +-
 .../plugin/hdPrman/renderParam.cpp            |  444 +----
 .../renderman-25/plugin/hdPrman/renderParam.h |   38 -
 ...inalOutputInvalidatingSceneIndexPlugin.cpp |   21 +-
 .../renderman-25/plugin/hdPrman/tokens.h      |    2 +-
 .../velocityMotionBlurSceneIndexPlugin.cpp    | 1013 ------------
 15 files changed, 1540 insertions(+), 1604 deletions(-)
 create mode 100644 third_party/renderman-25/plugin/hdPrman/motionBlurSceneIndexPlugin.cpp
 rename third_party/renderman-25/plugin/hdPrman/{velocityMotionBlurSceneIndexPlugin.h => motionBlurSceneIndexPlugin.h} (56%)
 delete mode 100644 third_party/renderman-25/plugin/hdPrman/velocityMotionBlurSceneIndexPlugin.cpp

diff --git a/third_party/renderman-25/plugin/hdPrman/CMakeLists.txt b/third_party/renderman-25/plugin/hdPrman/CMakeLists.txt
index d89be46b48..7ecd3ae3ab 100644
--- a/third_party/renderman-25/plugin/hdPrman/CMakeLists.txt
+++ b/third_party/renderman-25/plugin/hdPrman/CMakeLists.txt
@@ -125,7 +125,7 @@ pxr_plugin(${PXR_PACKAGE}
         rileyRenderTargetPrim
         terminalSceneIndexObserver
         utils
-        velocityMotionBlurSceneIndexPlugin
+        motionBlurSceneIndexPlugin
         virtualStructResolvingSceneIndex
 
     PUBLIC_HEADERS
diff --git a/third_party/renderman-25/plugin/hdPrman/basisCurves.cpp b/third_party/renderman-25/plugin/hdPrman/basisCurves.cpp
index 0ffdab033f..15f4ee6edf 100644
--- a/third_party/renderman-25/plugin/hdPrman/basisCurves.cpp
+++ b/third_party/renderman-25/plugin/hdPrman/basisCurves.cpp
@@ -28,13 +28,8 @@
 #include "hdPrman/material.h"
 #include "hdPrman/rixStrings.h"
 #include "pxr/imaging/hd/basisCurvesTopology.h"
-#include "pxr/base/gf/matrix4f.h"
-#include "pxr/base/gf/matrix4d.h"
 
-#include "Riley.h"
 #include "RiTypesHelper.h"
-#include "RixShadingUtils.h"
-#include "RixPredefinedStrings.hpp"
 
 PXR_NAMESPACE_OPEN_SCOPE
 
@@ -150,18 +145,12 @@ HdPrman_BasisCurves::_ConvertGeometry(HdPrman_RenderParam *renderParam,
 
     // Points
     float primvarTime = 0.0f;
-    if( HdPrman_RenderParam::HasSceneIndexPlugin(
-            HdPrmanPluginTokens->velocityBlur) ) {
-        HdPrman_ConvertPointsPrimvar(
-            sceneDelegate,
-            id,
-            renderParam->GetShutterInterval(),
-            primvars,
-            vertexPrimvarCount);
-    } else {
-        primvarTime = renderParam->ConvertPositions(
-            sceneDelegate, id, vertexPrimvarCount, primvars);
-    }
+    HdPrman_ConvertPointsPrimvar(
+        sceneDelegate,
+        id,
+        renderParam->GetShutterInterval(),
+        primvars,
+        vertexPrimvarCount);
 
     // Set element ID.  Overloaded use of "__faceIndex" to support picking...
     std::vector<int32_t> elementId(numCurves);
diff --git a/third_party/renderman-25/plugin/hdPrman/debugCodes.cpp b/third_party/renderman-25/plugin/hdPrman/debugCodes.cpp
index 567ae3f676..013966389a 100644
--- a/third_party/renderman-25/plugin/hdPrman/debugCodes.cpp
+++ b/third_party/renderman-25/plugin/hdPrman/debugCodes.cpp
@@ -49,6 +49,7 @@ TF_REGISTRY_FUNCTION(TfDebug)
         "computations.");
     TF_DEBUG_ENVIRONMENT_SYMBOL(HDPRMAN_TERMINAL_SCENE_INDEX_OBSERVER,
         "Debug logging for HdPrman terminal scene index observer.");
+    TF_DEBUG_ENVIRONMENT_SYMBOL(HDPRMAN_MOTION_BLUR, "Motion blur");
 }
 
 PXR_NAMESPACE_CLOSE_SCOPE
diff --git a/third_party/renderman-25/plugin/hdPrman/debugCodes.h b/third_party/renderman-25/plugin/hdPrman/debugCodes.h
index 951418d2a6..efdafcc7d8 100644
--- a/third_party/renderman-25/plugin/hdPrman/debugCodes.h
+++ b/third_party/renderman-25/plugin/hdPrman/debugCodes.h
@@ -42,7 +42,8 @@ TF_DEBUG_CODES(
     HDPRMAN_MESHLIGHT,
     HDPRMAN_RENDER_SETTINGS,
     HDPRMAN_RENDER_PASS,
-    HDPRMAN_TERMINAL_SCENE_INDEX_OBSERVER
+    HDPRMAN_TERMINAL_SCENE_INDEX_OBSERVER,
+    HDPRMAN_MOTION_BLUR
 );
 
 PXR_NAMESPACE_CLOSE_SCOPE
diff --git a/third_party/renderman-25/plugin/hdPrman/gprim.h b/third_party/renderman-25/plugin/hdPrman/gprim.h
index 026b7795f1..42f3cc0b48 100644
--- a/third_party/renderman-25/plugin/hdPrman/gprim.h
+++ b/third_party/renderman-25/plugin/hdPrman/gprim.h
@@ -25,7 +25,6 @@
 #define EXT_RMANPKG_25_0_PLUGIN_RENDERMAN_PLUGIN_HD_PRMAN_GPRIM_H
 
 #include "pxr/pxr.h"
-#include "pxr/imaging/hd/enums.h"
 #include "pxr/usd/sdf/types.h"
 #include "pxr/base/gf/matrix4d.h"
 
@@ -37,8 +36,6 @@
 #include "hdPrman/utils.h"
 
 #include "Riley.h"
-#include "RixShadingUtils.h"
-#include "RixPredefinedStrings.hpp"
 
 PXR_NAMESPACE_OPEN_SCOPE
 
@@ -181,18 +178,6 @@ HdPrman_Gprim<BASE>::Sync(HdSceneDelegate* sceneDelegate,
     HdTimeSampleArray<GfMatrix4d, HDPRMAN_MAX_TIME_SAMPLES> xf;
     sceneDelegate->SampleTransform(id, &xf);
 
-    // If blur is explicitly disabled, use single time 0 sample
-    const bool enableMotionBlur =
-        param->IsMotionBlurEnabled() &&
-        HdPrman_IsMotionBlurPrimvarEnabled(sceneDelegate, id) &&
-        HdPrman_GetNumXformSamples(sceneDelegate, id) >= 2;
-
-    if (!enableMotionBlur) {
-        xf.values[0] = xf.Resample(0.f);
-        xf.times[0] = 0.f;
-        xf.Resize(1);
-    }
-
     // Update visibility so thet rprim->IsVisible() will work in render pass
     if (HdChangeTracker::IsVisibilityDirty(*dirtyBits, id)) {
         BASE::_UpdateVisibility(sceneDelegate, dirtyBits);
diff --git a/third_party/renderman-25/plugin/hdPrman/mesh.cpp b/third_party/renderman-25/plugin/hdPrman/mesh.cpp
index c94eba4660..e7dcc50e9b 100644
--- a/third_party/renderman-25/plugin/hdPrman/mesh.cpp
+++ b/third_party/renderman-25/plugin/hdPrman/mesh.cpp
@@ -25,25 +25,14 @@
 #include "hdPrman/mesh.h"
 #include "hdPrman/renderParam.h"
 #include "hdPrman/coordSys.h"
-#include "hdPrman/instancer.h"
 #include "hdPrman/material.h"
 #include "hdPrman/rixStrings.h"
-#include "pxr/base/gf/matrix4d.h"
-#include "pxr/base/gf/matrix4f.h"
-#include "pxr/base/gf/vec2f.h"
-#include "pxr/base/gf/vec3f.h"
-#include "pxr/base/gf/vec4f.h"
-#include "pxr/imaging/hd/coordSys.h"
 #include "pxr/imaging/hd/meshTopology.h"
-#include "pxr/imaging/hd/meshUtil.h"
 #include "pxr/imaging/pxOsd/subdivTags.h"
 #include "pxr/imaging/pxOsd/tokens.h"
 #include "pxr/usd/usdRi/rmanUtilities.h"
 
-#include "Riley.h"
 #include "RiTypesHelper.h"
-#include "RixShadingUtils.h"
-#include "RixPredefinedStrings.hpp"
 
 #include <algorithm>
 
@@ -169,18 +158,12 @@ HdPrman_Mesh::_ConvertGeometry(HdPrman_RenderParam *renderParam,
     // Point positions (P)
     //
     float primvarTime = 0.0f;
-    if( HdPrman_RenderParam::HasSceneIndexPlugin(
-            HdPrmanPluginTokens->velocityBlur) ) {
-        HdPrman_ConvertPointsPrimvar(
-            sceneDelegate,
-            id,
-            renderParam->GetShutterInterval(),
-            primvars,
-            npoints);
-    } else {
-        primvarTime = renderParam->ConvertPositions(
-            sceneDelegate, id, npoints, primvars);
-    }
+    HdPrman_ConvertPointsPrimvar(
+        sceneDelegate,
+        id,
+        renderParam->GetShutterInterval(),
+        primvars,
+        npoints);
     // Topology.
     primvars.SetIntegerDetail(RixStr.k_Ri_nvertices, nverts.cdata(),
                               RtDetailType::k_uniform);
diff --git a/third_party/renderman-25/plugin/hdPrman/motionBlurSceneIndexPlugin.cpp b/third_party/renderman-25/plugin/hdPrman/motionBlurSceneIndexPlugin.cpp
new file mode 100644
index 0000000000..09f824c655
--- /dev/null
+++ b/third_party/renderman-25/plugin/hdPrman/motionBlurSceneIndexPlugin.cpp
@@ -0,0 +1,1460 @@
+//
+// Copyright 2022 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+//    names, trademarks, service marks, or product names of the Licensor
+//    and its affiliates, except as required to comply with Section 4(c) of
+//    the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+
+#include "hdPrman/motionBlurSceneIndexPlugin.h"
+
+#include "hdPrman/debugCodes.h"
+#include "hdPrman/tokens.h"
+
+#include "pxr/imaging/hd/filteringSceneIndex.h"
+#include "pxr/imaging/hd/primvarsSchema.h"
+#include "pxr/imaging/hd/retainedDataSource.h"
+#include "pxr/imaging/hd/sceneIndexPluginRegistry.h"
+#include "pxr/imaging/hd/tokens.h"
+#include "pxr/imaging/hd/xformSchema.h"
+
+#include "pxr/base/vt/array.h"
+#include "pxr/base/vt/typeHeaders.h"
+#include "pxr/base/vt/visitValue.h"
+
+#include <unordered_set>
+
+PXR_NAMESPACE_OPEN_SCOPE
+
+TF_DEFINE_PRIVATE_TOKENS(
+    _tokens,
+    (fps)
+    ((mblur,                "ri:object:mblur"))
+    ((vblur,                "ri:object:vblur"))
+    ((vblur_on,             "Velocity Blur"))
+    ((ablur_on,             "Acceleration Blur"))
+    ((vblur_off,            "No Velocity Blur"))
+    ((geosamples,           "ri:object:geosamples"))
+    ((xformsamples,         "ri:object:xformsamples"))
+    (angularVelocities) // XXX: Why is this not in HdTokens?
+);
+
+// XXX: These defaults are pulled from UsdMotionAPI, for which there is not yet
+// a corresponding Hydra schema. 
+static const int     _defaultNonlinearSampleCount = 3;
+static const float   _defaultBlurScale            = 1.0f;
+// There is no canonical source for these defaults. They were previously hard-
+// coded in renderParam.cpp.
+static const int     _defaultXformSamples         = 2;
+static const int     _defaultGeoSamples           = 2;
+static const bool    _defaultMblur                = true;
+static const TfToken _defaultVblur                = _tokens->ablur_on;
+
+// XXX: We need to encode the fps in the scene index (in a standard
+// place). Note that fps is called timeCodesPerSecond in USD.
+static const float _fps = 24.0f;
+
+static const float _minimumShutterInterval = 1.0e-10;
+
+// XXX: Set by HdPrman_MotionBlurSceneIndexPlugin::SetShutterInterval()
+// and needed by _MotionBlurHelper. These are part of our shutter
+// interval workaround. See comments on SetShutterInterval() at bottom of file.
+static float _shutterOpen = 0.0f;
+static float _shutterClose = 0.0f;
+
+using TfTokenSet = std::unordered_set<TfToken, TfToken::HashFunctor>;
+
+TF_REGISTRY_FUNCTION(TfType)
+{
+    HdSceneIndexPluginRegistry::Define<HdPrman_MotionBlurSceneIndexPlugin>();
+}
+
+TF_REGISTRY_FUNCTION(HdSceneIndexPlugin)
+{
+    // This plug-in should be inserted *after* the extComp plug-in,
+    // so that disabling of blur, etc. will also affect points from extComp
+    const HdSceneIndexPluginRegistry::InsertionPhase insertionPhase = 3;
+
+    const HdContainerDataSourceHandle inputArgs =
+        HdRetainedContainerDataSource::New(
+            _tokens->fps,
+            HdRetainedSampledDataSource::New(VtValue(_fps)));
+
+    for( auto const& pluginDisplayName : HdPrman_GetPluginDisplayNames() ) {
+        HdSceneIndexPluginRegistry::GetInstance().RegisterSceneIndexForRenderer(
+            pluginDisplayName,
+            HdPrmanPluginTokens->motionBlur,
+            inputArgs,
+            insertionPhase,
+            HdSceneIndexPluginRegistry::InsertionOrderAtStart);
+    }
+}
+
+namespace
+{
+
+// Get fps from input arguments data source
+float _GetFps(const HdContainerDataSourceHandle& inputArgs)
+{
+    if (!inputArgs) {
+        return _fps;
+    }
+
+    const auto source = HdSampledDataSource::Cast(inputArgs->Get(_tokens->fps));
+    if (!source) {
+        return _fps;
+    }
+    
+    const VtValue &value = source->GetValue(0.0f);
+    if (!value.IsHolding<float>()) {
+        return _fps;
+    }
+
+    return value.UncheckedGet<float>();
+}
+
+// Unfortunately, when encountering a legacy prim, the scene index emulation
+// calls GetContributingSampleTimesForInterval with startTime and endTime
+// being the smallest and largest finite floating point number. It does this
+// because it cannot query the scene delegate itself.
+//
+// We rely on the UsdImaging knowing the relevant camera and its
+// shutter interval and returning a sample time for the beginning and
+// end of the shutter interval.
+std::pair<HdSampledDataSource::Time, HdSampledDataSource::Time>
+_GetSamplingInterval(
+    const HdSampledDataSourceHandle& samplesSource,
+    const float shutterOpen, const float shutterClose,
+    const HdSampledDataSource::Time startTime,
+    const HdSampledDataSource::Time endTime)
+{
+    if (std::numeric_limits<HdSampledDataSource::Time>::lowest() < startTime &&
+        endTime < std::numeric_limits<HdSampledDataSource::Time>::max()) {
+        // Client gives us a valid shutter interval. Use it.
+        return { startTime, endTime };
+    }
+
+    // Do the shutter interval reconstruction described above.
+
+    std::vector<HdSampledDataSource::Time> sampleTimes;
+    // Ignore return value - just examine sampleTimes instead
+    samplesSource->GetContributingSampleTimesForInterval(
+        startTime, endTime, &sampleTimes);
+
+    // Not enough samples to reconstruct the shutter interval.
+    if (sampleTimes.size() < 2) {
+        // These fallback values are from the camera
+        return { shutterOpen, shutterClose };
+    }
+
+    const auto iteratorPair =
+        std::minmax_element(sampleTimes.begin(),
+                            sampleTimes.end());
+    return { *iteratorPair.first, *iteratorPair.second };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/// \class _MotionBlurHelper
+///
+/// Helper base class for motion blur. This class carries the implementations
+/// for methods to retrieve motion blur parameters from the prim, to compute
+/// contributing time samples, and to sample the given sampled data source.
+/// This class encapsulates all the logic for transform, velocity, and
+/// deformation motion blur.
+///
+class _MotionBlurHelper
+{
+public:
+    using Time = HdSampledDataSource::Time;
+    
+    /// samplesSource: the original data source
+    /// key: identifying name for samplesSource
+    /// primPath: path of sampleSource's parent prim (for diagnostics)
+    /// primType: type of sampleSource's parent prim
+    /// primvarsSource: data source for sampleSource's parent prim's primvars
+    /// inputArgs: data source from scene index plugin
+    _MotionBlurHelper(
+        const HdSampledDataSourceHandle& samplesSource,
+        const TfToken& key,
+        const SdfPath& primPath,
+        const TfToken& primType,
+        const HdContainerDataSourceHandle& primvarsSource,
+        const HdContainerDataSourceHandle& inputArgs)
+      : _samplesSource(samplesSource)
+      , _key(key)
+      , _primPath(primPath)
+      , _primType(primType)
+      , _primvarsSource(primvarsSource)
+      , _inputArgs(inputArgs)
+    { }
+
+protected:
+    bool
+    _GetContributingSampleTimesForInterval(
+        Time startTime,
+        Time endTime,
+        std::vector<Time>* const outSampleTimes);
+    
+    VtValue
+    _GetValue(Time shutterOffset);
+
+private:
+    // Samples the datasource at the given locator relative to the parent prim's
+    // primvars at the given shutter offset. Returns empty VtValue if not found.
+    VtValue _GetPrimvarValue(
+        const HdDataSourceLocator& locator,
+        const Time shutterOffset = 0.0f) const;
+
+    // Samples the underlying data source at the given shutter offset.
+    VtValue _GetSourceValue(const Time shutterOffset) const;
+
+    // Retrieves the value of ri:object:xformsamples or ri:object:geosamples
+    // from the parent prim as appropriate for the kind of data source this is.
+    int _GetLinearSampleCount() const;
+
+    // Retrieves the value of nonlinearSampleCount from the parent prim.
+    int _GetNonlinearSampleCount() const;
+
+    // Retrieves the value of blurScale from the parent prim.
+    float _GetBlurScale() const;
+
+    // Retrieves the value of ri:object:mblur from the parent prim.
+    bool _GetMblur() const;
+    
+    // Retrieves the value of ri:object:vblur from the parent prim.
+    TfToken _GetVblur() const;
+
+    // Retrieves the value of velocities (or angularVelocities if the parent
+    // prim is an instancer) from the parent prim.
+    VtValue _GetVelocities() const;
+
+    // Retrieves the value of accelerations from the parent prim.
+    VtValue _GetAccelerations() const;
+
+    // Checks whether the parent prim has non-empty velocities (or 
+    // angularVelocities if the parent prim is an instancer) of the
+    // correct type.
+    bool _HasVelocities() const;
+
+    // Checks whether the parent prim has non-empty accelerations of the
+    // correct type.
+    bool _HasAccelerations() const;
+
+    // Returns true if this data source is for instance rotations.
+    bool _IsRotations() const;
+
+    // Returns true if this data source is for a transformable prim's transform.
+    bool _IsTransform() const;
+
+    // Returns true if this data source is for a primvar whose time samples
+    // should contribute to motion blur. Used to ensure that other primvars
+    // only express downstream a single time sample, even if they might have
+    // multiple authored samples within the interval of interest.
+    bool _IsBlurablePrimvar() const;
+
+    // Returns true if this data source is for a primvar that can undergo
+    // velocity motion blur. Currently this is only points on points-based
+    // prims and positions & rotations on point instancers.
+    bool _IsVelocityBlurablePrimvar() const;
+    
+    HdSampledDataSourceHandle _samplesSource;
+    TfToken _key;
+    SdfPath _primPath;
+    TfToken _primType;
+    HdContainerDataSourceHandle _primvarsSource;
+    HdContainerDataSourceHandle _inputArgs;
+};
+
+VtValue
+_MotionBlurHelper::_GetPrimvarValue(
+    const HdDataSourceLocator& locator,
+    const Time shutterOffset) const
+{
+    if (const auto source = HdSampledDataSource::Cast(
+        HdContainerDataSource::Get(_primvarsSource, locator))) {
+        return source->GetValue(shutterOffset);
+    }
+    return VtValue();
+}
+
+VtValue
+_MotionBlurHelper::_GetSourceValue(const Time shutterOffset) const
+{
+    if (!_samplesSource) {
+        return VtValue();
+    }
+    return _samplesSource->GetValue(shutterOffset);
+}
+
+int
+_MotionBlurHelper::_GetLinearSampleCount() const
+{
+    const TfToken name =
+        _key == HdPrimvarsSchemaTokens->points
+          ? _tokens->geosamples
+          : _tokens->xformsamples;
+    const HdDataSourceLocator locator = {
+        name,
+        HdPrimvarSchemaTokens->primvarValue };
+    const VtValue value = _GetPrimvarValue(locator);
+    if (value.IsHolding<VtArray<int>>() && value.GetArraySize() > 0) {
+        return value.UncheckedGet<VtArray<int>>()[0];
+    }
+    return name == _tokens->geosamples
+        ? _defaultGeoSamples
+        : _defaultXformSamples;
+}
+
+int
+_MotionBlurHelper::_GetNonlinearSampleCount() const
+{
+    static const HdDataSourceLocator locator = {
+        HdTokens->nonlinearSampleCount,
+        HdPrimvarSchemaTokens->primvarValue };
+    return _GetPrimvarValue(locator)
+        .GetWithDefault<int>(_defaultNonlinearSampleCount);
+}
+
+float
+_MotionBlurHelper::_GetBlurScale() const
+{
+    static const HdDataSourceLocator locator = {
+        HdTokens->blurScale,
+        HdPrimvarSchemaTokens->primvarValue };
+    return _GetPrimvarValue(locator)
+        .GetWithDefault<float>(_defaultBlurScale);
+}
+
+bool
+_MotionBlurHelper::_GetMblur() const
+{
+    static const HdDataSourceLocator locator = {
+        _tokens->mblur,
+        HdPrimvarSchemaTokens->primvarValue };
+    const VtValue value = _GetPrimvarValue(locator);
+    if (value.IsHolding<VtArray<bool>>() && value.GetArraySize() > 0) {
+        return value.UncheckedGet<VtArray<bool>>()[0];
+    }
+    return _defaultMblur;
+}
+
+TfToken
+_MotionBlurHelper::_GetVblur() const
+{
+    static const HdDataSourceLocator locator = {
+        _tokens->vblur,
+        HdPrimvarSchemaTokens->primvarValue };
+    return _GetPrimvarValue(locator).GetWithDefault<TfToken>(_defaultVblur);
+}
+
+VtValue
+_MotionBlurHelper::_GetVelocities() const
+{
+    
+    if (_IsRotations()) {
+        static const HdDataSourceLocator locator = {
+            _tokens->angularVelocities,
+            HdPrimvarSchemaTokens->primvarValue };
+        return _GetPrimvarValue(locator);
+    } else {
+        static const HdDataSourceLocator locator = {
+            HdTokens->velocities,
+            HdPrimvarSchemaTokens->primvarValue };
+        return _GetPrimvarValue(locator);
+    }
+}
+
+VtValue
+_MotionBlurHelper::_GetAccelerations() const
+{
+    static const HdDataSourceLocator locator = {
+        HdTokens->accelerations,
+        HdPrimvarSchemaTokens->primvarValue };
+    return _GetPrimvarValue(locator);
+}
+
+bool
+_MotionBlurHelper::_HasVelocities() const
+{
+    const VtValue& value = _GetVelocities();
+    return value.IsHolding<VtVec3fArray>() && value.GetArraySize() > 0;
+}
+
+bool
+_MotionBlurHelper::_HasAccelerations() const
+{
+    const VtValue& value = _GetAccelerations();
+    return value.IsHolding<VtVec3fArray>() && value.GetArraySize() > 0;
+}
+
+bool
+_MotionBlurHelper::_IsRotations() const
+{
+    static const TfTokenSet rotateKeys =
+    {
+        HdInstancerTokens->rotate
+#if HD_API_VERSION >= 56
+        , HdInstancerTokens->instanceRotations
+#endif
+    };
+    return rotateKeys.find(_key) != rotateKeys.end();
+}
+
+bool
+_MotionBlurHelper::_IsTransform() const
+{
+    return _key == HdXformSchemaTokens->matrix;
+}
+
+bool
+_MotionBlurHelper::_IsBlurablePrimvar() const
+{
+    static const TfTokenSet blurables = {
+        HdPrimvarsSchemaTokens->points,
+        HdInstancerTokens->translate,
+        HdInstancerTokens->rotate,
+        HdInstancerTokens->scale,
+        HdInstancerTokens->instanceTransform
+#if HD_API_VERSION >= 56
+        , HdInstancerTokens->instanceTranslations
+        , HdInstancerTokens->instanceRotations
+        , HdInstancerTokens->instanceScales
+        , HdInstancerTokens->instanceTransforms
+#endif
+    };
+    return blurables.find(_key) != blurables.end();
+}
+
+bool
+_MotionBlurHelper::_IsVelocityBlurablePrimvar() const
+{
+    static const TfTokenSet blurables = {
+        HdPrimvarsSchemaTokens->points,
+        HdInstancerTokens->translate,
+        HdInstancerTokens->rotate
+#if HD_API_VERSION >= 56
+        , HdInstancerTokens->instanceTranslations
+        , HdInstancerTokens->instanceRotations
+#endif
+    };
+    return blurables.find(_key) != blurables.end();
+}
+
+bool
+_MotionBlurHelper::_GetContributingSampleTimesForInterval(
+    Time givenStartTime,
+    Time givenEndTime,
+    std::vector<Time>* const outSampleTimes)
+{
+    *outSampleTimes = { 0.0f };
+
+    if (!_samplesSource) {
+        TF_DEBUG(HDPRMAN_MOTION_BLUR).Msg(
+            "<%s.%s> (%s): no underlying source\n",
+            _primPath.GetText(), _key.GetText(), _primType.GetText());
+        return false;
+    }
+
+    // Check if shutterOpen and shutterClose are both 0. This is how
+    // HdPrman_RenderSettings communicates that motion blur has been globally
+    // disabled, either at the render product level (see
+    // _ResolveShutterInterval() in renderSettings.cpp) or by environment
+    // variable (see GetRileyOptionsFromEnvironment() in utils.cpp).
+    if (0.0f == _shutterOpen && _shutterOpen == _shutterClose) {
+        TF_DEBUG(HDPRMAN_MOTION_BLUR).Msg(
+            "<%s.%s> (%s): motion blur globally disabled\n",
+            _primPath.GetText(), _key.GetText(), _primType.GetText());
+        return false;
+    }
+
+    // Check if this sample source is blurable
+    const bool isTransform = _IsTransform();
+    if (!isTransform && !_IsBlurablePrimvar()) {
+        TF_DEBUG(HDPRMAN_MOTION_BLUR).Msg(
+            "<%s.%s> (%s): not blurable\n",
+            _primPath.GetText(), _key.GetText(), _primType.GetText());
+        return false;
+    }
+
+    // Check if motion blur is disabled by ri:object:mblur = [0]
+    if (!_GetMblur()) {
+        TF_DEBUG(HDPRMAN_MOTION_BLUR).Msg(
+            "<%s.%s> (%s): motion blur disabled by ri:object:mblur\n",
+            _primPath.GetText(), _key.GetText(), _primType.GetText());
+        return false;
+    }
+
+    // Check if motion blur is disabled by blurScale = 0.0f
+    float blurScale = _GetBlurScale();
+    if (blurScale == 0.0f) {
+        TF_DEBUG(HDPRMAN_MOTION_BLUR).Msg(
+            "<%s.%s> (%s): blurScale is 0\n",
+            _primPath.GetText(), _key.GetText(), _primType.GetText());
+        return false;
+    }
+
+    // Check if motion blur is disabled by ri:object:{geo|xform}samples < 2
+    int numSamples = _GetLinearSampleCount();
+    if (numSamples < 2) {
+        TF_DEBUG(HDPRMAN_MOTION_BLUR).Msg(
+            "<%s.%s> (%s): linear sample count < 2\n",
+            _primPath.GetText(), _key.GetText(), _primType.GetText());
+        return false;
+    }
+
+    // Try to get valid shutter interval
+    Time startTime, endTime;
+    std::tie(startTime, endTime) = _GetSamplingInterval(
+        _samplesSource,
+        _shutterOpen, _shutterClose,
+        givenStartTime, givenEndTime);
+
+    // Check if motion blur is disabled by too small shutter interval
+    if (endTime - startTime < _minimumShutterInterval) {
+        TF_DEBUG(HDPRMAN_MOTION_BLUR).Msg(
+            "<%s.%s> (%s): interval [%f, %f] is too short\n",
+            _primPath.GetText(), _key.GetText(), _primType.GetText(),
+            startTime, endTime);
+        return false;
+    }
+
+    // Check for velocity blur
+    if (_IsVelocityBlurablePrimvar()) {
+        const TfToken vblur = _GetVblur();
+        if (vblur != _tokens->vblur_off && _HasVelocities()) {
+            const size_t sourceCount = _GetSourceValue(0.0f).GetArraySize();
+            if (sourceCount <= _GetVelocities().GetArraySize()) {
+                // Switch to nonlinear sample count if doing nonlinear velocity
+                // blur. XXX: Velocity blur is always nonlinear for instance
+                // rotations. It is nonlinear for points/positions when:
+                //  * accelerations are present,
+                //  * accelerations are of the expected type,
+                //  * accelerations are at least as numerous as the source, and
+                //  * ri:object:vblur = "Acceleration Blur".
+                // TODO: There is an assumption here that nonlinearSampleCount
+                // has meaning only when we are performing a nonlinear type
+                // of motion blur. We should validate that assumption.
+                if (_IsRotations() ||
+                    (vblur == _tokens->ablur_on && _HasAccelerations() &&
+                        sourceCount <= _GetAccelerations().GetArraySize())) {
+                    numSamples = std::max(numSamples,
+                        _GetNonlinearSampleCount());
+                }
+                // Generate sample times unaffected by blurScale.
+                // XXX: blurScale is applied in GetValue when doing velocity
+                // blur, so we do not include its effect here.
+                const float m(numSamples - 1);
+                outSampleTimes->clear();
+                for (size_t i = 0; i < size_t(numSamples); ++i) {
+                    outSampleTimes->push_back(
+                        (float(m - i) / m) * startTime +
+                        (float(i    ) / m) * endTime);
+                }
+                if (TfDebug::IsEnabled(HDPRMAN_MOTION_BLUR)) {
+                    std::string s;
+                    for (const float& t : *outSampleTimes) {
+                        if (!s.empty()) {
+                            s += ", ";
+                        }
+                        s += TfStringPrintf("%f", t);
+                    }
+                    TF_DEBUG(HDPRMAN_MOTION_BLUR).Msg(
+                        "<%s.%s> (%s): velocity motion blur sample times: "
+                        "[%s]\n",
+                        _primPath.GetText(), _key.GetText(),
+                        _primType.GetText(), s.c_str());
+                }
+                return true;
+            }
+        }
+    }
+
+    // No velocity blur. Fall back to ordinary sampling.
+    // Scale start and end times by blurScale
+    if (blurScale != 1.0f) {
+        // Validate interval
+        if (!(std::numeric_limits<Time>::lowest() < startTime &&
+            endTime < std::numeric_limits<Time>::max())) {
+            static std::once_flag flag;
+            std::call_once(flag, [](){
+                TF_CODING_ERROR("blurScale is not supported when consumer "
+                    "is not specifying interval for contributing sample "
+                    "times. In particular, blurScale is not supported for "
+                    "legacy prims under scene index emulation.");
+            });
+            blurScale = 1.0f;
+        } else {
+            startTime *= blurScale;
+            endTime *= blurScale;
+        }
+    }
+
+    outSampleTimes->clear();
+
+    // Query the underlying samples source for sample times
+    if (!_samplesSource->GetContributingSampleTimesForInterval(
+        startTime, endTime, outSampleTimes)) {
+        TF_DEBUG(HDPRMAN_MOTION_BLUR).Msg(
+            "<%s.%s> (%s): underlying source has no motion\n",
+            _primPath.GetText(), _key.GetText(), _primType.GetText());
+        *outSampleTimes = { 0.0f };
+        return false;
+    }
+
+    // XXX: should not be necesary but some implementations of
+    // GetContributingSampleTimesForInterval() will return true with only a
+    // single sample time.
+    if (outSampleTimes->size() < 2) {
+        TF_DEBUG(HDPRMAN_MOTION_BLUR).Msg(
+            "<%s.%s> (%s): underlying source has <2 samples in interval\n",
+            _primPath.GetText(), _key.GetText(), _primType.GetText());
+        *outSampleTimes = { 0.0f };
+        return false;
+    }
+
+    // Check ordinality
+    const size_t count = _GetSourceValue((*outSampleTimes)[0]).GetArraySize();
+    for (size_t i = 1; i < outSampleTimes->size(); ++i) {
+        if (_GetSourceValue((*outSampleTimes)[i]).GetArraySize() != count) {
+            TF_DEBUG(HDPRMAN_MOTION_BLUR).Msg(
+                "<%s.%s> (%s): source array size varies over interval\n",
+                _primPath.GetText(), _key.GetText(), _primType.GetText());
+            *outSampleTimes = { 0.0f };
+            return false;
+        }
+    }
+
+    // If more samples are requested than are authored, re-interpolate times
+    if (static_cast<int>(outSampleTimes->size()) < numSamples) {
+        const Time first = outSampleTimes->front();
+        const Time last = outSampleTimes->back();
+        const float m(numSamples - 1);
+        outSampleTimes->clear();
+        outSampleTimes->reserve(numSamples);
+        for (size_t i = 0; i < size_t(numSamples); ++i) {
+            outSampleTimes->push_back(
+                (float(m - i) / m) * first +
+                (float(i    ) / m) * last);
+        }
+    }
+
+    // rescale times back to requested interval
+    if (blurScale != 1.0f) {
+        const float invBlurScale = 1.0f / blurScale;
+        for (Time& time : *outSampleTimes) {
+            time *= invBlurScale;
+        }
+    }
+
+    if (TfDebug::IsEnabled(HDPRMAN_MOTION_BLUR)) {
+        std::string s;
+        for (const float& t : *outSampleTimes) {
+            if (!s.empty()) {
+                s += ", ";
+            }
+            s += TfStringPrintf("%f", t);
+        }
+        TF_DEBUG(HDPRMAN_MOTION_BLUR).Msg(
+            "<%s.%s> (%s): motion blur sample times: [%s]\n",
+            _primPath.GetText(), _key.GetText(),
+            _primType.GetText(), s.c_str());
+    }
+
+    return true;
+}
+
+VtValue
+_MotionBlurHelper::_GetValue(Time givenShutterOffset)
+{
+    // Shortcut for offset of 0.0f
+    if (givenShutterOffset == 0.0f) {
+        return _GetSourceValue(0.0f);
+    }
+
+    const float blurScale = _GetBlurScale();
+    const Time shutterOffset = givenShutterOffset * blurScale;
+
+    // Shortcut for transform blur
+    if (_IsTransform()) {
+        return _GetSourceValue(shutterOffset);
+    }
+
+    // Due to how GetContributingSampleTimesForInterval works, we only get non-
+    // zero offset here if we have a blurable primvar and motion blur is
+    // enabled. We only need to figure out whether we're doing velocity blur.
+    const TfToken vblur = _GetVblur();
+    if (vblur == _tokens->vblur_off ||          // cheapest
+        !_IsVelocityBlurablePrimvar() ||        // slightly less cheap
+        !_HasVelocities()) {                    // least cheap
+        return _GetSourceValue(shutterOffset);
+    } 
+    
+    // Do velocity blur!
+    const VtValue sourceValue = _GetSourceValue(0.0f);
+    const size_t sourceCount = sourceValue.GetArraySize();
+    const VtValue velocitiesValue = _GetVelocities();
+    const float fps = _GetFps(_inputArgs);
+    const float scaledTime = shutterOffset / fps;
+    const VtVec3fArray& velocities = velocitiesValue
+        .UncheckedGet<VtVec3fArray>();
+    
+    // Check that we have enough velocities.
+    if (velocities.size() != sourceCount) {
+        TF_WARN("Number of angular velocity vectors (%zu) does not "
+            "match number of rotations (%zu).", velocities.size(),
+            sourceCount);
+        // Be forgiving and only bail if we're short on velocities.
+        if (velocities.size() < sourceCount) {
+            return _GetSourceValue(shutterOffset);
+        }
+    }
+
+    if (_IsRotations()) {
+        // Check the source type
+        if (!sourceValue.IsHolding<VtQuathArray>()) {
+            TF_WARN("Unexpected type encountered for instance "
+                "rotations. Expected VtQuathArray, got %s.",
+                sourceValue.GetTypeName().c_str());
+            return VtValue();
+        }
+
+        // Get the source
+        const VtQuathArray& rotations = sourceValue
+            .UncheckedGet<VtQuathArray>();
+
+        // Apply the angular velocities to the rotations
+        VtQuathArray result(sourceCount);
+        for (size_t i = 0; i < sourceCount; ++i) {
+            GfRotation rotation = GfRotation(rotations[i]);
+            rotation *= GfRotation(velocities[i],
+                scaledTime * velocities[i].GetLength());
+            result[i] = GfQuath(rotation.GetQuat());
+        }
+
+        return VtValue(result);
+    } else {
+        // Check the source type
+        if (!sourceValue.IsHolding<VtVec3fArray>()) {
+            TF_WARN("Unexpected type encountered for points/positions. "
+                "Expected VtVec3fArray, got %s.",
+                sourceValue.GetTypeName().c_str());
+            return VtValue();
+        }
+
+        // Get the source
+        const VtVec3fArray& positions = sourceValue
+            .UncheckedGet<VtVec3fArray>();
+        
+        // Check for acceleration blur
+        bool useAccelerations = vblur == _tokens->ablur_on
+            && _GetNonlinearSampleCount() >2
+            && _HasAccelerations();
+        static const VtVec3fArray emptyArray;
+        const VtVec3fArray& accelerations = useAccelerations
+            ? _GetAccelerations().UncheckedGet<VtVec3fArray>()
+            : emptyArray;
+
+        // Check that we have enough accelerations.
+        if (useAccelerations && accelerations.size() != sourceCount) {
+            TF_WARN("Number of acceleration vectors (%zu) does not "
+                "match number of points/positions (%zu).",
+                accelerations.size(), sourceCount);
+            // Be forgiving and only bail on acceleration if we're
+            // short on accelerations.
+            if (accelerations.size() < sourceCount) {
+                useAccelerations = false;
+            }
+        }
+
+        // Apply the velocities and accelerations to the
+        // points/positions.
+        VtVec3fArray result(sourceCount);
+        if (useAccelerations) {
+            const float timeSqrHalf = 0.5f * scaledTime * scaledTime;
+            for (size_t i = 0; i < sourceCount; i++) {
+                result[i] += positions[i]
+                    + scaledTime * velocities[i]
+                    + timeSqrHalf * accelerations[i];
+            }
+        } else {
+            for (size_t i = 0; i < sourceCount; i++) {
+                result[i] += positions[i]
+                    + scaledTime * velocities[i];
+            }
+        }
+        return VtValue(result);
+    } 
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/// \class _MotionBlurUntypedSampledDataSource
+///
+/// Data source for untyped sampled sources
+///
+class _MotionBlurUntypedSampledDataSource final
+  : public HdSampledDataSource
+  , private _MotionBlurHelper
+{
+public:
+    using Time = HdSampledDataSource::Time;
+
+    HD_DECLARE_DATASOURCE(_MotionBlurUntypedSampledDataSource);
+
+    /// samplesSource: the original data source
+    /// key: identifying name for samplesSource
+    /// primPath: path of sampleSource's parent prim (for diagnostics)
+    /// primType: type of sampleSource's parent prim
+    /// primvarsSource: data source for sampleSource's parent prim's primvars
+    /// inputArgs: data source from scene index plugin
+    _MotionBlurUntypedSampledDataSource(
+        const HdSampledDataSourceHandle& samplesSource,
+        const TfToken& key,
+        const SdfPath& primPath,
+        const TfToken& primType,
+        const HdContainerDataSourceHandle& primvarsSource,
+        const HdContainerDataSourceHandle& inputArgs)
+      : _MotionBlurHelper(
+            samplesSource, key, primPath, primType, primvarsSource, inputArgs)
+    { }
+
+    VtValue GetValue(Time shutterOffset) override
+    {
+        return _GetValue(shutterOffset);
+    }
+
+    bool GetContributingSampleTimesForInterval(
+        Time startTime, Time endTime,
+        std::vector<Time>* outSampleTimes) override
+    {
+        return _GetContributingSampleTimesForInterval(
+            startTime, endTime, outSampleTimes);
+    }
+};
+
+HD_DECLARE_DATASOURCE_HANDLES(_MotionBlurUntypedSampledDataSource);
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/// \class _MotionBlurTypedSampledDataSource
+///
+/// Data source for typed sampled sources
+///
+template <typename T>
+class _MotionBlurTypedSampledDataSource final
+  : public HdTypedSampledDataSource<T>
+  , private _MotionBlurHelper
+{
+public:
+    using Time = HdSampledDataSource::Time;
+
+    HD_DECLARE_DATASOURCE_ABSTRACT(_MotionBlurTypedSampledDataSource<T>);
+
+    /// samplesSource: the original data source
+    /// key: identifying name for samplesSource
+    /// primPath: path of sampleSource's parent prim (for diagnostics)
+    /// primType: type of sampleSource's parent prim
+    /// primvarsSource: data source for sampleSource's parent prim's primvars
+    /// inputArgs: data source from scene index plugin
+    _MotionBlurTypedSampledDataSource(
+        const HdSampledDataSourceHandle& samplesSource,
+        const TfToken& key,
+        const SdfPath& primPath,
+        const TfToken& primType,
+        const HdContainerDataSourceHandle& primvarsSource,
+        const HdContainerDataSourceHandle& inputArgs)
+      : _MotionBlurHelper(
+            samplesSource, key, primPath, primType, primvarsSource, inputArgs)
+    { }
+
+    VtValue GetValue(Time shutterOffset) override
+    {
+        return _GetValue(shutterOffset);
+    }
+
+    bool GetContributingSampleTimesForInterval(
+        Time startTime, Time endTime,
+        std::vector<Time>* outSampleTimes) override
+    {
+        return _GetContributingSampleTimesForInterval(
+            startTime, endTime, outSampleTimes);
+    }
+
+    T GetTypedValue(Time shutterOffset) override
+    {
+        const VtValue& v = GetValue(shutterOffset);
+        if (v.IsHolding<T>()) {
+            return v.UncheckedGet<T>();
+        }
+        return T();
+    }
+
+    static typename _MotionBlurTypedSampledDataSource<T>::Handle New(
+        const HdSampledDataSourceHandle& samplesSource,
+        const TfToken& key,
+        const SdfPath& primPath,
+        const TfToken& primType,
+        const HdContainerDataSourceHandle& primvarsSource,
+        const HdContainerDataSourceHandle& inputArgs)
+    {
+        return _MotionBlurTypedSampledDataSource<T>::Handle(
+            new _MotionBlurTypedSampledDataSource<T>(
+                samplesSource, key, primPath,
+                primType, primvarsSource, inputArgs));
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/// \class _Visitor
+///
+/// VtVisitValue visitor for constructing the right type of typed data source
+///
+struct _Visitor
+{
+    const HdSampledDataSourceHandle samplesSource;
+    const TfToken key;
+    const SdfPath primPath;
+    const TfToken primType;
+    const HdContainerDataSourceHandle primvarsSource;
+    const HdContainerDataSourceHandle inputArgs;
+
+    /// Handler for every type except the fallback VtValue type
+    template <typename T>
+    HdDataSourceBaseHandle
+    operator()(const T&)
+    {
+        return _MotionBlurTypedSampledDataSource<T>::New(
+            samplesSource, key, primPath, primType, primvarsSource, inputArgs);
+    }
+
+    /// Handler for the fallback VtValue type
+    HdDataSourceBaseHandle
+    operator()(const VtValue&)
+    {
+        return _MotionBlurUntypedSampledDataSource::New(
+            samplesSource, key, primPath, primType, primvarsSource, inputArgs);
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/// \class _PrimvarDataSource
+///
+/// Serves as data source for locator primvars>{name}
+///
+class _PrimvarDataSource final : public HdContainerDataSource
+{
+public:
+    HD_DECLARE_DATASOURCE(_PrimvarDataSource);
+
+    /// primvarSource: original data source for locator primvars>{primvarName}
+    /// primvarName: name of the primvar
+    /// primPath: path of primvarSource's parent prim (for diagnostics)
+    /// primType: type of primvarSource's parent prim
+    /// primvarsSource: data source for primvarSource's parent prim's primvars
+    /// inputArgs: data source from scene index plugin
+    _PrimvarDataSource(
+        const HdContainerDataSourceHandle& primvarSource,
+        const TfToken& primvarName,
+        const SdfPath& primPath,
+        const TfToken& primType,
+        const HdContainerDataSourceHandle& primvarsSource,
+        const HdContainerDataSourceHandle& inputArgs)
+      : _primvarSource(primvarSource)
+      , _primvarName(primvarName)
+      , _primPath(primPath)
+      , _primType(primType)
+      , _primvarsSource(primvarsSource)
+      , _inputArgs(inputArgs)
+    { }
+
+    TfTokenVector GetNames() override
+    {
+        if (!_primvarSource) {
+            return {};
+        }
+        return _primvarSource->GetNames();
+    }
+
+    HdDataSourceBaseHandle Get(const TfToken &name) override;
+    
+private:
+    HdContainerDataSourceHandle _primvarSource;
+    TfToken _primvarName;
+    SdfPath _primPath;
+    TfToken _primType;
+    HdContainerDataSourceHandle _primvarsSource;
+    HdContainerDataSourceHandle _inputArgs;
+};
+
+HD_DECLARE_DATASOURCE_HANDLES(_PrimvarDataSource);
+
+HdDataSourceBaseHandle
+_PrimvarDataSource::Get(const TfToken &name)
+{
+    if (!_primvarSource) {
+        return nullptr;
+    }
+
+    const HdDataSourceBaseHandle result = _primvarSource->Get(name);
+
+    if (name == HdPrimvarSchemaTokens->primvarValue) {
+        if (const auto source = HdSampledDataSource::Cast(result)) {
+            return VtVisitValue(source->GetValue(0.0f),
+                _Visitor { source, _primvarName, _primPath,
+                    _primType, _primvarsSource, _inputArgs });
+        }
+    }
+
+    return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/// \class _PrimvarsDataSource
+///
+/// Serves as data source for locator primvars
+///
+class _PrimvarsDataSource final : public HdContainerDataSource
+{
+public:
+    HD_DECLARE_DATASOURCE(_PrimvarsDataSource);
+
+    /// primvarsSource: original data source for locator primvars
+    /// primPath: path of primvarsSource's parent prim (for diagnostics)
+    /// primType: type of primvarsSource's parent prim
+    /// inputArgs: source from scene index plugin
+    _PrimvarsDataSource(
+        const HdContainerDataSourceHandle& primvarsSource,
+        const SdfPath& primPath,
+        const TfToken& primType,
+        const HdContainerDataSourceHandle& inputArgs)
+      : _primvarsSource(primvarsSource)
+      , _primPath(primPath)
+      , _primType(primType)
+      , _inputArgs(inputArgs)
+    { }
+
+    TfTokenVector GetNames() override
+    {
+        if (!_primvarsSource) {
+            return {};
+        }
+
+        return _primvarsSource->GetNames();
+    }
+
+    HdDataSourceBaseHandle Get(const TfToken &name) override;
+
+private:
+    HdContainerDataSourceHandle _primvarsSource;
+    SdfPath _primPath;
+    TfToken _primType;
+    HdContainerDataSourceHandle _inputArgs;
+};
+
+HD_DECLARE_DATASOURCE_HANDLES(_PrimvarsDataSource);
+
+HdDataSourceBaseHandle
+_PrimvarsDataSource::Get(const TfToken &name)
+{
+    if (!_primvarsSource) {
+        return nullptr;
+    }
+
+    HdDataSourceBaseHandle const result = _primvarsSource->Get(name);
+
+    // All primvars need to be handled, not just the blurable ones, because any
+    // primvar might have authored time samples, and we need to make sure
+    // that only a single time sample (at offset 0) makes it downstream when
+    // the primvar is not blurable.
+    if (const auto primvarSource = HdContainerDataSource::Cast(result)) {
+        return _PrimvarDataSource::New(
+            primvarSource,
+            name,
+            _primPath,
+            _primType,
+            _primvarsSource,
+            _inputArgs);
+    }
+
+    return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/// \class _XformDataSource
+///
+/// Serves as data source for locator xform
+///
+class _XformDataSource final : public HdContainerDataSource
+{
+public:
+    HD_DECLARE_DATASOURCE(_XformDataSource);
+
+    /// xformSource: the original data source for locator xform
+    /// primPath: path of xformSource's parent prim (for diagnostics)
+    /// primType: type of xformSource's parent prim
+    /// primvarsSource: data source for xformSource's parent prim's primvars
+    /// inputArgs: data source from scene index plugin
+    _XformDataSource(
+        const HdContainerDataSourceHandle& xformSource,
+        const SdfPath& primPath,
+        const TfToken& primType,
+        const HdContainerDataSourceHandle& primvarsSource,
+        const HdContainerDataSourceHandle& inputArgs)
+      : _xformSource(xformSource)
+      , _primPath(primPath)
+      , _primType(primType)
+      , _primvarsSource(primvarsSource)
+      , _inputArgs(inputArgs)
+    { }
+
+    TfTokenVector GetNames() override
+    {
+        if (!_xformSource) {
+            return {};
+        }
+        return _xformSource->GetNames();
+    }
+
+    HdDataSourceBaseHandle Get(const TfToken& name) override;
+
+private:
+    HdContainerDataSourceHandle _xformSource;
+    SdfPath _primPath;
+    TfToken _primType;
+    HdContainerDataSourceHandle _primvarsSource;
+    HdContainerDataSourceHandle _inputArgs;
+};
+
+HD_DECLARE_DATASOURCE_HANDLES(_XformDataSource);
+
+HdDataSourceBaseHandle
+_XformDataSource::Get(const TfToken& name)
+{
+    if (!_xformSource) {
+        return nullptr;
+    }
+    
+    const HdDataSourceBaseHandle result = _xformSource->Get(name);
+    
+    if (name == HdXformSchemaTokens->matrix) {
+        if (const auto source = HdSampledDataSource::Cast(result)) {
+            return VtVisitValue(source->GetValue(0.0f), 
+                _Visitor { source, name, _primPath,
+                    _primType, _primvarsSource, _inputArgs });
+        }
+    }
+    return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/// \class _PrimDataSource
+///
+/// Serves as data source for a prim.
+///
+class _PrimDataSource final : public HdContainerDataSource
+{
+public:
+    HD_DECLARE_DATASOURCE(_PrimDataSource);
+
+    /// primSource: original data source for prim
+    /// primPath: path of prim (for diagnostics)
+    /// primType: type of prim
+    /// inputArgs: source from scene index plugin
+    _PrimDataSource(
+        const HdContainerDataSourceHandle& primSource,
+        const SdfPath& primPath,
+        const TfToken& primType,
+        const HdContainerDataSourceHandle& inputArgs)
+      : _primSource(primSource)
+      , _primPath(primPath)
+      , _primType(primType)
+      , _inputArgs(inputArgs)
+    { }
+
+    TfTokenVector GetNames() override
+    {
+        if (!_primSource) {
+            return {};
+        }
+        
+        return _primSource->GetNames();
+    }
+
+    HdDataSourceBaseHandle Get(const TfToken &name) override;
+
+private:
+    HdContainerDataSourceHandle _primSource;
+    SdfPath _primPath;
+    TfToken _primType;
+    HdContainerDataSourceHandle _inputArgs;
+};
+
+HD_DECLARE_DATASOURCE_HANDLES(_PrimDataSource);
+
+HdDataSourceBaseHandle
+_PrimDataSource::Get(const TfToken &name)
+{
+    if (!_primSource) {
+        return nullptr;
+    }
+
+    const HdDataSourceBaseHandle result = _primSource->Get(name);
+
+    if (name == HdPrimvarsSchemaTokens->primvars) {
+        if (const auto primvarsSource = HdContainerDataSource::Cast(result)) {
+            return _PrimvarsDataSource::New(
+                primvarsSource, _primPath, _primType, _inputArgs);
+        }
+    }
+
+    if (name == HdXformSchemaTokens->xform) {
+        if (const auto xformSource = HdContainerDataSource::Cast(result)) {
+            if (const auto primvarsSource = HdContainerDataSource::Cast(
+                _primSource->Get(HdPrimvarsSchema::GetSchemaToken()))) {
+                return _XformDataSource::New(
+                    xformSource, _primPath, _primType,
+                    primvarsSource, _inputArgs);
+            }
+        }
+    }
+
+    return result;
+}
+
+TF_DECLARE_REF_PTRS(_HdPrmanMotionBlurSceneIndex);
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/// \class _HdPrmanMotionBlurSceneIndex
+///
+/// The scene index provided by the HdPrman_MotionBlurSceneIndexPlugin
+///
+class _HdPrmanMotionBlurSceneIndex final
+  : public HdSingleInputFilteringSceneIndexBase
+{
+public:
+    static _HdPrmanMotionBlurSceneIndexRefPtr New(
+        const HdSceneIndexBaseRefPtr& inputSceneIndex,
+        const HdContainerDataSourceHandle& inputArgs)
+    {
+        return TfCreateRefPtr(
+            new _HdPrmanMotionBlurSceneIndex(
+                inputSceneIndex, inputArgs));
+    }
+
+    HdSceneIndexPrim GetPrim(const SdfPath &primPath) const override
+    {
+        const HdSceneIndexPrim prim = _GetInputSceneIndex()->GetPrim(primPath);
+        if (_PrimIsBlurable(prim)) {
+            return {
+                prim.primType,
+                _PrimDataSource::New(
+                    prim.dataSource, primPath, prim.primType, _inputArgs) };
+        }
+        return prim;
+    }
+
+    SdfPathVector GetChildPrimPaths(const SdfPath &primPath) const override
+    {
+        return _GetInputSceneIndex()->GetChildPrimPaths(primPath);
+    }
+
+protected:
+    _HdPrmanMotionBlurSceneIndex(
+        const HdSceneIndexBaseRefPtr& inputSceneIndex,
+        const HdContainerDataSourceHandle& inputArgs)
+      : HdSingleInputFilteringSceneIndexBase(inputSceneIndex)
+      , _inputArgs(inputArgs)
+    { }
+
+    void _PrimsAdded(
+        const HdSceneIndexBase &sender,
+        const HdSceneIndexObserver::AddedPrimEntries &entries) override
+    {
+        if (!_IsObserved()) {
+            return;
+        }
+        _SendPrimsAdded(entries);
+    }
+
+    void _PrimsRemoved(
+        const HdSceneIndexBase &sender,
+        const HdSceneIndexObserver::RemovedPrimEntries &entries) override
+    {
+        if (!_IsObserved()) {
+            return;
+        }
+        _SendPrimsRemoved(entries);
+    }
+
+    void _PrimsDirtied(
+        const HdSceneIndexBase &sender,
+        const HdSceneIndexObserver::DirtiedPrimEntries &entries) override;
+
+private:
+    static bool _PrimIsBlurable(const HdSceneIndexPrim& prim)
+    {
+        // Transformables, points-based, and instancers are blurable, but
+        // points-based and instancers are always also transformable so 
+        // we only check for the xform schema.
+
+        // XXX: renderSettings and integrator prim types currently leak
+        // through a transformable check, so we also filter out those
+        // specific prim types
+
+        if (prim.primType == HdPrimTypeTokens->renderSettings ||
+            prim.primType == HdPrimTypeTokens->integrator) {
+            return false;
+        }
+        if (const auto container = HdContainerDataSource::Cast(
+            prim.dataSource)) {
+            if (HdXformSchema::GetFromParent(container)) {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    HdContainerDataSourceHandle _inputArgs;
+};
+
+HdDataSourceLocator
+_GetPrimvarValueLocator(const TfToken &name)
+{
+    return HdDataSourceLocator(
+        HdPrimvarsSchemaTokens->primvars,
+        name,
+        HdPrimvarSchemaTokens->primvarValue);
+}
+
+void
+_HdPrmanMotionBlurSceneIndex::_PrimsDirtied(
+    const HdSceneIndexBase& sender,
+    const HdSceneIndexObserver::DirtiedPrimEntries& entries)
+{
+    if (!_IsObserved()) {
+        return;
+    }
+
+    // XXX: Invalidating all primvars is a bit heavy handed, but currently 
+    // hdPrman (mostly) refreshes all primvars when any primvar gets
+    // invalidated anyway.
+
+    static const auto primvarsLocator =
+        HdDataSourceLocator(HdPrimvarsSchemaTokens->primvars);
+
+    static const auto xformLocator =
+        HdDataSourceLocator(HdXformSchemaTokens->xform);
+
+    // If any of these changed, we invalidate all primvars
+    static const HdDataSourceLocatorSet primvarsRelevantLocators {
+        _GetPrimvarValueLocator(HdTokens->velocities),
+        _GetPrimvarValueLocator(HdTokens->accelerations),
+        _GetPrimvarValueLocator(_tokens->angularVelocities),
+        _GetPrimvarValueLocator(_tokens->mblur),
+        _GetPrimvarValueLocator(_tokens->geosamples),
+        _GetPrimvarValueLocator(_tokens->xformsamples),
+        _GetPrimvarValueLocator(HdTokens->nonlinearSampleCount),
+        _GetPrimvarValueLocator(HdTokens->blurScale) };
+    
+    // If any of these changed, we invalidate the xform
+    static const HdDataSourceLocatorSet xformRelevantLocators {
+        _GetPrimvarValueLocator(_tokens->mblur),
+        _GetPrimvarValueLocator(_tokens->xformsamples),
+        _GetPrimvarValueLocator(HdTokens->blurScale) };
+
+    std::vector<size_t> primvarIndices;
+    std::vector<size_t> xformIndices;
+
+    for (size_t i = 0; i < entries.size(); i++) {
+        const HdDataSourceLocatorSet &locators = entries[i].dirtyLocators;
+        if (locators.Intersects(primvarsRelevantLocators)) {
+            if (!locators.Intersects(primvarsLocator)) {
+                primvarIndices.push_back(i);
+            }
+        }
+        if (locators.Intersects(xformRelevantLocators)) {
+            if (!locators.Intersects(xformLocator)) {
+                xformIndices.push_back(i);
+            }
+        }
+    }
+    
+    if (primvarIndices.empty() && xformIndices.empty()) {
+         _SendPrimsDirtied(entries);
+        return;
+    }
+    
+    HdSceneIndexObserver::DirtiedPrimEntries newEntries(entries);
+    for (size_t i : primvarIndices) {
+        newEntries[i].dirtyLocators.insert(primvarsLocator);
+    }
+    for (size_t i : xformIndices) {
+        newEntries[i].dirtyLocators.insert(xformLocator);
+    }
+
+    _SendPrimsDirtied(newEntries);
+}
+
+} // anonymous namespace
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+// Implementation of HdPrman_MotionBlurSceneIndexPlugin.
+
+HdPrman_MotionBlurSceneIndexPlugin::
+HdPrman_MotionBlurSceneIndexPlugin() = default;
+
+HdSceneIndexBaseRefPtr
+HdPrman_MotionBlurSceneIndexPlugin::_AppendSceneIndex(
+    const HdSceneIndexBaseRefPtr& inputScene,
+    const HdContainerDataSourceHandle& inputArgs)
+{
+    return _HdPrmanMotionBlurSceneIndex::New(inputScene, inputArgs);
+}
+
+// TODO: Query the camera's shutter interval in a better way!
+// This method is called by the camera to update
+// with its shutter interval, which is necessary
+// when we're doing velocity blur and UsdImaging doesn't have the sample times.
+void
+HdPrman_MotionBlurSceneIndexPlugin::SetShutterInterval(
+    float shutterOpen, float shutterClose)
+{
+    _shutterOpen = shutterOpen;
+    _shutterClose = shutterClose;
+}
+
+PXR_NAMESPACE_CLOSE_SCOPE
diff --git a/third_party/renderman-25/plugin/hdPrman/velocityMotionBlurSceneIndexPlugin.h b/third_party/renderman-25/plugin/hdPrman/motionBlurSceneIndexPlugin.h
similarity index 56%
rename from third_party/renderman-25/plugin/hdPrman/velocityMotionBlurSceneIndexPlugin.h
rename to third_party/renderman-25/plugin/hdPrman/motionBlurSceneIndexPlugin.h
index e191941bb9..7fd5f32c4b 100644
--- a/third_party/renderman-25/plugin/hdPrman/velocityMotionBlurSceneIndexPlugin.h
+++ b/third_party/renderman-25/plugin/hdPrman/motionBlurSceneIndexPlugin.h
@@ -21,37 +21,40 @@
 // KIND, either express or implied. See the Apache License for the specific
 // language governing permissions and limitations under the Apache License.
 //
-#ifndef EXT_RMANPKG_25_0_PLUGIN_RENDERMAN_PLUGIN_HD_PRMAN_VELOCITY_MOTION_BLUR_SCENE_INDEX_PLUGIN_H
-#define EXT_RMANPKG_25_0_PLUGIN_RENDERMAN_PLUGIN_HD_PRMAN_VELOCITY_MOTION_BLUR_SCENE_INDEX_PLUGIN_H
+#ifndef EXT_RMANPKG_25_0_PLUGIN_RENDERMAN_PLUGIN_HD_PRMAN_MOTION_BLUR_SCENE_INDEX_PLUGIN_H
+#define EXT_RMANPKG_25_0_PLUGIN_RENDERMAN_PLUGIN_HD_PRMAN_MOTION_BLUR_SCENE_INDEX_PLUGIN_H
 
 #include "pxr/pxr.h"
 #include "pxr/imaging/hd/sceneIndexPlugin.h"
-#include "hdPrman/api.h"
 
 PXR_NAMESPACE_OPEN_SCOPE
 
-/// \class HdPrman_VelocityMotionBlurSceneIndexPlugin
-///
-/// Plugin provides a scene index that, for each prim, modifies the
-/// VtVec3fArray at locator primvars>points>primvarValue to:
-/// - unroll velocity motion blur, that is adding the velocities
-///   primvars>velocities>primvarValue and (if present) the accelerations
-///   at primvars>accelerations>primvarValue multiplied by the
-///   respective power of the shutter time to the points
-/// - apply blurScale, by scaling the time that is used to compute the
-///   points from the velocities and accelerations or that is given
-///   to the source scene index when forwarding the
-///   HdSampledDataSource::GetValue or GetContributingTimeSamples call.
+/// \class HdPrman_MotionBlurSceneIndexPlugin
+/// 
+/// Plugin provides a scene index that interprets and reshapes the upstream
+/// scene for motion blur according to Prman's capabilities. This scene index
+/// plugin handles all types of motion blur, including:
+///  * transform motion blur, achieved by animating a prim's xform property or
+///    by animating individual instance positions, orientations, scales, or
+///    transforms,
+///  * deformation motion blur, achieved by animating a points-based prim's
+///    points primvar, and
+///  * velocity motion blur, achieved by providing velocities, angular
+///    velocities, and accelerations for a points-based or point instancer prim.
+/// This plugin is exclusively responsible for reshaping data sources for motion
+/// blur. Downstream consumers do not need to consider whether motion blur is
+/// enabled or any other details of whether or how motion blur should be
+/// applied.
 ///
 /// Note that the fps (needed because the shutter offset is in frames and
 /// the velocity in length/second) is hard-coded to 24.0.
 ///
 /// The plugin is registered with the scene index plugin registry for Prman.
 ///
-class HdPrman_VelocityMotionBlurSceneIndexPlugin : public HdSceneIndexPlugin
+class HdPrman_MotionBlurSceneIndexPlugin : public HdSceneIndexPlugin
 {
 public:
-    HdPrman_VelocityMotionBlurSceneIndexPlugin();
+    HdPrman_MotionBlurSceneIndexPlugin();
 
     static void SetShutterInterval(float shutterOpen, float shutterClose);
 
@@ -63,4 +66,4 @@ class HdPrman_VelocityMotionBlurSceneIndexPlugin : public HdSceneIndexPlugin
 
 PXR_NAMESPACE_CLOSE_SCOPE
 
-#endif // EXT_RMANPKG_25_0_PLUGIN_RENDERMAN_PLUGIN_HD_PRMAN_VELOCITY_MOTION_BLUR_SCENE_INDEX_PLUGIN_H
+#endif // EXT_RMANPKG_25_0_PLUGIN_RENDERMAN_PLUGIN_HD_PRMAN_MOTION_BLUR_SCENE_INDEX_PLUGIN_H
diff --git a/third_party/renderman-25/plugin/hdPrman/plugInfo.json b/third_party/renderman-25/plugin/hdPrman/plugInfo.json
index f485755874..6fa23e321b 100644
--- a/third_party/renderman-25/plugin/hdPrman/plugInfo.json
+++ b/third_party/renderman-25/plugin/hdPrman/plugInfo.json
@@ -3,11 +3,11 @@
         {
             "Info": {
                 "Types": {
-                    "HdPrman_VelocityMotionBlurSceneIndexPlugin" : {
+                    "HdPrman_MotionBlurSceneIndexPlugin" : {
                         "bases": ["HdSceneIndexPlugin"],
                         "loadWithRenderer": "Prman",
                         "priority": 0,
-                        "displayName": "Prman Velocity Motion Blur Scene Index"
+                        "displayName": "Prman Motion Blur Scene Index"
                     },
                     "HdPrman_PreviewMaterialFilteringSceneIndexPlugin" : {
                         "bases": ["HdSceneIndexPlugin"],
diff --git a/third_party/renderman-25/plugin/hdPrman/points.cpp b/third_party/renderman-25/plugin/hdPrman/points.cpp
index 67b12445b9..0f52d94a48 100644
--- a/third_party/renderman-25/plugin/hdPrman/points.cpp
+++ b/third_party/renderman-25/plugin/hdPrman/points.cpp
@@ -24,16 +24,10 @@
 #include "hdPrman/points.h"
 
 #include "hdPrman/renderParam.h"
-#include "hdPrman/instancer.h"
 #include "hdPrman/material.h"
 #include "hdPrman/rixStrings.h"
-#include "pxr/base/gf/matrix4f.h"
-#include "pxr/base/gf/matrix4d.h"
 
-#include "Riley.h"
 #include "RiTypesHelper.h"
-#include "RixShadingUtils.h"
-#include "RixPredefinedStrings.hpp"
 
 PXR_NAMESPACE_OPEN_SCOPE
 
@@ -75,46 +69,18 @@ HdPrman_Points::_ConvertGeometry(HdPrman_RenderParam *renderParam,
                                   RtUString *primType,
                                   std::vector<HdGeomSubset> *geomSubsets)
 {
-    if( HdPrman_RenderParam::HasSceneIndexPlugin(
-            HdPrmanPluginTokens->velocityBlur) ) {
+    RtPrimVarList primvars;
 
-        RtPrimVarList primvars;
+    const size_t npoints =
+        HdPrman_ConvertPointsPrimvarForPoints(
+            sceneDelegate, id, renderParam->GetShutterInterval(), primvars);
 
-        const size_t npoints =
-            HdPrman_ConvertPointsPrimvarForPoints(
-                sceneDelegate, id, renderParam->GetShutterInterval(), primvars);
+    *primType = RixStr.k_Ri_Points;
 
-        *primType = RixStr.k_Ri_Points;
+    HdPrman_ConvertPrimvars(sceneDelegate, id, primvars, 1,
+                            npoints, npoints, npoints);
 
-        HdPrman_ConvertPrimvars(sceneDelegate, id, primvars, 1,
-                                npoints, npoints, npoints);
-
-        return primvars;
-    } else {
-        // There does not seem to be an equivalent GetMeshTopology() or
-        // GetBasisCurvesTopology() we can use for points.
-        // Instead get the point count from the points attribute itself.
-        VtValue pointsVal = sceneDelegate->Get(id, HdTokens->points);
-        const int pointsSize = pointsVal.GetArraySize();
-
-        RtPrimVarList primvars(
-            1, /* uniform */
-            pointsSize, /* vertex */
-            pointsSize, /* varying */
-            pointsSize /* facevarying */);
-
-        // Points
-        const float primvarTime = renderParam->ConvertPositions(
-            sceneDelegate, id, pointsSize, primvars);
-
-        *primType = RixStr.k_Ri_Points;
-
-        HdPrman_ConvertPrimvars(
-            sceneDelegate, id, primvars, 1, pointsSize, pointsSize, pointsSize,
-            primvarTime);
-
-        return primvars;
-    }
+    return primvars;
 }
 
 PXR_NAMESPACE_CLOSE_SCOPE
diff --git a/third_party/renderman-25/plugin/hdPrman/renderParam.cpp b/third_party/renderman-25/plugin/hdPrman/renderParam.cpp
index 5a2784a221..b3e80ece69 100644
--- a/third_party/renderman-25/plugin/hdPrman/renderParam.cpp
+++ b/third_party/renderman-25/plugin/hdPrman/renderParam.cpp
@@ -31,49 +31,32 @@
 #include "hdPrman/framebuffer.h"
 #include "hdPrman/instancer.h"
 #include "hdPrman/material.h"
+#include "hdPrman/prmanArchDefs.h"
 #include "hdPrman/renderDelegate.h"
 #include "hdPrman/renderSettings.h"
 #include "hdPrman/rixStrings.h"
 #include "hdPrman/tokens.h"
 #include "hdPrman/utils.h"
-
-#if PXR_VERSION >= 2205
-#include "hdPrman/velocityMotionBlurSceneIndexPlugin.h"
-#endif
+#include "hdPrman/motionBlurSceneIndexPlugin.h"
 
 #include "pxr/base/arch/library.h"
 #include "pxr/base/plug/registry.h"
 #include "pxr/base/plug/plugin.h"
 #include "pxr/base/tf/debug.h"
-#include "pxr/base/tf/getenv.h"
 #include "pxr/base/tf/envSetting.h"
 #include "pxr/base/tf/pathUtils.h"  // Extract extension from tf token
 #include "pxr/base/tf/scopeDescription.h"
 #include "pxr/usd/sdf/path.h"
-#include "pxr/usd/sdr/registry.h"
-#include "pxr/imaging/hio/imageRegistry.h"
 #include "pxr/imaging/hd/extComputationUtils.h"
 #include "pxr/imaging/hd/sceneDelegate.h"
-#if PXR_VERSION >= 2205
 #include "pxr/imaging/hd/sceneIndexPluginRegistry.h"
-#endif
 #include "pxr/imaging/hd/renderBuffer.h"
 #include "pxr/imaging/hd/renderThread.h"
 
-// XXX: Statistics depend on a header that is only included in v24.4+
-#if (_PRMANAPI_VERSION_MAJOR_ > 24 || (_PRMANAPI_VERSION_MAJOR_ == 24 && _PRMANAPI_VERSION_MINOR_ >= 4))
-#define _ENABLE_STATS
-#endif
-
-#ifdef _ENABLE_STATS
 #include "stats/Session.h"
-#endif
-
 #include "Riley.h"
 #include "RiTypesHelper.h"
 #include "RixRiCtl.h"
-#include "RixShadingUtils.h"
-#include "RixPredefinedStrings.hpp"
 
 #include <thread>
 
@@ -86,13 +69,6 @@ TF_DEFINE_PRIVATE_TOKENS(
     (sourceName)
     (sourceType)
     (lpe)
-    (nonlinearSampleCount)
-    ((mblur,                "ri:object:mblur"))
-    ((vblur,                "ri:object:vblur"))
-    ((vblur_on,             "Velocity Blur"))
-    ((ablur_on,             "Acceleration Blur"))
-    ((geosamples,           "ri:object:geosamples"))
-    ((xformsamples,         "ri:object:xformsamples"))
 );
 
 TF_DEFINE_PRIVATE_TOKENS(
@@ -220,13 +196,6 @@ HdPrman_RenderParam::IsLightFilterUsed(TfToken const& name)
     return _lightFilterRefs.find(name) != _lightFilterRefs.end();
 }
 
-// See related note in HdPrman_RenderParam::IsMotionBlurEnabled below.
-static bool
-_IsMotionBlurEnabled(GfVec2f const& shutterInterval)
-{
-    return shutterInterval[0] != shutterInterval[1];
-}
-
 static size_t
 _ConvertPointsPrimvar(
     HdSceneDelegate *sceneDelegate,
@@ -257,9 +226,7 @@ _ConvertPointsPrimvar(
         HdTimeSampleArray<VtValue, HDPRMAN_MAX_TIME_SAMPLES> boxedPoints;
         if (compPrimvar.empty()) {
             sceneDelegate->SamplePrimvar(id, HdTokens->points, &boxedPoints);
-        }
-        else {
-#if PXR_VERSION > 2102
+        } else {
             HdExtComputationUtils::SampledValueStore<HDPRMAN_MAX_TIME_SAMPLES>
                 compSamples;
             HdExtComputationUtils::SampleComputedPrimvarValues<
@@ -267,29 +234,11 @@ _ConvertPointsPrimvar(
                     compPrimvar, sceneDelegate, HDPRMAN_MAX_TIME_SAMPLES,
                     &compSamples);
             boxedPoints = compSamples[HdTokens->points];
-#endif
         }
-#if PXR_VERSION <= 2111
-        points.UnboxFrom(boxedPointsSamples);
-#else
         if (!points.UnboxFrom(boxedPoints)) {
             TF_WARN("<%s> points did not have expected type vec3f[]",
                     id.GetText());
         }
-#endif
-    }
-
-    // This motion blur check is for legacy purposes;
-    // it's only relevant for externally computed points
-    // that didn't result from scene index plug-in
-    if (!compPrimvar.empty() &&
-        !(_IsMotionBlurEnabled(shutterInterval) &&
-          HdPrman_IsMotionBlurPrimvarEnabled(sceneDelegate, id))) {
-        VtVec3fArray pointsVal = points.Resample(0.f);
-        primvars.SetPointDetail(
-            RixStr.k_P, (RtPoint3 const*)pointsVal.cdata(),
-            RtDetailType::k_vertex);
-        return pointsVal.size();
     }
 
     size_t npoints = 0;
@@ -426,12 +375,8 @@ _GetComputedPrimvars(HdSceneDelegate* sceneDelegate,
     compPrimvars = sceneDelegate->GetExtComputationPrimvarDescriptors
                                     (id,interp);
     for (auto const& pv : compPrimvars) {
-#if PXR_VERSION > 2102
         if (HdChangeTracker::IsPrimvarDirty(dirtyBits, id, pv.name)
             && pv.name != HdTokens->points) {
-#else
-        if (HdChangeTracker::IsPrimvarDirty(dirtyBits, id, pv.name)) {
-#endif
             dirtyCompPrimvars.emplace_back(pv);
         }
     }
@@ -687,22 +632,18 @@ _Convert(HdSceneDelegate *sceneDelegate, SdfPath const& id,
         } else {
             name = _GetPrmanPrimvarName(primvar.name, detail);
         }
-#if PXR_VERSION >= 2108
-        // XXX HdPrman does not yet support time-sampled primvars,
-        // instead we find the sample at the requested time.
+
         HdTimeSampleArray<VtValue, HDPRMAN_MAX_TIME_SAMPLES> samples;
         sceneDelegate->SamplePrimvar(id, primvar.name, &samples);
+        // XXX: The motion blur scene index plugin ensures that only a single
+        // sample at offset 0 is returned for any primvar on which Prman does
+        // not support motion samples. Currently, that's all primvars except P.
+        // We call Resample() here because HdPrman also does not yet support
+        // time-sampled primvars other than P: _SetPrimVarValue expects a single
+        // VtValue and no mechanism exists to ensure all primvars are sampled
+        // at the same set of times, which would be a Prman requirement since
+        // times are a property of the whole RtPrimVarList.
         VtValue val = samples.Resample(time);
-#else
-        // XXX HdPrman does not yet support time-sampled primvars,
-        // but we want to exercise the SamplePrimvar() API, so use it
-        // to request a single sample.
-        const size_t maxNumTimeSamples = 1;
-        float times[1];
-        VtValue val;
-        sceneDelegate->SamplePrimvar(id, primvar.name, maxNumTimeSamples,
-                                     times, &val);
-#endif
 
         TF_DEBUG(HDPRMAN_PRIMVARS)
             .Msg("HdPrman: <%s> %s %s \"%s\" (%s) = \"%s\"\n",
@@ -883,8 +824,8 @@ HdPrman_RenderParam::ConvertAttributes(HdSceneDelegate *sceneDelegate,
             sceneDelegate->GetDoubleSided(id) ? 1 : 0
         );
     }
-        
-    return attrs;
+    
+    return std::move(attrs);
 }
 
 void
@@ -1286,17 +1227,12 @@ HdPrman_RenderParam::RegisterIntegratorCallbackForCamera(
 bool
 HdPrman_RenderParam::HasSceneIndexPlugin(const TfToken &id)
 {
-#if PXR_VERSION >= 2205
     return HdSceneIndexPluginRegistry::GetInstance().IsRegisteredPlugin(id);
-#else
-    return false;
-#endif
 }
 
 void
 HdPrman_RenderParam::_CreateStatsSession(void)
 {
-#ifdef _ENABLE_STATS
     // Set log level for diagnostics relating to initialization. If we succeed in loading a
     // config file then the log level specified in the config file will take precedence.
     stats::Logger::LogLevel statsDebugLevel = stats::GlobalLogger()->DefaultLogLevel();
@@ -1341,7 +1277,6 @@ HdPrman_RenderParam::_CreateStatsSession(void)
     // Validate and inform
     _statsSession->LogInfo("HDPRMan", "Created Roz stats session '" +
                                       _statsSession->GetName() + "'.");
-#endif
 }
 
 void
@@ -1369,10 +1304,8 @@ HdPrman_RenderParam::_CreateRiley(const std::string &rileyVariant,
     sArgs.push_back("hdPrman");
     sArgs.push_back("-woff");
     sArgs.push_back("R56008,R56009");
-#ifdef _ENABLE_STATS
     sArgs.push_back("-statssession");
     sArgs.push_back(_statsSession->GetName());
-#endif
     sArgs.insert(std::end(sArgs), std::begin(extraArgs), std::end(extraArgs));
 
     std::vector<const char*> cArgs;
@@ -1734,13 +1667,11 @@ HdPrman_RenderParam::_DestroyRiley()
 void
 HdPrman_RenderParam::_DestroyStatsSession(void)
 {
-#ifdef _ENABLE_STATS
     if (_statsSession)
     {
         stats::RemoveSession(*_statsSession);
         _statsSession = nullptr;
     }
-#endif
 }
 
 static
@@ -2214,13 +2145,11 @@ HdPrman_RenderParam::StartRender()
         _renderThread->StartThread();
     }
 
-#ifdef _ENABLE_STATS
     // Clear out old stats values
     if (_statsSession)
     {
         _statsSession->RemoveOldMetricData();
     }
-#endif
 
     _renderThread->StartRender();
 }
@@ -2262,13 +2191,11 @@ HdPrman_RenderParam::StopRender(bool blocking)
         std::this_thread::sleep_for(100us);
     }
 
-#ifdef _ENABLE_STATS
     // Clear out old stats values. TODO: should we be calling this here? 
     if (_statsSession)
     {
         _statsSession->RemoveOldMetricData();
     }
-#endif
 }
 
 bool
@@ -3074,17 +3001,11 @@ HdPrman_RenderParam::_UpdateShutterInterval(const RtParamList &composedParams)
         _shutterInterval = GfVec2f(val[0], val[1]);
     }
 
-    if (HdPrman_RenderParam::HasSceneIndexPlugin(
-        HdPrmanPluginTokens->velocityBlur) ) {
-
-#if PXR_VERSION >= 2205
-        // When there's only one sample available the velocity blur plug-in 
-        // doesn't have access to the correct shutter interval, so this is 
-        // a workaround to provide it.
-        HdPrman_VelocityMotionBlurSceneIndexPlugin::SetShutterInterval(
-            _shutterInterval[0], _shutterInterval[1]);
-#endif
-    }
+    // When there's only one sample available the motion blur plug-in 
+    // doesn't have access to the correct shutter interval, so this is 
+    // a workaround to provide it.
+    HdPrman_MotionBlurSceneIndexPlugin::SetShutterInterval(
+        _shutterInterval[0], _shutterInterval[1]);
 }
 
 riley::ShadingNode
@@ -3513,331 +3434,4 @@ HdPrman_RenderParam::GetInstancer(const SdfPath& id)
     return nullptr;
 }
 
-// Motion blur can be disabled in the following ways:
-// 1. Environment (HD_PRMAN_ENABLE_MOTIONBLUR env setting)
-// 2. Render settings prim (if _all_ products have it disabled)
-// 3. Legacy render settings map (disableMotionBlur setting)
-//
-// Riley concerns itself only with the Ri:Shutter param. Having composed
-// the above opinions when setting the Riley scene options, we use the resolved 
-// shutter interval to decipher whether motion blur is enabled.
-bool
-HdPrman_RenderParam::IsMotionBlurEnabled() const
-{
-    return _IsMotionBlurEnabled(_shutterInterval);
-}
-
-bool
-HdPrman_IsMotionBlurPrimvarEnabled(
-    HdSceneDelegate *sceneDelegate,
-    const SdfPath &id)
-{
-    // Then see if disabled locally
-    bool blur = true;
-    float t[1];
-    VtValue val;
-    sceneDelegate->SamplePrimvar(id, _tokens->mblur, 1, t, &val);
-    if (val.IsHolding<VtArray<bool>>()) {
-        blur = val.UncheckedGet<VtArray<bool>>()[0];
-    }
-    return blur;
-}
-
-static bool
-_GetVelocityBlur(
-    HdSceneDelegate *sceneDelegate,
-    const SdfPath &id)
-{
-    bool vblur = true;
-    float t[1];
-    VtValue val;
-    sceneDelegate->SamplePrimvar(id, _tokens->vblur, 1, t, &val);
-    if(val == _tokens->vblur_on)
-    {
-        vblur = true;
-    }
-
-    return vblur;
-}
-
-static bool
-_GetAccelerationBlur(
-    HdSceneDelegate *sceneDelegate,
-    const SdfPath &id)
-{
-    bool ablur = true;
-    float t[1];
-    VtValue val;
-    sceneDelegate->SamplePrimvar(id, _tokens->vblur, 1, t, &val);
-    if(val == _tokens->ablur_on)
-    {
-        ablur = true;
-    }
-
-    return ablur;
-}
-
-static int
-_GetNumGeoSamples(
-    HdSceneDelegate *sceneDelegate,
-    const SdfPath &id)
-{
-    int nsamples = 2;
-    float t[1];
-    VtValue val;
-    sceneDelegate->SamplePrimvar(
-        id, _tokens->nonlinearSampleCount, 1, t, &val);
-    if (val.IsHolding<int>()) {
-        nsamples = val.UncheckedGet<int>();
-        return nsamples;
-    }
-    sceneDelegate->SamplePrimvar(id, _tokens->geosamples, 1, t, &val);
-    if (val.IsHolding<VtArray<int>>()) {
-        nsamples = val.UncheckedGet<VtArray<int>>()[0];
-    }
-
-    return nsamples;
-}
-
-int
-HdPrman_GetNumXformSamples(
-    HdSceneDelegate *sceneDelegate,
-    const SdfPath &id)
-{
-    int nsamples = 2;
-    float t[1];
-    VtValue val;
-    sceneDelegate->SamplePrimvar(id, _tokens->xformsamples, 1, t, &val);
-    if (val.IsHolding<VtArray<int>>()) {
-        nsamples = val.UncheckedGet<VtArray<int>>()[0];
-    }
-    return nsamples;
-}
-
-
-
-// This method duplicates functionality in velocityMotionBlurSceneIndexPlugin,
-// and is for backward compatibility when scene index plug-ins aren't available.
-float
-HdPrman_RenderParam::ConvertPositions(
-    HdSceneDelegate* sceneDelegate,
-    const SdfPath& id,
-    int vertexPrimvarCount,
-    RtPrimVarList& primvars)
-{
-    int numSamples = 1;
-    float fps = 24.f; // TODO: get this from render settings?
-    float ifps = 1.f / fps;
-
-    // Check if points is a ext computed primvar
-    HdExtComputationPrimvarDescriptorVector compPrimvar;
-    {
-        HdExtComputationPrimvarDescriptorVector compPrimvars
-            = sceneDelegate->GetExtComputationPrimvarDescriptors(
-                id, HdInterpolationVertex);
-        for (auto const& pv : compPrimvars) {
-            if (pv.name == HdTokens->points) {
-                compPrimvar.emplace_back(pv);
-            }
-        }
-    }
-
-    // Get points time samples
-    HdTimeSampleArray<VtVec3fArray, HDPRMAN_MAX_TIME_SAMPLES> pointsSamples;
-    {
-        HdTimeSampleArray<VtValue, HDPRMAN_MAX_TIME_SAMPLES> boxedPointsSamples;
-        if (compPrimvar.empty()) {
-            sceneDelegate->SamplePrimvar(
-                id, HdTokens->points, &boxedPointsSamples);
-        }
-        else {
-#if PXR_VERSION > 2102
-            HdExtComputationUtils::SampledValueStore<HDPRMAN_MAX_TIME_SAMPLES>
-                compSamples;
-            HdExtComputationUtils::SampleComputedPrimvarValues<
-                HDPRMAN_MAX_TIME_SAMPLES>(
-                compPrimvar, sceneDelegate, HDPRMAN_MAX_TIME_SAMPLES,
-                &compSamples);
-            boxedPointsSamples = compSamples[HdTokens->points];
-#endif
-        }
-#if PXR_VERSION <= 2111
-        pointsSamples.UnboxFrom(boxedPointsSamples);
-#else
-        if (!pointsSamples.UnboxFrom(boxedPointsSamples)) {
-            TF_WARN(
-                "<%s> points did not have expected type vec3f[]", id.GetText());
-        }
-#endif
-    }
-
-    // Get motion blur settings
-    bool blur =
-        IsMotionBlurEnabled() &&
-        HdPrman_IsMotionBlurPrimvarEnabled(sceneDelegate, id);
-    float shutterOpen = 0.0f;
-    float shutterClose = 0.5f;
-    const HdPrman_CameraContext& camCtx = GetCameraContext();
-    const HdPrmanCamera* cam
-        = camCtx.GetCamera(&(sceneDelegate->GetRenderIndex()));
-    if (cam) {
-        shutterOpen = cam->GetShutterOpen();
-        shutterClose = cam->GetShutterClose();
-    }
-
-    // Do deformation blur unless velocity blur is requested
-    // or necessary due to changing numbers of P values
-    bool velocityBlur = false;
-    bool accelerationBlur = false;
-    if (blur) {
-        accelerationBlur = _GetAccelerationBlur(sceneDelegate, id);
-        velocityBlur =
-            _GetVelocityBlur(sceneDelegate, id) || accelerationBlur;
-        numSamples = _GetNumGeoSamples(sceneDelegate, id);
-    }
-    // Attempt motion blur
-    if (blur && numSamples > 1 && (shutterOpen != shutterClose)) {
-        // Attempt velocity blur
-        if (velocityBlur) {
-            // Get velocities
-            VtVec3fArray velocities;
-            {
-                HdTimeSampleArray<VtValue, HDPRMAN_MAX_TIME_SAMPLES>
-                    boxedVelocitiesSamples;
-                sceneDelegate->SamplePrimvar(
-                    id, HdTokens->velocities, &boxedVelocitiesSamples);
-                HdTimeSampleArray<VtVec3fArray, HDPRMAN_MAX_TIME_SAMPLES>
-                    velocitiesSamples;
-                velocitiesSamples.UnboxFrom(boxedVelocitiesSamples);
-                velocities = velocitiesSamples.Resample(0.f);
-            }
-
-            // Can't do velocity blur if velocities aren't present
-            if (!velocities.empty()) {
-                VtVec3fArray accelerations;
-                if (accelerationBlur) {
-                    HdTimeSampleArray<VtValue, HDPRMAN_MAX_TIME_SAMPLES>
-                        boxedAccelerationsSamples;
-                    sceneDelegate->SamplePrimvar(
-                        id, HdTokens->accelerations,
-                        &boxedAccelerationsSamples);
-                    HdTimeSampleArray<VtVec3fArray, HDPRMAN_MAX_TIME_SAMPLES>
-                        accelerationsSamples;
-                    accelerationsSamples.UnboxFrom(boxedAccelerationsSamples);
-                    // Get acceleration at time zero
-                    accelerations = accelerationsSamples.Resample(0.f);
-                    // Check acceleration is present
-                    accelerationBlur = !accelerations.empty();
-                }
-
-                // Only 2 samples are useful without acceleration
-                if (!accelerationBlur) {
-                    numSamples = 2;
-                }
-
-                // Shutter open
-                std::vector<float> shutterTimes;
-                shutterTimes.push_back(shutterOpen);
-
-                // Inbetween shutter samples
-                for (int i = 0; i < numSamples - 2; ++i) {
-                    shutterTimes.push_back(
-                        shutterOpen
-                        + (i + 1)
-                            * ((shutterClose - shutterOpen)
-                               / static_cast<float>(numSamples - 1)));
-                }
-                // Shutter close
-                shutterTimes.push_back(shutterClose);
-                primvars.SetTimes(shutterTimes.size(), shutterTimes.data());
-
-                VtVec3fArray points = pointsSamples.Resample(0.f);
-                // Sanity check that the number of points here matches the
-                // number that will be requested for other primvars.
-                if (points.size() == static_cast<size_t>(vertexPrimvarCount)) {
-                    for (size_t i = 0; i < shutterTimes.size(); ++i) {
-                        VtVec3fArray offsetPoints;
-                        offsetPoints.resize(points.size());
-                        // Velocity is per second.
-                        // Need to account for fps to convert from shutter time.
-                        const float time = shutterTimes[i] * ifps;
-                        for (size_t p = 0; p < points.size(); ++p) {
-                            offsetPoints[p]
-                                = points[p] + (velocities[p] * time);
-                            if (accelerationBlur) {
-                                offsetPoints[p]
-                                    += accelerations[p] * time * time * 0.5f;
-                            }
-                        }
-                        primvars.SetPointDetail(
-                            RixStr.k_P, (RtPoint3 const*)offsetPoints.cdata(),
-                            RtDetailType::k_vertex, i);
-                    }
-                }
-                else {
-                    TF_WARN(
-                        "<%s> primvar 'points' size (%zu) did not match expected (%zu)",
-                        id.GetText(), points.size(), 
-                        static_cast<size_t>(vertexPrimvarCount));
-                }
-
-                // Velocity blur success
-                return 0.f;
-            }
-        }
-
-        // Attempt deformation blur
-        {
-            // Get all possible sample shutter times.
-            std::vector<float> shutterTimes;
-            for (size_t i = 0; i < pointsSamples.count; ++i) {
-                if (pointsSamples.values[i].empty()) {
-                    continue;
-                }
-                if (pointsSamples.values[i].size() != 
-                        static_cast<size_t>(vertexPrimvarCount)) {
-                    // If any of the points arrays are different sizes, can't use for deforming blur
-                    TF_WARN(
-                        "<%s> primvar 'points' sample sizes differ: %zu %zu. Try velocity blur.",
-                        id.GetText(), static_cast<size_t>(vertexPrimvarCount),
-                        pointsSamples.values[i].size());
-                    continue;
-                }
-                shutterTimes.push_back(pointsSamples.times[i]);
-            }
-            // Check we have enough samples to do deformation motion blur.
-            if (shutterTimes.size() > 1) {
-                // TODO: Should we prune pointsSamples to match user requested numSamples?
-                primvars.SetTimes(shutterTimes.size(), shutterTimes.data());
-                size_t s = 0;
-                for (size_t i = 0; i < pointsSamples.count && s < shutterTimes.size(); ++i) {
-                    if (pointsSamples.times[i] == shutterTimes[s]) {
-                        primvars.SetPointDetail(
-                            RixStr.k_P, (RtPoint3 const*)pointsSamples.values[i].cdata(),
-                            RtDetailType::k_vertex, s);
-                        s++;
-                    }
-                }
-
-                // Deformation motion blur success
-                return shutterOpen + (shutterClose - shutterOpen) * 0.5f;
-            }
-        }
-
-    }
-
-    // No motion blur, just use time zero.
-    VtVec3fArray points = pointsSamples.Resample(0.f);
-    primvars.SetPointDetail(
-        RixStr.k_P, (RtPoint3 const*)points.cdata(),
-        RtDetailType::k_vertex);
-    if (points.size() != static_cast<size_t>(vertexPrimvarCount)) {
-        TF_WARN(
-            "<%s> primvar 'points' size (%zu) did not match expected (%zu)",
-            id.GetText(), points.size(), static_cast<size_t>(vertexPrimvarCount));
-    }
-    return 0.f;
-}
-
-
 PXR_NAMESPACE_CLOSE_SCOPE
diff --git a/third_party/renderman-25/plugin/hdPrman/renderParam.h b/third_party/renderman-25/plugin/hdPrman/renderParam.h
index 07972263ae..f6bdbf8fd1 100644
--- a/third_party/renderman-25/plugin/hdPrman/renderParam.h
+++ b/third_party/renderman-25/plugin/hdPrman/renderParam.h
@@ -26,11 +26,9 @@
 
 #include "pxr/pxr.h"
 #include "hdPrman/api.h"
-#include "hdPrman/prmanArchDefs.h"
 #include "hdPrman/xcpt.h"
 #include "hdPrman/cameraContext.h"
 #include "hdPrman/renderViewContext.h"
-#include "hdPrman/tokens.h"
 #include "pxr/base/gf/vec2f.h"
 #include "pxr/imaging/hd/sceneDelegate.h"
 #include "pxr/imaging/hd/renderDelegate.h"
@@ -180,15 +178,6 @@ class HdPrman_RenderParam : public HdRenderParam
     // Get RIX vs XPU
     bool IsXpu() const { return _xpu; }
 
-    // Convert P values including applying motion blur (deforming or velocity).
-    // Returns a time to sample other primvars.
-    HDPRMAN_API
-    float ConvertPositions(
-        HdSceneDelegate* sceneDelegate,
-        const SdfPath& id,
-        int vertexPrimvarCount,
-        RtPrimVarList& primvars);
-
     // Request edit access to the Riley scene and return it.
     HDPRMAN_API
     riley::Riley * AcquireRiley();
@@ -199,11 +188,6 @@ class HdPrman_RenderParam : public HdRenderParam
         return _shutterInterval;
     }
 
-    // Returns whether motion blur is enabled based on the cached riley shutter
-    // interval.
-    // Note: This function should be called after SetRileyOptions.
-    bool IsMotionBlurEnabled() const;
-
     // Provides external access to resources used to set parameters for
     // options and the active integrator.
     riley::IntegratorId GetActiveIntegratorId();
@@ -544,10 +528,6 @@ class HdPrman_RenderParam : public HdRenderParam
 };
 
 /// Convert Hydra points to Riley point primvar.
-/// This method is invoked when the velocityBlur scene index plugin
-/// is present. In this scenario, deformation or velocity motion blur has been
-/// pre-applied.
-/// \sa Compare to ConvertPositions(..) above.
 ///
 void
 HdPrman_ConvertPointsPrimvar(
@@ -559,10 +539,6 @@ HdPrman_ConvertPointsPrimvar(
 
 /// Count hydra points to set element count on primvars and then
 /// convert them to Riley point primvar.
-/// This method is invoked when the velocityBlur scene index plugin
-/// is present. In this scenario, deformation or velocity motion blur has been
-/// pre-applied.
-/// \sa Compare to ConvertPositions(..) above.
 /// 
 size_t
 HdPrman_ConvertPointsPrimvarForPoints(
@@ -599,20 +575,6 @@ HdPrman_ResolveMaterial(
     riley::MaterialId *materialId,
     riley::DisplacementId *dispId);
 
-/// Returns the value of the 'mblur' primvar on the prim if present.
-/// Returns true otherwise.
-bool
-HdPrman_IsMotionBlurPrimvarEnabled(
-    HdSceneDelegate *sceneDelegate,
-    const SdfPath& id);
-
-/// Returns the value of the 'xformsamples' primvar on the prim if present.
-/// It provides a way to disable xform motion blur on a prim.
-/// Returns 2 otherwise indicating that motion blur is enabled.
-int
-HdPrman_GetNumXformSamples(
-    HdSceneDelegate *sceneDelegate, const SdfPath& id);
-
 PXR_NAMESPACE_CLOSE_SCOPE
 
 #endif // EXT_RMANPKG_25_0_PLUGIN_RENDERMAN_PLUGIN_HD_PRMAN_RENDER_PARAM_H
diff --git a/third_party/renderman-25/plugin/hdPrman/renderTerminalOutputInvalidatingSceneIndexPlugin.cpp b/third_party/renderman-25/plugin/hdPrman/renderTerminalOutputInvalidatingSceneIndexPlugin.cpp
index 632c999b34..5f7e64a9f9 100644
--- a/third_party/renderman-25/plugin/hdPrman/renderTerminalOutputInvalidatingSceneIndexPlugin.cpp
+++ b/third_party/renderman-25/plugin/hdPrman/renderTerminalOutputInvalidatingSceneIndexPlugin.cpp
@@ -22,7 +22,6 @@
 // language governing permissions and limitations under the Apache License.
 
 #include "hdPrman/renderTerminalOutputInvalidatingSceneIndexPlugin.h"
-#include "hdPrman/debugCodes.h"
 
 #include "pxr/imaging/hd/filteringSceneIndex.h"
 #include "pxr/imaging/hd/perfLog.h"
@@ -112,24 +111,24 @@ _GetConnectedOutputs(const HdSceneIndexPrim &prim)
     return connectedOutputs;
 }
 
-TF_DECLARE_REF_PTRS(_HdPrmanRenderTerminalOutputFnvalidatingSceneIndex);
+TF_DECLARE_REF_PTRS(_HdPrmanRenderTerminalOutputInvalidatingSceneIndex);
 
 ////////////////////////////////////////////////////////////////////////////////
-/// \class _HdPrmanRenderTerminalOutputFnvalidatingSceneIndex
+/// \class _HdPrmanRenderTerminalOutputInvalidatingSceneIndex
 ///
 /// The scene index feeding into HdDependencyForwardingSceneIndex and
 /// constructed by the HdPrman_RenderTerminalOutputInvalidatingSceneIndexPlugin.
 ///
 
-class _HdPrmanRenderTerminalOutputFnvalidatingSceneIndex
+class _HdPrmanRenderTerminalOutputInvalidatingSceneIndex
     : public HdSingleInputFilteringSceneIndexBase
 {
 public:
-    static _HdPrmanRenderTerminalOutputFnvalidatingSceneIndexRefPtr
+    static _HdPrmanRenderTerminalOutputInvalidatingSceneIndexRefPtr
         New(const HdSceneIndexBaseRefPtr &inputSceneIndex)
     {
         return TfCreateRefPtr(
-            new _HdPrmanRenderTerminalOutputFnvalidatingSceneIndex(
+            new _HdPrmanRenderTerminalOutputInvalidatingSceneIndex(
                 inputSceneIndex));
     }
 
@@ -144,7 +143,7 @@ class _HdPrmanRenderTerminalOutputFnvalidatingSceneIndex
     }
 
 protected:
-    _HdPrmanRenderTerminalOutputFnvalidatingSceneIndex(
+    _HdPrmanRenderTerminalOutputInvalidatingSceneIndex(
         const HdSceneIndexBaseRefPtr &inputSceneIndex)
       : HdSingleInputFilteringSceneIndexBase(inputSceneIndex)
     {
@@ -165,6 +164,9 @@ class _HdPrmanRenderTerminalOutputFnvalidatingSceneIndex
             if (entry.primType == HdPrimTypeTokens->renderSettings) {
                 const HdSceneIndexPrim prim =
                     _GetInputSceneIndex()->GetPrim(entry.primPath);
+                if (!prim.dataSource) {
+                    continue;
+                }
                 for (auto const& path : _GetConnectedOutputs(prim)) {
                     const TfToken outputType = 
                         _GetInputSceneIndex()->GetPrim(path).primType;
@@ -215,6 +217,9 @@ class _HdPrmanRenderTerminalOutputFnvalidatingSceneIndex
                     HdRenderSettingsSchema::GetNamespacedSettingsLocator())) {
                 const HdSceneIndexPrim prim =
                     _GetInputSceneIndex()->GetPrim(entry.primPath);
+                if (!prim.dataSource) {
+                    continue;
+                }
                 for (auto const& path : _GetConnectedOutputs(prim)) {
                     const HdSceneIndexPrim prim =
                         _GetInputSceneIndex()->GetPrim(path);
@@ -244,7 +249,7 @@ HdPrman_RenderTerminalOutputInvalidatingSceneIndexPlugin::_AppendSceneIndex(
     const HdSceneIndexBaseRefPtr &inputScene,
     const HdContainerDataSourceHandle &inputArgs)
 {
-    return _HdPrmanRenderTerminalOutputFnvalidatingSceneIndex::New(inputScene);
+    return _HdPrmanRenderTerminalOutputInvalidatingSceneIndex::New(inputScene);
 }
 
 PXR_NAMESPACE_CLOSE_SCOPE
diff --git a/third_party/renderman-25/plugin/hdPrman/tokens.h b/third_party/renderman-25/plugin/hdPrman/tokens.h
index 2c1cf4f2a6..10310676d6 100644
--- a/third_party/renderman-25/plugin/hdPrman/tokens.h
+++ b/third_party/renderman-25/plugin/hdPrman/tokens.h
@@ -72,7 +72,7 @@ TF_DECLARE_PUBLIC_TOKENS(HdPrmanRileyPrimTypeTokens, HDPRMAN_API,
                          HD_PRMAN_RILEY_PRIM_TYPE_TOKENS);
 
 #define HD_PRMAN_PLUGIN_TOKENS \
-    ((velocityBlur,     "HdPrman_VelocityMotionBlurSceneIndexPlugin")) \
+    ((motionBlur,       "HdPrman_MotionBlurSceneIndexPlugin")) \
     ((extComp,          "HdPrman_ExtComputationPrimvarPruningSceneIndexPlugin"))
 
 TF_DECLARE_PUBLIC_TOKENS(HdPrmanPluginTokens, HD_PRMAN_PLUGIN_TOKENS);
diff --git a/third_party/renderman-25/plugin/hdPrman/velocityMotionBlurSceneIndexPlugin.cpp b/third_party/renderman-25/plugin/hdPrman/velocityMotionBlurSceneIndexPlugin.cpp
deleted file mode 100644
index 8de9420f11..0000000000
--- a/third_party/renderman-25/plugin/hdPrman/velocityMotionBlurSceneIndexPlugin.cpp
+++ /dev/null
@@ -1,1013 +0,0 @@
-//
-// Copyright 2022 Pixar
-//
-// Licensed under the Apache License, Version 2.0 (the "Apache License")
-// with the following modification; you may not use this file except in
-// compliance with the Apache License and the following modification to it:
-// Section 6. Trademarks. is deleted and replaced with:
-//
-// 6. Trademarks. This License does not grant permission to use the trade
-//    names, trademarks, service marks, or product names of the Licensor
-//    and its affiliates, except as required to comply with Section 4(c) of
-//    the License and to reproduce the content of the NOTICE file.
-//
-// You may obtain a copy of the Apache License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the Apache License with the above modification is
-// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied. See the Apache License for the specific
-// language governing permissions and limitations under the Apache License.
-//
-
-#include "hdPrman/velocityMotionBlurSceneIndexPlugin.h"
-#include "hdPrman/tokens.h"
-
-#include "pxr/imaging/hd/filteringSceneIndex.h"
-#include "pxr/imaging/hd/sceneIndexPluginRegistry.h"
-#include "pxr/imaging/hd/primvarsSchema.h"
-#include "pxr/imaging/hd/retainedDataSource.h"
-#include "pxr/imaging/hd/tokens.h"
-#include "pxr/base/vt/array.h"
-#include "pxr/base/gf/vec3f.h"
-
-PXR_NAMESPACE_OPEN_SCOPE
-
-TF_DEFINE_PRIVATE_TOKENS(
-    _tokens,
-    (fps)
-    ((sceneIndexPluginName, "HdPrman_VelocityMotionBlurSceneIndexPlugin"))
-    ((mblur,                "ri:object:mblur"))
-    ((vblur,                "ri:object:vblur"))
-    ((vblur_on,             "Velocity Blur"))
-    ((ablur_on,             "Acceleration Blur"))
-    ((vblur_off,            "No Velocity Blur"))
-    ((geosamples,           "ri:object:geosamples"))
-    ((xformsamples,         "ri:object:xformsamples"))
-);
-
-static const int _defaultNonlinearSampleCount = 3;
-
-// XXX: We need to encode the fps in the scene index (in a standard
-// place). Note that fps is called timeCodesPerSecond in USD.
-static const float _fps = 24.0f;
-
-static const float _minimumShutterInterval = 1.0e-10;
-
-static float _shutterOpen = 0.0f;
-static float _shutterClose = 0.0f;
-
-
-TF_REGISTRY_FUNCTION(TfType)
-{
-    HdSceneIndexPluginRegistry::Define<
-        HdPrman_VelocityMotionBlurSceneIndexPlugin>();
-}
-
-TF_REGISTRY_FUNCTION(HdSceneIndexPlugin)
-{
-    // This plug-in should be inserted *after* the extComp plug-in,
-    // so that disabling of blur, etc. will also affect points from extComp
-    const HdSceneIndexPluginRegistry::InsertionPhase insertionPhase = 3;
-
-    HdContainerDataSourceHandle const inputArgs =
-        HdRetainedContainerDataSource::New(
-            _tokens->fps,
-            HdRetainedSampledDataSource::New(VtValue(_fps)));
-
-    for( auto const& pluginDisplayName : HdPrman_GetPluginDisplayNames() ) {
-        HdSceneIndexPluginRegistry::GetInstance().RegisterSceneIndexForRenderer(
-            pluginDisplayName,
-            _tokens->sceneIndexPluginName,
-            inputArgs,
-            insertionPhase,
-            HdSceneIndexPluginRegistry::InsertionOrderAtStart);
-    }
-}
-
-namespace
-{
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-/// \class _PrimvarValueDataSource
-///
-/// Serves as data source for locator primvars>points>primvarValue.
-/// Adds the velocities at locator primvars>velocities>primvarValue
-///
-class _PrimvarValueDataSource final : public HdSampledDataSource
-{
-public:
-    HD_DECLARE_DATASOURCE(_PrimvarValueDataSource);
-
-    /// samplesSource: original source for locator primvars>points>primvarValue
-    /// primvarsSource: original source for locator primvars
-    /// inputArgs: source from scene index plugin
-    _PrimvarValueDataSource(
-        const HdSampledDataSourceHandle &samplesSource,
-        const HdContainerDataSourceHandle &primvarsSource,
-        const HdContainerDataSourceHandle &inputArgs,
-        bool isPoints = true)
-      : _samplesSource(samplesSource)
-      , _primvarsSource(primvarsSource)
-      , _inputArgs(inputArgs)
-      , _isPoints(isPoints)
-    {
-    }
-
-    VtValue GetValue(Time givenShutterOffset) override;
-    bool GetContributingSampleTimesForInterval(
-        Time startTime,
-        Time endTime,
-        std::vector<Time> * outSampleTimes) override;
-
-private: 
-    VtValue _GetSourcePointsValue(const Time shutterOffset) const;
-    VtValue _GetSourcePrimvarValue(const HdDataSourceLocator &locator) const;
-    VtValue _GetSourceVelocitiesValue() const;
-    VtValue _GetSourceAccelerationsValue() const;
-    int _GetSourceNonlinearSampleCount() const;
-    float _GetSourceBlurScale() const;
-    bool _GetSourceEnableMotionBlur() const;
-    bool _GetSourceEnableVelocityBlur() const;
-    bool _GetSourceEnableAccelerationBlur() const;
-    int _GetSourceGeoSamples() const;
-
-    std::pair<Time, Time> _GetSamplingInterval(
-        Time startTime,
-        Time endTime) const;
-
-    bool _HasVelocities() const;
-    bool _HasAccelerations() const;
-
-    bool _GetSamplesDeformBlur(
-        Time startTime,
-        Time endTime,
-        float blurScale,
-        std::vector<Time> * outSampleTimes);
-
-    bool _GetSamplesVelocityBlur(
-        Time givenStartTime,
-        Time givenEndTime,
-        std::vector<Time> * outSampleTimes);
-
-    HdSampledDataSourceHandle _samplesSource;
-    HdContainerDataSourceHandle _primvarsSource;
-    HdContainerDataSourceHandle _inputArgs;
-    bool _isPoints;
-};
-
-HD_DECLARE_DATASOURCE_HANDLES(_PrimvarValueDataSource);
-
-// Get fps from input arguments data source
-float _GetFps(const HdContainerDataSourceHandle &inputArgs)
-{
-    if (!inputArgs) {
-        return _fps;
-    }
-
-    HdSampledDataSourceHandle const source =
-        HdSampledDataSource::Cast(inputArgs->Get(_tokens->fps));
-    if (!source) {
-        return _fps;
-    }
-    
-    const VtValue &value = source->GetValue(0.0f);
-    if (!value.IsHolding<float>()) {
-        return _fps;
-    }
-
-    return value.UncheckedGet<float>();
-}
-
-VtValue
-_PrimvarValueDataSource::_GetSourcePointsValue(const Time shutterOffset) const
-{
-    return _samplesSource->GetValue(shutterOffset);
-}
-
-VtValue
-_PrimvarValueDataSource::_GetSourcePrimvarValue(
-    const HdDataSourceLocator &locator) const
-{
-    HdSampledDataSourceHandle const source =
-        HdSampledDataSource::Cast(
-            HdContainerDataSource::Get(_primvarsSource, locator));
-    if (!source) {
-        return VtValue();
-    }
-    
-    return source->GetValue(0.0f);
-}
-
-VtValue
-_PrimvarValueDataSource::_GetSourceVelocitiesValue() const
-{
-    // Find velocities located on prim at primvars>velocities>primvarValue
-    static const HdDataSourceLocator locator(
-        HdTokens->velocities, HdPrimvarSchemaTokens->primvarValue);
-    return _GetSourcePrimvarValue(locator);
-}
-
-VtValue
-_PrimvarValueDataSource::_GetSourceAccelerationsValue() const
-{
-    // Find velocities located on prim at primvars>velocities>primvarValue
-    static const HdDataSourceLocator locator(
-        HdTokens->accelerations, HdPrimvarSchemaTokens->primvarValue);
-    return _GetSourcePrimvarValue(locator);
-}
-
-int
-_PrimvarValueDataSource::_GetSourceNonlinearSampleCount() const
-{
-    // Find count located on prim at
-    // primvars>accelertionsSampleCount>primvarValue
-    static const HdDataSourceLocator locator(
-        HdTokens->nonlinearSampleCount, HdPrimvarSchemaTokens->primvarValue);
-    const VtValue value = _GetSourcePrimvarValue(locator);
-    if (!value.IsHolding<int>()) {
-        // If count not available on prim, fall back to this other method
-        return _GetSourceGeoSamples();
-    }
-    return value.GetWithDefault<int>(_defaultNonlinearSampleCount);
-}
-
-bool
-_PrimvarValueDataSource::_GetSourceEnableMotionBlur() const
-{
-    bool blur = true;
-
-    // When motion blur is disabled globally by the disableMotionBlur
-    // render setting, _shutterOpen and _shutterClose are set to 0.
-    // Need to notice that and return false here,
-    // or else we'll end up sampling at shutterOpen time rather than time 0.
-    if(0.0 == _shutterOpen && _shutterOpen == _shutterClose) {
-        return false;
-    }
-    static const HdDataSourceLocator locator(
-        _tokens->mblur, HdPrimvarSchemaTokens->primvarValue);
-    const VtValue value = _GetSourcePrimvarValue(locator);
-    if (value.IsHolding<VtArray<bool>>()) {
-        blur = value.UncheckedGet<VtArray<bool>>()[0];
-    }
-    return blur;
-}
-
-bool
-_PrimvarValueDataSource::_GetSourceEnableVelocityBlur() const
-{
-    // Assume velocity blur is desired when velcocities are present
-    // unless explicitly disabled
-    bool vblur = true;
-    static const HdDataSourceLocator locator(
-        _tokens->vblur, HdPrimvarSchemaTokens->primvarValue);
-    const VtValue value = _GetSourcePrimvarValue(locator);
-    if(value == _tokens->vblur_off) {
-        vblur = false;
-    }
-
-    return vblur;
-}
-
-bool
-_PrimvarValueDataSource::_GetSourceEnableAccelerationBlur() const
-{
-    // Assume acceleration blur is desired when accelerations are present
-    // unless explicitly disabled
-    bool ablur = true;
-    static const HdDataSourceLocator locator(
-        _tokens->vblur, HdPrimvarSchemaTokens->primvarValue);
-    const VtValue value = _GetSourcePrimvarValue(locator);
-    if(value == _tokens->vblur_off ||
-       value == _tokens->vblur_on) {
-        ablur = false;
-    }
-
-    return ablur;
-}
-
-int
-_PrimvarValueDataSource::_GetSourceGeoSamples() const
-{
-    int sampleCount = _defaultNonlinearSampleCount;
-    static const HdDataSourceLocator locator(
-        _tokens->geosamples, HdPrimvarSchemaTokens->primvarValue);
-    const VtValue value = _GetSourcePrimvarValue(locator);
-    if (value.IsHolding<VtArray<int>>()) {
-        sampleCount = value.UncheckedGet<VtArray<int>>()[0];
-    }
-    return sampleCount;
-}
-
-float
-_PrimvarValueDataSource::_GetSourceBlurScale() const
-{
-    // Find velocities located on prim at primvars>blurScale>primvarValue
-    static const HdDataSourceLocator locator(
-        HdTokens->blurScale, HdPrimvarSchemaTokens->primvarValue);
-    const VtValue value = _GetSourcePrimvarValue(locator);
-
-    // No blur if motion blur is disbled
-    if (!_GetSourceEnableMotionBlur()) {
-        return 0.0f;
-    }
-
-    return std::fabs(value.GetWithDefault<float>(1.0f));
-}
-
-bool
-_PrimvarValueDataSource::_HasVelocities() const
-{
-    // Allow for velocity blur to be disabled even when velocities are present
-    if (!_GetSourceEnableVelocityBlur()) {
-        return false;
-    }
-
-    const VtValue v = _GetSourceVelocitiesValue();
-    if (!v.IsHolding<VtVec3fArray>()) {
-        return false;
-    }
-
-    return !v.UncheckedGet<VtVec3fArray>().empty();
-}
-
-bool
-_PrimvarValueDataSource::_HasAccelerations() const
-{
-    // Allow for acceleration blur to be disabled even if accel vals are present
-    if (!_GetSourceEnableAccelerationBlur()) {
-        return false;
-    }
-
-    const VtValue v = _GetSourceAccelerationsValue();
-    if (!v.IsHolding<VtVec3fArray>()) {
-        return false;
-    }
-
-    return !v.UncheckedGet<VtVec3fArray>().empty();
-}
-
-VtValue
-_PrimvarValueDataSource::GetValue(const Time givenShutterOffset)
-{
-    if (!_samplesSource) {
-        return VtValue();
-    }
-
-    // No math to do at time zero.
-    if (givenShutterOffset == 0.0f) {
-        return _GetSourcePointsValue(0.0f);
-    }
-
-    const float blurScale = _GetSourceBlurScale();
-    if (blurScale == 0.0f) {
-        // Motion blur disabled, always return at time zero.
-        return _GetSourcePointsValue(0.0f);
-    }
-
-    const Time shutterOffset = givenShutterOffset * blurScale;
-
-    if (!_HasVelocities()) {
-        // Velocities are either not present or are disabled
-        return _GetSourcePointsValue(shutterOffset);
-    }
-
-    // Check that we have velocities matching the number of points.
-    //
-    // If this is not the case, simply use the points value from the source.
-    //
-    const VtValue velocitiesValue = _GetSourceVelocitiesValue();
-    if (!velocitiesValue.IsHolding<VtVec3fArray>()) {
-        return _GetSourcePointsValue(shutterOffset);
-    }
-
-    const VtVec3fArray &velocitiesArray =
-        velocitiesValue.UncheckedGet<VtVec3fArray>();
-    if (velocitiesArray.empty()) {
-        return _GetSourcePointsValue(shutterOffset);
-    }
-
-    const VtValue pointsValues = _GetSourcePointsValue(0.0f);
-    if (!pointsValues.IsHolding<VtVec3fArray>() || !_isPoints) {
-        // Velocities are enabled, but we're deling with some other primvar,
-        // which needs to be sampled at the same time as points, ie. time 0.0
-        return _GetSourcePointsValue(0.0f);
-    }
-
-    const VtVec3fArray &pointsArray = pointsValues.UncheckedGet<VtVec3fArray>();
-
-    const size_t num = pointsArray.size();
-    if (velocitiesArray.size() != num) {
-        TF_WARN("Number %zu of velocity vectors does not match number %zu "
-                "of points.", velocitiesArray.size(), num);
-
-        if(velocitiesArray.size() < num) {
-            // Be slightly forgiving - return values as long as there are enough
-            return _GetSourcePointsValue(shutterOffset);
-        }
-    }
-    
-    // We have valid velocities, now alsocheck for valid acclerations before
-    // applying them.
-
-    static const VtVec3fArray emptyArray;
-    const VtValue accelerationsValue = _GetSourceAccelerationsValue();
-    const VtVec3fArray &accelerationsArray =
-        accelerationsValue.IsHolding<VtVec3fArray>()
-        ? accelerationsValue.UncheckedGet<VtVec3fArray>()
-        : emptyArray;
-
-    // This is also false if acclerationsArray is empty (the case where
-    // points is empty doesn't matter).
-    const bool useAccelerations = (accelerationsArray.size() == num);
-
-    if (!accelerationsArray.empty()) {
-        // If we have acclerations, ...
-        if (!useAccelerations) {
-            // but it is the wrong number.
-            TF_WARN("Number %zu of accleration vectors does not match "
-                    "number %zu of points - applying velocities but not "
-                    "accelerations.", accelerationsArray.size(), num);
-        }
-    }
-
-    const float fps = _GetFps(_inputArgs);
-    const float time = shutterOffset / fps;
-    
-    // Apply velocities and acclerations to points
-    VtVec3fArray result(num);
-
-    if (useAccelerations) {
-        const float timeSqrHalf = 0.5f * time * time;
-        for (size_t i = 0; i < num; i++) {
-            result[i] +=
-                pointsArray[i]
-                + time * velocitiesArray[i]
-                + timeSqrHalf * accelerationsArray[i];
-        }
-    } else {
-        for (size_t i = 0; i < num; i++) {
-            result[i] +=
-                pointsArray[i]
-                + time * velocitiesArray[i];
-        }
-    }
-    return VtValue(result);
-}
-
-// Unfortunately, the scene emulation always calls
-// GetContributingSampleTimesForInterval with startTime and endTime
-// being the smallest and largest finite floating point number.
-//
-// We rely on the UsdImaging knowing the relevant camera and its
-// shutter interval and returning a sample time for the beginning and
-// end of the shutter interval.
-//
-std::pair<HdSampledDataSource::Time, HdSampledDataSource::Time>
-_PrimvarValueDataSource::_GetSamplingInterval(
-    const Time startTime, const Time endTime) const
-{
-    if (std::numeric_limits<Time>::lowest() < startTime &&
-        endTime < std::numeric_limits<Time>::max()) {
-        // Client gives us a valid shutter interval. Use it.
-        return { startTime, endTime };
-    }
-
-    // Do the shutter interval reconstruction described above.
-
-    std::vector<Time> sampleTimes;
-    // Ignore return value - just examine sampleTimes instead
-    _samplesSource->GetContributingSampleTimesForInterval(
-        startTime, endTime, &sampleTimes);
-
-    // Not enough samples to reconstruct the shutter interval.
-    if (sampleTimes.size() < 2) {
-        // These fallback values are from the camera
-        return {_shutterOpen, _shutterClose};
-    }
-
-    const auto iteratorPair =
-        std::minmax_element(sampleTimes.begin(),
-                            sampleTimes.end());
-    return { *iteratorPair.first, *iteratorPair.second };
-}
-
-bool
-_PrimvarValueDataSource::GetContributingSampleTimesForInterval(
-    const Time startTime,
-    const Time endTime,
-    std::vector<Time> * const outSampleTimes)
-{
-    if (!_samplesSource) {
-        return false;
-    }
-
-    const float blurScale = _GetSourceBlurScale();
-    if (blurScale == 0.0f) {
-        // Motion blur disabled, return false to indicate that
-        // this is constant across shutter interval.
-        *outSampleTimes = { 0.0f };
-        return false;
-    }
-
-    if (_HasVelocities()) {
-        // Velocities are given, forward call to source, applying
-        // blurScale if non-trivial.
-        if (_isPoints) {
-            return _GetSamplesVelocityBlur(
-                startTime, endTime, outSampleTimes);
-        } else {
-            // primvars other than points can't be blurred; sample at 0.0
-            *outSampleTimes = { 0.0f };
-            return false;
-        }
-    } else {
-        bool result = _GetSamplesDeformBlur(
-            startTime, endTime, blurScale, outSampleTimes);
-        if (outSampleTimes->size() > 1) {
-            std::vector<size_t> ptArraySizes;
-            std::transform (outSampleTimes->begin(), outSampleTimes->end(),
-                            std::back_inserter(ptArraySizes),
-                            [&](float t) {return _GetSourcePointsValue(t).GetArraySize();});
-            if (!std::equal(ptArraySizes.begin() + 1,
-                            ptArraySizes.end(),
-                            ptArraySizes.begin())) {
-                // The lengths of point arrays for each sample do not match
-                // so disable deforming blur.
-                *outSampleTimes = { 0.0f };
-                result = false;
-            } else if(!_isPoints) {
-                // For primvars other than points, that can't be blurred,
-                // sample from the middle of the time range.
-                *outSampleTimes =
-                    { _shutterOpen + (_shutterClose - _shutterOpen) * 0.5f };
-                result = false;
-            }
-        }
-        return result;
-    }
-}
-    
-bool
-_PrimvarValueDataSource::_GetSamplesDeformBlur(
-    const Time startTime,
-    const Time endTime,
-    const float blurScale,
-    std::vector<Time> * const outSampleTimes)
-{
-    // Blur scale is trivial, just forward to source.
-    if (blurScale == 1.0f) {
-        return
-            _samplesSource->GetContributingSampleTimesForInterval(
-                startTime, endTime, outSampleTimes);
-    }
-
-    // Can't do anything if given a meaningless shutter interval.
-    if (!(std::numeric_limits<Time>::lowest() < startTime &&
-          endTime < std::numeric_limits<Time>::max())) {
-        static std::once_flag flag;
-        std::call_once(flag, [](){
-                TF_CODING_ERROR(
-                    "blurScale is not supported when consumer is not "
-                    "specifying interval for contributing sample times. "
-                    "In particular, blurScale is not supported by the "
-                    "scene index emulation.");
-            });
-        return
-            _samplesSource->GetContributingSampleTimesForInterval(
-                startTime, endTime, outSampleTimes);
-    }
-
-    // Scale shutter interval
-    if (!_samplesSource->GetContributingSampleTimesForInterval(
-            blurScale * startTime,
-            blurScale * endTime,
-            outSampleTimes)) {
-        return false;
-    }
-    
-    // Scale time samples to fit into original shutter interval.
-    //
-    // _GetSamplesDeformBlur is never called with blurScale = 0.0.
-    //
-    const float invBlurScale = 1.0f / blurScale;
-    for (Time & time : *outSampleTimes) {
-        time *= invBlurScale;
-    }
-    
-    return true;
-}
-
-bool
-_PrimvarValueDataSource::_GetSamplesVelocityBlur(
-    Time givenStartTime,
-    Time givenEndTime,
-    std::vector<Time> * outSampleTimes)
-{
-    // No need to take blurScale into account here.
-    //
-    // We apply blurScale to time in GetValue instead.
-
-    // We have velocities!
-    Time startTime, endTime;
-    std::tie(startTime, endTime) = _GetSamplingInterval(
-                 givenStartTime, givenEndTime);
-
-    if (endTime - startTime < _minimumShutterInterval) {
-        // Only return one time if shutter interval is tiny.
-        *outSampleTimes = { startTime };
-        return true;
-    }
-
-    if (!_HasAccelerations()) {
-        // Velocity motion blur - linear motion described perfectly
-        // by just two samples.
-        *outSampleTimes = { startTime, endTime };
-        return true;
-    }
-
-    const size_t nonlinearSampleCount =
-        _GetSourceNonlinearSampleCount();
-
-    if (nonlinearSampleCount < 2) {
-        // Degenerate case (e.g. only one sample).
-        //
-        // Catch to avoid division by zero below.
-        //
-
-        *outSampleTimes = { 0.0f };
-
-        // Just disable motion blur.
-        return false;
-    }
-
-    const float m(nonlinearSampleCount - 1);
-
-    outSampleTimes->reserve(nonlinearSampleCount);
-    for (size_t i = 0; i < nonlinearSampleCount; ++i) {
-        // Do floating point operations in such a way that
-        // we get startTime and endTime on the nose for the first
-        // and last value.
-        outSampleTimes->push_back(
-            (float(m - i) / m) * startTime +
-            (float(i    ) / m) * endTime);
-    }
-
-    return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-/// \class _PrimvarDataSource
-///
-/// Serves as data source for locator primvars>points
-///
-class _PrimvarDataSource final : public HdContainerDataSource
-{
-public:
-    HD_DECLARE_DATASOURCE(_PrimvarDataSource);
-
-    /// primvarSource: original source for locator primvars>points
-    /// primvarsSource: original source for locator primvars
-    /// inputArgs: source from scene index plugin
-    _PrimvarDataSource(
-        const HdContainerDataSourceHandle &primvarSource,
-        const HdContainerDataSourceHandle &primvarsSource,
-        const HdContainerDataSourceHandle &inputArgs,
-        bool isPoints)
-      : _primvarSource(primvarSource)
-      , _primvarsSource(primvarsSource)
-      , _inputArgs(inputArgs)
-      , _isPoints(isPoints)
-    {
-    }
-
-    TfTokenVector GetNames() override
-    {
-        if (!_primvarSource) {
-            return {};
-        }
-        
-        return _primvarSource->GetNames();
-    }
-
-    HdDataSourceBaseHandle Get(const TfToken &name) override;
-    
-private:
-    HdContainerDataSourceHandle _primvarSource;
-    HdContainerDataSourceHandle _primvarsSource;
-    HdContainerDataSourceHandle _inputArgs;
-    bool                        _isPoints;
-};
-
-HD_DECLARE_DATASOURCE_HANDLES(_PrimvarDataSource);
-
-HdDataSourceBaseHandle
-_PrimvarDataSource::Get(const TfToken &name)
-{
-    if (!_primvarSource) {
-        return nullptr;
-    }
-
-    HdDataSourceBaseHandle const result = _primvarSource->Get(name);
-
-    if (name == HdPrimvarSchemaTokens->primvarValue) {
-        // Use our own data source for primvars>points>primvarValue
-        if (HdSampledDataSourceHandle const primvarValueSource =
-                HdSampledDataSource::Cast(result)) {
-            return _PrimvarValueDataSource::New(
-                primvarValueSource, _primvarsSource, _inputArgs, _isPoints);
-        }
-    }
-
-    return _primvarSource->Get(name);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-/// \class _PrimvarsDataSource
-///
-/// Serves as data source for locator primvars
-///
-class _PrimvarsDataSource final : public HdContainerDataSource
-{
-public:
-    HD_DECLARE_DATASOURCE(_PrimvarsDataSource);
-
-    /// primvarsSource: original source for locator primvars
-    /// inputArgs: source from scene index plugin
-    _PrimvarsDataSource(
-        const HdContainerDataSourceHandle &primvarsSource,
-        const HdContainerDataSourceHandle &inputArgs)
-      : _primvarsSource(primvarsSource)
-      , _inputArgs(inputArgs)
-    {
-    }
-
-    TfTokenVector GetNames() override
-    {
-        if (!_primvarsSource) {
-            return {};
-        }
-
-        return _primvarsSource->GetNames();
-    }
-
-    HdDataSourceBaseHandle Get(const TfToken &name) override;
-
-private:
-    HdContainerDataSourceHandle _primvarsSource;
-    HdContainerDataSourceHandle _inputArgs;
-};
-
-HD_DECLARE_DATASOURCE_HANDLES(_PrimvarsDataSource);
-
-HdDataSourceBaseHandle
-_PrimvarsDataSource::Get(const TfToken &name)
-{
-    if (!_primvarsSource) {
-        return nullptr;
-    }
-
-    HdDataSourceBaseHandle const result = _primvarsSource->Get(name);
-
-    // All primvars need to be handled, not just points, because their
-    // sample times are based on when the points end up being sampled,
-    // which depends on various things, like whether velocities are present,
-    // whether motion blur is enabled for the object, etc.
-    if (HdContainerDataSourceHandle const primvarSource =
-        HdContainerDataSource::Cast(result)) {
-        return _PrimvarDataSource::New(
-            primvarSource, _primvarsSource, _inputArgs,
-            // Are there more blurrable (by rman) primvars than these?
-            name == HdPrimvarsSchemaTokens->points ||
-            name == HdInstancerTokens->instanceTransform
-#if HD_API_VERSION >= 56
-            || name == HdInstancerTokens->instanceTransforms
-#endif
-            );
-    }
-
-    return result;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-/// \class _PrimDataSource
-///
-/// Serves as data source for a prim.
-///
-class _PrimDataSource final : public HdContainerDataSource
-{
-public:
-    HD_DECLARE_DATASOURCE(_PrimDataSource);
-
-    // primSource: original source for prim
-    // inputArgs: source from scene index plugin
-    _PrimDataSource(
-        const HdContainerDataSourceHandle &primSource,
-        const HdContainerDataSourceHandle &inputArgs)
-      : _primSource(primSource)
-      , _inputArgs(inputArgs)
-    {
-    }
-
-    TfTokenVector GetNames() override
-    {
-        if (!_primSource) {
-            return {};
-        }
-        
-        return _primSource->GetNames();
-    }
-
-    HdDataSourceBaseHandle Get(const TfToken &name) override;
-
-private:
-    HdContainerDataSourceHandle _primSource;
-    HdContainerDataSourceHandle _inputArgs;
-};
-
-HD_DECLARE_DATASOURCE_HANDLES(_PrimDataSource);
-
-HdDataSourceBaseHandle
-_PrimDataSource::Get(const TfToken &name)
-{
-    if (!_primSource) {
-        return nullptr;
-    }
-
-    HdDataSourceBaseHandle const result = _primSource->Get(name);
-    
-    // Use our own data source for primvars
-    if (name == HdPrimvarsSchemaTokens->primvars) {
-        if (HdContainerDataSourceHandle const primvarsSource =
-                HdContainerDataSource::Cast(result)) {
-            return _PrimvarsDataSource::New(primvarsSource, _inputArgs);
-        }
-    }
-
-    return result;
-}
-
-TF_DECLARE_REF_PTRS(_SceneIndex);
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-/// \class _SceneIndex
-///
-/// The scene index provided by the HdPrman_VelocityMotionBlurSceneIndexPlugin
-///
-class _SceneIndex final : public HdSingleInputFilteringSceneIndexBase
-{
-public:
-    static _SceneIndexRefPtr New(
-        const HdSceneIndexBaseRefPtr &inputSceneIndex,
-        const HdContainerDataSourceHandle &inputArgs)
-    {
-        return TfCreateRefPtr(
-            new _SceneIndex(
-                inputSceneIndex, inputArgs));
-    }
-
-    HdSceneIndexPrim GetPrim(const SdfPath &primPath) const override
-    {
-        const HdSceneIndexPrim prim = _GetInputSceneIndex()->GetPrim(primPath);
-        return { prim.primType,
-                 _PrimDataSource::New(
-                     prim.dataSource, _inputArgs) };
-    }
-
-    SdfPathVector GetChildPrimPaths(const SdfPath &primPath) const override
-    {
-        return _GetInputSceneIndex()->GetChildPrimPaths(primPath);
-    }
-
-protected:
-    _SceneIndex(
-        const HdSceneIndexBaseRefPtr &inputSceneIndex,
-        const HdContainerDataSourceHandle &inputArgs)
-      : HdSingleInputFilteringSceneIndexBase(inputSceneIndex)
-      , _inputArgs(inputArgs)
-    {
-    }
-
-    void _PrimsAdded(
-        const HdSceneIndexBase &sender,
-        const HdSceneIndexObserver::AddedPrimEntries &entries) override
-    {
-        if (!_IsObserved()) {
-            return;
-        }
-        
-        _SendPrimsAdded(entries);
-    }
-
-    void _PrimsRemoved(
-        const HdSceneIndexBase &sender,
-        const HdSceneIndexObserver::RemovedPrimEntries &entries) override
-    {
-        if (!_IsObserved()) {
-            return;
-        }
-        
-        _SendPrimsRemoved(entries);
-    }
-
-    void _PrimsDirtied(
-        const HdSceneIndexBase &sender,
-        const HdSceneIndexObserver::DirtiedPrimEntries &entries) override;
-
-private:
-    HdContainerDataSourceHandle _inputArgs;
-};
-
-HdDataSourceLocator
-_GetPrimvarValueLocator(const TfToken &name)
-{
-    return HdDataSourceLocator(HdPrimvarsSchemaTokens->primvars,
-                               name,
-                               HdPrimvarSchemaTokens->primvarValue);
-}
-
-void
-_SceneIndex::_PrimsDirtied(
-    const HdSceneIndexBase &sender,
-    const HdSceneIndexObserver::DirtiedPrimEntries &entries)
-{
-    if (!_IsObserved()) {
-        return;
-    }
-
-    static const HdDataSourceLocator pointsValueLocator =
-        _GetPrimvarValueLocator(HdTokens->points);
-
-    static const HdDataSourceLocatorSet relevantLocators{
-        _GetPrimvarValueLocator(HdTokens->velocities),
-        _GetPrimvarValueLocator(HdTokens->accelerations),
-        _GetPrimvarValueLocator(HdTokens->nonlinearSampleCount),
-        _GetPrimvarValueLocator(HdTokens->blurScale)};
-
-    std::vector<size_t> indices;
-
-    for (size_t i = 0; i < entries.size(); i++) {
-        const HdDataSourceLocatorSet &locators = entries[i].dirtyLocators;
-        if (locators.Intersects(relevantLocators)) {
-            if (!locators.Intersects(pointsValueLocator)) {
-                indices.push_back(i);
-            }
-        }
-    }
-    
-    if (indices.empty()) {
-         _SendPrimsDirtied(entries);
-        return;
-    }
-    
-    HdSceneIndexObserver::DirtiedPrimEntries newEntries(entries);
-    for (size_t i : indices) {
-        newEntries[i].dirtyLocators.insert(pointsValueLocator);
-    }
-
-    _SendPrimsDirtied(newEntries);
-}
-
-} // anonymous namespace
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-// Implementation of HdPrman_VelocityBlurSceneIndexPlugin.
-
-HdPrman_VelocityMotionBlurSceneIndexPlugin::
-HdPrman_VelocityMotionBlurSceneIndexPlugin() = default;
-
-HdSceneIndexBaseRefPtr
-HdPrman_VelocityMotionBlurSceneIndexPlugin::_AppendSceneIndex(
-    const HdSceneIndexBaseRefPtr &inputScene,
-    const HdContainerDataSourceHandle &inputArgs)
-{
-    return _SceneIndex::New(inputScene, inputArgs);
-}
-
-// TODO: Query the camera's shutter interval in a better way!
-// This method is called by the camera to update
-// with its shutter interval, which is necessary
-// when we're doing velocity blur and UsdImaging doesn't have the sample times.
-void
-HdPrman_VelocityMotionBlurSceneIndexPlugin::SetShutterInterval(
-    float shutterOpen, float shutterClose)
-{
-    _shutterOpen = shutterOpen;
-    _shutterClose = shutterClose;
-}
-
-PXR_NAMESPACE_CLOSE_SCOPE