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