From a0a47972201e6addbfe3bb0e0226ec074e75ac74 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 15 May 2024 11:21:25 -0400
Subject: [PATCH 001/112] Working point instancer highlighting with the
 different nested/propagated cases

---
 .../fvpDataProducerSceneIndexExample.cpp      |  35 +-
 ...pWireframeSelectionHighlightSceneIndex.cpp | 974 +++++++++++++++++-
 ...fvpWireframeSelectionHighlightSceneIndex.h |  37 +
 3 files changed, 1030 insertions(+), 16 deletions(-)

diff --git a/lib/flowViewport/API/samples/fvpDataProducerSceneIndexExample.cpp b/lib/flowViewport/API/samples/fvpDataProducerSceneIndexExample.cpp
index 56a0e22eec..a87f377096 100644
--- a/lib/flowViewport/API/samples/fvpDataProducerSceneIndexExample.cpp
+++ b/lib/flowViewport/API/samples/fvpDataProducerSceneIndexExample.cpp
@@ -21,6 +21,10 @@
 
 //Local headers
 #include "fvpDataProducerSceneIndexExample.h"
+#include <pxr/base/gf/matrix4d.h>
+#include <pxr/base/gf/vec3d.h>
+#include <pxr/base/gf/vec3f.h>
+#include <pxr/usd/sdf/path.h>
 
 #ifdef CODE_COVERAGE_WORKAROUND
 #include <flowViewport/fvpUtils.h>
@@ -223,13 +227,26 @@ void DataProducerSceneIndexExample::_AddAllPrims()
 void DataProducerSceneIndexExample::_AddAllPrimsWithInstancing()
 {
     static const bool instancing = true;
-
+    GfMatrix4d instanceeTransform;
+    instanceeTransform.SetTranslate(GfVec3d(1.67, 1.67, 1.67));
     //Copy the main cube primitive in the array, we will update only the SdfPath and the transform, all others attributes are identical
-    HdRetainedSceneIndex::AddedPrimEntry cubePrimEntry = _CreateCubePrim(_cubeRootPath, _currentCubeGridParams._halfSize, 
+    SdfPath cubePath = _cubeRootPath.AppendElementString("_mesh");
+    HdRetainedSceneIndex::AddedPrimEntry cubePrimEntry = _CreateCubePrim(cubePath, _currentCubeGridParams._halfSize, 
                                                                         _currentCubeGridParams._color, _currentCubeGridParams._opacity, 
-                                                                        _currentCubeGridParams._initalTransform, instancing);
+                                                                        instanceeTransform, instancing);
+    const HdDataSourceBaseHandle cubeRootInstancedByData =
+            HdInstancedBySchema::Builder()
+            .SetPaths(HdRetainedTypedSampledDataSource<VtArray<SdfPath>>::New(VtArray<SdfPath>({ _instancerPath })))
+            .SetPrototypeRoots(HdRetainedTypedSampledDataSource<VtArray<SdfPath>>::New(VtArray<SdfPath>({ _cubeRootPath })))
+            .Build();
+    HdRetainedSceneIndex::AddedPrimEntry cubeRoot;
+    cubeRoot.primPath = _cubeRootPath;
+    cubeRoot.dataSource = HdRetainedContainerDataSource::New(
+        HdInstancedBySchema::GetSchemaToken(), cubeRootInstancedByData
+    );
 
     //Add the cube to the retained scene index
+    _retainedSceneIndex->AddPrims({cubeRoot});
     _retainedSceneIndex->AddPrims({cubePrimEntry});
 
     const size_t totalSize = _currentCubeGridParams._numLevelsX * _currentCubeGridParams._numLevelsY * _currentCubeGridParams._numLevelsZ;
@@ -258,7 +275,7 @@ void DataProducerSceneIndexExample::_AddAllPrimsWithInstancing()
                         prototypeIndices[index] = index;
 
                         //Update translation
-                        matrices[index].SetTranslate(initTrans + (GfCompMult(_currentCubeGridParams._deltaTrans, GfVec3f(x,y,z))));
+                        matrices[index].SetTranslate(initTrans + (GfCompMult(_currentCubeGridParams._deltaTrans, GfVec3f(x + 2,y + 2,z + 2))));
 					}
 				}
 			}
@@ -267,6 +284,9 @@ void DataProducerSceneIndexExample::_AddAllPrimsWithInstancing()
 
     //Add new prims to the scene index
     PrototypeInstancing::createInstancer(_instancerPath, _cubeRootPath, prototypeIndices, matrices, _retainedSceneIndex);
+    //SdfPath cubePath = _instancerPath.AppendElementString("MyCube");
+    //auto cube = _CreateCubePrim(cubePath, 2, GfVec3f(1, 0, 0), 1.0, GfMatrix4d(1), false);
+    //_retainedSceneIndex->AddPrims({cube});
 }
 
 void DataProducerSceneIndexExample::_AddAllPrimsNoInstancing()
@@ -494,9 +514,10 @@ HdRetainedSceneIndex::AddedPrimEntry DataProducerSceneIndexExample::_CreateCubeP
     addedPrim.primType      = HdPrimTypeTokens->mesh;
     if (instanced){
 
-        const HdDataSourceBaseHandle instancedByData =
+        const HdDataSourceBaseHandle cubeInstancedByData =
             HdInstancedBySchema::Builder()
             .SetPaths(HdRetainedTypedSampledDataSource<VtArray<SdfPath>>::New(VtArray<SdfPath>({ _instancerPath })))
+            .SetPrototypeRoots(HdRetainedTypedSampledDataSource<VtArray<SdfPath>>::New(VtArray<SdfPath>({ _cubeRootPath })))
             .Build();
 
         addedPrim.dataSource = HdRetainedContainerDataSource::New(
@@ -523,8 +544,8 @@ HdRetainedSceneIndex::AddedPrimEntry DataProducerSceneIndexExample::_CreateCubeP
                         HdPrimvarsSchemaTokens->primvars,
                         primvarsDs,
 
-                        HdInstancedBySchema::GetSchemaToken(), //Add the instancer path in the HdInstancedBySchema
-                        instancedByData
+                        HdInstancedBySchema::GetSchemaToken(),
+                        cubeInstancedByData
                     );
     }else{
 
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index dfaf66b3ce..893cad2a4a 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -19,12 +19,35 @@
 #include "flowViewport/fvpUtils.h"
 
 #include "flowViewport/debugCodes.h"
+#include "fvpWireframeSelectionHighlightSceneIndex.h"
 
+#include <pxr/base/gf/matrix4d.h>
+#include <pxr/base/tf/diagnosticLite.h>
+#include <pxr/base/vt/array.h>
+#include <pxr/base/vt/types.h>
+#include <pxr/imaging/hd/dataSource.h>
+#include <pxr/imaging/hd/dataSourceLocator.h>
+#include <pxr/imaging/hd/instancedBySchema.h>
+#include <pxr/imaging/hd/instancerTopologySchema.h>
 #include <pxr/imaging/hd/legacyDisplayStyleSchema.h>
 #include <pxr/imaging/hd/overlayContainerDataSource.h>
 #include <pxr/imaging/hd/containerDataSourceEditor.h>
+#include <pxr/imaging/hd/retainedDataSource.h>
+#include <pxr/imaging/hd/sceneIndex.h>
+#include <pxr/imaging/hd/sceneIndexObserver.h>
+#include <pxr/imaging/hd/schemaTypeDefs.h>
+#include <pxr/imaging/hd/selectionSchema.h>
 #include <pxr/imaging/hd/tokens.h>
 #include <pxr/imaging/hd/selectionsSchema.h>
+#include <pxr/imaging/hd/instanceIndicesSchema.h>
+#include <pxr/imaging/hd/xformSchema.h>
+#include <pxr/usd/sdf/path.h>
+#include <pxr/usdImaging/usdImaging/rerootingSceneIndex.h>
+#include <algorithm>
+#include <numeric>
+#include <stack>
+#include <iostream>
+#include <mutex>
 
 PXR_NAMESPACE_USING_DIRECTIVE
 
@@ -50,10 +73,370 @@ const HdDataSourceLocator reprSelectorLocator(
 
 const HdDataSourceLocator primvarsOverrideWireframeColorLocator(
         HdPrimvarsSchema::GetDefaultLocator().Append(_primVarsTokens->overrideWireframeColor));
+
+const std::string testInstancer = "ParentPointInstancer";
+
+const std::string shMirrorTag = "_SHMirror";
+
+class SelectionHighlightDataSource : public HdContainerDataSource
+{
+public:
+    HD_DECLARE_DATASOURCE(SelectionHighlightDataSource);
+
+    SelectionHighlightDataSource(const HdContainerDataSourceHandle& originalDataSource) : _originalDataSource(originalDataSource)
+    {
+    }
+
+    TfTokenVector GetNames() override {
+        TfTokenVector names = _originalDataSource->GetNames();
+        /*names.erase(std::remove_if(names.begin(), names.end(), [](const TfToken& token) -> bool {
+            return token == HdSelectionsSchemaTokens->selections;
+        }));*/
+        return names;
+    }
+
+    HdDataSourceBaseHandle Get(const TfToken &name) override
+    {
+        return _originalDataSource->Get(name);
+    }
+
+private:
+    HdContainerDataSourceHandle _originalDataSource;
+};
+
+bool _IsSelectionHighlightMirrorPath(const SdfPath& path)
+{
+    return path.GetElementString().find(shMirrorTag) != std::string::npos;
+}
+
+SdfPath _GetSelectionHighlightMirrorPathFromOriginal(const SdfPath& originalPath)
+{
+    return originalPath.GetParentPath().AppendElementString(originalPath.GetElementString() + shMirrorTag);
+}
+
+SdfPath _GetOriginalPathFromSelectionHighlightMirror(const SdfPath& mirrorPath)
+{
+    return mirrorPath.GetParentPath().AppendElementString(mirrorPath.GetElementString().substr(0, mirrorPath.GetElementString().size() - shMirrorTag.size()));
+}
+
+VtBoolArray _GetSelectionHighlightMask(const VtBoolArray& originalMask, const HdSelectionsSchema& selections) 
+{
+    VtBoolArray selectionHighlightMask(originalMask.size(), false);
+
+    for (size_t iSelection = 0; iSelection < selections.GetNumElements(); iSelection++) {
+        HdSelectionSchema selection = selections.GetElement(iSelection);
+        if (!selection.GetFullySelected() || !selection.GetFullySelected()->GetTypedValue(0)) {
+            continue;
+        }
+        HdInstanceIndicesVectorSchema nestedInstanceIndices = selection.GetNestedInstanceIndices();
+        for (size_t iInstanceIndices = 0; iInstanceIndices < nestedInstanceIndices.GetNumElements(); iInstanceIndices++) {
+            HdInstanceIndicesSchema instanceIndices = nestedInstanceIndices.GetElement(0);
+            for (const auto& instanceIndex : instanceIndices.GetInstanceIndices()->GetTypedValue(0)) {
+                selectionHighlightMask[instanceIndex] = originalMask[instanceIndex];
+            }
+        }
+    }
+
+    return selectionHighlightMask;
+}
+
+HdContainerDataSourceHandle _CreateSelectionHighlightInstancer(const SdfPath& originalPath, const HdContainerDataSourceHandle& originalDataSource)
+{
+
+}
+
+HdContainerDataSourceHandle _GetSelectionHighlightInstancerDataSource(const HdContainerDataSourceHandle& originalDataSource)
+{
+    HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(originalDataSource);
+    HdSelectionsSchema selections = HdSelectionsSchema::GetFromParent(originalDataSource);
+
+    HdContainerDataSourceEditor editedDataSource = HdContainerDataSourceEditor(originalDataSource);
+
+
+    HdDataSourceLocator maskLocator(TfToken("instancerTopology"), TfToken("mask"));
+    VtBoolArray originalMask = instancerTopology.GetMask()->GetTypedValue(0);
+    //VtBoolArray selectionHighlightMask = _GetSelectionHighlightMask(originalMask, selections);
+    VtBoolArray selectionHighlightMask = {true, false};
+    auto selectionHighlightMaskDataSource = HdRetainedTypedSampledDataSource<VtBoolArray>::New(selectionHighlightMask);
+    editedDataSource.Set(maskLocator, selectionHighlightMaskDataSource);
+
+    HdDataSourceLocator prototypesLocator(TfToken("instancerTopology"), TfToken("prototypes"));
+    VtArray<SdfPath> originalPrototypes = instancerTopology.GetPrototypes()->GetTypedValue(0);
+    VtArray<SdfPath> selectionHighlightPrototypes = originalPrototypes;
+    for (auto& shProtoPath : selectionHighlightPrototypes) {
+        shProtoPath = _GetSelectionHighlightMirrorPathFromOriginal(shProtoPath);
+    }
+    editedDataSource.Set(prototypesLocator, HdRetainedTypedSampledDataSource<VtArray<SdfPath>>::New(selectionHighlightPrototypes));
+
+    return SelectionHighlightDataSource::New(editedDataSource.Finish());
+}
+
+
+
+// HdContainerDataSourceHandle _FilterInstances(const HdContainerDataSourceHandle& dataSource)
+// {
+//     auto edited = HdContainerDataSourceEditor(dataSource);
+//     HdDataSourceLocator maskLocator(TfToken("instancerTopology"), TfToken("mask"));
+//     auto replacementDataSource = HdRetainedTypedSampledDataSource<VtBoolArray>::New(VtBoolArray({true, false, true, false, true, true, false, false}));
+//     edited.Set(maskLocator, replacementDataSource);
+
+    
+//     // //Is the prim in refined displayStyle (meaning shaded) ?
+//     // if (HdLegacyDisplayStyleSchema styleSchema =
+//     //         HdLegacyDisplayStyleSchema::GetFromParent(dataSource)) {
+
+//     //     if (HdTokenArrayDataSourceHandle ds =
+//     //             styleSchema.GetReprSelector()) {
+//     //         VtArray<TfToken> ar = ds->GetTypedValue(0.0f);
+//     //         TfToken refinedToken = ar[0];
+//     //         if(HdReprTokens->refined == refinedToken){
+//     //             //Is in refined display style, apply the wire on top of shaded reprselector
+//     //             return HdOverlayContainerDataSource::New({ edited.Finish(), sRefinedWireOnSurfaceDisplayStyleDataSource});
+//     //         }
+//     //     }else{
+//     //         //No reprSelector found, assume it's in the Collection that we have set HdReprTokens->refined
+//     //         return HdOverlayContainerDataSource::New({ edited.Finish(), sRefinedWireOnSurfaceDisplayStyleDataSource});
+//     //     }
+//     // }
+
+//     //For the other case, we are only updating the wireframe color assuming we are already drawing lines
+//     return edited.Finish();
+// }
+
+bool _IsInstancerWithSelections(const HdSceneIndexPrim& prim)
+{
+    if (prim.primType != HdPrimTypeTokens->instancer) {
+        return false;
+    }
+    auto selections = HdSelectionsSchema::GetFromParent(prim.dataSource);
+    return selections.IsDefined() && selections.GetNumElements() > 0;
+}
+
+bool _IsConcretePrototype(const SdfPath& primPath, const HdSceneIndexPrim& prim)
+{
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+    return instancedBy.IsDefined() && instancedBy.GetPrototypeRoots();
+}
+
+bool _IsPartOfSelectionHighlightMirror(const SdfPath& path)
+{
+    auto ancestorsRange = path.GetAncestorsRange();
+    for (auto ancestor : ancestorsRange) {
+        if (_IsSelectionHighlightMirrorPath(ancestor)) {
+            return true;
+        }
+    }
+    return false;
+}
+
 }
 
 namespace FVP_NS_DEF {
 
+SdfPath
+WireframeSelectionHighlightSceneIndex::_FindSelectionHighlightMirrorAncestor(const SdfPath& path) const
+{
+    auto ancestorsRange = path.GetAncestorsRange();
+    for (auto ancestor : ancestorsRange) {
+        if (_shMirrorsUseCount.find(ancestor) != _shMirrorsUseCount.end()) {
+            return ancestor;
+        }
+    }
+    return SdfPath::EmptyPath();
+}
+
+SdfPath
+WireframeSelectionHighlightSceneIndex::_RepathToSelectionHighlightMirror(const SdfPath& path) const
+{
+    auto ancestorsRange = path.GetAncestorsRange();
+    for (auto ancestor : ancestorsRange) {
+        const SdfPath mirrorPath = _GetSelectionHighlightMirrorPathFromOriginal(ancestor);
+        if (_shMirrorsUseCount.find(mirrorPath) != _shMirrorsUseCount.end()) {
+            return path.ReplacePrefix(ancestor, mirrorPath);
+        }
+    }
+    return SdfPath::EmptyPath();
+}
+
+class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathDataSource : public HdPathDataSource
+{
+public:
+    HD_DECLARE_DATASOURCE(_RerootingSceneIndexPathDataSource)
+
+    _RerootingSceneIndexPathDataSource(
+        HdPathDataSourceHandle const &inputDataSource,
+        WireframeSelectionHighlightSceneIndex const * const inputSceneIndex)
+      : _inputDataSource(inputDataSource),
+        _inputSceneIndex(inputSceneIndex)
+    {
+    }
+
+    VtValue GetValue(const Time shutterOffset) override
+    {
+        return VtValue(GetTypedValue(shutterOffset));
+    }
+
+    bool GetContributingSampleTimesForInterval(
+        const Time startTime,
+        const Time endTime,
+        std::vector<Time> * const outSampleTimes) override
+    {
+        if (!_inputDataSource) {
+            return false;
+        }
+
+        return _inputDataSource->GetContributingSampleTimesForInterval(
+                startTime, endTime, outSampleTimes);
+    }
+
+    SdfPath GetTypedValue(const Time shutterOffset) override
+    {
+        if (!_inputDataSource) {
+            return SdfPath();
+        }
+
+        const SdfPath srcPath = _inputDataSource->GetTypedValue(shutterOffset);
+        const SdfPath mirrorPath =_inputSceneIndex->_RepathToSelectionHighlightMirror(srcPath);
+        if (!mirrorPath.IsEmpty()) {
+            return mirrorPath;
+        }
+        // for (const auto& shSceneIndex : _inputSceneIndex->_shSceneIndices) {
+        //     const SdfPath originalShSceneIndexPath = _GetOriginalPathFromSelectionHighlightMirror(shSceneIndex.first);
+        //     if (srcPath.HasPrefix(originalShSceneIndexPath)) {
+        //         return srcPath.ReplacePrefix(originalShSceneIndexPath, shSceneIndex.first);
+        //     }
+        // }
+        return srcPath;
+    }
+
+private:
+    HdPathDataSourceHandle const _inputDataSource;
+    WireframeSelectionHighlightSceneIndex const * const _inputSceneIndex;
+};
+
+// ----------------------------------------------------------------------------
+
+class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathArrayDataSource : public HdPathArrayDataSource
+{
+public:
+    HD_DECLARE_DATASOURCE(_RerootingSceneIndexPathArrayDataSource)
+
+    _RerootingSceneIndexPathArrayDataSource(
+        HdPathArrayDataSourceHandle const & inputDataSource,
+        WireframeSelectionHighlightSceneIndex const * const inputSceneIndex)
+      : _inputDataSource(inputDataSource),
+        _inputSceneIndex(inputSceneIndex)
+    {
+    }
+
+    VtValue GetValue(const Time shutterOffset) override
+    {
+        return VtValue(GetTypedValue(shutterOffset));
+    }
+
+    bool GetContributingSampleTimesForInterval(
+        const Time startTime,
+        const Time endTime,
+        std::vector<Time>*  const outSampleTimes) override
+    {
+        if (!_inputDataSource) {
+            return false;
+        }
+
+        return _inputDataSource->GetContributingSampleTimesForInterval(
+            startTime, endTime, outSampleTimes);
+    }
+
+    VtArray<SdfPath> GetTypedValue(const Time shutterOffset) override
+    {
+        if (!_inputDataSource) {
+            return {};
+        }
+
+        VtArray<SdfPath> result
+            = _inputDataSource->GetTypedValue(shutterOffset);
+
+        for (size_t i = 0; i < result.size(); i++) {
+            const SdfPath mirrorPath = _inputSceneIndex->_RepathToSelectionHighlightMirror(result[i]);
+            if (!mirrorPath.IsEmpty()) {
+                result[i] = mirrorPath;
+            }
+            // for (const auto& shSceneIndex : _inputSceneIndex->_shSceneIndices) {
+            //     const SdfPath originalShSceneIndexPath = _GetOriginalPathFromSelectionHighlightMirror(shSceneIndex.first);
+            //     if (result[i].HasPrefix(originalShSceneIndexPath)) {
+            //         result[i] = result[i].ReplacePrefix(originalShSceneIndexPath, shSceneIndex.first);
+            //     }
+            // }
+        }
+
+        return result;
+    }
+
+private:
+    HdPathArrayDataSourceHandle const _inputDataSource;
+    WireframeSelectionHighlightSceneIndex const * const _inputSceneIndex;
+};
+
+// ----------------------------------------------------------------------------
+
+class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexContainerDataSource : public HdContainerDataSource
+{
+public:
+    HD_DECLARE_DATASOURCE(_RerootingSceneIndexContainerDataSource)
+
+    _RerootingSceneIndexContainerDataSource(
+        HdContainerDataSourceHandle const &inputDataSource,
+        WireframeSelectionHighlightSceneIndex const * const inputSceneIndex)
+      : _inputDataSource(inputDataSource),
+        _inputSceneIndex(inputSceneIndex)
+    {
+    }
+
+    TfTokenVector GetNames() override
+    {
+        if (!_inputDataSource) {
+            return {};
+        }
+
+        return _inputDataSource->GetNames();
+    }
+
+    HdDataSourceBaseHandle Get(const TfToken& name) override
+    {
+        if (!_inputDataSource) {
+            return nullptr;
+        }
+
+        // wrap child containers so that we can wrap their children
+        HdDataSourceBaseHandle const childSource = _inputDataSource->Get(name);
+        if (!childSource) {
+            return nullptr;
+        }
+
+        if (auto childContainer =
+                HdContainerDataSource::Cast(childSource)) {
+            return New(std::move(childContainer), _inputSceneIndex);
+        }
+
+        if (auto childPathDataSource =
+                HdTypedSampledDataSource<SdfPath>::Cast(childSource)) {
+            return _RerootingSceneIndexPathDataSource::New(childPathDataSource, _inputSceneIndex);
+        }
+
+        if (auto childPathArrayDataSource =
+                HdTypedSampledDataSource<VtArray<SdfPath>>::Cast(
+                    childSource)) {
+            return _RerootingSceneIndexPathArrayDataSource::New(childPathArrayDataSource, _inputSceneIndex);
+        }
+
+        return childSource;
+    }
+
+private:
+    HdContainerDataSourceHandle const _inputDataSource;
+    WireframeSelectionHighlightSceneIndex const * const _inputSceneIndex;
+};
+
 HdSceneIndexBaseRefPtr
 WireframeSelectionHighlightSceneIndex::New(
     const HdSceneIndexBaseRefPtr& inputSceneIndex,
@@ -69,6 +452,231 @@ const HdDataSourceLocator& WireframeSelectionHighlightSceneIndex::ReprSelectorLo
     return reprSelectorLocator;
 }
 
+SdfPathVector
+WireframeSelectionHighlightSceneIndex::_CollectAffectedOriginalPrimPaths(const SdfPath& originalPrimPath)
+{
+    TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
+
+    HdSceneIndexPrim originalPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
+    SdfPathVector affectedOriginalPrimPaths;
+
+    HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(originalPrim.dataSource);
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(originalPrim.dataSource);
+    HdSelectionsSchema selections = HdSelectionsSchema::GetFromParent(originalPrim.dataSource);
+
+    if (instancerTopology.IsDefined()) {
+        auto protoPaths = instancerTopology.GetPrototypes()->GetTypedValue(0);
+        for (const auto& protoPath : protoPaths) {
+            affectedOriginalPrimPaths.push_back(protoPath);
+        }
+    }
+
+    if (instancedBy.IsDefined()) {
+        auto instancerPaths = instancedBy.GetPaths()->GetTypedValue(0);
+        for (const auto& instancerPath : instancerPaths) {
+            affectedOriginalPrimPaths.push_back(instancerPath);
+        }
+
+        auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
+        for (const auto& protoRootPath : protoRootPaths) {
+            affectedOriginalPrimPaths.push_back(protoRootPath);
+        }
+    }
+
+    return affectedOriginalPrimPaths;
+}
+
+bool
+WireframeSelectionHighlightSceneIndex::_IsPrototypeRoot(const SdfPath& primPath)
+{
+    HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+    if (instancedBy.IsDefined()) {
+        auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
+        for (const auto& protoRootPath : protoRootPaths) {
+            if (protoRootPath == primPath) {
+                return true;
+            }
+        }
+        return false;
+    }
+    return true;
+}
+
+bool
+WireframeSelectionHighlightSceneIndex::_IsInstancingRoot(const SdfPath& primPath)
+{
+    HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+    if (!instancedBy.IsDefined()) {
+        return true;
+    }
+    if (!instancedBy.GetPrototypeRoots()) {
+        return true;
+    }
+    auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
+    for (const auto& protoRootPath : protoRootPaths) {
+        if (protoRootPath == primPath) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool
+WireframeSelectionHighlightSceneIndex::_IsPropagatedPrototype(const SdfPath& primPath)
+{
+    HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+    return instancedBy.IsDefined() && instancedBy.GetPrototypeRoots() && !instancedBy.GetPrototypeRoots()->GetTypedValue(0).empty();
+}
+
+void
+WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightMirror(const SdfPath& originalPrimPath, HdSceneIndexObserver::AddedPrimEntries& createdPrims)
+{
+    // This should never be called on selection highlight mirrors, only on original prims
+    // TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
+
+    // if (!_IsPrototypeRoot(originalPrimPath)) {
+    //     HdSceneIndexPrim originalPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
+    //     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(originalPrim.dataSource);
+    //     if (instancedBy.IsDefined()) {
+    //         auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
+    //         for (const auto& protoRootPath : protoRootPaths) {
+    //             _CreateSelectionHighlightMirror(protoRootPath, createdPrims);
+    //         }
+    //     }
+    //     return;
+    // }
+    
+    // SdfPath selectionHighlightPrimPath = _GetSelectionHighlightMirrorPathFromOriginal(originalPrimPath);
+    
+    // bool isNewShMirror = _shMirrorPathsUseCount.find(selectionHighlightPrimPath) == _shMirrorPathsUseCount.end();
+    // if (isNewShMirror) {
+    //     TF_AXIOM(_shMirrorPathsUseCount.find(selectionHighlightPrimPath) == _shMirrorPathsUseCount.end());
+    //     _shMirrorPathsUseCount[selectionHighlightPrimPath] = 1;
+    //     TF_AXIOM(_shSceneIndices.find(selectionHighlightPrimPath) == _shSceneIndices.end());
+    //     _shSceneIndices[selectionHighlightPrimPath] = UsdImagingRerootingSceneIndex::New(GetInputSceneIndex(), originalPrimPath, selectionHighlightPrimPath);
+    //     createdPrims.push_back({selectionHighlightPrimPath, GetInputSceneIndex()->GetPrim(originalPrimPath).primType});
+    // }
+    // else {
+    //     TF_AXIOM(_shMirrorPathsUseCount.find(selectionHighlightPrimPath) != _shMirrorPathsUseCount.end());
+    //     TF_AXIOM(_shMirrorPathsUseCount[selectionHighlightPrimPath] > 0);
+    //     TF_AXIOM(_shSceneIndices.find(selectionHighlightPrimPath) != _shSceneIndices.end());
+    //     _shMirrorPathsUseCount[selectionHighlightPrimPath]++;
+    // }
+    // TF_AXIOM(_shMirrorPathsUseCount[selectionHighlightPrimPath] > 0);
+
+    // SdfPathVector affectedOriginalPrimPaths = _CollectAffectedOriginalPrimPaths(originalPrimPath);
+
+    // std::stack<SdfPath> childPaths;
+    // for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(originalPrimPath)) {
+    //     childPaths.push(childPath);
+    // }
+    // while (!childPaths.empty()) {
+    //     SdfPath currPath = childPaths.top();
+    //     childPaths.pop();
+
+    //     HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
+    //     if (isNewShMirror) {
+    //         createdPrims.push_back({currPath.ReplacePrefix(originalPrimPath, selectionHighlightPrimPath), currPrim.primType});
+    //     }
+    //     if (currPrim.primType == HdPrimTypeTokens->instancer) {
+    //         SdfPathVector extraAffectedPaths = _CollectAffectedOriginalPrimPaths(currPath);
+    //         affectedOriginalPrimPaths.insert(affectedOriginalPrimPaths.end(), extraAffectedPaths.begin(), extraAffectedPaths.end());
+    //     }
+
+    //     for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
+    //         childPaths.push(childPath);
+    //     }
+    // }
+
+    // for (const auto& affectedOriginalPrimPath : affectedOriginalPrimPaths) {
+    //     _CreateSelectionHighlightMirror(affectedOriginalPrimPath, createdPrims);
+    // }
+}
+
+void
+WireframeSelectionHighlightSceneIndex::_InvalidateSelectionHighlightMirror(const SdfPath& originalPrimPath, HdSceneIndexObserver::RemovedPrimEntries& removedPrims)
+{
+    // This should never be called on selection highlight mirrors, only on original prims
+    // TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
+
+    // if (!_IsPrototypeRoot(originalPrimPath)) {
+    //     return;
+    // }
+
+    // SdfPath selectionHighlightPrimPath = _GetSelectionHighlightMirrorPathFromOriginal(originalPrimPath);
+
+    // if (_shMirrorPathsUseCount.find(selectionHighlightPrimPath) == _shMirrorPathsUseCount.end()) {
+    //     return;
+    // }
+    // TF_AXIOM(_shMirrorPathsUseCount.find(selectionHighlightPrimPath) != _shMirrorPathsUseCount.end());
+    // TF_AXIOM(_shMirrorPathsUseCount[selectionHighlightPrimPath] > 0);
+    // TF_AXIOM(_shSceneIndices.find(selectionHighlightPrimPath) != _shSceneIndices.end());
+
+    // _shMirrorPathsUseCount[selectionHighlightPrimPath]--;
+    // bool shouldDeleteShMirror = _shMirrorPathsUseCount[selectionHighlightPrimPath] == 0;
+    // if (shouldDeleteShMirror) {
+    //     _shMirrorPathsUseCount.erase(selectionHighlightPrimPath);
+    //     _shSceneIndices.erase(selectionHighlightPrimPath);
+    //     removedPrims.push_back({selectionHighlightPrimPath});
+    // }
+    
+    // SdfPathVector affectedOriginalPrimPaths = _CollectAffectedOriginalPrimPaths(originalPrimPath);
+
+    // std::stack<SdfPath> childPaths;
+    // for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(originalPrimPath)) {
+    //     childPaths.push(childPath);
+    // }
+    // while (!childPaths.empty()) {
+    //     SdfPath currPath = childPaths.top();
+    //     childPaths.pop();
+
+    //     HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
+    //     if (currPrim.primType == HdPrimTypeTokens->instancer) {
+    //         SdfPathVector extraAffectedPaths = _CollectAffectedOriginalPrimPaths(currPath);
+    //         affectedOriginalPrimPaths.insert(affectedOriginalPrimPaths.end(), extraAffectedPaths.begin(), extraAffectedPaths.end());
+    //     }
+
+    //     for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
+    //         childPaths.push(childPath);
+    //     }
+    // }
+
+    // for (const auto& affectedOriginalPrimPath : affectedOriginalPrimPaths) {
+    //     _InvalidateSelectionHighlightMirror(affectedOriginalPrimPath, removedPrims);
+    // }
+}
+
+void
+WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightMirrorForInstancer(const SdfPath& primPath, const HdSceneIndexPrim& prim)
+{
+    HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(prim.dataSource);
+    TF_AXIOM(instancerTopology.IsDefined());
+
+
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+    if (instancedBy.IsDefined()) {
+        for (const auto& instancedByPath : instancedBy.GetPaths()->GetTypedValue(0)) {
+            // TODO : GetPrototypeRoots? -> goes into overlay, same as new instancedBy paths
+            _CreateSelectionHighlightMirrorForInstancer(instancedByPath, GetInputSceneIndex()->GetPrim(instancedByPath));
+        }
+    }
+}
+
+void
+WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightMirrorForMesh(const SdfPath& primPath, const HdSceneIndexPrim& prim)
+{
+
+}
+
+void
+WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightMirrorForArbitraryPrim(const SdfPath& primPath, const HdSceneIndexPrim& prim)
+{
+
+}
+
 WireframeSelectionHighlightSceneIndex::
 WireframeSelectionHighlightSceneIndex(
     const HdSceneIndexBaseRefPtr& inputSceneIndex,
@@ -81,6 +689,153 @@ WireframeSelectionHighlightSceneIndex(
     , _wireframeColorInterface(wireframeColorInterface)
 {
     TF_AXIOM(_wireframeColorInterface);
+
+    std::stack<SdfPath> primPathsToTraverse({ SdfPath::AbsoluteRootPath() });
+    while (!primPathsToTraverse.empty()) {
+        SdfPath currPrimPath = primPathsToTraverse.top();
+        primPathsToTraverse.pop();
+
+        HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPrimPath);
+        if (_IsInstancerWithSelections(currPrim)) {
+            HdSceneIndexObserver::AddedPrimEntries newPrims;
+            _CreateSelectionHighlightMirror(currPrimPath, newPrims);
+        }
+
+        for (const auto& childPath : inputSceneIndex->GetChildPrimPaths(currPrimPath)) {
+            primPathsToTraverse.push(childPath);
+        }
+    }
+}
+
+void 
+WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightInstancer(const PXR_NS::SdfPath& originalPath, const PXR_NS::HdContainerDataSourceHandle& originalDataSource)
+{
+
+}
+
+bool
+WireframeSelectionHighlightSceneIndex::_CollectShMirrorPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outShMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outCreatedPrims)
+{
+    // This should never be called on selection highlight mirrors, only on original prims
+    TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
+
+    static std::mutex printMutex;
+    {
+        std::lock_guard printLock(printMutex);
+        std::cout << "Processing : " << originalPrimPath.GetString() << std::endl;
+    }
+
+    if (!_IsInstancingRoot(originalPrimPath)) {
+        HdSceneIndexPrim originalPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
+        HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(originalPrim.dataSource);
+        bool result = false;
+        if (instancedBy.IsDefined()) {
+            auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
+            for (const auto& protoRootPath : protoRootPaths) {
+                result = result || _CollectShMirrorPaths(protoRootPath, outShMirrorPaths, outCreatedPrims);
+            }
+        }
+        return result;
+    }
+    
+    SdfPath selectionHighlightPrimPath = _GetSelectionHighlightMirrorPathFromOriginal(originalPrimPath);
+    
+    if (outShMirrorPaths.find(selectionHighlightPrimPath) != outShMirrorPaths.end()) {
+        return false;
+    }
+    outShMirrorPaths.insert(selectionHighlightPrimPath);
+
+    SdfPathVector affectedOriginalPrimPaths;
+    std::stack<SdfPath> pathsToTraverse({originalPrimPath});
+    while (!pathsToTraverse.empty()) {
+        SdfPath currPath = pathsToTraverse.top();
+        pathsToTraverse.pop();
+
+        if (_IsPropagatedPrototype(currPath) && _IsInstancingRoot(currPath) && currPath != originalPrimPath) {
+            continue;
+        }
+
+        HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
+        outCreatedPrims.push_back({currPath.ReplacePrefix(originalPrimPath, selectionHighlightPrimPath), currPrim.primType});
+        if (currPrim.primType == HdPrimTypeTokens->instancer) {
+            SdfPathVector extraAffectedOriginalPrimPaths = _CollectAffectedOriginalPrimPaths(currPath);
+            std::cout << "Processing extra paths for : " << currPath.GetString() << std::endl;
+            for (const auto& path : extraAffectedOriginalPrimPaths) {
+                {
+                    std::lock_guard printLock(printMutex);
+                    std::cout << "|-----Adding : " << path.GetString() << std::endl;
+                }
+            }
+            affectedOriginalPrimPaths.insert(affectedOriginalPrimPaths.end(), extraAffectedOriginalPrimPaths.begin(), extraAffectedOriginalPrimPaths.end());
+        }
+
+        for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
+            pathsToTraverse.push(childPath);
+        }
+    }
+
+    for (const auto& affectedOriginalPrimPath : affectedOriginalPrimPaths) {
+        _CollectShMirrorPaths(affectedOriginalPrimPath, outShMirrorPaths, outCreatedPrims);
+    }
+
+    return true;
+}
+
+void 
+WireframeSelectionHighlightSceneIndex::_RemoveShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
+{
+    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
+
+    HdSceneIndexObserver::RemovedPrimEntries removedPrims;
+
+    SdfPathSet oldShMirrors;
+    if (_shMirrorsByInstancer.find(instancerPath) != _shMirrorsByInstancer.end()) {
+        oldShMirrors = _shMirrorsByInstancer.at(instancerPath);
+    }
+    for (const auto& shMirror : oldShMirrors) {
+        TF_AXIOM(_shMirrorsUseCount.find(shMirror) != _shMirrorsUseCount.end());
+        TF_AXIOM(_shMirrorsUseCount[shMirror] > 0);
+        _shMirrorsUseCount[shMirror]--;
+        if (_shMirrorsUseCount[shMirror] == 0) {
+            _shMirrorsUseCount.erase(shMirror);
+            removedPrims.push_back(shMirror);
+        }
+    }
+
+    _shMirrorsByInstancer.erase(instancerPath);
+    
+    if (!removedPrims.empty()) {
+        _SendPrimsRemoved(removedPrims);
+    }
+}
+
+void 
+WireframeSelectionHighlightSceneIndex::_CreateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
+{
+    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
+
+    if (_shMirrorsByInstancer.find(instancerPath) != _shMirrorsByInstancer.end()) {
+        _RemoveShMirrorsForInstancer(instancerPath);
+    }
+
+    SdfPathSet newShMirrors;
+    HdSceneIndexObserver::AddedPrimEntries addedPrims;
+    _CollectShMirrorPaths(instancerPath, newShMirrors, addedPrims);
+
+    _shMirrorsByInstancer[instancerPath] = newShMirrors;
+    for (const auto& shMirror : newShMirrors) {
+        if (_shMirrorsUseCount.find(shMirror) == _shMirrorsUseCount.end()) {
+            _shMirrorsUseCount[shMirror] = 1;
+        } else {
+            TF_AXIOM(_shMirrorsUseCount.find(shMirror) != _shMirrorsUseCount.end());
+            TF_AXIOM(_shMirrorsUseCount[shMirror] > 0);
+            _shMirrorsUseCount[shMirror]++;
+        }
+    }
+
+    if (!addedPrims.empty()) {
+        _SendPrimsAdded(addedPrims);
+    }
 }
 
 HdSceneIndexPrim
@@ -89,25 +844,178 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
     TF_DEBUG(FVP_WIREFRAME_SELECTION_HIGHLIGHT_SCENE_INDEX)
         .Msg("WireframeSelectionHighlightSceneIndex::GetPrim(%s) called.\n", primPath.GetText());
 
-    auto prim = GetInputSceneIndex()->GetPrim(primPath);
+    // if (_IsSelectionHighlightMirrorPath(primPath)) {
+    //     HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(_GetOriginalPathFromSelectionHighlightMirror(primPath));
+    //     return {prim.primType, {}};
+    // }
+
+    // auto ancestorsRange = primPath.GetAncestorsRange();
+    // for (auto ancestor : ancestorsRange) {
+    //     if (_IsSelectionHighlightMirrorPath(ancestor)) {
+    //         auto originalPath = primPath.ReplacePrefix(ancestor, _GetOriginalPathFromSelectionHighlightMirror(ancestor));
+    //         HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(originalPath);
+    //         return {prim.primType, {}};
+    //     }
+    // }
+    if (primPath.GetElementString() == "TopInstancer") {
+        //return {};
+    }
+    static std::mutex printMutex;
+    std::lock_guard printLock(printMutex);
+    SdfPath shMirrorAncestor = _FindSelectionHighlightMirrorAncestor(primPath);
+    //std::cout << "For " << primPath.GetString() << " , SH is : " << shMirrorAncestor.GetString() << std::endl;
+    if (!shMirrorAncestor.IsEmpty()) {
+        // TODO : Use _shSceneIndices?
+        HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath.ReplacePrefix(shMirrorAncestor, _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestor)));
+        if (prim.dataSource) {
+            prim.dataSource = WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexContainerDataSource::New(prim.dataSource, this);
+        }
+        if (prim.primType == HdPrimTypeTokens->mesh) {
+            prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath.ReplacePrefix(shMirrorAncestor, _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestor)));
+        }
+        return prim;
+    }
+    // for (const auto& shSceneIndex : _shSceneIndices) {
+    //     if (primPath.HasPrefix(shSceneIndex.first)) {
+    //         //HdSceneIndexPrim prim = shSceneIndex.second->GetPrim(primPath);
+    //         HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath.ReplacePrefix(shSceneIndex.first, _GetOriginalPathFromSelectionHighlightMirror(shSceneIndex.first)));
+    //         if (prim.dataSource) {
+    //             prim.dataSource = WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexContainerDataSource::New(prim.dataSource, this);
+    //         }
+    //         if (prim.primType == HdPrimTypeTokens->mesh) {
+    //             prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath.ReplacePrefix(shSceneIndex.first, _GetOriginalPathFromSelectionHighlightMirror(shSceneIndex.first)));
+    //         }
+    //         return prim;
+    //     }
+    // }
+    //HdSceneIndexPrim prim;
+    //if (_IsSelectionHighlightMirrorPath(primPath)) {
+    //    prim = GetInputSceneIndex()->GetPrim(_GetOriginalFromMirrorPath(primPath));
+    //} else {
+    //    prim = GetInputSceneIndex()->GetPrim(primPath);
+    //}
+//
+    //if (_IsSelectionHighlightMirrorPath(primPath)) {
+    //    if (prim.primType == HdPrimTypeTokens->instancer) {
+    //        prim.dataSource = _GetSelectionHighlightInstancerDataSource(prim.dataSource);
+    //    }
+    //    else if (prim.primType == HdPrimTypeTokens->mesh) {
+    //        prim.dataSource = _HighlightSelectedPrim(prim.dataSource, _GetOriginalFromMirrorPath(primPath));
+    //    }
+    //}
+
+    // if (_selectionHighlightDataSourceOverlays.find(primPath) != _selectionHighlightDataSourceOverlays.end()) {
+    //     prim.dataSource = HdOverlayContainerDataSource::New(_selectionHighlightDataSourceOverlays.at(primPath), prim.dataSource);
+    //     return prim;
+    // }
 
     // If prim is in excluded hierarchy, don't provide selection highlighting
     // for it.  Selection highlighting is done only on meshes.  HYDRA-569: this
     // means that HdsiImplicitSurfaceSceneIndex must be used before this scene
     // index to convert implicit surfaces (e.g. USD cube / cone / sphere /
     // capsule primitive types) to meshes.
-    if (! _IsExcluded(primPath) && prim.primType == HdPrimTypeTokens->mesh) {
-        if (_selection->HasFullySelectedAncestorInclusive(primPath)) {
-            prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath);
-        }
-    }
-    return prim;
+    // if (! _IsExcluded(primPath) && prim.primType == HdPrimTypeTokens->mesh) {
+    //     // TODO : Check that this is not an instanced mesh (check there is no instancedBy schema)
+    //     if (_selection->HasFullySelectedAncestorInclusive(primPath)) {
+    //         prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath);
+    //     }
+    // }
+
+    // if (!_IsSelectionHighlightMirror(primPath)) {
+    //     return prim;
+    // }
+
+    // if (prim.primType == HdPrimTypeTokens->instancer) {
+    //     prim.dataSource = _GetSelectionHighlightInstancerDataSource(prim.dataSource);
+    // } else if (prim.primType == HdPrimTypeTokens->mesh) {
+    //     SdfPath originalPath = _GetOriginalFromMirrorPath(primPath);
+    //     prim.dataSource = _HighlightSelectedPrim(prim.dataSource, originalPath);
+    // }
+
+    return GetInputSceneIndex()->GetPrim(primPath);
 }
 
 SdfPathVector
 WireframeSelectionHighlightSceneIndex::GetChildPrimPaths(const SdfPath &primPath) const
 {
-    return GetInputSceneIndex()->GetChildPrimPaths(primPath);
+    // if (primPath.GetElementString().find("ForInstancer") != std::string::npos &&
+    // GetInputSceneIndex()->GetPrim(primPath).primType == HdPrimTypeTokens->instancer) {
+    //     return {};
+    // }
+    // if (primPath.GetElementString().find("ForInstancer") != std::string::npos &&
+    // GetInputSceneIndex()->GetPrim(primPath).primType == HdPrimTypeTokens->instancer) {
+    //     static std::mutex printMutex;
+    //     SdfPath rerootedPath = primPath.ReplacePrefix(SdfPath::AbsoluteRootPath(), SdfPath("Potato"));
+    //     std::lock_guard printLock(printMutex);
+    //     std::cout << rerootedPath << std::endl;
+    // }
+    // auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath);
+    // if (_extraChildPaths.find(primPath) != _extraChildPaths.end()) {
+    //     SdfPathVector extraChildPaths = _extraChildPaths.at(primPath);
+    //     childPaths.insert(childPaths.end(), extraChildPaths.begin(), extraChildPaths.end());
+    // }
+    // SdfPathVector additionalChildPaths;
+    // for (const auto& childPath : childPaths) {
+    //     if (_originalPrimPathsToSelectionHighlightMirrorPrimPaths.find(childPath) != _originalPrimPathsToSelectionHighlightMirrorPrimPaths.end()) {
+    //         additionalChildPaths.push_back(_originalPrimPathsToSelectionHighlightMirrorPrimPaths.at(childPath));
+    //     }
+    // }
+    // childPaths.insert(childPaths.end(), additionalChildPaths.begin(), additionalChildPaths.end());
+    // SdfPathVector additionalChildPaths;
+    // for (auto& childPath : childPaths) {
+    //     if (GetInputSceneIndex()->GetPrim(childPath).primType == HdPrimTypeTokens->instancer
+    //     || GetInputSceneIndex()->GetPrim(childPath).primType == HdPrimTypeTokens->mesh) {
+    //         SdfPath mirrorPath = _GetSelectionHighlightMirrorPath(childPath);
+    //         additionalChildPaths.push_back(mirrorPath);
+    //     }
+    // }
+    // childPaths.insert(childPaths.end(), additionalChildPaths.begin(), additionalChildPaths.end());
+    
+    //SdfPathVector additionalChildPaths;
+    //for (const auto& childPath : childPaths) {
+    //    if (_topLevelInstancers.find(childPath) != _topLevelInstancers.end()) {
+    //        additionalChildPaths.push_back(_GetSelectionHighlightMirrorPath(childPath));
+    //    }
+    //}
+    //childPaths.insert(childPaths.end(), additionalChildPaths.begin(), additionalChildPaths.end());
+    // auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath);
+    // SdfPathVector additionalChildPaths;
+    // for (const auto& childPath : childPaths) {
+    //     HdSceneIndexPrim childPrim = GetInputSceneIndex()->GetPrim(childPath);
+    //     HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(childPrim.dataSource);
+    //     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(childPrim.dataSource);
+
+    // }
+    SdfPath shMirrorAncestor = _FindSelectionHighlightMirrorAncestor(primPath);
+    if (!shMirrorAncestor.IsEmpty()) {
+        SdfPath originalShMirrorAncestor = _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestor);
+        auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath.ReplacePrefix(shMirrorAncestor, originalShMirrorAncestor));
+        for (auto& childPath : childPaths) {
+            childPath = childPath.ReplacePrefix(originalShMirrorAncestor, shMirrorAncestor);
+        }
+        return childPaths;
+    }
+    // for (const auto& shSceneIndex : _shSceneIndices) {
+    //     if (primPath.HasPrefix(shSceneIndex.first)) {
+    //         //return shSceneIndex.second->GetChildPrimPaths(primPath);
+    //         auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath.ReplacePrefix(shSceneIndex.first, _GetOriginalPathFromSelectionHighlightMirror(shSceneIndex.first)));
+    //         for (auto& childPath : childPaths) {
+    //             childPath = childPath.ReplacePrefix(const SdfPath &oldPrefix, const SdfPath &newPrefix)
+    //         }
+    //     }
+    // }
+
+    auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath);
+    SdfPathVector additionalChildPaths;
+    for (const auto& childPath : childPaths) {
+        SdfPath shPath = _GetSelectionHighlightMirrorPathFromOriginal(childPath);
+        if (_shMirrorsUseCount.find(shPath) != _shMirrorsUseCount.end()) {
+            additionalChildPaths.push_back(shPath);
+        }
+    }
+    childPaths.insert(childPaths.end(), additionalChildPaths.begin(), additionalChildPaths.end());
+
+    return childPaths;
 }
 
 //We want to set the displayStyle of the selected prim to refinedWireOnSurf only if the displayStyle of the prim is refined (meaning shaded)
@@ -120,6 +1028,12 @@ HdContainerDataSourceHandle WireframeSelectionHighlightSceneIndex::_HighlightSel
                             HdRetainedTypedSampledDataSource<VtVec4fArray>::New(VtVec4fArray{_wireframeColorInterface->getWireframeColor(primPath)}),
                             HdPrimvarSchemaTokens->constant,
                             HdPrimvarSchemaTokens->color));
+
+    HdXformSchema::Builder xformBuilder;
+    GfMatrix4d matrix;
+    matrix.SetScale(1.25);
+    xformBuilder.SetMatrix(HdRetainedTypedSampledDataSource<GfMatrix4d>::New(matrix));
+    edited.Set(HdXformSchema::GetDefaultLocator(), xformBuilder.Build());
     
     //Is the prim in refined displayStyle (meaning shaded) ?
     if (HdLegacyDisplayStyleSchema styleSchema =
@@ -152,7 +1066,29 @@ WireframeSelectionHighlightSceneIndex::_PrimsAdded(
     TF_DEBUG(FVP_WIREFRAME_SELECTION_HIGHLIGHT_SCENE_INDEX)
         .Msg("WireframeSelectionHighlightSceneIndex::_PrimsAdded() called.\n");
 
-    _SendPrimsAdded(entries);
+    auto newEntries = entries;
+    // for (auto& entry : entries) {
+    //     if (entry.primType == HdPrimTypeTokens->instancer) {
+
+    //         SdfPath mirrorPath = _GetSelectionHighlightMirrorPath(entry.primPath);
+    //         newEntries.push_back({mirrorPath, entry.primType});
+    //     }
+    // }
+    for (const auto& entry : entries) {
+        // TODO : Check if instancer with selections, or if an instancee whose instancer(s) have selections?
+        // Maybe only need new instancers with selections?
+        // New proto subprim : handled automatically
+        // New proto : means an instancer has changed -> should be reflected automatically?
+        if (_IsInstancerWithSelections(GetInputSceneIndex()->GetPrim(entry.primPath))) {
+            _CreateShMirrorsForInstancer(entry.primPath);
+        }
+    }
+    // for (const auto& entry : entries) {
+    //     if (_originalPrimPathsToSelectionHighlightMirrorPrimPaths.find(entry.primPath) != _originalPrimPathsToSelectionHighlightMirrorPrimPaths.end()) {
+    //         newEntries.push_back({_originalPrimPathsToSelectionHighlightMirrorPrimPaths.at(entry.primPath), entry.primType});
+    //     }
+    // }
+    _SendPrimsAdded(newEntries);
 }
 
 void
@@ -178,6 +1114,26 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
         }
     }
 
+    HdSceneIndexObserver::AddedPrimEntries newSelectionHighlightPrims;
+    HdSceneIndexObserver::RemovedPrimEntries removedSelectionHighlightPrims;
+    for (const auto& entry : entries) {
+        if (entry.dirtyLocators.Contains(HdSelectionsSchema::GetDefaultLocator())) {
+            HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(entry.primPath);
+            if (_IsInstancerWithSelections(prim)) {
+                _CreateShMirrorsForInstancer(entry.primPath);
+            } else if (prim.primType == HdPrimTypeTokens->instancer) {
+                _RemoveShMirrorsForInstancer(entry.primPath);
+            }
+            // Forward dirtiness to SH mirrors masks
+        }
+    }
+    if (!newSelectionHighlightPrims.empty())
+        _SendPrimsAdded(newSelectionHighlightPrims);
+    if (!removedSelectionHighlightPrims.empty()) {
+        _SendPrimsRemoved(removedSelectionHighlightPrims);
+    }
+
+
     if (!highlightEntries.empty()) {
         // Append all incoming dirty entries.
         highlightEntries.reserve(highlightEntries.size()+entries.size());
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index e5ad1234b0..512384341b 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -20,10 +20,15 @@
 #include "flowViewport/sceneIndex/fvpSceneIndexUtils.h"
 #include "flowViewport/fvpWireframeColorInterface.h"
 
+#include <pxr/imaging/hd/dataSource.h>
 #include <pxr/imaging/hd/filteringSceneIndex.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
+#include <pxr/imaging/hd/sceneIndex.h>
+#include <pxr/usdImaging/usdImaging/rerootingSceneIndex.h>
+#include <pxr/usd/sdf/path.h>
 
 #include <set>
+#include <unordered_map>
 
 namespace FVP_NS_DEF {
 
@@ -106,8 +111,40 @@ class WireframeSelectionHighlightSceneIndex
     std::set<PXR_NS::SdfPath> _excludedSceneRoots;
     PXR_NS::HdContainerDataSourceHandle _HighlightSelectedPrim(const PXR_NS::HdContainerDataSourceHandle& dataSource, const PXR_NS::SdfPath& primPath)const;
 
+    void _CreateSelectionHighlightInstancer(const PXR_NS::SdfPath& originalPath, const PXR_NS::HdContainerDataSourceHandle& originalDataSource);
+    
+    bool _IsPrototypeRoot(const PXR_NS::SdfPath& primPath);
+    bool _IsInstancingRoot(const PXR_NS::SdfPath& primPath);
+    bool _IsPropagatedPrototype(const PXR_NS::SdfPath& primPath);
+    PXR_NS::SdfPathVector _CollectAffectedOriginalPrimPaths(const PXR_NS::SdfPath& primPath);
+    void _CreateSelectionHighlightMirror(const PXR_NS::SdfPath& primPath, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& createdPrims);
+    void _InvalidateSelectionHighlightMirror(const PXR_NS::SdfPath& primPath, PXR_NS::HdSceneIndexObserver::RemovedPrimEntries& removedPrims);
+    void _PropagateDirtySelectionHighlightMirror(const PXR_NS::SdfPath& primPath, PXR_NS::HdSceneIndexObserver::DirtiedPrimEntries& dirtiedPrims);
+
+    bool _CollectShMirrorPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outShMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outCreatedPrims);
+    void _UpdateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
+    void _RemoveShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
+    void _CreateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
+
+    void _CreateSelectionHighlightMirrorForInstancer(const PXR_NS::SdfPath& primPath, const PXR_NS::HdSceneIndexPrim& prim);
+    void _CreateSelectionHighlightMirrorForMesh(const PXR_NS::SdfPath& primPath, const PXR_NS::HdSceneIndexPrim& prim);
+    void _CreateSelectionHighlightMirrorForArbitraryPrim(const PXR_NS::SdfPath& primPath, const PXR_NS::HdSceneIndexPrim& prim);
+
+    PXR_NS::SdfPath _FindSelectionHighlightMirrorAncestor(const PXR_NS::SdfPath& path) const;
+    PXR_NS::SdfPath _RepathToSelectionHighlightMirror(const PXR_NS::SdfPath& path) const;
+
     const SelectionConstPtr   _selection;
     const std::shared_ptr<WireframeColorInterface> _wireframeColorInterface;
+
+    //std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPath, PXR_NS::SdfPath::Hash> _pathsOgToSh;
+    //std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPath, PXR_NS::SdfPath::Hash> _pathsShToOg;
+    //std::unordered_map<PXR_NS::SdfPath, PXR_NS::HdContainerDataSourceHandle, PXR_NS::SdfPath::Hash> _selectionHighlightDataSourceOverlays;
+    //std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathVector, PXR_NS::SdfPath::Hash> _extraChildPaths;
+    std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _shMirrorsByInstancer;
+    std::unordered_map<PXR_NS::SdfPath, size_t, PXR_NS::SdfPath::Hash> _shMirrorsUseCount;
+    class _RerootingSceneIndexPathDataSource;
+    class _RerootingSceneIndexPathArrayDataSource;
+    class _RerootingSceneIndexContainerDataSource;
 };
 
 }

From fe6f344fb96d8edcde0dc571cd799fad3a42c0b9 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 23 May 2024 10:29:36 -0400
Subject: [PATCH 002/112] Add PrimsRemoved support

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 35 +++++++++++++++++--
 1 file changed, 33 insertions(+), 2 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 893cad2a4a..44f5ad022c 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -27,6 +27,7 @@
 #include <pxr/base/vt/types.h>
 #include <pxr/imaging/hd/dataSource.h>
 #include <pxr/imaging/hd/dataSourceLocator.h>
+#include <pxr/imaging/hd/dataSourceTypeDefs.h>
 #include <pxr/imaging/hd/instancedBySchema.h>
 #include <pxr/imaging/hd/instancerTopologySchema.h>
 #include <pxr/imaging/hd/legacyDisplayStyleSchema.h>
@@ -65,7 +66,7 @@ const HdRetainedContainerDataSourceHandle sRefinedWireOnSurfaceDisplayStyleDataS
         HdRetainedContainerDataSource::New(
             HdLegacyDisplayStyleSchemaTokens->reprSelector,
             HdRetainedTypedSampledDataSource<VtArray<TfToken>>::New(
-                { HdReprTokens->refinedWireOnSurf, TfToken(), TfToken() })));
+                { HdReprTokens->refinedWire, TfToken(), TfToken() })));
 
 const HdDataSourceLocator reprSelectorLocator(
         HdLegacyDisplayStyleSchemaTokens->displayStyle,
@@ -873,6 +874,26 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         if (prim.primType == HdPrimTypeTokens->mesh) {
             prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath.ReplacePrefix(shMirrorAncestor, _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestor)));
         }
+        // if (prim.primType == HdPrimTypeTokens->instancer) {
+        //     HdSelectionsSchema selections = HdSelectionsSchema::GetFromParent(prim.dataSource);
+        //     if (selections.IsDefined()) {
+        //         HdInstanceIndicesSchema::Builder instanceIndicesBuilder;
+        //         instanceIndicesBuilder.SetInstancer(HdRetainedTypedSampledDataSource<SdfPath>::New(primPath));
+        //         instanceIndicesBuilder.SetInstanceIndices(HdRetainedTypedSampledDataSource<VtArray<int>>::New({0}));
+        //         instanceIndicesBuilder.SetPrototypeIndex(HdRetainedTypedSampledDataSource<int>::New(0));
+        //         HdSelectionSchema::Builder selectionBuilder;
+        //         selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
+        //         auto newInstanceIndices = HdDataSourceBase::Cast(instanceIndicesBuilder.Build());
+        //         selectionBuilder.SetNestedInstanceIndices(HdRetainedSmallVectorDataSource::New(1, &newInstanceIndices));
+        //         auto newSelection = HdDataSourceBase::Cast(selectionBuilder.Build());
+        //         auto newSelections = HdRetainedSmallVectorDataSource::New(1, &newSelection);
+        //         HdContainerDataSourceEditor editor(prim.dataSource);
+        //         editor.Set(HdSelectionsSchema::GetDefaultLocator(), newSelections);
+
+        //         editor.Set(HdInstancerTopologySchema::GetDefaultLocator().Append(TfToken("mask")), HdRetainedTypedSampledDataSource<VtArray<bool>>::New(VtArray<bool>({true, false})));
+        //         prim.dataSource = editor.Finish();
+        //     }
+        // }
         return prim;
     }
     // for (const auto& shSceneIndex : _shSceneIndices) {
@@ -1033,7 +1054,7 @@ HdContainerDataSourceHandle WireframeSelectionHighlightSceneIndex::_HighlightSel
     GfMatrix4d matrix;
     matrix.SetScale(1.25);
     xformBuilder.SetMatrix(HdRetainedTypedSampledDataSource<GfMatrix4d>::New(matrix));
-    edited.Set(HdXformSchema::GetDefaultLocator(), xformBuilder.Build());
+    //edited.Set(HdXformSchema::GetDefaultLocator(), xformBuilder.Build());
     
     //Is the prim in refined displayStyle (meaning shaded) ?
     if (HdLegacyDisplayStyleSchema styleSchema =
@@ -1154,6 +1175,16 @@ WireframeSelectionHighlightSceneIndex::_PrimsRemoved(
     TF_DEBUG(FVP_WIREFRAME_SELECTION_HIGHLIGHT_SCENE_INDEX)
         .Msg("WireframeSelectionHighlightSceneIndex::_PrimsRemoved() called.\n");
 
+    for (const auto& entry : entries) {
+        // TODO : Check if instancer with selections, or if an instancee whose instancer(s) have selections?
+        // Maybe only need new instancers with selections?
+        // New proto subprim : handled automatically
+        // New proto : means an instancer has changed -> should be reflected automatically?
+        if (_IsInstancerWithSelections(GetInputSceneIndex()->GetPrim(entry.primPath))) {
+            _RemoveShMirrorsForInstancer(entry.primPath);
+        }
+    }
+
     _SendPrimsRemoved(entries);
 }
 

From 73e9fa11a063acfc5ae40e371d521c5ec1cd54c2 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 23 May 2024 12:37:22 -0400
Subject: [PATCH 003/112] Refactor SceneIndexPath method to return multiple
 selections + instances

---
 ...fvpBlockPrimRemovalPropagationSceneIndex.h |  5 +-
 .../sceneIndex/fvpMergingSceneIndex.cpp       | 11 ++--
 .../sceneIndex/fvpMergingSceneIndex.h         |  3 +-
 .../sceneIndex/fvpPathInterface.h             | 15 ++++-
 .../sceneIndex/fvpPathInterfaceSceneIndex.h   |  2 +-
 .../sceneIndex/fvpSelectionSceneIndex.cpp     | 63 ++++++++++++-------
 .../sceneIndex/fvpSelectionSceneIndex.h       |  3 +-
 lib/flowViewport/selection/fvpSelection.cpp   | 19 +++---
 lib/flowViewport/selection/fvpSelection.h     | 10 ++-
 .../mhLeadObjectPathTracker.cpp               | 10 ++-
 .../sceneIndex/mayaHydraSceneIndex.cpp        | 14 ++++-
 .../sceneIndex/mayaHydraSceneIndex.h          |  2 +-
 .../sceneIndex/registration.cpp               | 38 +++++++++--
 .../render/mayaToHydra/cpp/testHydraPrim.cpp  |  5 +-
 .../mayaToHydra/cpp/testMergingSceneIndex.cpp | 22 +++----
 .../mayaToHydra/cpp/testPathInterface.cpp     |  2 +-
 .../cpp/testSelectionSceneIndex.cpp           |  6 +-
 .../render/mayaToHydra/cpp/testUsdAnim.cpp    |  2 +-
 .../render/mayaToHydra/cpp/testUsdPicking.cpp |  2 +-
 .../cpp/testUsdPointInstancePicking.cpp       |  2 +-
 ...tWireframeSelectionHighlightSceneIndex.cpp | 10 +--
 21 files changed, 164 insertions(+), 82 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h b/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
index a8e5f7f1f4..ae0b41d5b7 100644
--- a/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
@@ -21,6 +21,7 @@
 #include "flowViewport/sceneIndex/fvpSceneIndexUtils.h"
 #include "flowViewport/selection/fvpSelectionFwd.h"
 #include "flowViewport/sceneIndex/fvpPathInterface.h"
+#include "fvpPathInterface.h"
 
 //Hydra headers
 #include <pxr/imaging/hd/filteringSceneIndex.h>
@@ -70,8 +71,8 @@ class BlockPrimRemovalPropagationSceneIndex : public PXR_NS::HdSingleInputFilter
 
     //from PathInterface
     FVP_API
-    PXR_NS::SdfPath SceneIndexPath(const Ufe::Path& appPath) const override{
-        return _pathInterface->SceneIndexPath(appPath);
+    PrimSelectionInfoVector ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const override{
+        return _pathInterface->ConvertUfeSelectionToHydra(appPath);
     }
 
 protected:
diff --git a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
index 6a46bfbe80..bde260bdbe 100644
--- a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
@@ -16,6 +16,7 @@
 #include "flowViewport/sceneIndex/fvpMergingSceneIndex.h"
 
 #include "flowViewport/debugCodes.h"
+#include "fvpPathInterface.h"
 
 PXR_NAMESPACE_USING_DIRECTIVE
 
@@ -34,7 +35,7 @@ MergingSceneIndex::MergingSceneIndex() : HdMergingSceneIndex()
         .Msg("MergingSceneIndex::MergingSceneIndex() called.\n");
 }
 
-SdfPath MergingSceneIndex::SceneIndexPath(const Ufe::Path& appPath) const
+PrimSelectionInfoVector MergingSceneIndex::ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const
 {
     // FLOW_VIEWPORT_TODO  May be able to use a caching scheme for app path to
     // scene index path conversion using the run-time ID of the UFE path, as it
@@ -50,13 +51,13 @@ SdfPath MergingSceneIndex::SceneIndexPath(const Ufe::Path& appPath) const
         // scene we know whether it supports the PathInterface or not.
         auto pathInterface = dynamic_cast<const PathInterface*>(&*inputScene);
         if (pathInterface) {
-            auto sceneIndexPath = pathInterface->SceneIndexPath(appPath);
-            if (!sceneIndexPath.IsEmpty()) {
-                return sceneIndexPath;
+            auto primSelections = pathInterface->ConvertUfeSelectionToHydra(appPath);
+            if (!primSelections.empty()) {
+                return primSelections;
             }
         }
     }
-    return SdfPath();
+    return PrimSelectionInfoVector();
 }
 
 }
diff --git a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
index d4b98b26cb..25b924bb6a 100644
--- a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
@@ -17,6 +17,7 @@
 
 #include "flowViewport/api.h"
 #include "flowViewport/sceneIndex/fvpPathInterface.h"
+#include "fvpPathInterface.h"
 
 #include <pxr/imaging/hd/mergingSceneIndex.h>
 
@@ -41,7 +42,7 @@ class MergingSceneIndex
     static MergingSceneIndexRefPtr New();
 
     FVP_API
-    PXR_NS::SdfPath SceneIndexPath(const Ufe::Path& appPath) const override;
+    PrimSelectionInfoVector ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const override;
 
 private:
     MergingSceneIndex();
diff --git a/lib/flowViewport/sceneIndex/fvpPathInterface.h b/lib/flowViewport/sceneIndex/fvpPathInterface.h
index 55d16c944e..0434b61115 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterface.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterface.h
@@ -19,6 +19,9 @@
 
 #include <ufe/ufe.h>
 
+#include <pxr/base/tf/smallVector.h>
+#include <pxr/usd/sdf/path.h>
+#include <pxr/imaging/hd/dataSource.h>
 #include <pxr/pxr.h>
 
 UFE_NS_DEF {
@@ -31,6 +34,15 @@ PXR_NAMESPACE_CLOSE_SCOPE
 
 namespace FVP_NS_DEF {
 
+struct PrimSelectionInfo
+{
+    PXR_NS::SdfPath primPath;
+    PXR_NS::HdVectorDataSourceHandle selectionsDataSource;
+};
+
+// TODO : Use TfSmallVector for perf?
+using PrimSelectionInfoVector = std::vector<PrimSelectionInfo>;
+
 /// \class PathInterface
 ///
 /// A pure interface class to allow for conversion between an application's
@@ -45,7 +57,8 @@ class PathInterface
     //! If no such path exists, an empty SdfPath should be returned.
     //! \return scene index path.
     FVP_API
-    virtual PXR_NS::SdfPath SceneIndexPath(const Ufe::Path& appPath) const = 0;
+    // TODO : Use TfSmallVector for perf?
+    virtual PrimSelectionInfoVector ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const = 0;
 
 protected:
 
diff --git a/lib/flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h b/lib/flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h
index 9ea5a62db2..0afc682480 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h
@@ -27,7 +27,7 @@ namespace FVP_NS_DEF {
 ///
 /// A simple pass-through filtering scene index that adds support for the path
 /// interface.  Derived classes need only implement the 
-/// PathInterface::SceneIndexPath() virtual.
+/// PathInterface::ConvertUfeSelectionToHydra() virtual.
 ///
 class PathInterfaceSceneIndexBase 
     : public PXR_NS::HdSingleInputFilteringSceneIndexBase
diff --git a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
index 5503d72a3a..854789cb2c 100644
--- a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
@@ -42,9 +42,11 @@
 
 #include "flowViewport/debugCodes.h"
 
+#include "fvpPathInterface.h"
 #include "pxr/imaging/hd/retainedDataSource.h"
 #include "pxr/imaging/hd/selectionSchema.h"
 #include "pxr/imaging/hd/selectionsSchema.h"
+#include <pxr/base/tf/smallVector.h>
 
 #include <ufe/pathString.h>
 #include <ufe/selection.h>
@@ -156,13 +158,17 @@ SelectionSceneIndex::AddSelection(const Ufe::Path& appPath)
 
     // Call our input scene index to convert the application path to a scene
     // index path.
-    auto sceneIndexPath = SceneIndexPath(appPath);
+    auto primSelections = ConvertUfeSelectionToHydra(appPath);
 
-    TF_DEBUG(FVP_SELECTION_SCENE_INDEX)
-        .Msg("    Adding %s to the Hydra selection.\n", sceneIndexPath.GetText());
+    for (const auto& primSelection : primSelections) {
+        TF_DEBUG(FVP_SELECTION_SCENE_INDEX)
+        .Msg("    Adding %s to the Hydra selection.\n", primSelection.primPath.GetText());
+    }
 
-    if (_selection->Add(sceneIndexPath)) {
-        _SendPrimsDirtied({{sceneIndexPath, selectionsSchemaDefaultLocator}});
+    for (const auto& primSelection : primSelections) {
+        if (_selection->Add(primSelection)) {
+            _SendPrimsDirtied({{primSelection.primPath, selectionsSchemaDefaultLocator}});
+        }
     }
 }
 
@@ -173,10 +179,12 @@ void SelectionSceneIndex::RemoveSelection(const Ufe::Path& appPath)
 
     // Call our input scene index to convert the application path to a scene
     // index path.
-    auto sceneIndexPath = SceneIndexPath(appPath);
+    auto primSelections = ConvertUfeSelectionToHydra(appPath);
 
-    if (_selection->Remove(sceneIndexPath)) {
-        _SendPrimsDirtied({{sceneIndexPath, selectionsSchemaDefaultLocator}});
+    for (const auto& primSelection : primSelections) {
+        if (_selection->Remove(primSelection.primPath)) {
+            _SendPrimsDirtied({{primSelection.primPath, selectionsSchemaDefaultLocator}});
+        }
     }
 }
 
@@ -219,21 +227,32 @@ void SelectionSceneIndex::ReplaceSelection(const Ufe::Selection& selection)
 
     _selection->Clear();
 
-    SdfPathVector sceneIndexSn;
-    sceneIndexSn.reserve(selection.size());
+    PrimSelectionInfoVector sceneIndexSn;
+    sceneIndexSn.reserve(selection.size());//TODO: sufficient/efficient? Ufe selection may not 1:1 map to a single SdfPath
     for (const auto& snItem : selection) {
         // Call our input scene index to convert the application path to a scene
         // index path.
-        auto sceneIndexPath = SceneIndexPath(snItem->path());
-
-        if (sceneIndexPath.IsEmpty()) {
+        // TODO : What if a single UFE path maps to multiple SdfPaths?
+        // TODO : Handle instances selection.
+        // Potential : make (and rename) SceneIndexPath to return a "PrimSelectionInfoVector"
+        // struct PrimSelectionInfo
+        // {
+        //     SdfPath primPath;
+        //     HdSelectionsSchema selections;
+        // };
+        // using PrimSelectionInfoVector = TfSmallVector<PrimSelectionInfo, 8>;
+        auto primSelections = ConvertUfeSelectionToHydra(snItem->path());
+
+        if (primSelections.empty()) {
             continue;
         }
 
-        sceneIndexSn.emplace_back(sceneIndexPath);
-        TF_DEBUG(FVP_SELECTION_SCENE_INDEX)
-            .Msg("    Adding %s to the Hydra selection.\n", sceneIndexPath.GetText());
-        entries.emplace_back(sceneIndexPath, selectionsSchemaDefaultLocator);
+        for (const auto& primSelection : primSelections) {
+            sceneIndexSn.emplace_back(primSelection);
+            TF_DEBUG(FVP_SELECTION_SCENE_INDEX)
+                .Msg("    Adding %s to the Hydra selection.\n", primSelection.primPath.GetText());
+            entries.emplace_back(primSelection.primPath, selectionsSchemaDefaultLocator);
+        }
     }
 
     _selection->Replace(sceneIndexSn);
@@ -250,15 +269,15 @@ bool SelectionSceneIndex::HasFullySelectedAncestorInclusive(const SdfPath& primP
     return _selection->HasFullySelectedAncestorInclusive(primPath);
 }
 
-SdfPath SelectionSceneIndex::SceneIndexPath(const Ufe::Path& appPath) const
+PrimSelectionInfoVector SelectionSceneIndex::ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const
 {
-    auto sceneIndexPath = _inputSceneIndexPathInterface->SceneIndexPath(appPath);
+    auto primSelections = _inputSceneIndexPathInterface->ConvertUfeSelectionToHydra(appPath);
 
-    if (sceneIndexPath.IsEmpty()) {
-        TF_WARN("SelectionSceneIndex::SceneIndexPath(%s) returned an empty path, Hydra selection will be incorrect", Ufe::PathString::string(appPath).c_str());
+    if (primSelections.empty()) {
+        TF_WARN("SelectionSceneIndex::ConvertUfeSelectionToHydra(%s) returned no selection, Hydra selection will be incorrect", Ufe::PathString::string(appPath).c_str());
     }
 
-    return sceneIndexPath;
+    return primSelections;
 }
 
 SdfPathVector SelectionSceneIndex::GetFullySelectedPaths() const
diff --git a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
index f9f806a444..6bc53a33db 100644
--- a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
@@ -42,6 +42,7 @@
 #include "flowViewport/selection/fvpSelectionFwd.h"
 #include "flowViewport/sceneIndex/fvpPathInterface.h"
 #include "flowViewport/sceneIndex/fvpSceneIndexUtils.h"
+#include "fvpPathInterface.h"
 
 #include <pxr/imaging/hd/filteringSceneIndex.h>
 
@@ -117,7 +118,7 @@ class SelectionSceneIndex final
     //! and warns about empty return paths.
     //@{
     FVP_API
-    PXR_NS::SdfPath SceneIndexPath(const Ufe::Path& appPath) const override;
+    PrimSelectionInfoVector ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const override;
     //@}
 
     FVP_API
diff --git a/lib/flowViewport/selection/fvpSelection.cpp b/lib/flowViewport/selection/fvpSelection.cpp
index 851ec064c9..30a16fba0d 100644
--- a/lib/flowViewport/selection/fvpSelection.cpp
+++ b/lib/flowViewport/selection/fvpSelection.cpp
@@ -37,7 +37,9 @@
 //
 
 #include "flowViewport/selection/fvpSelection.h"
+#include "flowViewport/sceneIndex/fvpPathInterface.h"
 
+#include "fvpSelection.h"
 #include "pxr/imaging/hd/selectionSchema.h"
 #include "pxr/imaging/hd/selectionsSchema.h"
 
@@ -75,13 +77,13 @@ Selection::_PrimSelectionState::GetVectorDataSource() const
 };
 
 bool
-Selection::Add(const PXR_NS::SdfPath& primPath)
+Selection::Add(const PrimSelectionInfo& primSelection)
 {
-    if (primPath.IsEmpty()) {
+    if (primSelection.primPath.IsEmpty()) {
         return false;
     }
 
-    _pathToState[primPath].selectionSources.push_back(selectionBuilder.Build());
+    _pathToState[primSelection.primPath] = primSelection.selectionsDataSource;
 
     return true;
 }
@@ -97,16 +99,15 @@ Selection::Clear()
     _pathToState.clear();
 }
 
-void Selection::Replace(const PXR_NS::SdfPathVector& selection)
+void Selection::Replace(const PrimSelectionInfoVector& primSelections)
 {
     Clear();
 
-    for (const auto& primPath : selection) {
-        if (primPath.IsEmpty()) {
+    for (const auto& primSelection : primSelections) {
+        if (primSelection.primPath.IsEmpty()) {
             continue;
         }
-        _pathToState[primPath].selectionSources.push_back(
-            selectionBuilder.Build());
+        _pathToState[primSelection.primPath] = primSelection.selectionsDataSource;
     }
 }
 
@@ -157,7 +158,7 @@ HdDataSourceBaseHandle Selection::GetVectorDataSource(
 {
     auto it = _pathToState.find(primPath);
     return (it != _pathToState.end()) ? 
-        it->second.GetVectorDataSource() : nullptr;
+        it->second : nullptr;
 }
 
 }
diff --git a/lib/flowViewport/selection/fvpSelection.h b/lib/flowViewport/selection/fvpSelection.h
index 697120f995..36aa198b12 100644
--- a/lib/flowViewport/selection/fvpSelection.h
+++ b/lib/flowViewport/selection/fvpSelection.h
@@ -19,6 +19,7 @@
 #include "flowViewport/api.h"
 #include "flowViewport/selection/fvpSelectionFwd.h"
 
+#include <pxr/imaging/hd/dataSource.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
 #include <pxr/usd/sdf/path.h>
 
@@ -26,6 +27,9 @@
 
 namespace FVP_NS_DEF {
 
+struct PrimSelectionInfo;
+using PrimSelectionInfoVector = std::vector<PrimSelectionInfo>;
+
 /// \class Selection
 ///
 /// Represents selection in the Flow Viewport.
@@ -44,7 +48,7 @@ class Selection
 
     // Add primPath to selection and return true if the argument is not empty.
     FVP_API
-    bool Add(const PXR_NS::SdfPath& primPath);
+    bool Add(const PrimSelectionInfo& primSelection);
 
     // Returns true if the removal was successful, false otherwise.
     FVP_API
@@ -53,7 +57,7 @@ class Selection
     // Replace the selection with the contents of the argument primPath vector.
     // Any empty primPath in the argument will be skipped.
     FVP_API
-    void Replace(const PXR_NS::SdfPathVector& selection);
+    void Replace(const PrimSelectionInfoVector& primSelections);
 
     // Remove all entries from the selection.
     FVP_API
@@ -94,7 +98,7 @@ class Selection
     
     // Maps prim path to data sources to be returned by the vector data
     // source at locator selections.
-    std::map<PXR_NS::SdfPath, _PrimSelectionState> _pathToState;
+    std::map<PXR_NS::SdfPath, PXR_NS::HdVectorDataSourceHandle> _pathToState;
 };
 
 }
diff --git a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
index 938dcabfcd..36df17fb82 100644
--- a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
+++ b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
@@ -83,7 +83,9 @@ MhLeadObjectPathTracker::MhLeadObjectPathTracker(const HdSceneIndexBaseRefPtr& s
         _leadObjectUfePath = leadObjectSceneItem->path();
         //_leadObjectPrimPath can be empty with a valid _leadObjectUfePath when the lead object is in a data producer scene index not yet added to the merging scene index
         //This is fixed at some point by calling updatePrimPath()
-        _leadObjectPrimPath = _pathInterface->SceneIndexPath(_leadObjectUfePath); 
+        // TODO : Handle multiple lead prim paths
+        auto hydraSelections = _pathInterface->ConvertUfeSelectionToHydra(_leadObjectUfePath);
+        _leadObjectPrimPath = hydraSelections.empty() ? SdfPath() : hydraSelections.front().primPath;
     }
 
    // Add ourself as an observer to the selection
@@ -114,7 +116,8 @@ void MhLeadObjectPathTracker::setLeadObjectUfePath(const Ufe::Path& newLeadObjec
     auto oldLeadObjectPrimPath = _leadObjectPrimPath;
 
     _leadObjectUfePath  = newLeadObjectUfePath;
-    _leadObjectPrimPath = _pathInterface->SceneIndexPath(_leadObjectUfePath);
+    auto hydraSelections = _pathInterface->ConvertUfeSelectionToHydra(_leadObjectUfePath);
+    _leadObjectPrimPath = hydraSelections.empty() ? SdfPath() : hydraSelections.front().primPath;
 
     // Dirty the previous lead object
     if(_dirtyLeadObjectSceneIndex){
@@ -126,7 +129,8 @@ void MhLeadObjectPathTracker::updatePrimPath()
 { 
    // Update the lead object prim path in case it was not valid yet
     if ( (_leadObjectUfePath.size() > 0) && _leadObjectPrimPath.IsEmpty()) {
-        _leadObjectPrimPath = _pathInterface->SceneIndexPath(_leadObjectUfePath);
+        auto hydraSelections = _pathInterface->ConvertUfeSelectionToHydra(_leadObjectUfePath);
+        _leadObjectPrimPath = hydraSelections.empty() ? SdfPath() : hydraSelections.front().primPath;
     }
 }
 
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
index 8e7d7e88db..06e4ecc0b8 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
@@ -48,6 +48,9 @@
 #include <pxr/imaging/hd/meshSchema.h>
 #include <pxr/imaging/hd/primvarSchema.h>
 #include <pxr/imaging/hd/primvarsSchema.h>
+#include <pxr/imaging/hd/instanceIndicesSchema.h>
+#include <pxr/imaging/hd/selectionSchema.h>
+#include <pxr/imaging/hd/selectionsSchema.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
 #include "pxr/imaging/hd/dirtyBitsTranslator.h"
 #include <pxr/imaging/hd/rprim.h>
@@ -645,10 +648,10 @@ VtValue MayaHydraSceneIndex::CreateMayaDefaultMaterial()
     return VtValue(networkMap);
 }
 
-SdfPath MayaHydraSceneIndex::SceneIndexPath(const Ufe::Path& appPath) const
+Fvp::PrimSelectionInfoVector MayaHydraSceneIndex::ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const
 {
     TF_DEBUG(MAYAHYDRALIB_SCENE_INDEX)
-        .Msg("MayaHydraSceneIndex::SceneIndexPath(const Ufe::Path& %s) called.\n", Ufe::PathString::string(appPath).c_str());
+        .Msg("MayaHydraSceneIndex::ConvertUfeSelectionToHydra(const Ufe::Path& %s) called.\n", Ufe::PathString::string(appPath).c_str());
 
     // We only handle Maya objects, so if the UFE path is not a Maya object,
     // early out with failure.
@@ -659,7 +662,12 @@ SdfPath MayaHydraSceneIndex::SceneIndexPath(const Ufe::Path& appPath) const
     // Not the best implementation performance-wise, as ufeToDagPath converts
     // the UFE path to a string, then does a Dag path lookup with the string.
     constexpr bool isSprim = false; // Can't handle sprims as of 15-Aug-2023.
-    return GetPrimPath(UfeExtensions::ufeToDagPath(appPath), isSprim);
+    SdfPath primPath = GetPrimPath(UfeExtensions::ufeToDagPath(appPath), isSprim);
+    HdSelectionSchema::Builder selectionBuilder;
+    selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
+    auto selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
+    Fvp::PrimSelectionInfo primSelection {primPath, HdRetainedSmallVectorDataSource::New(1, &selectionDataSource)};
+    return Fvp::PrimSelectionInfoVector({primSelection});
 }
 
 SdfPath MayaHydraSceneIndex::SetCameraViewport(const MDagPath& camPath, const GfVec4d& viewport)
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h
index c0af98cfee..c70626f84f 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h
@@ -202,7 +202,7 @@ class MAYAHYDRALIB_API MayaHydraSceneIndex : public HdRetainedSceneIndex, public
 
     void SetDefaultMaterial(bool useDefMaterial);
 
-    SdfPath SceneIndexPath(const Ufe::Path& appPath) const override;
+    Fvp::PrimSelectionInfoVector ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const override;
 
     // Common function to return templated sample types
     template <typename T, typename Getter>
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
index 1c5ed0c0fd..429801a7a6 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
@@ -17,6 +17,7 @@
 #include "mayaHydraLib/hydraUtils.h"
 #include "mayaHydraLib/sceneIndex/registration.h"
 #include "mayaHydraLib/sceneIndex/mhMayaUsdProxyShapeSceneIndex.h"
+#include <pxr/imaging/hd/dataSource.h>
 
 #include <flowViewport/sceneIndex/fvpRenderIndexProxy.h>
 #include <flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h>
@@ -25,6 +26,9 @@
 #include <flowViewport/fvpUtils.h>
 #endif
 
+#include <pxr/imaging/hd/instanceIndicesSchema.h>
+#include <pxr/imaging/hd/selectionSchema.h>
+#include <pxr/imaging/hd/selectionsSchema.h>
 #include <pxr/imaging/hd/dataSourceTypeDefs.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
 #include <pxr/imaging/hd/sceneIndexPlugin.h>
@@ -104,7 +108,7 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
             inputSceneIndex, sceneIndexPathPrefix, sceneIndexAppPath));
     }
 
-    SdfPath SceneIndexPath(const Ufe::Path& appPath) const override
+    Fvp::PrimSelectionInfoVector ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const override
     {
         // We only handle USD objects, so if the UFE path is not a USD object,
         // early out with failure.
@@ -122,14 +126,38 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
         // 1) The scene index path prefix, which is fixed on construction.
         // 2) The second segment of the UFE path, with each UFE path component
         //    becoming an SdfPath component.
-        SdfPath sceneIndexPath = _sceneIndexPathPrefix;
+        SdfPath primPath = _sceneIndexPathPrefix;
         TF_AXIOM(appPath.nbSegments() == 2);
         const auto& secondSegment = appPath.getSegments()[1];
         for (const auto& pathComponent : secondSegment) {
-            sceneIndexPath = sceneIndexPath.AppendChild(
-                TfToken(pathComponent.string()));
+            if (pathComponent.string().find_first_not_of("0123456789") == std::string::npos) {
+                continue;
+            }
+            primPath = primPath.AppendChild(TfToken(pathComponent.string()));
+        }
+        const auto lastComponentString = secondSegment.components().back().string();
+        bool lastComponentIsNumeric = lastComponentString.find_first_not_of("0123456789") == std::string::npos;
+        HdVectorDataSourceHandle selectionsDataSource;
+        if (lastComponentIsNumeric) {
+            HdInstanceIndicesSchema::Builder instanceIndicesBuilder;
+            instanceIndicesBuilder.SetInstancer(HdRetainedTypedSampledDataSource<SdfPath>::New(primPath));
+            instanceIndicesBuilder.SetInstanceIndices(HdRetainedTypedSampledDataSource<VtArray<int>>::New({std::stoi(lastComponentString)}));
+            //instanceIndicesBuilder.SetPrototypeIndex(HdRetainedTypedSampledDataSource<int>::New(0));
+            HdSelectionSchema::Builder selectionBuilder;
+            selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
+            auto instanceIndicesDataSource = HdDataSourceBase::Cast(instanceIndicesBuilder.Build());
+            selectionBuilder.SetNestedInstanceIndices(HdRetainedSmallVectorDataSource::New(1, &instanceIndicesDataSource));
+            auto selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
+            selectionsDataSource = HdRetainedSmallVectorDataSource::New(1, &selectionDataSource);
+        }
+        else {
+            HdSelectionSchema::Builder selectionBuilder;
+            selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
+            auto selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
+            selectionsDataSource = HdRetainedSmallVectorDataSource::New(1, &selectionDataSource);
         }
-        return sceneIndexPath;
+        Fvp::PrimSelectionInfo primSelection {primPath, selectionsDataSource};
+        return Fvp::PrimSelectionInfoVector({primSelection});
     }
 
     const Ufe::Path& GetSceneIndexAppPath() const { return _sceneIndexAppPath; }
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
index 99ce31aa27..91e260a807 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
@@ -39,7 +39,8 @@ TEST(TestHydraPrim, fromAppPath)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto sceneIndexPath = snSi->SceneIndexPath(appPath);
+    const auto primSelections = snSi->ConvertUfeSelectionToHydra(appPath);
 
-    ASSERT_FALSE(sceneIndexPath.IsEmpty());
+    ASSERT_EQ(primSelections.size(), 1u);
+    ASSERT_FALSE(primSelections.front().primPath.IsEmpty());
 }
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
index 1278463104..51bcc4bdf8 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
@@ -69,11 +69,11 @@ TEST(FlowViewport, mergingSceneIndex)
 
     // The Maya data producer scene index supports the path interface.  Ask it
     // to translate the application path into a scene index path.
-    auto sceneIndexPath = mayaSi->SceneIndexPath(mayaPath);
+    auto primSelections = mayaSi->ConvertUfeSelectionToHydra(mayaPath);
 
     // Regardless of prefix, the scene index path tail component will match the
     // Maya node name
-    ASSERT_EQ(sceneIndexPath.GetName(), mayaPath.back().string());
+    ASSERT_EQ(primSelections.front().primPath.GetName(), mayaPath.back().string());
 
     // If we ask the terminal scene index for a prim at that path, there must be
     // one.  Prims that exist have a non-null data source.
@@ -81,12 +81,12 @@ TEST(FlowViewport, mergingSceneIndex)
     auto nonExistentPrim = sceneIndices.front()->GetPrim(nonExistentPrimPath);
     ASSERT_FALSE(nonExistentPrim.dataSource);
     
-    auto spherePrim = sceneIndices.front()->GetPrim(sceneIndexPath);
+    auto spherePrim = sceneIndices.front()->GetPrim(primSelections.front().primPath);
     ASSERT_TRUE(spherePrim.dataSource);
 
     // Flow Viewport merging scene index must give the same scene index path
     // answer as the Maya data producer scene index.
-    ASSERT_EQ(mergingSi->SceneIndexPath(mayaPath), sceneIndexPath);
+    ASSERT_EQ(mergingSi->ConvertUfeSelectionToHydra(mayaPath).front().primPath, primSelections.front().primPath);
 }
 
 TEST(FlowViewport, mergingSceneIndexAddRemove)
@@ -105,13 +105,13 @@ TEST(FlowViewport, mergingSceneIndexAddRemove)
         producers.begin(), producers.end(), isMayaProducerSceneIndex);
     auto mayaSi = TfDynamic_cast<PXR_NS::MayaHydraSceneIndexRefPtr>(*found);
     auto mayaPath = Ufe::PathString::path("|aSphere");
-    auto sceneIndexPath = mayaSi->SceneIndexPath(mayaPath);
+    auto primSelections = mayaSi->ConvertUfeSelectionToHydra(mayaPath);
 
     // With Maya scene index in the merging scene index, the sphere prim has
     // a valid scene index path.
-    auto spherePrim = sceneIndices.front()->GetPrim(sceneIndexPath);
+    auto spherePrim = sceneIndices.front()->GetPrim(primSelections.front().primPath);
     ASSERT_TRUE(spherePrim.dataSource);
-    spherePrim = mergingSi->GetPrim(sceneIndexPath);
+    spherePrim = mergingSi->GetPrim(primSelections.front().primPath);
     ASSERT_TRUE(spherePrim.dataSource);
 
     // Remove the Maya scene index from the Flow Viewport merging scene index.
@@ -121,9 +121,9 @@ TEST(FlowViewport, mergingSceneIndexAddRemove)
 
     // Without the Maya scene index in the merging scene index, the sphere prim
     // is no longer in the Hydra scene index scene.
-    spherePrim = sceneIndices.front()->GetPrim(sceneIndexPath);
+    spherePrim = sceneIndices.front()->GetPrim(primSelections.front().primPath);
     ASSERT_FALSE(spherePrim.dataSource);
-    spherePrim = mergingSi->GetPrim(sceneIndexPath);
+    spherePrim = mergingSi->GetPrim(primSelections.front().primPath);
     ASSERT_FALSE(spherePrim.dataSource);
 
     // Add the Maya scene index back to the Flow Viewport merging scene index,
@@ -131,8 +131,8 @@ TEST(FlowViewport, mergingSceneIndexAddRemove)
     // with the absolute root path as scene root, so duplicate that here.
     mergingSi->AddInputScene(mayaSi, SdfPath::AbsoluteRootPath());
     ASSERT_EQ(mergingSi->GetInputScenes().size(), 1u);
-    spherePrim = sceneIndices.front()->GetPrim(sceneIndexPath);
+    spherePrim = sceneIndices.front()->GetPrim(primSelections.front().primPath);
     ASSERT_TRUE(spherePrim.dataSource);
-    spherePrim = mergingSi->GetPrim(sceneIndexPath);
+    spherePrim = mergingSi->GetPrim(primSelections.front().primPath);
     ASSERT_TRUE(spherePrim.dataSource);
 }
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
index cfefc90600..e95c9d4250 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
@@ -38,7 +38,7 @@ SdfPath getArgSceneIndexPath(const Fvp::SelectionSceneIndexRefPtr& snSi)
     const auto mayaPath = Ufe::PathString::path(argv[0]);
 
     // Translate the application path into a scene index path.
-    return snSi->SceneIndexPath(mayaPath);
+    return snSi->ConvertUfeSelectionToHydra(mayaPath).front().primPath;
 }
 
 Fvp::SelectionSceneIndexRefPtr getSelectionSceneIndex()
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
index e3836d232b..21864ddb44 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
@@ -61,7 +61,7 @@ TEST(FlowViewport, selectionSceneIndex)
 
     // The sphere prim in the Hydra scene index scene has no selection data
     // source.  First, translate the application path into a scene index path.
-    const auto sceneIndexPath = selectionSi->SceneIndexPath(mayaPath);
+    const auto sceneIndexPath = selectionSi->ConvertUfeSelectionToHydra(mayaPath).front().primPath;
     ASSERT_EQ(sceneIndexPath.GetName(), mayaPath.back().string());
 
     // Next, check that there is no selections data source on the prim.
@@ -104,7 +104,7 @@ TEST(FlowViewport, selectionSceneIndex)
     // The shape under the sphere transform is not selected, but it has a
     // selected ancestor.
     auto mayaShapePath = Ufe::PathString::path("|aSphere|aSphereShape");
-    const auto sceneIndexShapePath = selectionSi->SceneIndexPath(mayaShapePath);
+    const auto sceneIndexShapePath = selectionSi->ConvertUfeSelectionToHydra(mayaShapePath).front().primPath;
 
     auto sphereShapePrim = sceneIndices.front()->GetPrim(sceneIndexShapePath);
     ASSERT_TRUE(sphereShapePrim.dataSource);
@@ -153,7 +153,7 @@ TEST(FlowViewport, selectionSceneIndexDirty)
     MSelectionList sphereSn;
     sphereSn.add("|aSphere");
     const auto mayaPath = Ufe::PathString::path("|aSphere");
-    const auto sceneIndexPath = selectionSi->SceneIndexPath(mayaPath);
+    const auto sceneIndexPath = selectionSi->ConvertUfeSelectionToHydra(mayaPath).front().primPath;
 
     MGlobal::setActiveSelectionList(sphereSn);
     hdSn = ssio.GetSelection();
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
index c1fcda3164..2476c8597a 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
@@ -27,7 +27,7 @@ TEST(TestUsdAnim, timeVaryingTransform)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto cubeSiPath = snSi->SceneIndexPath(cubePath);
+    const auto cubeSiPath = snSi->ConvertUfeSelectionToHydra(cubePath).front().primPath;
 
     ASSERT_FALSE(cubeSiPath.IsEmpty());
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
index 95b5afe00e..d22a04c7d4 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
@@ -53,7 +53,7 @@ TEST(TestUsdPicking, pick)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto sceneIndexPath = snSi->SceneIndexPath(selected);
+    const auto sceneIndexPath = snSi->ConvertUfeSelectionToHydra(selected).front().primPath;
 
     ASSERT_FALSE(sceneIndexPath.IsEmpty());
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
index a153d20476..ed05706362 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
@@ -51,7 +51,7 @@ TEST(TestUsdPointInstancePicking, pickPointInstance)
     const auto selectionSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(selectionSi);
 
-    const auto sceneIndexPath = selectionSi->SceneIndexPath(marker);
+    const auto sceneIndexPath = selectionSi->ConvertUfeSelectionToHydra(marker).front().primPath;
 
     ASSERT_FALSE(sceneIndexPath.IsEmpty());
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
index f29f4a98d8..b0c4ebdd0e 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
@@ -161,8 +161,8 @@ TEST(FlowViewport, wireframeSelectionHighlightSceneIndexDirty)
     sn->append(sphereItem);
 
     // Find the sphere in the Hydra scene index scene.
-    auto sphereSiPath = mergingSi->SceneIndexPath(spherePath);
-    auto cubeSiPath = mergingSi->SceneIndexPath(scParentPath + "cube");
+    auto sphereSiPath = mergingSi->ConvertUfeSelectionToHydra(spherePath).front().primPath;
+    auto cubeSiPath = mergingSi->ConvertUfeSelectionToHydra(scParentPath + "cube").front().primPath;
 
     // Sphere is selected.
     hdSn = ssio.GetSelection();
@@ -191,9 +191,9 @@ TEST(FlowViewport, wireframeSelectionHighlightSceneIndexDirty)
 
     sn->replaceWith(newSn);
 
-    auto ccSiPath = mergingSi->SceneIndexPath(ccParentPath);
-    auto coneSiPath = mergingSi->SceneIndexPath(ccParentPath + "cone");
-    auto cylinderSiPath = mergingSi->SceneIndexPath(ccParentPath + "cylinder");
+    auto ccSiPath = mergingSi->ConvertUfeSelectionToHydra(ccParentPath).front().primPath;
+    auto coneSiPath = mergingSi->ConvertUfeSelectionToHydra(ccParentPath + "cone").front().primPath;
+    auto cylinderSiPath = mergingSi->ConvertUfeSelectionToHydra(ccParentPath + "cylinder").front().primPath;
 
     // Cone and cylinder parent is selected.
     // Cone is not selected.

From f014fd6b59b2d01e79f5806869add58e6575e596 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 23 May 2024 14:57:09 -0400
Subject: [PATCH 004/112] Use _CreateShMirrors in ctor

---
 .../fvpWireframeSelectionHighlightSceneIndex.cpp       | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 44f5ad022c..14fc52d111 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -698,8 +698,7 @@ WireframeSelectionHighlightSceneIndex(
 
         HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPrimPath);
         if (_IsInstancerWithSelections(currPrim)) {
-            HdSceneIndexObserver::AddedPrimEntries newPrims;
-            _CreateSelectionHighlightMirror(currPrimPath, newPrims);
+            _CreateShMirrorsForInstancer(currPrimPath);
         }
 
         for (const auto& childPath : inputSceneIndex->GetChildPrimPaths(currPrimPath)) {
@@ -896,6 +895,13 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         // }
         return prim;
     }
+    // TODO: 
+    //else {
+        // do as before with isancestorselected
+    //}
+
+
+    
     // for (const auto& shSceneIndex : _shSceneIndices) {
     //     if (primPath.HasPrefix(shSceneIndex.first)) {
     //         //HdSceneIndexPrim prim = shSceneIndex.second->GetPrim(primPath);

From 2409262ce82e2c4a7e82bd76f57066a841a3d35f Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 23 May 2024 16:15:30 -0400
Subject: [PATCH 005/112] Individual instance highlighting

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 55 +++++++++++++------
 1 file changed, 38 insertions(+), 17 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 14fc52d111..47267d56a0 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -120,20 +120,37 @@ SdfPath _GetOriginalPathFromSelectionHighlightMirror(const SdfPath& mirrorPath)
     return mirrorPath.GetParentPath().AppendElementString(mirrorPath.GetElementString().substr(0, mirrorPath.GetElementString().size() - shMirrorTag.size()));
 }
 
-VtBoolArray _GetSelectionHighlightMask(const VtBoolArray& originalMask, const HdSelectionsSchema& selections) 
+VtBoolArray _GetSelectionHighlightMask(const HdInstancerTopologySchema& originalInstancerTopology, const HdSelectionsSchema& selections) 
 {
-    VtBoolArray selectionHighlightMask(originalMask.size(), false);
+    if (!selections.IsDefined()) {
+        return originalInstancerTopology.GetMask()->GetTypedValue(0);
+    }
+    size_t nbInstances = 0;
+    auto instanceIndices = originalInstancerTopology.GetInstanceIndices();
+    for (size_t iInstanceIndex = 0; iInstanceIndex < instanceIndices.GetNumElements(); iInstanceIndex++) {
+        auto protoInstances = instanceIndices.GetElement(iInstanceIndex)->GetTypedValue(0);
+        nbInstances += protoInstances.size();
+    }
+    VtBoolArray originalMask = originalInstancerTopology.GetMask()->GetTypedValue(0);
+    TF_AXIOM(originalMask.empty() || originalMask.size() == nbInstances);
+    VtBoolArray selectionHighlightMask(nbInstances, false);
 
     for (size_t iSelection = 0; iSelection < selections.GetNumElements(); iSelection++) {
         HdSelectionSchema selection = selections.GetElement(iSelection);
+        // See something.cpp for comment mentioning that currently only fully selected is supported.
         if (!selection.GetFullySelected() || !selection.GetFullySelected()->GetTypedValue(0)) {
             continue;
         }
+        if (!selection.GetNestedInstanceIndices()) {
+            // We have a selection that has no instances, which means the whole instancer is selected :
+            // this overrides any individual instance selection.
+            return originalInstancerTopology.GetMask()->GetTypedValue(0);
+        }
         HdInstanceIndicesVectorSchema nestedInstanceIndices = selection.GetNestedInstanceIndices();
         for (size_t iInstanceIndices = 0; iInstanceIndices < nestedInstanceIndices.GetNumElements(); iInstanceIndices++) {
             HdInstanceIndicesSchema instanceIndices = nestedInstanceIndices.GetElement(0);
             for (const auto& instanceIndex : instanceIndices.GetInstanceIndices()->GetTypedValue(0)) {
-                selectionHighlightMask[instanceIndex] = originalMask[instanceIndex];
+                selectionHighlightMask[instanceIndex] = originalMask.empty() ? true : originalMask[instanceIndex];
             }
         }
     }
@@ -153,23 +170,24 @@ HdContainerDataSourceHandle _GetSelectionHighlightInstancerDataSource(const HdCo
 
     HdContainerDataSourceEditor editedDataSource = HdContainerDataSourceEditor(originalDataSource);
 
+    if (selections.IsDefined()) {
+        HdDataSourceLocator maskLocator(TfToken("instancerTopology"), TfToken("mask"));
+        VtBoolArray selectionHighlightMask = _GetSelectionHighlightMask(instancerTopology, selections);
+        auto selectionHighlightMaskDataSource = HdRetainedTypedSampledDataSource<VtBoolArray>::New(selectionHighlightMask);
+        editedDataSource.Set(maskLocator, selectionHighlightMaskDataSource);
+    }
 
-    HdDataSourceLocator maskLocator(TfToken("instancerTopology"), TfToken("mask"));
-    VtBoolArray originalMask = instancerTopology.GetMask()->GetTypedValue(0);
-    //VtBoolArray selectionHighlightMask = _GetSelectionHighlightMask(originalMask, selections);
-    VtBoolArray selectionHighlightMask = {true, false};
-    auto selectionHighlightMaskDataSource = HdRetainedTypedSampledDataSource<VtBoolArray>::New(selectionHighlightMask);
-    editedDataSource.Set(maskLocator, selectionHighlightMaskDataSource);
+    // HdDataSourceLocator prototypesLocator(TfToken("instancerTopology"), TfToken("prototypes"));
+    // VtArray<SdfPath> originalPrototypes = instancerTopology.GetPrototypes()->GetTypedValue(0);
+    // VtArray<SdfPath> selectionHighlightPrototypes = originalPrototypes;
+    // for (auto& shProtoPath : selectionHighlightPrototypes) {
+    //     shProtoPath = _GetSelectionHighlightMirrorPathFromOriginal(shProtoPath);
+    // }
+    // editedDataSource.Set(prototypesLocator, HdRetainedTypedSampledDataSource<VtArray<SdfPath>>::New(selectionHighlightPrototypes));
 
-    HdDataSourceLocator prototypesLocator(TfToken("instancerTopology"), TfToken("prototypes"));
-    VtArray<SdfPath> originalPrototypes = instancerTopology.GetPrototypes()->GetTypedValue(0);
-    VtArray<SdfPath> selectionHighlightPrototypes = originalPrototypes;
-    for (auto& shProtoPath : selectionHighlightPrototypes) {
-        shProtoPath = _GetSelectionHighlightMirrorPathFromOriginal(shProtoPath);
-    }
-    editedDataSource.Set(prototypesLocator, HdRetainedTypedSampledDataSource<VtArray<SdfPath>>::New(selectionHighlightPrototypes));
+    editedDataSource.Set(HdSelectionsSchema::GetDefaultLocator(), HdBlockDataSource::New());
 
-    return SelectionHighlightDataSource::New(editedDataSource.Finish());
+    return editedDataSource.Finish();
 }
 
 
@@ -873,6 +891,9 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         if (prim.primType == HdPrimTypeTokens->mesh) {
             prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath.ReplacePrefix(shMirrorAncestor, _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestor)));
         }
+        if (prim.primType == HdPrimTypeTokens->instancer) {
+            prim.dataSource = _GetSelectionHighlightInstancerDataSource(prim.dataSource);
+        }
         // if (prim.primType == HdPrimTypeTokens->instancer) {
         //     HdSelectionsSchema selections = HdSelectionsSchema::GetFromParent(prim.dataSource);
         //     if (selections.IsDefined()) {

From 064830083aa43c0ba1ecb3b0256183c596c2a6d0 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 23 May 2024 16:15:48 -0400
Subject: [PATCH 006/112] Propagate dirtying from original prims to selection
 highlight mirrors

---
 .../fvpWireframeSelectionHighlightSceneIndex.cpp         | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 47267d56a0..2aac3e7514 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -1162,6 +1162,15 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
         }
     }
 
+    HdSceneIndexObserver::DirtiedPrimEntries dirtiedShMirrors;
+    for (const auto& entry : entries) {
+        auto shMirrorPath = _RepathToSelectionHighlightMirror(entry.primPath);
+        if (!shMirrorPath.IsEmpty()) {
+            dirtiedShMirrors.emplace_back(shMirrorPath, entry.dirtyLocators);
+        }
+    }
+    _SendPrimsDirtied(dirtiedShMirrors);
+
     HdSceneIndexObserver::AddedPrimEntries newSelectionHighlightPrims;
     HdSceneIndexObserver::RemovedPrimEntries removedSelectionHighlightPrims;
     for (const auto& entry : entries) {

From cff4d308dffe9262ae99e1388b960a76fda3814f Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 23 May 2024 23:54:41 -0400
Subject: [PATCH 007/112] Allow multiple selections per prim across multiple
 conversions

---
 lib/flowViewport/sceneIndex/fvpPathInterface.h         |  2 +-
 lib/flowViewport/selection/fvpSelection.cpp            |  6 +++---
 lib/flowViewport/selection/fvpSelection.h              |  2 +-
 .../hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp |  2 +-
 .../hydraExtensions/sceneIndex/registration.cpp        | 10 ++++------
 5 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpPathInterface.h b/lib/flowViewport/sceneIndex/fvpPathInterface.h
index 0434b61115..cdea9250b2 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterface.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterface.h
@@ -37,7 +37,7 @@ namespace FVP_NS_DEF {
 struct PrimSelectionInfo
 {
     PXR_NS::SdfPath primPath;
-    PXR_NS::HdVectorDataSourceHandle selectionsDataSource;
+    PXR_NS::HdDataSourceBaseHandle selectionDataSource;
 };
 
 // TODO : Use TfSmallVector for perf?
diff --git a/lib/flowViewport/selection/fvpSelection.cpp b/lib/flowViewport/selection/fvpSelection.cpp
index 30a16fba0d..098cba80f3 100644
--- a/lib/flowViewport/selection/fvpSelection.cpp
+++ b/lib/flowViewport/selection/fvpSelection.cpp
@@ -83,7 +83,7 @@ Selection::Add(const PrimSelectionInfo& primSelection)
         return false;
     }
 
-    _pathToState[primSelection.primPath] = primSelection.selectionsDataSource;
+    _pathToState[primSelection.primPath].selectionSources.push_back(primSelection.selectionDataSource);
 
     return true;
 }
@@ -107,7 +107,7 @@ void Selection::Replace(const PrimSelectionInfoVector& primSelections)
         if (primSelection.primPath.IsEmpty()) {
             continue;
         }
-        _pathToState[primSelection.primPath] = primSelection.selectionsDataSource;
+        _pathToState[primSelection.primPath].selectionSources.push_back(primSelection.selectionDataSource);
     }
 }
 
@@ -158,7 +158,7 @@ HdDataSourceBaseHandle Selection::GetVectorDataSource(
 {
     auto it = _pathToState.find(primPath);
     return (it != _pathToState.end()) ? 
-        it->second : nullptr;
+        it->second.GetVectorDataSource() : nullptr;
 }
 
 }
diff --git a/lib/flowViewport/selection/fvpSelection.h b/lib/flowViewport/selection/fvpSelection.h
index 36aa198b12..4e5ffdebd1 100644
--- a/lib/flowViewport/selection/fvpSelection.h
+++ b/lib/flowViewport/selection/fvpSelection.h
@@ -98,7 +98,7 @@ class Selection
     
     // Maps prim path to data sources to be returned by the vector data
     // source at locator selections.
-    std::map<PXR_NS::SdfPath, PXR_NS::HdVectorDataSourceHandle> _pathToState;
+    std::map<PXR_NS::SdfPath, _PrimSelectionState> _pathToState;
 };
 
 }
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
index 06e4ecc0b8..3840611484 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
@@ -666,7 +666,7 @@ Fvp::PrimSelectionInfoVector MayaHydraSceneIndex::ConvertUfeSelectionToHydra(con
     HdSelectionSchema::Builder selectionBuilder;
     selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
     auto selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
-    Fvp::PrimSelectionInfo primSelection {primPath, HdRetainedSmallVectorDataSource::New(1, &selectionDataSource)};
+    Fvp::PrimSelectionInfo primSelection {primPath, selectionDataSource};
     return Fvp::PrimSelectionInfoVector({primSelection});
 }
 
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
index 429801a7a6..e98d53ec72 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
@@ -137,7 +137,7 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
         }
         const auto lastComponentString = secondSegment.components().back().string();
         bool lastComponentIsNumeric = lastComponentString.find_first_not_of("0123456789") == std::string::npos;
-        HdVectorDataSourceHandle selectionsDataSource;
+        HdDataSourceBaseHandle selectionDataSource;
         if (lastComponentIsNumeric) {
             HdInstanceIndicesSchema::Builder instanceIndicesBuilder;
             instanceIndicesBuilder.SetInstancer(HdRetainedTypedSampledDataSource<SdfPath>::New(primPath));
@@ -147,16 +147,14 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
             selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
             auto instanceIndicesDataSource = HdDataSourceBase::Cast(instanceIndicesBuilder.Build());
             selectionBuilder.SetNestedInstanceIndices(HdRetainedSmallVectorDataSource::New(1, &instanceIndicesDataSource));
-            auto selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
-            selectionsDataSource = HdRetainedSmallVectorDataSource::New(1, &selectionDataSource);
+            selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
         }
         else {
             HdSelectionSchema::Builder selectionBuilder;
             selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
-            auto selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
-            selectionsDataSource = HdRetainedSmallVectorDataSource::New(1, &selectionDataSource);
+            selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
         }
-        Fvp::PrimSelectionInfo primSelection {primPath, selectionsDataSource};
+        Fvp::PrimSelectionInfo primSelection {primPath, selectionDataSource};
         return Fvp::PrimSelectionInfoVector({primSelection});
     }
 

From 45fa2ea61a5761f2f435adeb673da17f50a8b698 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 27 May 2024 11:22:20 -0400
Subject: [PATCH 008/112] Base prototype selection highlight support

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 105 +++++++++++++++++-
 ...fvpWireframeSelectionHighlightSceneIndex.h |   6 +-
 2 files changed, 107 insertions(+), 4 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 2aac3e7514..32a4499528 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -33,6 +33,7 @@
 #include <pxr/imaging/hd/legacyDisplayStyleSchema.h>
 #include <pxr/imaging/hd/overlayContainerDataSource.h>
 #include <pxr/imaging/hd/containerDataSourceEditor.h>
+#include <pxr/imaging/hd/primOriginSchema.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
 #include <pxr/imaging/hd/sceneIndex.h>
 #include <pxr/imaging/hd/sceneIndexObserver.h>
@@ -44,6 +45,7 @@
 #include <pxr/imaging/hd/xformSchema.h>
 #include <pxr/usd/sdf/path.h>
 #include <pxr/usdImaging/usdImaging/rerootingSceneIndex.h>
+#include <pxr/usdImaging/usdImaging/usdPrimInfoSchema.h>
 #include <algorithm>
 #include <numeric>
 #include <stack>
@@ -523,7 +525,7 @@ WireframeSelectionHighlightSceneIndex::_IsPrototypeRoot(const SdfPath& primPath)
 }
 
 bool
-WireframeSelectionHighlightSceneIndex::_IsInstancingRoot(const SdfPath& primPath)
+WireframeSelectionHighlightSceneIndex::_IsInstancingRoot(const SdfPath& primPath) const
 {
     HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
@@ -543,13 +545,21 @@ WireframeSelectionHighlightSceneIndex::_IsInstancingRoot(const SdfPath& primPath
 }
 
 bool
-WireframeSelectionHighlightSceneIndex::_IsPropagatedPrototype(const SdfPath& primPath)
+WireframeSelectionHighlightSceneIndex::_IsPropagatedPrototype(const SdfPath& primPath) const
 {
     HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
     return instancedBy.IsDefined() && instancedBy.GetPrototypeRoots() && !instancedBy.GetPrototypeRoots()->GetTypedValue(0).empty();
 }
 
+bool
+WireframeSelectionHighlightSceneIndex::_IsPrototype(const SdfPath& primPath) const
+{
+    HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+    return instancedBy.IsDefined();
+}
+
 void
 WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightMirror(const SdfPath& originalPrimPath, HdSceneIndexObserver::AddedPrimEntries& createdPrims)
 {
@@ -769,6 +779,7 @@ WireframeSelectionHighlightSceneIndex::_CollectShMirrorPaths(const PXR_NS::SdfPa
         SdfPath currPath = pathsToTraverse.top();
         pathsToTraverse.pop();
 
+        // TODO : Propagated protos only or all protos?
         if (_IsPropagatedPrototype(currPath) && _IsInstancingRoot(currPath) && currPath != originalPrimPath) {
             continue;
         }
@@ -862,6 +873,9 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
     TF_DEBUG(FVP_WIREFRAME_SELECTION_HIGHLIGHT_SCENE_INDEX)
         .Msg("WireframeSelectionHighlightSceneIndex::GetPrim(%s) called.\n", primPath.GetText());
 
+    if (_IsExcluded(primPath)) {
+        return GetInputSceneIndex()->GetPrim(primPath);
+    }
     // if (_IsSelectionHighlightMirrorPath(primPath)) {
     //     HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(_GetOriginalPathFromSelectionHighlightMirror(primPath));
     //     return {prim.primType, {}};
@@ -881,6 +895,9 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
     static std::mutex printMutex;
     std::lock_guard printLock(printMutex);
     SdfPath shMirrorAncestor = _FindSelectionHighlightMirrorAncestor(primPath);
+    if (primPath.GetElementString() == "Pyramid") {
+        std::cout << "Pyramid" << std::endl;
+    }
     //std::cout << "For " << primPath.GetString() << " , SH is : " << shMirrorAncestor.GetString() << std::endl;
     if (!shMirrorAncestor.IsEmpty()) {
         // TODO : Use _shSceneIndices?
@@ -916,11 +933,50 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         // }
         return prim;
     }
+    
     // TODO: 
     //else {
         // do as before with isancestorselected
     //}
 
+    HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
+
+    //if ()/// is proto and/or is propagated proto
+    if (prim.primType == HdPrimTypeTokens->mesh) {
+        if (_IsPrototype(primPath)) {
+            //HdPrimOriginSchema primOrigin = HdPrimOriginSchema::GetFromParent(prim.dataSource);
+            //auto primOriginScenePath = primOrigin.GetOriginPath(HdPrimOriginSchemaTokens->scenePath);
+            if (_selection->IsFullySelected(primPath)) {
+                prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath);
+            }
+            else if (_highlightedProtoPaths.find(primPath) != _highlightedProtoPaths.end()) {
+                std::cout << "Highlighting " << primPath.GetString() << std::endl;
+                prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath);
+            }
+            return prim;
+        } else {
+            if (_selection->HasFullySelectedAncestorInclusive(primPath)) {
+                prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath);
+            }
+            return prim;
+        }
+    }
+
+    //else
+    // as before with isancestorselected? prolly not, need to skip if under an instancer. or is that going to be taken care of/avoided automatically?
+
+    // // If prim is in excluded hierarchy, don't provide selection highlighting
+    // // for it.  Selection highlighting is done only on meshes.  HYDRA-569: this
+    // // means that HdsiImplicitSurfaceSceneIndex must be used before this scene
+    // // index to convert implicit surfaces (e.g. USD cube / cone / sphere /
+    // // capsule primitive types) to meshes.
+    // if (prim.primType == HdPrimTypeTokens->mesh) {
+    //     // TODO : Check that this is not an instanced mesh (check there is no instancedBy schema)
+    //     if (_selection->HasFullySelectedAncestorInclusive(primPath)) {
+    //         prim.dataSource =
+    //          _HighlightSelectedPrim(prim.dataSource, primPath);
+    //     }
+    // }
 
     
     // for (const auto& shSceneIndex : _shSceneIndices) {
@@ -1162,6 +1218,51 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
         }
     }
 
+    HdSceneIndexObserver::DirtiedPrimEntries dirtiedSelectedMeshProtos;
+    for (const auto& entry : entries) {
+        HdSceneIndexPrim entryPrim = GetInputSceneIndex()->GetPrim(entry.primPath);
+        if (!entry.dirtyLocators.Contains(HdSelectionsSchema::GetDefaultLocator())) {
+            continue;
+        }
+        auto ancestorsRange = entry.primPath.GetAncestorsRange();
+        bool foundPropagatedProtos = false;
+        for (const auto& ancestorPath : ancestorsRange) {
+            HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(ancestorPath);
+            UsdImagingUsdPrimInfoSchema usdPrimInfo = UsdImagingUsdPrimInfoSchema::GetFromParent(currPrim.dataSource);
+            if (usdPrimInfo.IsDefined()) {
+                auto propagatedProtosDataSource = usdPrimInfo.GetPiPropagatedPrototypes();
+                if (propagatedProtosDataSource) {
+                    auto propagatedProtoNames = propagatedProtosDataSource->GetNames();
+                    for (const auto& propagatedProtoName : propagatedProtoNames) {
+                        auto propagatedProtoPathDataSource = HdTypedSampledDataSource<SdfPath>::Cast(propagatedProtosDataSource->Get(propagatedProtoName));
+                        if (propagatedProtoPathDataSource) {
+                            SdfPath propagatedProtoPath = propagatedProtoPathDataSource->GetTypedValue(0);
+                            SdfPath propagatedPrimPath = entry.primPath.ReplacePrefix(ancestorPath, propagatedProtoPath);
+                            HdSceneIndexPrim propagatedPrim = GetInputSceneIndex()->GetPrim(propagatedPrimPath);
+                            if (propagatedPrim.primType == HdPrimTypeTokens->mesh) {
+                                auto newLocators = HdDataSourceLocatorSet(entry.dirtyLocators);
+                                newLocators.append(HdLegacyDisplayStyleSchema::GetDefaultLocator());
+                                dirtiedSelectedMeshProtos.push_back({propagatedPrimPath, newLocators});
+                                if (HdSelectionsSchema::GetFromParent(entryPrim.dataSource).IsDefined()) {
+                                    _highlightedProtoPaths.insert(propagatedPrimPath);
+                                } else {
+                                    _highlightedProtoPaths.erase(propagatedPrimPath);
+                                }
+                            }
+                            foundPropagatedProtos = true;
+                        }
+                    }
+                }
+            }
+            if (foundPropagatedProtos) {
+                break;
+            }
+        }
+    }
+    if (!dirtiedSelectedMeshProtos.empty()) {
+        _SendPrimsDirtied(dirtiedSelectedMeshProtos);
+    }
+
     HdSceneIndexObserver::DirtiedPrimEntries dirtiedShMirrors;
     for (const auto& entry : entries) {
         auto shMirrorPath = _RepathToSelectionHighlightMirror(entry.primPath);
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 512384341b..4d62f263c3 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -114,8 +114,9 @@ class WireframeSelectionHighlightSceneIndex
     void _CreateSelectionHighlightInstancer(const PXR_NS::SdfPath& originalPath, const PXR_NS::HdContainerDataSourceHandle& originalDataSource);
     
     bool _IsPrototypeRoot(const PXR_NS::SdfPath& primPath);
-    bool _IsInstancingRoot(const PXR_NS::SdfPath& primPath);
-    bool _IsPropagatedPrototype(const PXR_NS::SdfPath& primPath);
+    bool _IsInstancingRoot(const PXR_NS::SdfPath& primPath) const;
+    bool _IsPropagatedPrototype(const PXR_NS::SdfPath& primPath) const;
+    bool _IsPrototype(const PXR_NS::SdfPath& primPath) const;
     PXR_NS::SdfPathVector _CollectAffectedOriginalPrimPaths(const PXR_NS::SdfPath& primPath);
     void _CreateSelectionHighlightMirror(const PXR_NS::SdfPath& primPath, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& createdPrims);
     void _InvalidateSelectionHighlightMirror(const PXR_NS::SdfPath& primPath, PXR_NS::HdSceneIndexObserver::RemovedPrimEntries& removedPrims);
@@ -142,6 +143,7 @@ class WireframeSelectionHighlightSceneIndex
     //std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathVector, PXR_NS::SdfPath::Hash> _extraChildPaths;
     std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _shMirrorsByInstancer;
     std::unordered_map<PXR_NS::SdfPath, size_t, PXR_NS::SdfPath::Hash> _shMirrorsUseCount;
+    std::set<PXR_NS::SdfPath> _highlightedProtoPaths;
     class _RerootingSceneIndexPathDataSource;
     class _RerootingSceneIndexPathArrayDataSource;
     class _RerootingSceneIndexContainerDataSource;

From e2c0cb3a4ebadfa6f35903d6bb12f619dc37ed33 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 27 May 2024 16:31:53 -0400
Subject: [PATCH 009/112] Cleanup

---
 ...fvpBlockPrimRemovalPropagationSceneIndex.h |  1 -
 .../sceneIndex/fvpMergingSceneIndex.cpp       |  2 +-
 .../sceneIndex/fvpMergingSceneIndex.h         |  1 -
 .../sceneIndex/fvpPathInterface.h             |  4 +--
 .../sceneIndex/fvpSelectionSceneIndex.cpp     | 26 ++++++-------------
 .../sceneIndex/fvpSelectionSceneIndex.h       |  1 -
 lib/flowViewport/selection/fvpSelection.cpp   |  1 -
 lib/flowViewport/selection/fvpSelection.h     |  5 +---
 .../mhLeadObjectPathTracker.cpp               |  2 ++
 .../sceneIndex/mayaHydraSceneIndex.cpp        |  2 +-
 .../sceneIndex/registration.cpp               | 10 +++----
 .../mayaToHydra/cpp/testMergingSceneIndex.cpp |  6 ++++-
 .../mayaToHydra/cpp/testPathInterface.cpp     |  3 ++-
 .../cpp/testSelectionSceneIndex.cpp           |  4 ++-
 .../render/mayaToHydra/cpp/testUsdAnim.cpp    |  4 ++-
 .../render/mayaToHydra/cpp/testUsdPicking.cpp |  4 ++-
 .../cpp/testUsdPointInstancePicking.cpp       |  4 ++-
 ...tWireframeSelectionHighlightSceneIndex.cpp | 20 ++++++++++----
 18 files changed, 53 insertions(+), 47 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h b/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
index ae0b41d5b7..af90328f33 100644
--- a/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
@@ -21,7 +21,6 @@
 #include "flowViewport/sceneIndex/fvpSceneIndexUtils.h"
 #include "flowViewport/selection/fvpSelectionFwd.h"
 #include "flowViewport/sceneIndex/fvpPathInterface.h"
-#include "fvpPathInterface.h"
 
 //Hydra headers
 #include <pxr/imaging/hd/filteringSceneIndex.h>
diff --git a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
index bde260bdbe..86b8f96540 100644
--- a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
@@ -14,9 +14,9 @@
 //
 
 #include "flowViewport/sceneIndex/fvpMergingSceneIndex.h"
+#include "flowViewport/sceneIndex/fvpPathInterface.h"
 
 #include "flowViewport/debugCodes.h"
-#include "fvpPathInterface.h"
 
 PXR_NAMESPACE_USING_DIRECTIVE
 
diff --git a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
index 25b924bb6a..d9d8e11edf 100644
--- a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
@@ -17,7 +17,6 @@
 
 #include "flowViewport/api.h"
 #include "flowViewport/sceneIndex/fvpPathInterface.h"
-#include "fvpPathInterface.h"
 
 #include <pxr/imaging/hd/mergingSceneIndex.h>
 
diff --git a/lib/flowViewport/sceneIndex/fvpPathInterface.h b/lib/flowViewport/sceneIndex/fvpPathInterface.h
index cdea9250b2..21df8c7be9 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterface.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterface.h
@@ -19,10 +19,10 @@
 
 #include <ufe/ufe.h>
 
+#include <pxr/pxr.h>
 #include <pxr/base/tf/smallVector.h>
-#include <pxr/usd/sdf/path.h>
 #include <pxr/imaging/hd/dataSource.h>
-#include <pxr/pxr.h>
+#include <pxr/usd/sdf/path.h>
 
 UFE_NS_DEF {
 class Path;
diff --git a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
index 854789cb2c..567bfcc34e 100644
--- a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
@@ -42,11 +42,9 @@
 
 #include "flowViewport/debugCodes.h"
 
-#include "fvpPathInterface.h"
 #include "pxr/imaging/hd/retainedDataSource.h"
 #include "pxr/imaging/hd/selectionSchema.h"
 #include "pxr/imaging/hd/selectionsSchema.h"
-#include <pxr/base/tf/smallVector.h>
 
 #include <ufe/pathString.h>
 #include <ufe/selection.h>
@@ -156,13 +154,12 @@ SelectionSceneIndex::AddSelection(const Ufe::Path& appPath)
     TF_DEBUG(FVP_SELECTION_SCENE_INDEX)
         .Msg("SelectionSceneIndex::AddSelection(const Ufe::Path& %s) called.\n", Ufe::PathString::string(appPath).c_str());
 
-    // Call our input scene index to convert the application path to a scene
-    // index path.
+    // Call our input scene index to convert the application path to scene index paths.
     auto primSelections = ConvertUfeSelectionToHydra(appPath);
 
     for (const auto& primSelection : primSelections) {
         TF_DEBUG(FVP_SELECTION_SCENE_INDEX)
-        .Msg("    Adding %s to the Hydra selection.\n", primSelection.primPath.GetText());
+            .Msg("    Adding %s to the Hydra selection.\n", primSelection.primPath.GetText());
     }
 
     for (const auto& primSelection : primSelections) {
@@ -228,19 +225,12 @@ void SelectionSceneIndex::ReplaceSelection(const Ufe::Selection& selection)
     _selection->Clear();
 
     PrimSelectionInfoVector sceneIndexSn;
-    sceneIndexSn.reserve(selection.size());//TODO: sufficient/efficient? Ufe selection may not 1:1 map to a single SdfPath
+    // This .reserve() call is mostly a heuristic : the ConvertUfeSelectionToHydra API allows one UFE path
+    // to map to any number of SdfPaths (0 to infinity). However, in most cases, it is likely to map to 
+    // one SdfPath, so we reserve space accordingly. (2024/05/27)
+    sceneIndexSn.reserve(selection.size());
     for (const auto& snItem : selection) {
-        // Call our input scene index to convert the application path to a scene
-        // index path.
-        // TODO : What if a single UFE path maps to multiple SdfPaths?
-        // TODO : Handle instances selection.
-        // Potential : make (and rename) SceneIndexPath to return a "PrimSelectionInfoVector"
-        // struct PrimSelectionInfo
-        // {
-        //     SdfPath primPath;
-        //     HdSelectionsSchema selections;
-        // };
-        // using PrimSelectionInfoVector = TfSmallVector<PrimSelectionInfo, 8>;
+        // Call our input scene index to convert the application path to scene index paths.
         auto primSelections = ConvertUfeSelectionToHydra(snItem->path());
 
         if (primSelections.empty()) {
@@ -274,7 +264,7 @@ PrimSelectionInfoVector SelectionSceneIndex::ConvertUfeSelectionToHydra(const Uf
     auto primSelections = _inputSceneIndexPathInterface->ConvertUfeSelectionToHydra(appPath);
 
     if (primSelections.empty()) {
-        TF_WARN("SelectionSceneIndex::ConvertUfeSelectionToHydra(%s) returned no selection, Hydra selection will be incorrect", Ufe::PathString::string(appPath).c_str());
+        TF_WARN("SelectionSceneIndex::ConvertUfeSelectionToHydra(%s) returned no path, Hydra selection will be incorrect", Ufe::PathString::string(appPath).c_str());
     }
 
     return primSelections;
diff --git a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
index 6bc53a33db..bcc7088bb4 100644
--- a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
@@ -42,7 +42,6 @@
 #include "flowViewport/selection/fvpSelectionFwd.h"
 #include "flowViewport/sceneIndex/fvpPathInterface.h"
 #include "flowViewport/sceneIndex/fvpSceneIndexUtils.h"
-#include "fvpPathInterface.h"
 
 #include <pxr/imaging/hd/filteringSceneIndex.h>
 
diff --git a/lib/flowViewport/selection/fvpSelection.cpp b/lib/flowViewport/selection/fvpSelection.cpp
index 098cba80f3..03c4e1cba2 100644
--- a/lib/flowViewport/selection/fvpSelection.cpp
+++ b/lib/flowViewport/selection/fvpSelection.cpp
@@ -39,7 +39,6 @@
 #include "flowViewport/selection/fvpSelection.h"
 #include "flowViewport/sceneIndex/fvpPathInterface.h"
 
-#include "fvpSelection.h"
 #include "pxr/imaging/hd/selectionSchema.h"
 #include "pxr/imaging/hd/selectionsSchema.h"
 
diff --git a/lib/flowViewport/selection/fvpSelection.h b/lib/flowViewport/selection/fvpSelection.h
index 4e5ffdebd1..32e2780735 100644
--- a/lib/flowViewport/selection/fvpSelection.h
+++ b/lib/flowViewport/selection/fvpSelection.h
@@ -18,8 +18,8 @@
 
 #include "flowViewport/api.h"
 #include "flowViewport/selection/fvpSelectionFwd.h"
+#include "flowViewport/sceneIndex/fvpPathInterface.h"
 
-#include <pxr/imaging/hd/dataSource.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
 #include <pxr/usd/sdf/path.h>
 
@@ -27,9 +27,6 @@
 
 namespace FVP_NS_DEF {
 
-struct PrimSelectionInfo;
-using PrimSelectionInfoVector = std::vector<PrimSelectionInfo>;
-
 /// \class Selection
 ///
 /// Represents selection in the Flow Viewport.
diff --git a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
index 36df17fb82..83bbbc4af7 100644
--- a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
+++ b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
@@ -116,6 +116,7 @@ void MhLeadObjectPathTracker::setLeadObjectUfePath(const Ufe::Path& newLeadObjec
     auto oldLeadObjectPrimPath = _leadObjectPrimPath;
 
     _leadObjectUfePath  = newLeadObjectUfePath;
+    // TODO : Handle multiple lead prim paths
     auto hydraSelections = _pathInterface->ConvertUfeSelectionToHydra(_leadObjectUfePath);
     _leadObjectPrimPath = hydraSelections.empty() ? SdfPath() : hydraSelections.front().primPath;
 
@@ -129,6 +130,7 @@ void MhLeadObjectPathTracker::updatePrimPath()
 { 
    // Update the lead object prim path in case it was not valid yet
     if ( (_leadObjectUfePath.size() > 0) && _leadObjectPrimPath.IsEmpty()) {
+        // TODO : Handle multiple lead prim paths
         auto hydraSelections = _pathInterface->ConvertUfeSelectionToHydra(_leadObjectUfePath);
         _leadObjectPrimPath = hydraSelections.empty() ? SdfPath() : hydraSelections.front().primPath;
     }
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
index 3840611484..780c520c35 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
@@ -45,10 +45,10 @@
 #include <ufe/pathString.h>
 
 #include <pxr/base/tf/envSetting.h>
+#include <pxr/imaging/hd/instanceIndicesSchema.h>
 #include <pxr/imaging/hd/meshSchema.h>
 #include <pxr/imaging/hd/primvarSchema.h>
 #include <pxr/imaging/hd/primvarsSchema.h>
-#include <pxr/imaging/hd/instanceIndicesSchema.h>
 #include <pxr/imaging/hd/selectionSchema.h>
 #include <pxr/imaging/hd/selectionsSchema.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
index e98d53ec72..111290cc06 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
@@ -17,7 +17,6 @@
 #include "mayaHydraLib/hydraUtils.h"
 #include "mayaHydraLib/sceneIndex/registration.h"
 #include "mayaHydraLib/sceneIndex/mhMayaUsdProxyShapeSceneIndex.h"
-#include <pxr/imaging/hd/dataSource.h>
 
 #include <flowViewport/sceneIndex/fvpRenderIndexProxy.h>
 #include <flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h>
@@ -26,15 +25,15 @@
 #include <flowViewport/fvpUtils.h>
 #endif
 
-#include <pxr/imaging/hd/instanceIndicesSchema.h>
-#include <pxr/imaging/hd/selectionSchema.h>
-#include <pxr/imaging/hd/selectionsSchema.h>
 #include <pxr/imaging/hd/dataSourceTypeDefs.h>
+#include <pxr/imaging/hd/instanceIndicesSchema.h>
+#include <pxr/imaging/hd/prefixingSceneIndex.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
 #include <pxr/imaging/hd/sceneIndexPlugin.h>
 #include <pxr/imaging/hd/sceneIndexPluginRegistry.h>
+#include <pxr/imaging/hd/selectionSchema.h>
+#include <pxr/imaging/hd/selectionsSchema.h>
 #include <pxr/imaging/hd/renderDelegate.h>
-#include <pxr/imaging/hd/prefixingSceneIndex.h>
 #include <pxr/usd/sdf/path.h>
 
 #if defined(MAYAHYDRALIB_MAYAUSDAPI_ENABLED)
@@ -142,7 +141,6 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
             HdInstanceIndicesSchema::Builder instanceIndicesBuilder;
             instanceIndicesBuilder.SetInstancer(HdRetainedTypedSampledDataSource<SdfPath>::New(primPath));
             instanceIndicesBuilder.SetInstanceIndices(HdRetainedTypedSampledDataSource<VtArray<int>>::New({std::stoi(lastComponentString)}));
-            //instanceIndicesBuilder.SetPrototypeIndex(HdRetainedTypedSampledDataSource<int>::New(0));
             HdSelectionSchema::Builder selectionBuilder;
             selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
             auto instanceIndicesDataSource = HdDataSourceBase::Cast(instanceIndicesBuilder.Build());
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
index 51bcc4bdf8..5caf51b81d 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
@@ -70,6 +70,7 @@ TEST(FlowViewport, mergingSceneIndex)
     // The Maya data producer scene index supports the path interface.  Ask it
     // to translate the application path into a scene index path.
     auto primSelections = mayaSi->ConvertUfeSelectionToHydra(mayaPath);
+    ASSERT_EQ(primSelections.size(), 1u);
 
     // Regardless of prefix, the scene index path tail component will match the
     // Maya node name
@@ -86,7 +87,9 @@ TEST(FlowViewport, mergingSceneIndex)
 
     // Flow Viewport merging scene index must give the same scene index path
     // answer as the Maya data producer scene index.
-    ASSERT_EQ(mergingSi->ConvertUfeSelectionToHydra(mayaPath).front().primPath, primSelections.front().primPath);
+    auto mergingSiSelections = mergingSi->ConvertUfeSelectionToHydra(mayaPath);
+    ASSERT_EQ(mergingSiSelections.size(), 1u);
+    ASSERT_EQ(mergingSiSelections.front().primPath, primSelections.front().primPath);
 }
 
 TEST(FlowViewport, mergingSceneIndexAddRemove)
@@ -106,6 +109,7 @@ TEST(FlowViewport, mergingSceneIndexAddRemove)
     auto mayaSi = TfDynamic_cast<PXR_NS::MayaHydraSceneIndexRefPtr>(*found);
     auto mayaPath = Ufe::PathString::path("|aSphere");
     auto primSelections = mayaSi->ConvertUfeSelectionToHydra(mayaPath);
+    ASSERT_EQ(primSelections.size(), 1u);
 
     // With Maya scene index in the merging scene index, the sphere prim has
     // a valid scene index path.
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
index e95c9d4250..439942bffd 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
@@ -38,7 +38,8 @@ SdfPath getArgSceneIndexPath(const Fvp::SelectionSceneIndexRefPtr& snSi)
     const auto mayaPath = Ufe::PathString::path(argv[0]);
 
     // Translate the application path into a scene index path.
-    return snSi->ConvertUfeSelectionToHydra(mayaPath).front().primPath;
+    auto primSelections = snSi->ConvertUfeSelectionToHydra(mayaPath);
+    return primSelections.empty() ? SdfPath() : primSelections.front().primPath;
 }
 
 Fvp::SelectionSceneIndexRefPtr getSelectionSceneIndex()
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
index 21864ddb44..8799029af1 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
@@ -153,7 +153,9 @@ TEST(FlowViewport, selectionSceneIndexDirty)
     MSelectionList sphereSn;
     sphereSn.add("|aSphere");
     const auto mayaPath = Ufe::PathString::path("|aSphere");
-    const auto sceneIndexPath = selectionSi->ConvertUfeSelectionToHydra(mayaPath).front().primPath;
+    const auto primSelections = selectionSi->ConvertUfeSelectionToHydra(mayaPath);
+    ASSERT_EQ(primSelections.size(), 1u);
+    const auto sceneIndexPath = primSelections.front().primPath;
 
     MGlobal::setActiveSelectionList(sphereSn);
     hdSn = ssio.GetSelection();
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
index 2476c8597a..59819bd923 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
@@ -27,7 +27,9 @@ TEST(TestUsdAnim, timeVaryingTransform)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto cubeSiPath = snSi->ConvertUfeSelectionToHydra(cubePath).front().primPath;
+    const auto primSelections = snSi->ConvertUfeSelectionToHydra(cubePath);
+    ASSERT_EQ(primSelections.size(), 1u);
+    const auto cubeSiPath = primSelections.front().primPath;
 
     ASSERT_FALSE(cubeSiPath.IsEmpty());
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
index d22a04c7d4..7d3af32000 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
@@ -53,7 +53,9 @@ TEST(TestUsdPicking, pick)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto sceneIndexPath = snSi->ConvertUfeSelectionToHydra(selected).front().primPath;
+    const auto primSelections = snSi->ConvertUfeSelectionToHydra(selected);
+    ASSERT_EQ(primSelections.size(), 1u);
+    const auto sceneIndexPath = primSelections.front().primPath;
 
     ASSERT_FALSE(sceneIndexPath.IsEmpty());
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
index ed05706362..2494a4a9b1 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
@@ -51,7 +51,9 @@ TEST(TestUsdPointInstancePicking, pickPointInstance)
     const auto selectionSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(selectionSi);
 
-    const auto sceneIndexPath = selectionSi->ConvertUfeSelectionToHydra(marker).front().primPath;
+    const auto primSelections = selectionSi->ConvertUfeSelectionToHydra(marker);
+    ASSERT_EQ(primSelections.size(), 1u);
+    const auto sceneIndexPath = primSelections.front().primPath;
 
     ASSERT_FALSE(sceneIndexPath.IsEmpty());
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
index b0c4ebdd0e..3d442fc48c 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
@@ -161,8 +161,12 @@ TEST(FlowViewport, wireframeSelectionHighlightSceneIndexDirty)
     sn->append(sphereItem);
 
     // Find the sphere in the Hydra scene index scene.
-    auto sphereSiPath = mergingSi->ConvertUfeSelectionToHydra(spherePath).front().primPath;
-    auto cubeSiPath = mergingSi->ConvertUfeSelectionToHydra(scParentPath + "cube").front().primPath;
+    auto sphereSelections = mergingSi->ConvertUfeSelectionToHydra(spherePath);
+    ASSERT_EQ(sphereSelections.size(), 1u);
+    auto sphereSiPath = sphereSelections.front().primPath;
+    auto cubeSelections = mergingSi->ConvertUfeSelectionToHydra(scParentPath + "cube");
+    ASSERT_EQ(cubeSelections.size(), 1u);
+    auto cubeSiPath = cubeSelections.front().primPath;
 
     // Sphere is selected.
     hdSn = ssio.GetSelection();
@@ -191,9 +195,15 @@ TEST(FlowViewport, wireframeSelectionHighlightSceneIndexDirty)
 
     sn->replaceWith(newSn);
 
-    auto ccSiPath = mergingSi->ConvertUfeSelectionToHydra(ccParentPath).front().primPath;
-    auto coneSiPath = mergingSi->ConvertUfeSelectionToHydra(ccParentPath + "cone").front().primPath;
-    auto cylinderSiPath = mergingSi->ConvertUfeSelectionToHydra(ccParentPath + "cylinder").front().primPath;
+    auto ccSelections = mergingSi->ConvertUfeSelectionToHydra(ccParentPath);
+    ASSERT_EQ(ccSelections.size(), 1u);
+    auto ccSiPath = ccSelections.front().primPath;
+    auto coneSelections = mergingSi->ConvertUfeSelectionToHydra(ccParentPath + "cone");
+    ASSERT_EQ(coneSelections.size(), 1u);
+    auto coneSiPath = coneSelections.front().primPath;
+    auto cylinderSelections = mergingSi->ConvertUfeSelectionToHydra(ccParentPath + "cylinder");
+    ASSERT_EQ(cylinderSelections.size(), 1u);
+    auto cylinderSiPath = cylinderSelections.front().primPath;
 
     // Cone and cylinder parent is selected.
     // Cone is not selected.

From c53dec7866a7bacee96e4fbd1d6515fab7a00180 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 27 May 2024 17:07:14 -0400
Subject: [PATCH 010/112] Cleanup of wireframe selection highlight scene index

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 480 +-----------------
 ...fvpWireframeSelectionHighlightSceneIndex.h |  16 +-
 2 files changed, 11 insertions(+), 485 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 32a4499528..b5da0090df 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -77,41 +77,8 @@ const HdDataSourceLocator reprSelectorLocator(
 const HdDataSourceLocator primvarsOverrideWireframeColorLocator(
         HdPrimvarsSchema::GetDefaultLocator().Append(_primVarsTokens->overrideWireframeColor));
 
-const std::string testInstancer = "ParentPointInstancer";
-
 const std::string shMirrorTag = "_SHMirror";
 
-class SelectionHighlightDataSource : public HdContainerDataSource
-{
-public:
-    HD_DECLARE_DATASOURCE(SelectionHighlightDataSource);
-
-    SelectionHighlightDataSource(const HdContainerDataSourceHandle& originalDataSource) : _originalDataSource(originalDataSource)
-    {
-    }
-
-    TfTokenVector GetNames() override {
-        TfTokenVector names = _originalDataSource->GetNames();
-        /*names.erase(std::remove_if(names.begin(), names.end(), [](const TfToken& token) -> bool {
-            return token == HdSelectionsSchemaTokens->selections;
-        }));*/
-        return names;
-    }
-
-    HdDataSourceBaseHandle Get(const TfToken &name) override
-    {
-        return _originalDataSource->Get(name);
-    }
-
-private:
-    HdContainerDataSourceHandle _originalDataSource;
-};
-
-bool _IsSelectionHighlightMirrorPath(const SdfPath& path)
-{
-    return path.GetElementString().find(shMirrorTag) != std::string::npos;
-}
-
 SdfPath _GetSelectionHighlightMirrorPathFromOriginal(const SdfPath& originalPath)
 {
     return originalPath.GetParentPath().AppendElementString(originalPath.GetElementString() + shMirrorTag);
@@ -160,11 +127,6 @@ VtBoolArray _GetSelectionHighlightMask(const HdInstancerTopologySchema& original
     return selectionHighlightMask;
 }
 
-HdContainerDataSourceHandle _CreateSelectionHighlightInstancer(const SdfPath& originalPath, const HdContainerDataSourceHandle& originalDataSource)
-{
-
-}
-
 HdContainerDataSourceHandle _GetSelectionHighlightInstancerDataSource(const HdContainerDataSourceHandle& originalDataSource)
 {
     HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(originalDataSource);
@@ -179,51 +141,11 @@ HdContainerDataSourceHandle _GetSelectionHighlightInstancerDataSource(const HdCo
         editedDataSource.Set(maskLocator, selectionHighlightMaskDataSource);
     }
 
-    // HdDataSourceLocator prototypesLocator(TfToken("instancerTopology"), TfToken("prototypes"));
-    // VtArray<SdfPath> originalPrototypes = instancerTopology.GetPrototypes()->GetTypedValue(0);
-    // VtArray<SdfPath> selectionHighlightPrototypes = originalPrototypes;
-    // for (auto& shProtoPath : selectionHighlightPrototypes) {
-    //     shProtoPath = _GetSelectionHighlightMirrorPathFromOriginal(shProtoPath);
-    // }
-    // editedDataSource.Set(prototypesLocator, HdRetainedTypedSampledDataSource<VtArray<SdfPath>>::New(selectionHighlightPrototypes));
-
     editedDataSource.Set(HdSelectionsSchema::GetDefaultLocator(), HdBlockDataSource::New());
 
     return editedDataSource.Finish();
 }
 
-
-
-// HdContainerDataSourceHandle _FilterInstances(const HdContainerDataSourceHandle& dataSource)
-// {
-//     auto edited = HdContainerDataSourceEditor(dataSource);
-//     HdDataSourceLocator maskLocator(TfToken("instancerTopology"), TfToken("mask"));
-//     auto replacementDataSource = HdRetainedTypedSampledDataSource<VtBoolArray>::New(VtBoolArray({true, false, true, false, true, true, false, false}));
-//     edited.Set(maskLocator, replacementDataSource);
-
-    
-//     // //Is the prim in refined displayStyle (meaning shaded) ?
-//     // if (HdLegacyDisplayStyleSchema styleSchema =
-//     //         HdLegacyDisplayStyleSchema::GetFromParent(dataSource)) {
-
-//     //     if (HdTokenArrayDataSourceHandle ds =
-//     //             styleSchema.GetReprSelector()) {
-//     //         VtArray<TfToken> ar = ds->GetTypedValue(0.0f);
-//     //         TfToken refinedToken = ar[0];
-//     //         if(HdReprTokens->refined == refinedToken){
-//     //             //Is in refined display style, apply the wire on top of shaded reprselector
-//     //             return HdOverlayContainerDataSource::New({ edited.Finish(), sRefinedWireOnSurfaceDisplayStyleDataSource});
-//     //         }
-//     //     }else{
-//     //         //No reprSelector found, assume it's in the Collection that we have set HdReprTokens->refined
-//     //         return HdOverlayContainerDataSource::New({ edited.Finish(), sRefinedWireOnSurfaceDisplayStyleDataSource});
-//     //     }
-//     // }
-
-//     //For the other case, we are only updating the wireframe color assuming we are already drawing lines
-//     return edited.Finish();
-// }
-
 bool _IsInstancerWithSelections(const HdSceneIndexPrim& prim)
 {
     if (prim.primType != HdPrimTypeTokens->instancer) {
@@ -233,23 +155,6 @@ bool _IsInstancerWithSelections(const HdSceneIndexPrim& prim)
     return selections.IsDefined() && selections.GetNumElements() > 0;
 }
 
-bool _IsConcretePrototype(const SdfPath& primPath, const HdSceneIndexPrim& prim)
-{
-    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
-    return instancedBy.IsDefined() && instancedBy.GetPrototypeRoots();
-}
-
-bool _IsPartOfSelectionHighlightMirror(const SdfPath& path)
-{
-    auto ancestorsRange = path.GetAncestorsRange();
-    for (auto ancestor : ancestorsRange) {
-        if (_IsSelectionHighlightMirrorPath(ancestor)) {
-            return true;
-        }
-    }
-    return false;
-}
-
 }
 
 namespace FVP_NS_DEF {
@@ -318,16 +223,7 @@ class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathDataSource
 
         const SdfPath srcPath = _inputDataSource->GetTypedValue(shutterOffset);
         const SdfPath mirrorPath =_inputSceneIndex->_RepathToSelectionHighlightMirror(srcPath);
-        if (!mirrorPath.IsEmpty()) {
-            return mirrorPath;
-        }
-        // for (const auto& shSceneIndex : _inputSceneIndex->_shSceneIndices) {
-        //     const SdfPath originalShSceneIndexPath = _GetOriginalPathFromSelectionHighlightMirror(shSceneIndex.first);
-        //     if (srcPath.HasPrefix(originalShSceneIndexPath)) {
-        //         return srcPath.ReplacePrefix(originalShSceneIndexPath, shSceneIndex.first);
-        //     }
-        // }
-        return srcPath;
+        return mirrorPath.IsEmpty() ? srcPath : mirrorPath;
     }
 
 private:
@@ -382,12 +278,6 @@ class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathArrayDataSo
             if (!mirrorPath.IsEmpty()) {
                 result[i] = mirrorPath;
             }
-            // for (const auto& shSceneIndex : _inputSceneIndex->_shSceneIndices) {
-            //     const SdfPath originalShSceneIndexPath = _GetOriginalPathFromSelectionHighlightMirror(shSceneIndex.first);
-            //     if (result[i].HasPrefix(originalShSceneIndexPath)) {
-            //         result[i] = result[i].ReplacePrefix(originalShSceneIndexPath, shSceneIndex.first);
-            //     }
-            // }
         }
 
         return result;
@@ -560,152 +450,6 @@ WireframeSelectionHighlightSceneIndex::_IsPrototype(const SdfPath& primPath) con
     return instancedBy.IsDefined();
 }
 
-void
-WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightMirror(const SdfPath& originalPrimPath, HdSceneIndexObserver::AddedPrimEntries& createdPrims)
-{
-    // This should never be called on selection highlight mirrors, only on original prims
-    // TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
-
-    // if (!_IsPrototypeRoot(originalPrimPath)) {
-    //     HdSceneIndexPrim originalPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
-    //     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(originalPrim.dataSource);
-    //     if (instancedBy.IsDefined()) {
-    //         auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
-    //         for (const auto& protoRootPath : protoRootPaths) {
-    //             _CreateSelectionHighlightMirror(protoRootPath, createdPrims);
-    //         }
-    //     }
-    //     return;
-    // }
-    
-    // SdfPath selectionHighlightPrimPath = _GetSelectionHighlightMirrorPathFromOriginal(originalPrimPath);
-    
-    // bool isNewShMirror = _shMirrorPathsUseCount.find(selectionHighlightPrimPath) == _shMirrorPathsUseCount.end();
-    // if (isNewShMirror) {
-    //     TF_AXIOM(_shMirrorPathsUseCount.find(selectionHighlightPrimPath) == _shMirrorPathsUseCount.end());
-    //     _shMirrorPathsUseCount[selectionHighlightPrimPath] = 1;
-    //     TF_AXIOM(_shSceneIndices.find(selectionHighlightPrimPath) == _shSceneIndices.end());
-    //     _shSceneIndices[selectionHighlightPrimPath] = UsdImagingRerootingSceneIndex::New(GetInputSceneIndex(), originalPrimPath, selectionHighlightPrimPath);
-    //     createdPrims.push_back({selectionHighlightPrimPath, GetInputSceneIndex()->GetPrim(originalPrimPath).primType});
-    // }
-    // else {
-    //     TF_AXIOM(_shMirrorPathsUseCount.find(selectionHighlightPrimPath) != _shMirrorPathsUseCount.end());
-    //     TF_AXIOM(_shMirrorPathsUseCount[selectionHighlightPrimPath] > 0);
-    //     TF_AXIOM(_shSceneIndices.find(selectionHighlightPrimPath) != _shSceneIndices.end());
-    //     _shMirrorPathsUseCount[selectionHighlightPrimPath]++;
-    // }
-    // TF_AXIOM(_shMirrorPathsUseCount[selectionHighlightPrimPath] > 0);
-
-    // SdfPathVector affectedOriginalPrimPaths = _CollectAffectedOriginalPrimPaths(originalPrimPath);
-
-    // std::stack<SdfPath> childPaths;
-    // for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(originalPrimPath)) {
-    //     childPaths.push(childPath);
-    // }
-    // while (!childPaths.empty()) {
-    //     SdfPath currPath = childPaths.top();
-    //     childPaths.pop();
-
-    //     HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
-    //     if (isNewShMirror) {
-    //         createdPrims.push_back({currPath.ReplacePrefix(originalPrimPath, selectionHighlightPrimPath), currPrim.primType});
-    //     }
-    //     if (currPrim.primType == HdPrimTypeTokens->instancer) {
-    //         SdfPathVector extraAffectedPaths = _CollectAffectedOriginalPrimPaths(currPath);
-    //         affectedOriginalPrimPaths.insert(affectedOriginalPrimPaths.end(), extraAffectedPaths.begin(), extraAffectedPaths.end());
-    //     }
-
-    //     for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
-    //         childPaths.push(childPath);
-    //     }
-    // }
-
-    // for (const auto& affectedOriginalPrimPath : affectedOriginalPrimPaths) {
-    //     _CreateSelectionHighlightMirror(affectedOriginalPrimPath, createdPrims);
-    // }
-}
-
-void
-WireframeSelectionHighlightSceneIndex::_InvalidateSelectionHighlightMirror(const SdfPath& originalPrimPath, HdSceneIndexObserver::RemovedPrimEntries& removedPrims)
-{
-    // This should never be called on selection highlight mirrors, only on original prims
-    // TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
-
-    // if (!_IsPrototypeRoot(originalPrimPath)) {
-    //     return;
-    // }
-
-    // SdfPath selectionHighlightPrimPath = _GetSelectionHighlightMirrorPathFromOriginal(originalPrimPath);
-
-    // if (_shMirrorPathsUseCount.find(selectionHighlightPrimPath) == _shMirrorPathsUseCount.end()) {
-    //     return;
-    // }
-    // TF_AXIOM(_shMirrorPathsUseCount.find(selectionHighlightPrimPath) != _shMirrorPathsUseCount.end());
-    // TF_AXIOM(_shMirrorPathsUseCount[selectionHighlightPrimPath] > 0);
-    // TF_AXIOM(_shSceneIndices.find(selectionHighlightPrimPath) != _shSceneIndices.end());
-
-    // _shMirrorPathsUseCount[selectionHighlightPrimPath]--;
-    // bool shouldDeleteShMirror = _shMirrorPathsUseCount[selectionHighlightPrimPath] == 0;
-    // if (shouldDeleteShMirror) {
-    //     _shMirrorPathsUseCount.erase(selectionHighlightPrimPath);
-    //     _shSceneIndices.erase(selectionHighlightPrimPath);
-    //     removedPrims.push_back({selectionHighlightPrimPath});
-    // }
-    
-    // SdfPathVector affectedOriginalPrimPaths = _CollectAffectedOriginalPrimPaths(originalPrimPath);
-
-    // std::stack<SdfPath> childPaths;
-    // for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(originalPrimPath)) {
-    //     childPaths.push(childPath);
-    // }
-    // while (!childPaths.empty()) {
-    //     SdfPath currPath = childPaths.top();
-    //     childPaths.pop();
-
-    //     HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
-    //     if (currPrim.primType == HdPrimTypeTokens->instancer) {
-    //         SdfPathVector extraAffectedPaths = _CollectAffectedOriginalPrimPaths(currPath);
-    //         affectedOriginalPrimPaths.insert(affectedOriginalPrimPaths.end(), extraAffectedPaths.begin(), extraAffectedPaths.end());
-    //     }
-
-    //     for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
-    //         childPaths.push(childPath);
-    //     }
-    // }
-
-    // for (const auto& affectedOriginalPrimPath : affectedOriginalPrimPaths) {
-    //     _InvalidateSelectionHighlightMirror(affectedOriginalPrimPath, removedPrims);
-    // }
-}
-
-void
-WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightMirrorForInstancer(const SdfPath& primPath, const HdSceneIndexPrim& prim)
-{
-    HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(prim.dataSource);
-    TF_AXIOM(instancerTopology.IsDefined());
-
-
-    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
-    if (instancedBy.IsDefined()) {
-        for (const auto& instancedByPath : instancedBy.GetPaths()->GetTypedValue(0)) {
-            // TODO : GetPrototypeRoots? -> goes into overlay, same as new instancedBy paths
-            _CreateSelectionHighlightMirrorForInstancer(instancedByPath, GetInputSceneIndex()->GetPrim(instancedByPath));
-        }
-    }
-}
-
-void
-WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightMirrorForMesh(const SdfPath& primPath, const HdSceneIndexPrim& prim)
-{
-
-}
-
-void
-WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightMirrorForArbitraryPrim(const SdfPath& primPath, const HdSceneIndexPrim& prim)
-{
-
-}
-
 WireframeSelectionHighlightSceneIndex::
 WireframeSelectionHighlightSceneIndex(
     const HdSceneIndexBaseRefPtr& inputSceneIndex,
@@ -735,12 +479,6 @@ WireframeSelectionHighlightSceneIndex(
     }
 }
 
-void 
-WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightInstancer(const PXR_NS::SdfPath& originalPath, const PXR_NS::HdContainerDataSourceHandle& originalDataSource)
-{
-
-}
-
 bool
 WireframeSelectionHighlightSceneIndex::_CollectShMirrorPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outShMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outCreatedPrims)
 {
@@ -876,220 +614,49 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
     if (_IsExcluded(primPath)) {
         return GetInputSceneIndex()->GetPrim(primPath);
     }
-    // if (_IsSelectionHighlightMirrorPath(primPath)) {
-    //     HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(_GetOriginalPathFromSelectionHighlightMirror(primPath));
-    //     return {prim.primType, {}};
-    // }
-
-    // auto ancestorsRange = primPath.GetAncestorsRange();
-    // for (auto ancestor : ancestorsRange) {
-    //     if (_IsSelectionHighlightMirrorPath(ancestor)) {
-    //         auto originalPath = primPath.ReplacePrefix(ancestor, _GetOriginalPathFromSelectionHighlightMirror(ancestor));
-    //         HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(originalPath);
-    //         return {prim.primType, {}};
-    //     }
-    // }
-    if (primPath.GetElementString() == "TopInstancer") {
-        //return {};
-    }
-    static std::mutex printMutex;
-    std::lock_guard printLock(printMutex);
+    
     SdfPath shMirrorAncestor = _FindSelectionHighlightMirrorAncestor(primPath);
-    if (primPath.GetElementString() == "Pyramid") {
-        std::cout << "Pyramid" << std::endl;
-    }
-    //std::cout << "For " << primPath.GetString() << " , SH is : " << shMirrorAncestor.GetString() << std::endl;
     if (!shMirrorAncestor.IsEmpty()) {
-        // TODO : Use _shSceneIndices?
-        HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath.ReplacePrefix(shMirrorAncestor, _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestor)));
+        SdfPath originalPrimPath = primPath.ReplacePrefix(shMirrorAncestor, _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestor));
+        HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(originalPrimPath);
         if (prim.dataSource) {
             prim.dataSource = WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexContainerDataSource::New(prim.dataSource, this);
         }
         if (prim.primType == HdPrimTypeTokens->mesh) {
-            prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath.ReplacePrefix(shMirrorAncestor, _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestor)));
+            prim.dataSource = _HighlightSelectedPrim(prim.dataSource, originalPrimPath);
         }
         if (prim.primType == HdPrimTypeTokens->instancer) {
             prim.dataSource = _GetSelectionHighlightInstancerDataSource(prim.dataSource);
         }
-        // if (prim.primType == HdPrimTypeTokens->instancer) {
-        //     HdSelectionsSchema selections = HdSelectionsSchema::GetFromParent(prim.dataSource);
-        //     if (selections.IsDefined()) {
-        //         HdInstanceIndicesSchema::Builder instanceIndicesBuilder;
-        //         instanceIndicesBuilder.SetInstancer(HdRetainedTypedSampledDataSource<SdfPath>::New(primPath));
-        //         instanceIndicesBuilder.SetInstanceIndices(HdRetainedTypedSampledDataSource<VtArray<int>>::New({0}));
-        //         instanceIndicesBuilder.SetPrototypeIndex(HdRetainedTypedSampledDataSource<int>::New(0));
-        //         HdSelectionSchema::Builder selectionBuilder;
-        //         selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
-        //         auto newInstanceIndices = HdDataSourceBase::Cast(instanceIndicesBuilder.Build());
-        //         selectionBuilder.SetNestedInstanceIndices(HdRetainedSmallVectorDataSource::New(1, &newInstanceIndices));
-        //         auto newSelection = HdDataSourceBase::Cast(selectionBuilder.Build());
-        //         auto newSelections = HdRetainedSmallVectorDataSource::New(1, &newSelection);
-        //         HdContainerDataSourceEditor editor(prim.dataSource);
-        //         editor.Set(HdSelectionsSchema::GetDefaultLocator(), newSelections);
-
-        //         editor.Set(HdInstancerTopologySchema::GetDefaultLocator().Append(TfToken("mask")), HdRetainedTypedSampledDataSource<VtArray<bool>>::New(VtArray<bool>({true, false})));
-        //         prim.dataSource = editor.Finish();
-        //     }
-        // }
         return prim;
     }
     
-    // TODO: 
-    //else {
-        // do as before with isancestorselected
-    //}
-
     HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
 
-    //if ()/// is proto and/or is propagated proto
     if (prim.primType == HdPrimTypeTokens->mesh) {
+        // Note : in the USD data model, the original prims that get propagated as prototypes have their original prim types erased.
+        // Only the resulting propagated prototypes keep the original prim type. Presumably this is to avoid drawing the original
+        // prim (even though it should already not be drawn due to being under an instancer, this is an additional safety? to confirm)
         if (_IsPrototype(primPath)) {
-            //HdPrimOriginSchema primOrigin = HdPrimOriginSchema::GetFromParent(prim.dataSource);
-            //auto primOriginScenePath = primOrigin.GetOriginPath(HdPrimOriginSchemaTokens->scenePath);
             if (_selection->IsFullySelected(primPath)) {
                 prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath);
             }
             else if (_highlightedProtoPaths.find(primPath) != _highlightedProtoPaths.end()) {
-                std::cout << "Highlighting " << primPath.GetString() << std::endl;
                 prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath);
             }
-            return prim;
         } else {
             if (_selection->HasFullySelectedAncestorInclusive(primPath)) {
                 prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath);
             }
-            return prim;
         }
     }
 
-    //else
-    // as before with isancestorselected? prolly not, need to skip if under an instancer. or is that going to be taken care of/avoided automatically?
-
-    // // If prim is in excluded hierarchy, don't provide selection highlighting
-    // // for it.  Selection highlighting is done only on meshes.  HYDRA-569: this
-    // // means that HdsiImplicitSurfaceSceneIndex must be used before this scene
-    // // index to convert implicit surfaces (e.g. USD cube / cone / sphere /
-    // // capsule primitive types) to meshes.
-    // if (prim.primType == HdPrimTypeTokens->mesh) {
-    //     // TODO : Check that this is not an instanced mesh (check there is no instancedBy schema)
-    //     if (_selection->HasFullySelectedAncestorInclusive(primPath)) {
-    //         prim.dataSource =
-    //          _HighlightSelectedPrim(prim.dataSource, primPath);
-    //     }
-    // }
-
-    
-    // for (const auto& shSceneIndex : _shSceneIndices) {
-    //     if (primPath.HasPrefix(shSceneIndex.first)) {
-    //         //HdSceneIndexPrim prim = shSceneIndex.second->GetPrim(primPath);
-    //         HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath.ReplacePrefix(shSceneIndex.first, _GetOriginalPathFromSelectionHighlightMirror(shSceneIndex.first)));
-    //         if (prim.dataSource) {
-    //             prim.dataSource = WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexContainerDataSource::New(prim.dataSource, this);
-    //         }
-    //         if (prim.primType == HdPrimTypeTokens->mesh) {
-    //             prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath.ReplacePrefix(shSceneIndex.first, _GetOriginalPathFromSelectionHighlightMirror(shSceneIndex.first)));
-    //         }
-    //         return prim;
-    //     }
-    // }
-    //HdSceneIndexPrim prim;
-    //if (_IsSelectionHighlightMirrorPath(primPath)) {
-    //    prim = GetInputSceneIndex()->GetPrim(_GetOriginalFromMirrorPath(primPath));
-    //} else {
-    //    prim = GetInputSceneIndex()->GetPrim(primPath);
-    //}
-//
-    //if (_IsSelectionHighlightMirrorPath(primPath)) {
-    //    if (prim.primType == HdPrimTypeTokens->instancer) {
-    //        prim.dataSource = _GetSelectionHighlightInstancerDataSource(prim.dataSource);
-    //    }
-    //    else if (prim.primType == HdPrimTypeTokens->mesh) {
-    //        prim.dataSource = _HighlightSelectedPrim(prim.dataSource, _GetOriginalFromMirrorPath(primPath));
-    //    }
-    //}
-
-    // if (_selectionHighlightDataSourceOverlays.find(primPath) != _selectionHighlightDataSourceOverlays.end()) {
-    //     prim.dataSource = HdOverlayContainerDataSource::New(_selectionHighlightDataSourceOverlays.at(primPath), prim.dataSource);
-    //     return prim;
-    // }
-
-    // If prim is in excluded hierarchy, don't provide selection highlighting
-    // for it.  Selection highlighting is done only on meshes.  HYDRA-569: this
-    // means that HdsiImplicitSurfaceSceneIndex must be used before this scene
-    // index to convert implicit surfaces (e.g. USD cube / cone / sphere /
-    // capsule primitive types) to meshes.
-    // if (! _IsExcluded(primPath) && prim.primType == HdPrimTypeTokens->mesh) {
-    //     // TODO : Check that this is not an instanced mesh (check there is no instancedBy schema)
-    //     if (_selection->HasFullySelectedAncestorInclusive(primPath)) {
-    //         prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath);
-    //     }
-    // }
-
-    // if (!_IsSelectionHighlightMirror(primPath)) {
-    //     return prim;
-    // }
-
-    // if (prim.primType == HdPrimTypeTokens->instancer) {
-    //     prim.dataSource = _GetSelectionHighlightInstancerDataSource(prim.dataSource);
-    // } else if (prim.primType == HdPrimTypeTokens->mesh) {
-    //     SdfPath originalPath = _GetOriginalFromMirrorPath(primPath);
-    //     prim.dataSource = _HighlightSelectedPrim(prim.dataSource, originalPath);
-    // }
-
-    return GetInputSceneIndex()->GetPrim(primPath);
+    return prim;
 }
 
 SdfPathVector
 WireframeSelectionHighlightSceneIndex::GetChildPrimPaths(const SdfPath &primPath) const
 {
-    // if (primPath.GetElementString().find("ForInstancer") != std::string::npos &&
-    // GetInputSceneIndex()->GetPrim(primPath).primType == HdPrimTypeTokens->instancer) {
-    //     return {};
-    // }
-    // if (primPath.GetElementString().find("ForInstancer") != std::string::npos &&
-    // GetInputSceneIndex()->GetPrim(primPath).primType == HdPrimTypeTokens->instancer) {
-    //     static std::mutex printMutex;
-    //     SdfPath rerootedPath = primPath.ReplacePrefix(SdfPath::AbsoluteRootPath(), SdfPath("Potato"));
-    //     std::lock_guard printLock(printMutex);
-    //     std::cout << rerootedPath << std::endl;
-    // }
-    // auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath);
-    // if (_extraChildPaths.find(primPath) != _extraChildPaths.end()) {
-    //     SdfPathVector extraChildPaths = _extraChildPaths.at(primPath);
-    //     childPaths.insert(childPaths.end(), extraChildPaths.begin(), extraChildPaths.end());
-    // }
-    // SdfPathVector additionalChildPaths;
-    // for (const auto& childPath : childPaths) {
-    //     if (_originalPrimPathsToSelectionHighlightMirrorPrimPaths.find(childPath) != _originalPrimPathsToSelectionHighlightMirrorPrimPaths.end()) {
-    //         additionalChildPaths.push_back(_originalPrimPathsToSelectionHighlightMirrorPrimPaths.at(childPath));
-    //     }
-    // }
-    // childPaths.insert(childPaths.end(), additionalChildPaths.begin(), additionalChildPaths.end());
-    // SdfPathVector additionalChildPaths;
-    // for (auto& childPath : childPaths) {
-    //     if (GetInputSceneIndex()->GetPrim(childPath).primType == HdPrimTypeTokens->instancer
-    //     || GetInputSceneIndex()->GetPrim(childPath).primType == HdPrimTypeTokens->mesh) {
-    //         SdfPath mirrorPath = _GetSelectionHighlightMirrorPath(childPath);
-    //         additionalChildPaths.push_back(mirrorPath);
-    //     }
-    // }
-    // childPaths.insert(childPaths.end(), additionalChildPaths.begin(), additionalChildPaths.end());
-    
-    //SdfPathVector additionalChildPaths;
-    //for (const auto& childPath : childPaths) {
-    //    if (_topLevelInstancers.find(childPath) != _topLevelInstancers.end()) {
-    //        additionalChildPaths.push_back(_GetSelectionHighlightMirrorPath(childPath));
-    //    }
-    //}
-    //childPaths.insert(childPaths.end(), additionalChildPaths.begin(), additionalChildPaths.end());
-    // auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath);
-    // SdfPathVector additionalChildPaths;
-    // for (const auto& childPath : childPaths) {
-    //     HdSceneIndexPrim childPrim = GetInputSceneIndex()->GetPrim(childPath);
-    //     HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(childPrim.dataSource);
-    //     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(childPrim.dataSource);
-
-    // }
     SdfPath shMirrorAncestor = _FindSelectionHighlightMirrorAncestor(primPath);
     if (!shMirrorAncestor.IsEmpty()) {
         SdfPath originalShMirrorAncestor = _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestor);
@@ -1099,15 +666,6 @@ WireframeSelectionHighlightSceneIndex::GetChildPrimPaths(const SdfPath &primPath
         }
         return childPaths;
     }
-    // for (const auto& shSceneIndex : _shSceneIndices) {
-    //     if (primPath.HasPrefix(shSceneIndex.first)) {
-    //         //return shSceneIndex.second->GetChildPrimPaths(primPath);
-    //         auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath.ReplacePrefix(shSceneIndex.first, _GetOriginalPathFromSelectionHighlightMirror(shSceneIndex.first)));
-    //         for (auto& childPath : childPaths) {
-    //             childPath = childPath.ReplacePrefix(const SdfPath &oldPrefix, const SdfPath &newPrefix)
-    //         }
-    //     }
-    // }
 
     auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath);
     SdfPathVector additionalChildPaths;
@@ -1132,12 +690,6 @@ HdContainerDataSourceHandle WireframeSelectionHighlightSceneIndex::_HighlightSel
                             HdRetainedTypedSampledDataSource<VtVec4fArray>::New(VtVec4fArray{_wireframeColorInterface->getWireframeColor(primPath)}),
                             HdPrimvarSchemaTokens->constant,
                             HdPrimvarSchemaTokens->color));
-
-    HdXformSchema::Builder xformBuilder;
-    GfMatrix4d matrix;
-    matrix.SetScale(1.25);
-    xformBuilder.SetMatrix(HdRetainedTypedSampledDataSource<GfMatrix4d>::New(matrix));
-    //edited.Set(HdXformSchema::GetDefaultLocator(), xformBuilder.Build());
     
     //Is the prim in refined displayStyle (meaning shaded) ?
     if (HdLegacyDisplayStyleSchema styleSchema =
@@ -1171,13 +723,6 @@ WireframeSelectionHighlightSceneIndex::_PrimsAdded(
         .Msg("WireframeSelectionHighlightSceneIndex::_PrimsAdded() called.\n");
 
     auto newEntries = entries;
-    // for (auto& entry : entries) {
-    //     if (entry.primType == HdPrimTypeTokens->instancer) {
-
-    //         SdfPath mirrorPath = _GetSelectionHighlightMirrorPath(entry.primPath);
-    //         newEntries.push_back({mirrorPath, entry.primType});
-    //     }
-    // }
     for (const auto& entry : entries) {
         // TODO : Check if instancer with selections, or if an instancee whose instancer(s) have selections?
         // Maybe only need new instancers with selections?
@@ -1187,11 +732,6 @@ WireframeSelectionHighlightSceneIndex::_PrimsAdded(
             _CreateShMirrorsForInstancer(entry.primPath);
         }
     }
-    // for (const auto& entry : entries) {
-    //     if (_originalPrimPathsToSelectionHighlightMirrorPrimPaths.find(entry.primPath) != _originalPrimPathsToSelectionHighlightMirrorPrimPaths.end()) {
-    //         newEntries.push_back({_originalPrimPathsToSelectionHighlightMirrorPrimPaths.at(entry.primPath), entry.primType});
-    //     }
-    // }
     _SendPrimsAdded(newEntries);
 }
 
@@ -1282,7 +822,7 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
             } else if (prim.primType == HdPrimTypeTokens->instancer) {
                 _RemoveShMirrorsForInstancer(entry.primPath);
             }
-            // Forward dirtiness to SH mirrors masks
+            // TODO : Forward dirtiness to SH mirrors masks
         }
     }
     if (!newSelectionHighlightPrims.empty())
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 4d62f263c3..fb9e379fae 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -111,36 +111,22 @@ class WireframeSelectionHighlightSceneIndex
     std::set<PXR_NS::SdfPath> _excludedSceneRoots;
     PXR_NS::HdContainerDataSourceHandle _HighlightSelectedPrim(const PXR_NS::HdContainerDataSourceHandle& dataSource, const PXR_NS::SdfPath& primPath)const;
 
-    void _CreateSelectionHighlightInstancer(const PXR_NS::SdfPath& originalPath, const PXR_NS::HdContainerDataSourceHandle& originalDataSource);
-    
     bool _IsPrototypeRoot(const PXR_NS::SdfPath& primPath);
     bool _IsInstancingRoot(const PXR_NS::SdfPath& primPath) const;
     bool _IsPropagatedPrototype(const PXR_NS::SdfPath& primPath) const;
     bool _IsPrototype(const PXR_NS::SdfPath& primPath) const;
-    PXR_NS::SdfPathVector _CollectAffectedOriginalPrimPaths(const PXR_NS::SdfPath& primPath);
-    void _CreateSelectionHighlightMirror(const PXR_NS::SdfPath& primPath, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& createdPrims);
-    void _InvalidateSelectionHighlightMirror(const PXR_NS::SdfPath& primPath, PXR_NS::HdSceneIndexObserver::RemovedPrimEntries& removedPrims);
-    void _PropagateDirtySelectionHighlightMirror(const PXR_NS::SdfPath& primPath, PXR_NS::HdSceneIndexObserver::DirtiedPrimEntries& dirtiedPrims);
 
+    PXR_NS::SdfPathVector _CollectAffectedOriginalPrimPaths(const PXR_NS::SdfPath& primPath);
     bool _CollectShMirrorPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outShMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outCreatedPrims);
-    void _UpdateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
     void _RemoveShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
     void _CreateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
 
-    void _CreateSelectionHighlightMirrorForInstancer(const PXR_NS::SdfPath& primPath, const PXR_NS::HdSceneIndexPrim& prim);
-    void _CreateSelectionHighlightMirrorForMesh(const PXR_NS::SdfPath& primPath, const PXR_NS::HdSceneIndexPrim& prim);
-    void _CreateSelectionHighlightMirrorForArbitraryPrim(const PXR_NS::SdfPath& primPath, const PXR_NS::HdSceneIndexPrim& prim);
-
     PXR_NS::SdfPath _FindSelectionHighlightMirrorAncestor(const PXR_NS::SdfPath& path) const;
     PXR_NS::SdfPath _RepathToSelectionHighlightMirror(const PXR_NS::SdfPath& path) const;
 
     const SelectionConstPtr   _selection;
     const std::shared_ptr<WireframeColorInterface> _wireframeColorInterface;
 
-    //std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPath, PXR_NS::SdfPath::Hash> _pathsOgToSh;
-    //std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPath, PXR_NS::SdfPath::Hash> _pathsShToOg;
-    //std::unordered_map<PXR_NS::SdfPath, PXR_NS::HdContainerDataSourceHandle, PXR_NS::SdfPath::Hash> _selectionHighlightDataSourceOverlays;
-    //std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathVector, PXR_NS::SdfPath::Hash> _extraChildPaths;
     std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _shMirrorsByInstancer;
     std::unordered_map<PXR_NS::SdfPath, size_t, PXR_NS::SdfPath::Hash> _shMirrorsUseCount;
     std::set<PXR_NS::SdfPath> _highlightedProtoPaths;

From 92d59c9439f7ff56ac92a119b99eb962ae25d719 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 27 May 2024 17:36:13 -0400
Subject: [PATCH 011/112] Use refinedWire vs refinedWireOnSurface in
 appropriate cases

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 24 ++++++++++++-------
 ...fvpWireframeSelectionHighlightSceneIndex.h |  2 +-
 2 files changed, 17 insertions(+), 9 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index b5da0090df..2d670a06f0 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -62,7 +62,7 @@ TF_DEFINE_PRIVATE_TOKENS(
      (overrideWireframeColor)    // Works in HdStorm to override the wireframe color
  );
 
-const HdRetainedContainerDataSourceHandle sRefinedWireOnSurfaceDisplayStyleDataSource
+const HdRetainedContainerDataSourceHandle sRefinedWireDisplayStyleDataSource
     = HdRetainedContainerDataSource::New(
         HdLegacyDisplayStyleSchemaTokens->displayStyle,
         HdRetainedContainerDataSource::New(
@@ -70,6 +70,14 @@ const HdRetainedContainerDataSourceHandle sRefinedWireOnSurfaceDisplayStyleDataS
             HdRetainedTypedSampledDataSource<VtArray<TfToken>>::New(
                 { HdReprTokens->refinedWire, TfToken(), TfToken() })));
 
+const HdRetainedContainerDataSourceHandle sRefinedWireOnSurfaceDisplayStyleDataSource
+    = HdRetainedContainerDataSource::New(
+        HdLegacyDisplayStyleSchemaTokens->displayStyle,
+        HdRetainedContainerDataSource::New(
+            HdLegacyDisplayStyleSchemaTokens->reprSelector,
+            HdRetainedTypedSampledDataSource<VtArray<TfToken>>::New(
+                { HdReprTokens->refinedWireOnSurf, TfToken(), TfToken() })));
+
 const HdDataSourceLocator reprSelectorLocator(
         HdLegacyDisplayStyleSchemaTokens->displayStyle,
         HdLegacyDisplayStyleSchemaTokens->reprSelector);
@@ -623,7 +631,7 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
             prim.dataSource = WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexContainerDataSource::New(prim.dataSource, this);
         }
         if (prim.primType == HdPrimTypeTokens->mesh) {
-            prim.dataSource = _HighlightSelectedPrim(prim.dataSource, originalPrimPath);
+            prim.dataSource = _HighlightSelectedPrim(prim.dataSource, originalPrimPath, sRefinedWireDisplayStyleDataSource);
         }
         if (prim.primType == HdPrimTypeTokens->instancer) {
             prim.dataSource = _GetSelectionHighlightInstancerDataSource(prim.dataSource);
@@ -639,14 +647,14 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         // prim (even though it should already not be drawn due to being under an instancer, this is an additional safety? to confirm)
         if (_IsPrototype(primPath)) {
             if (_selection->IsFullySelected(primPath)) {
-                prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath);
+                prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
             }
             else if (_highlightedProtoPaths.find(primPath) != _highlightedProtoPaths.end()) {
-                prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath);
+                prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
             }
         } else {
             if (_selection->HasFullySelectedAncestorInclusive(primPath)) {
-                prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath);
+                prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
             }
         }
     }
@@ -681,7 +689,7 @@ WireframeSelectionHighlightSceneIndex::GetChildPrimPaths(const SdfPath &primPath
 }
 
 //We want to set the displayStyle of the selected prim to refinedWireOnSurf only if the displayStyle of the prim is refined (meaning shaded)
-HdContainerDataSourceHandle WireframeSelectionHighlightSceneIndex::_HighlightSelectedPrim(const HdContainerDataSourceHandle& dataSource, const SdfPath& primPath)const
+HdContainerDataSourceHandle WireframeSelectionHighlightSceneIndex::_HighlightSelectedPrim(const HdContainerDataSourceHandle& dataSource, const SdfPath& primPath, const HdContainerDataSourceHandle& highlightDataSource) const
 {
     //Always edit its override wireframe color
     auto edited = HdContainerDataSourceEditor(dataSource);
@@ -701,11 +709,11 @@ HdContainerDataSourceHandle WireframeSelectionHighlightSceneIndex::_HighlightSel
             TfToken refinedToken = ar[0];
             if(HdReprTokens->refined == refinedToken){
                 //Is in refined display style, apply the wire on top of shaded reprselector
-                return HdOverlayContainerDataSource::New({ edited.Finish(), sRefinedWireOnSurfaceDisplayStyleDataSource});
+                return HdOverlayContainerDataSource::New({ edited.Finish(), highlightDataSource});
             }
         }else{
             //No reprSelector found, assume it's in the Collection that we have set HdReprTokens->refined
-            return HdOverlayContainerDataSource::New({ edited.Finish(), sRefinedWireOnSurfaceDisplayStyleDataSource});
+            return HdOverlayContainerDataSource::New({ edited.Finish(), highlightDataSource});
         }
     }
 
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index fb9e379fae..b50e60079d 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -109,7 +109,7 @@ class WireframeSelectionHighlightSceneIndex
     bool _IsExcluded(const PXR_NS::SdfPath& sceneRoot) const;
 
     std::set<PXR_NS::SdfPath> _excludedSceneRoots;
-    PXR_NS::HdContainerDataSourceHandle _HighlightSelectedPrim(const PXR_NS::HdContainerDataSourceHandle& dataSource, const PXR_NS::SdfPath& primPath)const;
+    PXR_NS::HdContainerDataSourceHandle _HighlightSelectedPrim(const PXR_NS::HdContainerDataSourceHandle& dataSource, const PXR_NS::SdfPath& primPath, const PXR_NS::HdContainerDataSourceHandle& highlightDataSource) const;
 
     bool _IsPrototypeRoot(const PXR_NS::SdfPath& primPath);
     bool _IsInstancingRoot(const PXR_NS::SdfPath& primPath) const;

From 4253847e7f2d628652d99b5d3b0fa9011e61b73c Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 10:27:27 -0400
Subject: [PATCH 012/112] Hardcode wireframe color for now

---
 .../fvpWireframeSelectionHighlightSceneIndex.cpp         | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 2d670a06f0..61c24fc0e2 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -16,12 +16,15 @@
 
 #include "flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h"
 #include "flowViewport/selection/fvpSelection.h"
+#include "flowViewport/colorPreferences/fvpColorPreferences.h"
+#include "flowViewport/colorPreferences/fvpColorPreferencesTokens.h"
 #include "flowViewport/fvpUtils.h"
 
 #include "flowViewport/debugCodes.h"
 #include "fvpWireframeSelectionHighlightSceneIndex.h"
 
 #include <pxr/base/gf/matrix4d.h>
+#include <pxr/base/gf/vec4f.h>
 #include <pxr/base/tf/diagnosticLite.h>
 #include <pxr/base/vt/array.h>
 #include <pxr/base/vt/types.h>
@@ -693,9 +696,13 @@ HdContainerDataSourceHandle WireframeSelectionHighlightSceneIndex::_HighlightSel
 {
     //Always edit its override wireframe color
     auto edited = HdContainerDataSourceEditor(dataSource);
+
+    // TODO HYDRA-1047 : Handle the different wireframe selection highlight colors
+    GfVec4f wireframeColor;
+    ColorPreferences::getInstance().getColor(FvpColorPreferencesTokens->wireframeSelection, wireframeColor);
     edited.Set(HdPrimvarsSchema::GetDefaultLocator().Append(_primVarsTokens->overrideWireframeColor),
                         Fvp::PrimvarDataSource::New(
-                            HdRetainedTypedSampledDataSource<VtVec4fArray>::New(VtVec4fArray{_wireframeColorInterface->getWireframeColor(primPath)}),
+                            HdRetainedTypedSampledDataSource<VtVec4fArray>::New(VtVec4fArray{wireframeColor}),
                             HdPrimvarSchemaTokens->constant,
                             HdPrimvarSchemaTokens->color));
     

From 5fab06c9932d8655b5add5382c17d788de36659b Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 10:46:43 -0400
Subject: [PATCH 013/112] Refactor method to get selection highlight path of a
 prim

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 24 +++++++++----------
 ...fvpWireframeSelectionHighlightSceneIndex.h |  4 +++-
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 61c24fc0e2..7a620b2085 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -183,7 +183,7 @@ WireframeSelectionHighlightSceneIndex::_FindSelectionHighlightMirrorAncestor(con
 }
 
 SdfPath
-WireframeSelectionHighlightSceneIndex::_RepathToSelectionHighlightMirror(const SdfPath& path) const
+WireframeSelectionHighlightSceneIndex::GetSelectionHighlightPath(const SdfPath& path) const
 {
     auto ancestorsRange = path.GetAncestorsRange();
     for (auto ancestor : ancestorsRange) {
@@ -192,7 +192,7 @@ WireframeSelectionHighlightSceneIndex::_RepathToSelectionHighlightMirror(const S
             return path.ReplacePrefix(ancestor, mirrorPath);
         }
     }
-    return SdfPath::EmptyPath();
+    return path;
 }
 
 class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathDataSource : public HdPathDataSource
@@ -233,8 +233,7 @@ class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathDataSource
         }
 
         const SdfPath srcPath = _inputDataSource->GetTypedValue(shutterOffset);
-        const SdfPath mirrorPath =_inputSceneIndex->_RepathToSelectionHighlightMirror(srcPath);
-        return mirrorPath.IsEmpty() ? srcPath : mirrorPath;
+        return _inputSceneIndex->GetSelectionHighlightPath(srcPath);
     }
 
 private:
@@ -285,10 +284,7 @@ class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathArrayDataSo
             = _inputDataSource->GetTypedValue(shutterOffset);
 
         for (size_t i = 0; i < result.size(); i++) {
-            const SdfPath mirrorPath = _inputSceneIndex->_RepathToSelectionHighlightMirror(result[i]);
-            if (!mirrorPath.IsEmpty()) {
-                result[i] = mirrorPath;
-            }
+            result[i] = _inputSceneIndex->GetSelectionHighlightPath(result[i]);
         }
 
         return result;
@@ -818,14 +814,16 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
         _SendPrimsDirtied(dirtiedSelectedMeshProtos);
     }
 
-    HdSceneIndexObserver::DirtiedPrimEntries dirtiedShMirrors;
+    HdSceneIndexObserver::DirtiedPrimEntries dirtiedSelectionHighlightPrims;
     for (const auto& entry : entries) {
-        auto shMirrorPath = _RepathToSelectionHighlightMirror(entry.primPath);
-        if (!shMirrorPath.IsEmpty()) {
-            dirtiedShMirrors.emplace_back(shMirrorPath, entry.dirtyLocators);
+        auto selectionHighlightPath = GetSelectionHighlightPath(entry.primPath);
+        if (selectionHighlightPath != entry.primPath) {
+            dirtiedSelectionHighlightPrims.emplace_back(selectionHighlightPath, entry.dirtyLocators);
         }
     }
-    _SendPrimsDirtied(dirtiedShMirrors);
+    if (!dirtiedSelectionHighlightPrims.empty()) {
+        _SendPrimsDirtied(dirtiedSelectionHighlightPrims);
+    }
 
     HdSceneIndexObserver::AddedPrimEntries newSelectionHighlightPrims;
     HdSceneIndexObserver::RemovedPrimEntries removedSelectionHighlightPrims;
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index b50e60079d..d5e59da57f 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -75,6 +75,9 @@ class WireframeSelectionHighlightSceneIndex
     FVP_API
     void addExcludedSceneRoot(const PXR_NS::SdfPath& sceneRoot);
 
+    FVP_API
+    PXR_NS::SdfPath GetSelectionHighlightPath(const PXR_NS::SdfPath& path) const;
+
 protected:
 
     FVP_API
@@ -122,7 +125,6 @@ class WireframeSelectionHighlightSceneIndex
     void _CreateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
 
     PXR_NS::SdfPath _FindSelectionHighlightMirrorAncestor(const PXR_NS::SdfPath& path) const;
-    PXR_NS::SdfPath _RepathToSelectionHighlightMirror(const PXR_NS::SdfPath& path) const;
 
     const SelectionConstPtr   _selection;
     const std::shared_ptr<WireframeColorInterface> _wireframeColorInterface;

From 26f9ed6f41c33c19c0d048144ef41b8145a3614d Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 11:01:16 -0400
Subject: [PATCH 014/112] Rework selection highlight repathing data sources

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 137 ++++++++----------
 ...fvpWireframeSelectionHighlightSceneIndex.h |   3 -
 2 files changed, 62 insertions(+), 78 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 7a620b2085..b9239401a0 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -166,43 +166,14 @@ bool _IsInstancerWithSelections(const HdSceneIndexPrim& prim)
     return selections.IsDefined() && selections.GetNumElements() > 0;
 }
 
-}
-
-namespace FVP_NS_DEF {
-
-SdfPath
-WireframeSelectionHighlightSceneIndex::_FindSelectionHighlightMirrorAncestor(const SdfPath& path) const
-{
-    auto ancestorsRange = path.GetAncestorsRange();
-    for (auto ancestor : ancestorsRange) {
-        if (_shMirrorsUseCount.find(ancestor) != _shMirrorsUseCount.end()) {
-            return ancestor;
-        }
-    }
-    return SdfPath::EmptyPath();
-}
-
-SdfPath
-WireframeSelectionHighlightSceneIndex::GetSelectionHighlightPath(const SdfPath& path) const
-{
-    auto ancestorsRange = path.GetAncestorsRange();
-    for (auto ancestor : ancestorsRange) {
-        const SdfPath mirrorPath = _GetSelectionHighlightMirrorPathFromOriginal(ancestor);
-        if (_shMirrorsUseCount.find(mirrorPath) != _shMirrorsUseCount.end()) {
-            return path.ReplacePrefix(ancestor, mirrorPath);
-        }
-    }
-    return path;
-}
-
-class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathDataSource : public HdPathDataSource
+class _SelectionHighlightRepathingPathDataSource : public HdPathDataSource
 {
 public:
-    HD_DECLARE_DATASOURCE(_RerootingSceneIndexPathDataSource)
+    HD_DECLARE_DATASOURCE(_SelectionHighlightRepathingPathDataSource)
 
-    _RerootingSceneIndexPathDataSource(
+    _SelectionHighlightRepathingPathDataSource(
         HdPathDataSourceHandle const &inputDataSource,
-        WireframeSelectionHighlightSceneIndex const * const inputSceneIndex)
+        Fvp::WireframeSelectionHighlightSceneIndex const * const inputSceneIndex)
       : _inputDataSource(inputDataSource),
         _inputSceneIndex(inputSceneIndex)
     {
@@ -222,8 +193,7 @@ class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathDataSource
             return false;
         }
 
-        return _inputDataSource->GetContributingSampleTimesForInterval(
-                startTime, endTime, outSampleTimes);
+        return _inputDataSource->GetContributingSampleTimesForInterval(startTime, endTime, outSampleTimes);
     }
 
     SdfPath GetTypedValue(const Time shutterOffset) override
@@ -232,25 +202,25 @@ class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathDataSource
             return SdfPath();
         }
 
-        const SdfPath srcPath = _inputDataSource->GetTypedValue(shutterOffset);
-        return _inputSceneIndex->GetSelectionHighlightPath(srcPath);
+        const SdfPath originalPath = _inputDataSource->GetTypedValue(shutterOffset);
+        return _inputSceneIndex->GetSelectionHighlightPath(originalPath);
     }
 
 private:
     HdPathDataSourceHandle const _inputDataSource;
-    WireframeSelectionHighlightSceneIndex const * const _inputSceneIndex;
+    Fvp::WireframeSelectionHighlightSceneIndex const * const _inputSceneIndex;
 };
 
 // ----------------------------------------------------------------------------
 
-class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathArrayDataSource : public HdPathArrayDataSource
+class _SelectionHighlightRepathingPathArrayDataSource : public HdPathArrayDataSource
 {
 public:
-    HD_DECLARE_DATASOURCE(_RerootingSceneIndexPathArrayDataSource)
+    HD_DECLARE_DATASOURCE(_SelectionHighlightRepathingPathArrayDataSource)
 
-    _RerootingSceneIndexPathArrayDataSource(
+    _SelectionHighlightRepathingPathArrayDataSource(
         HdPathArrayDataSourceHandle const & inputDataSource,
-        WireframeSelectionHighlightSceneIndex const * const inputSceneIndex)
+        Fvp::WireframeSelectionHighlightSceneIndex const * const inputSceneIndex)
       : _inputDataSource(inputDataSource),
         _inputSceneIndex(inputSceneIndex)
     {
@@ -270,8 +240,7 @@ class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathArrayDataSo
             return false;
         }
 
-        return _inputDataSource->GetContributingSampleTimesForInterval(
-            startTime, endTime, outSampleTimes);
+        return _inputDataSource->GetContributingSampleTimesForInterval(startTime, endTime, outSampleTimes);
     }
 
     VtArray<SdfPath> GetTypedValue(const Time shutterOffset) override
@@ -280,11 +249,9 @@ class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathArrayDataSo
             return {};
         }
 
-        VtArray<SdfPath> result
-            = _inputDataSource->GetTypedValue(shutterOffset);
-
-        for (size_t i = 0; i < result.size(); i++) {
-            result[i] = _inputSceneIndex->GetSelectionHighlightPath(result[i]);
+        VtArray<SdfPath> result = _inputDataSource->GetTypedValue(shutterOffset);
+        for (auto& path : result) {
+            path = _inputSceneIndex->GetSelectionHighlightPath(path);
         }
 
         return result;
@@ -292,19 +259,19 @@ class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexPathArrayDataSo
 
 private:
     HdPathArrayDataSourceHandle const _inputDataSource;
-    WireframeSelectionHighlightSceneIndex const * const _inputSceneIndex;
+    Fvp::WireframeSelectionHighlightSceneIndex const * const _inputSceneIndex;
 };
 
 // ----------------------------------------------------------------------------
 
-class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexContainerDataSource : public HdContainerDataSource
+class _SelectionHighlightRepathingContainerDataSource : public HdContainerDataSource
 {
 public:
-    HD_DECLARE_DATASOURCE(_RerootingSceneIndexContainerDataSource)
+    HD_DECLARE_DATASOURCE(_SelectionHighlightRepathingContainerDataSource)
 
-    _RerootingSceneIndexContainerDataSource(
+    _SelectionHighlightRepathingContainerDataSource(
         HdContainerDataSourceHandle const &inputDataSource,
-        WireframeSelectionHighlightSceneIndex const * const inputSceneIndex)
+        Fvp::WireframeSelectionHighlightSceneIndex const * const inputSceneIndex)
       : _inputDataSource(inputDataSource),
         _inputSceneIndex(inputSceneIndex)
     {
@@ -312,11 +279,7 @@ class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexContainerDataSo
 
     TfTokenVector GetNames() override
     {
-        if (!_inputDataSource) {
-            return {};
-        }
-
-        return _inputDataSource->GetNames();
+        return _inputDataSource ? _inputDataSource->GetNames() : TfTokenVector();
     }
 
     HdDataSourceBaseHandle Get(const TfToken& name) override
@@ -325,36 +288,60 @@ class WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexContainerDataSo
             return nullptr;
         }
 
-        // wrap child containers so that we can wrap their children
-        HdDataSourceBaseHandle const childSource = _inputDataSource->Get(name);
-        if (!childSource) {
+        HdDataSourceBaseHandle const childDataSource = _inputDataSource->Get(name);
+        if (!childDataSource) {
             return nullptr;
         }
 
-        if (auto childContainer =
-                HdContainerDataSource::Cast(childSource)) {
-            return New(std::move(childContainer), _inputSceneIndex);
+        if (auto childContainerDataSource = HdContainerDataSource::Cast(childDataSource)) {
+            return New(childContainerDataSource, _inputSceneIndex);
         }
 
-        if (auto childPathDataSource =
-                HdTypedSampledDataSource<SdfPath>::Cast(childSource)) {
-            return _RerootingSceneIndexPathDataSource::New(childPathDataSource, _inputSceneIndex);
+        if (auto childPathDataSource = HdTypedSampledDataSource<SdfPath>::Cast(childDataSource)) {
+            return _SelectionHighlightRepathingPathDataSource::New(childPathDataSource, _inputSceneIndex);
         }
 
-        if (auto childPathArrayDataSource =
-                HdTypedSampledDataSource<VtArray<SdfPath>>::Cast(
-                    childSource)) {
-            return _RerootingSceneIndexPathArrayDataSource::New(childPathArrayDataSource, _inputSceneIndex);
+        if (auto childPathArrayDataSource = HdTypedSampledDataSource<VtArray<SdfPath>>::Cast(childDataSource)) {
+            return _SelectionHighlightRepathingPathArrayDataSource::New(childPathArrayDataSource, _inputSceneIndex);
         }
 
-        return childSource;
+        return childDataSource;
     }
 
 private:
     HdContainerDataSourceHandle const _inputDataSource;
-    WireframeSelectionHighlightSceneIndex const * const _inputSceneIndex;
+    Fvp::WireframeSelectionHighlightSceneIndex const * const _inputSceneIndex;
 };
 
+}
+
+namespace FVP_NS_DEF {
+
+SdfPath
+WireframeSelectionHighlightSceneIndex::_FindSelectionHighlightMirrorAncestor(const SdfPath& path) const
+{
+    auto ancestorsRange = path.GetAncestorsRange();
+    for (auto ancestor : ancestorsRange) {
+        if (_shMirrorsUseCount.find(ancestor) != _shMirrorsUseCount.end()) {
+            return ancestor;
+        }
+    }
+    return SdfPath::EmptyPath();
+}
+
+SdfPath
+WireframeSelectionHighlightSceneIndex::GetSelectionHighlightPath(const SdfPath& path) const
+{
+    auto ancestorsRange = path.GetAncestorsRange();
+    for (auto ancestor : ancestorsRange) {
+        const SdfPath mirrorPath = _GetSelectionHighlightMirrorPathFromOriginal(ancestor);
+        if (_shMirrorsUseCount.find(mirrorPath) != _shMirrorsUseCount.end()) {
+            return path.ReplacePrefix(ancestor, mirrorPath);
+        }
+    }
+    return path;
+}
+
 HdSceneIndexBaseRefPtr
 WireframeSelectionHighlightSceneIndex::New(
     const HdSceneIndexBaseRefPtr& inputSceneIndex,
@@ -627,7 +614,7 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         SdfPath originalPrimPath = primPath.ReplacePrefix(shMirrorAncestor, _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestor));
         HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(originalPrimPath);
         if (prim.dataSource) {
-            prim.dataSource = WireframeSelectionHighlightSceneIndex::_RerootingSceneIndexContainerDataSource::New(prim.dataSource, this);
+            prim.dataSource = _SelectionHighlightRepathingContainerDataSource::New(prim.dataSource, this);
         }
         if (prim.primType == HdPrimTypeTokens->mesh) {
             prim.dataSource = _HighlightSelectedPrim(prim.dataSource, originalPrimPath, sRefinedWireDisplayStyleDataSource);
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index d5e59da57f..06de2183c4 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -132,9 +132,6 @@ class WireframeSelectionHighlightSceneIndex
     std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _shMirrorsByInstancer;
     std::unordered_map<PXR_NS::SdfPath, size_t, PXR_NS::SdfPath::Hash> _shMirrorsUseCount;
     std::set<PXR_NS::SdfPath> _highlightedProtoPaths;
-    class _RerootingSceneIndexPathDataSource;
-    class _RerootingSceneIndexPathArrayDataSource;
-    class _RerootingSceneIndexContainerDataSource;
 };
 
 }

From 096307f08fbec952e6883de7a0e681bfce790358 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 11:18:59 -0400
Subject: [PATCH 015/112] Cleanup GetPrim

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 34 +++++++++----------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index b9239401a0..d46ea20aab 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -609,42 +609,42 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         return GetInputSceneIndex()->GetPrim(primPath);
     }
     
-    SdfPath shMirrorAncestor = _FindSelectionHighlightMirrorAncestor(primPath);
-    if (!shMirrorAncestor.IsEmpty()) {
-        SdfPath originalPrimPath = primPath.ReplacePrefix(shMirrorAncestor, _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestor));
-        HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(originalPrimPath);
-        if (prim.dataSource) {
-            prim.dataSource = _SelectionHighlightRepathingContainerDataSource::New(prim.dataSource, this);
+    // Is this prim part of a selection highlight mirror hierarchy?
+    // If so, then we are dealing with a point instancer or instance selection.
+    SdfPath shMirrorAncestorPath = _FindSelectionHighlightMirrorAncestor(primPath);
+    if (!shMirrorAncestorPath.IsEmpty()) {
+        SdfPath originalPrimPath = primPath.ReplacePrefix(shMirrorAncestorPath, _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestorPath));
+        HdSceneIndexPrim shPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
+        if (shPrim.dataSource) {
+            shPrim.dataSource = _SelectionHighlightRepathingContainerDataSource::New(shPrim.dataSource, this);
         }
-        if (prim.primType == HdPrimTypeTokens->mesh) {
-            prim.dataSource = _HighlightSelectedPrim(prim.dataSource, originalPrimPath, sRefinedWireDisplayStyleDataSource);
+        if (shPrim.primType == HdPrimTypeTokens->mesh) {
+            shPrim.dataSource = _HighlightSelectedPrim(shPrim.dataSource, originalPrimPath, sRefinedWireDisplayStyleDataSource);
         }
-        if (prim.primType == HdPrimTypeTokens->instancer) {
-            prim.dataSource = _GetSelectionHighlightInstancerDataSource(prim.dataSource);
+        if (shPrim.primType == HdPrimTypeTokens->instancer) {
+            shPrim.dataSource = _GetSelectionHighlightInstancerDataSource(shPrim.dataSource);
         }
-        return prim;
+        return shPrim;
     }
     
+    // We may be dealing with a prototype selection, a regular selection, or no selection at all.
     HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
-
     if (prim.primType == HdPrimTypeTokens->mesh) {
         // Note : in the USD data model, the original prims that get propagated as prototypes have their original prim types erased.
         // Only the resulting propagated prototypes keep the original prim type. Presumably this is to avoid drawing the original
         // prim (even though it should already not be drawn due to being under an instancer, this is an additional safety? to confirm)
         if (_IsPrototype(primPath)) {
-            if (_selection->IsFullySelected(primPath)) {
-                prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
-            }
-            else if (_highlightedProtoPaths.find(primPath) != _highlightedProtoPaths.end()) {
+            // Prototype selection
+            if (_selection->IsFullySelected(primPath) || _highlightedProtoPaths.find(primPath) != _highlightedProtoPaths.end()) {
                 prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
             }
         } else {
+            // Regular selection
             if (_selection->HasFullySelectedAncestorInclusive(primPath)) {
                 prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
             }
         }
     }
-
     return prim;
 }
 

From 4e93f73de293a8c16c66daa0e0abd9fcf3972ce7 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 11:48:16 -0400
Subject: [PATCH 016/112] Rename methods for collecting affected SdfPaths

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 26 +++++++++----------
 ...fvpWireframeSelectionHighlightSceneIndex.h |  4 +--
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index d46ea20aab..51b6fa945e 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -358,37 +358,37 @@ const HdDataSourceLocator& WireframeSelectionHighlightSceneIndex::ReprSelectorLo
 }
 
 SdfPathVector
-WireframeSelectionHighlightSceneIndex::_CollectAffectedOriginalPrimPaths(const SdfPath& originalPrimPath)
+WireframeSelectionHighlightSceneIndex::_GetInstancingRelatedPaths(const SdfPath& originalPrimPath)
 {
     TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
 
     HdSceneIndexPrim originalPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
-    SdfPathVector affectedOriginalPrimPaths;
-
+    
     HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(originalPrim.dataSource);
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(originalPrim.dataSource);
-    HdSelectionsSchema selections = HdSelectionsSchema::GetFromParent(originalPrim.dataSource);
+    
+    SdfPathVector instancingRelatedPaths;
 
     if (instancerTopology.IsDefined()) {
         auto protoPaths = instancerTopology.GetPrototypes()->GetTypedValue(0);
         for (const auto& protoPath : protoPaths) {
-            affectedOriginalPrimPaths.push_back(protoPath);
+            instancingRelatedPaths.push_back(protoPath);
         }
     }
 
     if (instancedBy.IsDefined()) {
         auto instancerPaths = instancedBy.GetPaths()->GetTypedValue(0);
         for (const auto& instancerPath : instancerPaths) {
-            affectedOriginalPrimPaths.push_back(instancerPath);
+            instancingRelatedPaths.push_back(instancerPath);
         }
 
         auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
         for (const auto& protoRootPath : protoRootPaths) {
-            affectedOriginalPrimPaths.push_back(protoRootPath);
+            instancingRelatedPaths.push_back(protoRootPath);
         }
     }
 
-    return affectedOriginalPrimPaths;
+    return instancingRelatedPaths;
 }
 
 bool
@@ -474,7 +474,7 @@ WireframeSelectionHighlightSceneIndex(
 }
 
 bool
-WireframeSelectionHighlightSceneIndex::_CollectShMirrorPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outShMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outCreatedPrims)
+WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outShMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outCreatedPrims)
 {
     // This should never be called on selection highlight mirrors, only on original prims
     TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
@@ -492,7 +492,7 @@ WireframeSelectionHighlightSceneIndex::_CollectShMirrorPaths(const PXR_NS::SdfPa
         if (instancedBy.IsDefined()) {
             auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
             for (const auto& protoRootPath : protoRootPaths) {
-                result = result || _CollectShMirrorPaths(protoRootPath, outShMirrorPaths, outCreatedPrims);
+                result = result || _CollectSelectionHighlightPaths(protoRootPath, outShMirrorPaths, outCreatedPrims);
             }
         }
         return result;
@@ -519,7 +519,7 @@ WireframeSelectionHighlightSceneIndex::_CollectShMirrorPaths(const PXR_NS::SdfPa
         HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
         outCreatedPrims.push_back({currPath.ReplacePrefix(originalPrimPath, selectionHighlightPrimPath), currPrim.primType});
         if (currPrim.primType == HdPrimTypeTokens->instancer) {
-            SdfPathVector extraAffectedOriginalPrimPaths = _CollectAffectedOriginalPrimPaths(currPath);
+            SdfPathVector extraAffectedOriginalPrimPaths = _GetInstancingRelatedPaths(currPath);
             std::cout << "Processing extra paths for : " << currPath.GetString() << std::endl;
             for (const auto& path : extraAffectedOriginalPrimPaths) {
                 {
@@ -536,7 +536,7 @@ WireframeSelectionHighlightSceneIndex::_CollectShMirrorPaths(const PXR_NS::SdfPa
     }
 
     for (const auto& affectedOriginalPrimPath : affectedOriginalPrimPaths) {
-        _CollectShMirrorPaths(affectedOriginalPrimPath, outShMirrorPaths, outCreatedPrims);
+        _CollectSelectionHighlightPaths(affectedOriginalPrimPath, outShMirrorPaths, outCreatedPrims);
     }
 
     return true;
@@ -581,7 +581,7 @@ WireframeSelectionHighlightSceneIndex::_CreateShMirrorsForInstancer(const PXR_NS
 
     SdfPathSet newShMirrors;
     HdSceneIndexObserver::AddedPrimEntries addedPrims;
-    _CollectShMirrorPaths(instancerPath, newShMirrors, addedPrims);
+    _CollectSelectionHighlightPaths(instancerPath, newShMirrors, addedPrims);
 
     _shMirrorsByInstancer[instancerPath] = newShMirrors;
     for (const auto& shMirror : newShMirrors) {
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 06de2183c4..a0fb8587b6 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -119,8 +119,8 @@ class WireframeSelectionHighlightSceneIndex
     bool _IsPropagatedPrototype(const PXR_NS::SdfPath& primPath) const;
     bool _IsPrototype(const PXR_NS::SdfPath& primPath) const;
 
-    PXR_NS::SdfPathVector _CollectAffectedOriginalPrimPaths(const PXR_NS::SdfPath& primPath);
-    bool _CollectShMirrorPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outShMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outCreatedPrims);
+    PXR_NS::SdfPathVector _GetInstancingRelatedPaths(const PXR_NS::SdfPath& primPath);
+    bool _CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outShMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outCreatedPrims);
     void _RemoveShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
     void _CreateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
 

From 2e59fa10e85c8ff4deb65c4b25f66853d62ace61 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 12:20:19 -0400
Subject: [PATCH 017/112] Cleanup

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 50 ++++++-------------
 ...fvpWireframeSelectionHighlightSceneIndex.h |  4 +-
 2 files changed, 17 insertions(+), 37 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 51b6fa945e..dbc34154aa 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -358,14 +358,10 @@ const HdDataSourceLocator& WireframeSelectionHighlightSceneIndex::ReprSelectorLo
 }
 
 SdfPathVector
-WireframeSelectionHighlightSceneIndex::_GetInstancingRelatedPaths(const SdfPath& originalPrimPath)
+WireframeSelectionHighlightSceneIndex::_GetInstancingRelatedPaths(const HdContainerDataSourceHandle& dataSource)
 {
-    TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
-
-    HdSceneIndexPrim originalPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
-    
-    HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(originalPrim.dataSource);
-    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(originalPrim.dataSource);
+    HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(dataSource);
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(dataSource);
     
     SdfPathVector instancingRelatedPaths;
 
@@ -473,35 +469,26 @@ WireframeSelectionHighlightSceneIndex(
     }
 }
 
-bool
+void
 WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outShMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outCreatedPrims)
 {
     // This should never be called on selection highlight mirrors, only on original prims
     TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
 
-    static std::mutex printMutex;
-    {
-        std::lock_guard printLock(printMutex);
-        std::cout << "Processing : " << originalPrimPath.GetString() << std::endl;
-    }
-
     if (!_IsInstancingRoot(originalPrimPath)) {
         HdSceneIndexPrim originalPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
         HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(originalPrim.dataSource);
-        bool result = false;
-        if (instancedBy.IsDefined()) {
-            auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
-            for (const auto& protoRootPath : protoRootPaths) {
-                result = result || _CollectSelectionHighlightPaths(protoRootPath, outShMirrorPaths, outCreatedPrims);
-            }
+        auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
+        for (const auto& protoRootPath : protoRootPaths) {
+            _CollectSelectionHighlightPaths(protoRootPath, outShMirrorPaths, outCreatedPrims);
         }
-        return result;
+        return;
     }
     
     SdfPath selectionHighlightPrimPath = _GetSelectionHighlightMirrorPathFromOriginal(originalPrimPath);
     
     if (outShMirrorPaths.find(selectionHighlightPrimPath) != outShMirrorPaths.end()) {
-        return false;
+        return;
     }
     outShMirrorPaths.insert(selectionHighlightPrimPath);
 
@@ -511,23 +498,18 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightPaths(const PXR
         SdfPath currPath = pathsToTraverse.top();
         pathsToTraverse.pop();
 
-        // TODO : Propagated protos only or all protos?
-        if (_IsPropagatedPrototype(currPath) && _IsInstancingRoot(currPath) && currPath != originalPrimPath) {
+        // Skip processing of prototypes nested under the prim's hierarchy, as prototypes should be processed by
+        // traversing the instancing-related paths of instancers and instancees. And if they aren't, then it means
+        // the prototype is either not instanced in the first place, or is part of a different instancing hierarchy.
+        if (_IsPrototype(currPath) && _IsInstancingRoot(currPath) && currPath != originalPrimPath) {
             continue;
         }
 
         HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
         outCreatedPrims.push_back({currPath.ReplacePrefix(originalPrimPath, selectionHighlightPrimPath), currPrim.primType});
         if (currPrim.primType == HdPrimTypeTokens->instancer) {
-            SdfPathVector extraAffectedOriginalPrimPaths = _GetInstancingRelatedPaths(currPath);
-            std::cout << "Processing extra paths for : " << currPath.GetString() << std::endl;
-            for (const auto& path : extraAffectedOriginalPrimPaths) {
-                {
-                    std::lock_guard printLock(printMutex);
-                    std::cout << "|-----Adding : " << path.GetString() << std::endl;
-                }
-            }
-            affectedOriginalPrimPaths.insert(affectedOriginalPrimPaths.end(), extraAffectedOriginalPrimPaths.begin(), extraAffectedOriginalPrimPaths.end());
+            SdfPathVector instancingRelatedPaths = _GetInstancingRelatedPaths(currPrim.dataSource);
+            affectedOriginalPrimPaths.insert(affectedOriginalPrimPaths.end(), instancingRelatedPaths.begin(), instancingRelatedPaths.end());
         }
 
         for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
@@ -538,8 +520,6 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightPaths(const PXR
     for (const auto& affectedOriginalPrimPath : affectedOriginalPrimPaths) {
         _CollectSelectionHighlightPaths(affectedOriginalPrimPath, outShMirrorPaths, outCreatedPrims);
     }
-
-    return true;
 }
 
 void 
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index a0fb8587b6..e297292008 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -119,8 +119,8 @@ class WireframeSelectionHighlightSceneIndex
     bool _IsPropagatedPrototype(const PXR_NS::SdfPath& primPath) const;
     bool _IsPrototype(const PXR_NS::SdfPath& primPath) const;
 
-    PXR_NS::SdfPathVector _GetInstancingRelatedPaths(const PXR_NS::SdfPath& primPath);
-    bool _CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outShMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outCreatedPrims);
+    PXR_NS::SdfPathVector _GetInstancingRelatedPaths(const PXR_NS::HdContainerDataSourceHandle& dataSource);
+    void _CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outShMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outCreatedPrims);
     void _RemoveShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
     void _CreateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
 

From bf7be91a83efab51511e98acd05c55bff0c88241 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 12:31:53 -0400
Subject: [PATCH 018/112] Reduce GetPrim calls

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 60 +++++++------------
 ...fvpWireframeSelectionHighlightSceneIndex.h | 11 ++--
 2 files changed, 26 insertions(+), 45 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index dbc34154aa..1e32d09a50 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -358,10 +358,10 @@ const HdDataSourceLocator& WireframeSelectionHighlightSceneIndex::ReprSelectorLo
 }
 
 SdfPathVector
-WireframeSelectionHighlightSceneIndex::_GetInstancingRelatedPaths(const HdContainerDataSourceHandle& dataSource)
+WireframeSelectionHighlightSceneIndex::_GetInstancingRelatedPaths(const HdSceneIndexPrim& prim)
 {
-    HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(dataSource);
-    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(dataSource);
+    HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(prim.dataSource);
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
     
     SdfPathVector instancingRelatedPaths;
 
@@ -388,26 +388,8 @@ WireframeSelectionHighlightSceneIndex::_GetInstancingRelatedPaths(const HdContai
 }
 
 bool
-WireframeSelectionHighlightSceneIndex::_IsPrototypeRoot(const SdfPath& primPath)
+WireframeSelectionHighlightSceneIndex::_IsInstancingRoot(const HdSceneIndexPrim& prim, const SdfPath& primPath) const
 {
-    HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
-    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
-    if (instancedBy.IsDefined()) {
-        auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
-        for (const auto& protoRootPath : protoRootPaths) {
-            if (protoRootPath == primPath) {
-                return true;
-            }
-        }
-        return false;
-    }
-    return true;
-}
-
-bool
-WireframeSelectionHighlightSceneIndex::_IsInstancingRoot(const SdfPath& primPath) const
-{
-    HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
     if (!instancedBy.IsDefined()) {
         return true;
@@ -425,17 +407,15 @@ WireframeSelectionHighlightSceneIndex::_IsInstancingRoot(const SdfPath& primPath
 }
 
 bool
-WireframeSelectionHighlightSceneIndex::_IsPropagatedPrototype(const SdfPath& primPath) const
+WireframeSelectionHighlightSceneIndex::_IsPropagatedPrototype(const HdSceneIndexPrim& prim) const
 {
-    HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
     return instancedBy.IsDefined() && instancedBy.GetPrototypeRoots() && !instancedBy.GetPrototypeRoots()->GetTypedValue(0).empty();
 }
 
 bool
-WireframeSelectionHighlightSceneIndex::_IsPrototype(const SdfPath& primPath) const
+WireframeSelectionHighlightSceneIndex::_IsPrototype(const HdSceneIndexPrim& prim) const
 {
-    HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
     return instancedBy.IsDefined();
 }
@@ -470,27 +450,27 @@ WireframeSelectionHighlightSceneIndex(
 }
 
 void
-WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outShMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outCreatedPrims)
+WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims)
 {
-    // This should never be called on selection highlight mirrors, only on original prims
+    // This should never be called on selection highlight prims, only on original prims
     TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
 
-    if (!_IsInstancingRoot(originalPrimPath)) {
-        HdSceneIndexPrim originalPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
+    HdSceneIndexPrim originalPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
+    if (!_IsInstancingRoot(originalPrim, originalPrimPath)) {
         HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(originalPrim.dataSource);
         auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
         for (const auto& protoRootPath : protoRootPaths) {
-            _CollectSelectionHighlightPaths(protoRootPath, outShMirrorPaths, outCreatedPrims);
+            _CollectSelectionHighlightPaths(protoRootPath, outSelectionHighlightMirrorPaths, outAddedPrims);
         }
         return;
     }
     
     SdfPath selectionHighlightPrimPath = _GetSelectionHighlightMirrorPathFromOriginal(originalPrimPath);
     
-    if (outShMirrorPaths.find(selectionHighlightPrimPath) != outShMirrorPaths.end()) {
+    if (outSelectionHighlightMirrorPaths.find(selectionHighlightPrimPath) != outSelectionHighlightMirrorPaths.end()) {
         return;
     }
-    outShMirrorPaths.insert(selectionHighlightPrimPath);
+    outSelectionHighlightMirrorPaths.insert(selectionHighlightPrimPath);
 
     SdfPathVector affectedOriginalPrimPaths;
     std::stack<SdfPath> pathsToTraverse({originalPrimPath});
@@ -498,17 +478,19 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightPaths(const PXR
         SdfPath currPath = pathsToTraverse.top();
         pathsToTraverse.pop();
 
+        HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
+
         // Skip processing of prototypes nested under the prim's hierarchy, as prototypes should be processed by
         // traversing the instancing-related paths of instancers and instancees. And if they aren't, then it means
         // the prototype is either not instanced in the first place, or is part of a different instancing hierarchy.
-        if (_IsPrototype(currPath) && _IsInstancingRoot(currPath) && currPath != originalPrimPath) {
+        if (_IsPrototype(currPrim) && _IsInstancingRoot(currPrim, currPath) && currPath != originalPrimPath) {
             continue;
         }
 
-        HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
-        outCreatedPrims.push_back({currPath.ReplacePrefix(originalPrimPath, selectionHighlightPrimPath), currPrim.primType});
+        outAddedPrims.push_back({currPath.ReplacePrefix(originalPrimPath, selectionHighlightPrimPath), currPrim.primType});
+
         if (currPrim.primType == HdPrimTypeTokens->instancer) {
-            SdfPathVector instancingRelatedPaths = _GetInstancingRelatedPaths(currPrim.dataSource);
+            SdfPathVector instancingRelatedPaths = _GetInstancingRelatedPaths(currPrim);
             affectedOriginalPrimPaths.insert(affectedOriginalPrimPaths.end(), instancingRelatedPaths.begin(), instancingRelatedPaths.end());
         }
 
@@ -518,7 +500,7 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightPaths(const PXR
     }
 
     for (const auto& affectedOriginalPrimPath : affectedOriginalPrimPaths) {
-        _CollectSelectionHighlightPaths(affectedOriginalPrimPath, outShMirrorPaths, outCreatedPrims);
+        _CollectSelectionHighlightPaths(affectedOriginalPrimPath, outSelectionHighlightMirrorPaths, outAddedPrims);
     }
 }
 
@@ -613,7 +595,7 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         // Note : in the USD data model, the original prims that get propagated as prototypes have their original prim types erased.
         // Only the resulting propagated prototypes keep the original prim type. Presumably this is to avoid drawing the original
         // prim (even though it should already not be drawn due to being under an instancer, this is an additional safety? to confirm)
-        if (_IsPrototype(primPath)) {
+        if (_IsPrototype(prim)) {
             // Prototype selection
             if (_selection->IsFullySelected(primPath) || _highlightedProtoPaths.find(primPath) != _highlightedProtoPaths.end()) {
                 prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index e297292008..e73dc70f63 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -114,13 +114,12 @@ class WireframeSelectionHighlightSceneIndex
     std::set<PXR_NS::SdfPath> _excludedSceneRoots;
     PXR_NS::HdContainerDataSourceHandle _HighlightSelectedPrim(const PXR_NS::HdContainerDataSourceHandle& dataSource, const PXR_NS::SdfPath& primPath, const PXR_NS::HdContainerDataSourceHandle& highlightDataSource) const;
 
-    bool _IsPrototypeRoot(const PXR_NS::SdfPath& primPath);
-    bool _IsInstancingRoot(const PXR_NS::SdfPath& primPath) const;
-    bool _IsPropagatedPrototype(const PXR_NS::SdfPath& primPath) const;
-    bool _IsPrototype(const PXR_NS::SdfPath& primPath) const;
+    bool _IsInstancingRoot(const PXR_NS::HdSceneIndexPrim& prim, const PXR_NS::SdfPath& primPath) const;
+    bool _IsPropagatedPrototype(const PXR_NS::HdSceneIndexPrim& prim) const;
+    bool _IsPrototype(const PXR_NS::HdSceneIndexPrim& prim) const;
 
-    PXR_NS::SdfPathVector _GetInstancingRelatedPaths(const PXR_NS::HdContainerDataSourceHandle& dataSource);
-    void _CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outShMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outCreatedPrims);
+    PXR_NS::SdfPathVector _GetInstancingRelatedPaths(const PXR_NS::HdSceneIndexPrim& prim);
+    void _CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims);
     void _RemoveShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
     void _CreateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
 

From e687b19d67769b539d1530e34ba2a8fcee73e17c Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 12:35:49 -0400
Subject: [PATCH 019/112] Move out some utility functions out of class

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 126 ++++++++----------
 ...fvpWireframeSelectionHighlightSceneIndex.h |   5 -
 2 files changed, 59 insertions(+), 72 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 1e32d09a50..32906d3102 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -166,6 +166,65 @@ bool _IsInstancerWithSelections(const HdSceneIndexPrim& prim)
     return selections.IsDefined() && selections.GetNumElements() > 0;
 }
 
+SdfPathVector _GetInstancingRelatedPaths(const HdSceneIndexPrim& prim)
+{
+    HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(prim.dataSource);
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+    
+    SdfPathVector instancingRelatedPaths;
+
+    if (instancerTopology.IsDefined()) {
+        auto protoPaths = instancerTopology.GetPrototypes()->GetTypedValue(0);
+        for (const auto& protoPath : protoPaths) {
+            instancingRelatedPaths.push_back(protoPath);
+        }
+    }
+
+    if (instancedBy.IsDefined()) {
+        auto instancerPaths = instancedBy.GetPaths()->GetTypedValue(0);
+        for (const auto& instancerPath : instancerPaths) {
+            instancingRelatedPaths.push_back(instancerPath);
+        }
+
+        auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
+        for (const auto& protoRootPath : protoRootPaths) {
+            instancingRelatedPaths.push_back(protoRootPath);
+        }
+    }
+
+    return instancingRelatedPaths;
+}
+
+bool _IsInstancingRoot(const HdSceneIndexPrim& prim, const SdfPath& primPath)
+{
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+    if (!instancedBy.IsDefined()) {
+        return true;
+    }
+    if (!instancedBy.GetPrototypeRoots()) {
+        return true;
+    }
+    auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
+    for (const auto& protoRootPath : protoRootPaths) {
+        if (protoRootPath == primPath) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool _IsPropagatedPrototype(const HdSceneIndexPrim& prim)
+{
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+    return instancedBy.IsDefined() && instancedBy.GetPrototypeRoots() && !instancedBy.GetPrototypeRoots()->GetTypedValue(0).empty();
+}
+
+bool _IsPrototype(const HdSceneIndexPrim& prim)
+{
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+    return instancedBy.IsDefined();
+}
+
 class _SelectionHighlightRepathingPathDataSource : public HdPathDataSource
 {
 public:
@@ -211,8 +270,6 @@ class _SelectionHighlightRepathingPathDataSource : public HdPathDataSource
     Fvp::WireframeSelectionHighlightSceneIndex const * const _inputSceneIndex;
 };
 
-// ----------------------------------------------------------------------------
-
 class _SelectionHighlightRepathingPathArrayDataSource : public HdPathArrayDataSource
 {
 public:
@@ -262,8 +319,6 @@ class _SelectionHighlightRepathingPathArrayDataSource : public HdPathArrayDataSo
     Fvp::WireframeSelectionHighlightSceneIndex const * const _inputSceneIndex;
 };
 
-// ----------------------------------------------------------------------------
-
 class _SelectionHighlightRepathingContainerDataSource : public HdContainerDataSource
 {
 public:
@@ -357,69 +412,6 @@ const HdDataSourceLocator& WireframeSelectionHighlightSceneIndex::ReprSelectorLo
     return reprSelectorLocator;
 }
 
-SdfPathVector
-WireframeSelectionHighlightSceneIndex::_GetInstancingRelatedPaths(const HdSceneIndexPrim& prim)
-{
-    HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(prim.dataSource);
-    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
-    
-    SdfPathVector instancingRelatedPaths;
-
-    if (instancerTopology.IsDefined()) {
-        auto protoPaths = instancerTopology.GetPrototypes()->GetTypedValue(0);
-        for (const auto& protoPath : protoPaths) {
-            instancingRelatedPaths.push_back(protoPath);
-        }
-    }
-
-    if (instancedBy.IsDefined()) {
-        auto instancerPaths = instancedBy.GetPaths()->GetTypedValue(0);
-        for (const auto& instancerPath : instancerPaths) {
-            instancingRelatedPaths.push_back(instancerPath);
-        }
-
-        auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
-        for (const auto& protoRootPath : protoRootPaths) {
-            instancingRelatedPaths.push_back(protoRootPath);
-        }
-    }
-
-    return instancingRelatedPaths;
-}
-
-bool
-WireframeSelectionHighlightSceneIndex::_IsInstancingRoot(const HdSceneIndexPrim& prim, const SdfPath& primPath) const
-{
-    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
-    if (!instancedBy.IsDefined()) {
-        return true;
-    }
-    if (!instancedBy.GetPrototypeRoots()) {
-        return true;
-    }
-    auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
-    for (const auto& protoRootPath : protoRootPaths) {
-        if (protoRootPath == primPath) {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool
-WireframeSelectionHighlightSceneIndex::_IsPropagatedPrototype(const HdSceneIndexPrim& prim) const
-{
-    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
-    return instancedBy.IsDefined() && instancedBy.GetPrototypeRoots() && !instancedBy.GetPrototypeRoots()->GetTypedValue(0).empty();
-}
-
-bool
-WireframeSelectionHighlightSceneIndex::_IsPrototype(const HdSceneIndexPrim& prim) const
-{
-    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
-    return instancedBy.IsDefined();
-}
-
 WireframeSelectionHighlightSceneIndex::
 WireframeSelectionHighlightSceneIndex(
     const HdSceneIndexBaseRefPtr& inputSceneIndex,
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index e73dc70f63..1ebafc121c 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -114,11 +114,6 @@ class WireframeSelectionHighlightSceneIndex
     std::set<PXR_NS::SdfPath> _excludedSceneRoots;
     PXR_NS::HdContainerDataSourceHandle _HighlightSelectedPrim(const PXR_NS::HdContainerDataSourceHandle& dataSource, const PXR_NS::SdfPath& primPath, const PXR_NS::HdContainerDataSourceHandle& highlightDataSource) const;
 
-    bool _IsInstancingRoot(const PXR_NS::HdSceneIndexPrim& prim, const PXR_NS::SdfPath& primPath) const;
-    bool _IsPropagatedPrototype(const PXR_NS::HdSceneIndexPrim& prim) const;
-    bool _IsPrototype(const PXR_NS::HdSceneIndexPrim& prim) const;
-
-    PXR_NS::SdfPathVector _GetInstancingRelatedPaths(const PXR_NS::HdSceneIndexPrim& prim);
     void _CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims);
     void _RemoveShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
     void _CreateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);

From c6a13df6dc608d7fb7a9e0209ff8fb035888d737 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 12:45:31 -0400
Subject: [PATCH 020/112] Cleanup

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 35 ++++++++++---------
 1 file changed, 18 insertions(+), 17 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 32906d3102..d9eccbbd34 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -88,16 +88,16 @@ const HdDataSourceLocator reprSelectorLocator(
 const HdDataSourceLocator primvarsOverrideWireframeColorLocator(
         HdPrimvarsSchema::GetDefaultLocator().Append(_primVarsTokens->overrideWireframeColor));
 
-const std::string shMirrorTag = "_SHMirror";
+const std::string selectionHighlightMirrorTag = "_SelectionHighlight";
 
 SdfPath _GetSelectionHighlightMirrorPathFromOriginal(const SdfPath& originalPath)
 {
-    return originalPath.GetParentPath().AppendElementString(originalPath.GetElementString() + shMirrorTag);
+    return originalPath.GetParentPath().AppendElementString(originalPath.GetElementString() + selectionHighlightMirrorTag);
 }
 
 SdfPath _GetOriginalPathFromSelectionHighlightMirror(const SdfPath& mirrorPath)
 {
-    return mirrorPath.GetParentPath().AppendElementString(mirrorPath.GetElementString().substr(0, mirrorPath.GetElementString().size() - shMirrorTag.size()));
+    return mirrorPath.GetParentPath().AppendElementString(mirrorPath.GetElementString().substr(0, mirrorPath.GetElementString().size() - selectionHighlightMirrorTag.size()));
 }
 
 VtBoolArray _GetSelectionHighlightMask(const HdInstancerTopologySchema& originalInstancerTopology, const HdSelectionsSchema& selections) 
@@ -105,6 +105,7 @@ VtBoolArray _GetSelectionHighlightMask(const HdInstancerTopologySchema& original
     if (!selections.IsDefined()) {
         return originalInstancerTopology.GetMask()->GetTypedValue(0);
     }
+
     size_t nbInstances = 0;
     auto instanceIndices = originalInstancerTopology.GetInstanceIndices();
     for (size_t iInstanceIndex = 0; iInstanceIndex < instanceIndices.GetNumElements(); iInstanceIndex++) {
@@ -146,7 +147,7 @@ HdContainerDataSourceHandle _GetSelectionHighlightInstancerDataSource(const HdCo
     HdContainerDataSourceEditor editedDataSource = HdContainerDataSourceEditor(originalDataSource);
 
     if (selections.IsDefined()) {
-        HdDataSourceLocator maskLocator(TfToken("instancerTopology"), TfToken("mask"));
+        HdDataSourceLocator maskLocator = HdInstancerTopologySchema::GetDefaultLocator().Append(HdInstancerTopologySchemaTokens->mask);
         VtBoolArray selectionHighlightMask = _GetSelectionHighlightMask(instancerTopology, selections);
         auto selectionHighlightMaskDataSource = HdRetainedTypedSampledDataSource<VtBoolArray>::New(selectionHighlightMask);
         editedDataSource.Set(maskLocator, selectionHighlightMaskDataSource);
@@ -157,15 +158,6 @@ HdContainerDataSourceHandle _GetSelectionHighlightInstancerDataSource(const HdCo
     return editedDataSource.Finish();
 }
 
-bool _IsInstancerWithSelections(const HdSceneIndexPrim& prim)
-{
-    if (prim.primType != HdPrimTypeTokens->instancer) {
-        return false;
-    }
-    auto selections = HdSelectionsSchema::GetFromParent(prim.dataSource);
-    return selections.IsDefined() && selections.GetNumElements() > 0;
-}
-
 SdfPathVector _GetInstancingRelatedPaths(const HdSceneIndexPrim& prim)
 {
     HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(prim.dataSource);
@@ -195,6 +187,15 @@ SdfPathVector _GetInstancingRelatedPaths(const HdSceneIndexPrim& prim)
     return instancingRelatedPaths;
 }
 
+bool _IsInstancerWithSelections(const HdSceneIndexPrim& prim)
+{
+    if (prim.primType != HdPrimTypeTokens->instancer) {
+        return false;
+    }
+    auto selections = HdSelectionsSchema::GetFromParent(prim.dataSource);
+    return selections.IsDefined() && selections.GetNumElements() > 0;
+}
+
 bool _IsInstancingRoot(const HdSceneIndexPrim& prim, const SdfPath& primPath)
 {
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
@@ -213,16 +214,16 @@ bool _IsInstancingRoot(const HdSceneIndexPrim& prim, const SdfPath& primPath)
     return false;
 }
 
-bool _IsPropagatedPrototype(const HdSceneIndexPrim& prim)
+bool _IsPrototype(const HdSceneIndexPrim& prim)
 {
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
-    return instancedBy.IsDefined() && instancedBy.GetPrototypeRoots() && !instancedBy.GetPrototypeRoots()->GetTypedValue(0).empty();
+    return instancedBy.IsDefined();
 }
 
-bool _IsPrototype(const HdSceneIndexPrim& prim)
+bool _IsPropagatedPrototype(const HdSceneIndexPrim& prim)
 {
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
-    return instancedBy.IsDefined();
+    return instancedBy.IsDefined() && instancedBy.GetPrototypeRoots() && !instancedBy.GetPrototypeRoots()->GetTypedValue(0).empty();
 }
 
 class _SelectionHighlightRepathingPathDataSource : public HdPathDataSource

From 122067fda611d8eb5c16ab19d7dced9a1f727162 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 14:30:27 -0400
Subject: [PATCH 021/112] Reorder methods

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 282 +++++++++---------
 1 file changed, 141 insertions(+), 141 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index d9eccbbd34..4ddd4ba84c 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -373,31 +373,6 @@ class _SelectionHighlightRepathingContainerDataSource : public HdContainerDataSo
 
 namespace FVP_NS_DEF {
 
-SdfPath
-WireframeSelectionHighlightSceneIndex::_FindSelectionHighlightMirrorAncestor(const SdfPath& path) const
-{
-    auto ancestorsRange = path.GetAncestorsRange();
-    for (auto ancestor : ancestorsRange) {
-        if (_shMirrorsUseCount.find(ancestor) != _shMirrorsUseCount.end()) {
-            return ancestor;
-        }
-    }
-    return SdfPath::EmptyPath();
-}
-
-SdfPath
-WireframeSelectionHighlightSceneIndex::GetSelectionHighlightPath(const SdfPath& path) const
-{
-    auto ancestorsRange = path.GetAncestorsRange();
-    for (auto ancestor : ancestorsRange) {
-        const SdfPath mirrorPath = _GetSelectionHighlightMirrorPathFromOriginal(ancestor);
-        if (_shMirrorsUseCount.find(mirrorPath) != _shMirrorsUseCount.end()) {
-            return path.ReplacePrefix(ancestor, mirrorPath);
-        }
-    }
-    return path;
-}
-
 HdSceneIndexBaseRefPtr
 WireframeSelectionHighlightSceneIndex::New(
     const HdSceneIndexBaseRefPtr& inputSceneIndex,
@@ -426,10 +401,10 @@ WireframeSelectionHighlightSceneIndex(
 {
     TF_AXIOM(_wireframeColorInterface);
 
-    std::stack<SdfPath> primPathsToTraverse({ SdfPath::AbsoluteRootPath() });
-    while (!primPathsToTraverse.empty()) {
-        SdfPath currPrimPath = primPathsToTraverse.top();
-        primPathsToTraverse.pop();
+    std::stack<SdfPath> pathsToTraverse({ SdfPath::AbsoluteRootPath() });
+    while (!pathsToTraverse.empty()) {
+        SdfPath currPrimPath = pathsToTraverse.top();
+        pathsToTraverse.pop();
 
         HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPrimPath);
         if (_IsInstancerWithSelections(currPrim)) {
@@ -437,121 +412,9 @@ WireframeSelectionHighlightSceneIndex(
         }
 
         for (const auto& childPath : inputSceneIndex->GetChildPrimPaths(currPrimPath)) {
-            primPathsToTraverse.push(childPath);
-        }
-    }
-}
-
-void
-WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims)
-{
-    // This should never be called on selection highlight prims, only on original prims
-    TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
-
-    HdSceneIndexPrim originalPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
-    if (!_IsInstancingRoot(originalPrim, originalPrimPath)) {
-        HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(originalPrim.dataSource);
-        auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
-        for (const auto& protoRootPath : protoRootPaths) {
-            _CollectSelectionHighlightPaths(protoRootPath, outSelectionHighlightMirrorPaths, outAddedPrims);
-        }
-        return;
-    }
-    
-    SdfPath selectionHighlightPrimPath = _GetSelectionHighlightMirrorPathFromOriginal(originalPrimPath);
-    
-    if (outSelectionHighlightMirrorPaths.find(selectionHighlightPrimPath) != outSelectionHighlightMirrorPaths.end()) {
-        return;
-    }
-    outSelectionHighlightMirrorPaths.insert(selectionHighlightPrimPath);
-
-    SdfPathVector affectedOriginalPrimPaths;
-    std::stack<SdfPath> pathsToTraverse({originalPrimPath});
-    while (!pathsToTraverse.empty()) {
-        SdfPath currPath = pathsToTraverse.top();
-        pathsToTraverse.pop();
-
-        HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
-
-        // Skip processing of prototypes nested under the prim's hierarchy, as prototypes should be processed by
-        // traversing the instancing-related paths of instancers and instancees. And if they aren't, then it means
-        // the prototype is either not instanced in the first place, or is part of a different instancing hierarchy.
-        if (_IsPrototype(currPrim) && _IsInstancingRoot(currPrim, currPath) && currPath != originalPrimPath) {
-            continue;
-        }
-
-        outAddedPrims.push_back({currPath.ReplacePrefix(originalPrimPath, selectionHighlightPrimPath), currPrim.primType});
-
-        if (currPrim.primType == HdPrimTypeTokens->instancer) {
-            SdfPathVector instancingRelatedPaths = _GetInstancingRelatedPaths(currPrim);
-            affectedOriginalPrimPaths.insert(affectedOriginalPrimPaths.end(), instancingRelatedPaths.begin(), instancingRelatedPaths.end());
-        }
-
-        for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
             pathsToTraverse.push(childPath);
         }
     }
-
-    for (const auto& affectedOriginalPrimPath : affectedOriginalPrimPaths) {
-        _CollectSelectionHighlightPaths(affectedOriginalPrimPath, outSelectionHighlightMirrorPaths, outAddedPrims);
-    }
-}
-
-void 
-WireframeSelectionHighlightSceneIndex::_RemoveShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
-{
-    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
-
-    HdSceneIndexObserver::RemovedPrimEntries removedPrims;
-
-    SdfPathSet oldShMirrors;
-    if (_shMirrorsByInstancer.find(instancerPath) != _shMirrorsByInstancer.end()) {
-        oldShMirrors = _shMirrorsByInstancer.at(instancerPath);
-    }
-    for (const auto& shMirror : oldShMirrors) {
-        TF_AXIOM(_shMirrorsUseCount.find(shMirror) != _shMirrorsUseCount.end());
-        TF_AXIOM(_shMirrorsUseCount[shMirror] > 0);
-        _shMirrorsUseCount[shMirror]--;
-        if (_shMirrorsUseCount[shMirror] == 0) {
-            _shMirrorsUseCount.erase(shMirror);
-            removedPrims.push_back(shMirror);
-        }
-    }
-
-    _shMirrorsByInstancer.erase(instancerPath);
-    
-    if (!removedPrims.empty()) {
-        _SendPrimsRemoved(removedPrims);
-    }
-}
-
-void 
-WireframeSelectionHighlightSceneIndex::_CreateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
-{
-    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
-
-    if (_shMirrorsByInstancer.find(instancerPath) != _shMirrorsByInstancer.end()) {
-        _RemoveShMirrorsForInstancer(instancerPath);
-    }
-
-    SdfPathSet newShMirrors;
-    HdSceneIndexObserver::AddedPrimEntries addedPrims;
-    _CollectSelectionHighlightPaths(instancerPath, newShMirrors, addedPrims);
-
-    _shMirrorsByInstancer[instancerPath] = newShMirrors;
-    for (const auto& shMirror : newShMirrors) {
-        if (_shMirrorsUseCount.find(shMirror) == _shMirrorsUseCount.end()) {
-            _shMirrorsUseCount[shMirror] = 1;
-        } else {
-            TF_AXIOM(_shMirrorsUseCount.find(shMirror) != _shMirrorsUseCount.end());
-            TF_AXIOM(_shMirrorsUseCount[shMirror] > 0);
-            _shMirrorsUseCount[shMirror]++;
-        }
-    }
-
-    if (!addedPrims.empty()) {
-        _SendPrimsAdded(addedPrims);
-    }
 }
 
 HdSceneIndexPrim
@@ -853,4 +716,141 @@ bool WireframeSelectionHighlightSceneIndex::_IsExcluded(
     return false;
 }
 
+SdfPath
+WireframeSelectionHighlightSceneIndex::GetSelectionHighlightPath(const SdfPath& path) const
+{
+    auto ancestorsRange = path.GetAncestorsRange();
+    for (auto ancestor : ancestorsRange) {
+        const SdfPath mirrorPath = _GetSelectionHighlightMirrorPathFromOriginal(ancestor);
+        if (_shMirrorsUseCount.find(mirrorPath) != _shMirrorsUseCount.end()) {
+            return path.ReplacePrefix(ancestor, mirrorPath);
+        }
+    }
+    return path;
+}
+
+SdfPath
+WireframeSelectionHighlightSceneIndex::_FindSelectionHighlightMirrorAncestor(const SdfPath& path) const
+{
+    auto ancestorsRange = path.GetAncestorsRange();
+    for (auto ancestor : ancestorsRange) {
+        if (_shMirrorsUseCount.find(ancestor) != _shMirrorsUseCount.end()) {
+            return ancestor;
+        }
+    }
+    return SdfPath::EmptyPath();
+}
+
+void
+WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims)
+{
+    // This should never be called on selection highlight prims, only on original prims
+    TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
+
+    HdSceneIndexPrim originalPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
+    if (!_IsInstancingRoot(originalPrim, originalPrimPath)) {
+        HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(originalPrim.dataSource);
+        auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
+        for (const auto& protoRootPath : protoRootPaths) {
+            _CollectSelectionHighlightPaths(protoRootPath, outSelectionHighlightMirrorPaths, outAddedPrims);
+        }
+        return;
+    }
+    
+    SdfPath selectionHighlightPrimPath = _GetSelectionHighlightMirrorPathFromOriginal(originalPrimPath);
+    
+    if (outSelectionHighlightMirrorPaths.find(selectionHighlightPrimPath) != outSelectionHighlightMirrorPaths.end()) {
+        return;
+    }
+    outSelectionHighlightMirrorPaths.insert(selectionHighlightPrimPath);
+
+    SdfPathVector affectedOriginalPrimPaths;
+    std::stack<SdfPath> pathsToTraverse({originalPrimPath});
+    while (!pathsToTraverse.empty()) {
+        SdfPath currPath = pathsToTraverse.top();
+        pathsToTraverse.pop();
+
+        HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
+
+        // Skip processing of prototypes nested under the prim's hierarchy, as prototypes should be processed by
+        // traversing the instancing-related paths of instancers and instancees. And if they aren't, then it means
+        // the prototype is either not instanced in the first place, or is part of a different instancing hierarchy.
+        if (_IsPrototype(currPrim) && _IsInstancingRoot(currPrim, currPath) && currPath != originalPrimPath) {
+            continue;
+        }
+
+        outAddedPrims.push_back({currPath.ReplacePrefix(originalPrimPath, selectionHighlightPrimPath), currPrim.primType});
+
+        if (currPrim.primType == HdPrimTypeTokens->instancer) {
+            SdfPathVector instancingRelatedPaths = _GetInstancingRelatedPaths(currPrim);
+            affectedOriginalPrimPaths.insert(affectedOriginalPrimPaths.end(), instancingRelatedPaths.begin(), instancingRelatedPaths.end());
+        }
+
+        for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
+            pathsToTraverse.push(childPath);
+        }
+    }
+
+    for (const auto& affectedOriginalPrimPath : affectedOriginalPrimPaths) {
+        _CollectSelectionHighlightPaths(affectedOriginalPrimPath, outSelectionHighlightMirrorPaths, outAddedPrims);
+    }
+}
+
+void 
+WireframeSelectionHighlightSceneIndex::_RemoveShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
+{
+    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
+
+    HdSceneIndexObserver::RemovedPrimEntries removedPrims;
+
+    SdfPathSet oldShMirrors;
+    if (_shMirrorsByInstancer.find(instancerPath) != _shMirrorsByInstancer.end()) {
+        oldShMirrors = _shMirrorsByInstancer.at(instancerPath);
+    }
+    for (const auto& shMirror : oldShMirrors) {
+        TF_AXIOM(_shMirrorsUseCount.find(shMirror) != _shMirrorsUseCount.end());
+        TF_AXIOM(_shMirrorsUseCount[shMirror] > 0);
+        _shMirrorsUseCount[shMirror]--;
+        if (_shMirrorsUseCount[shMirror] == 0) {
+            _shMirrorsUseCount.erase(shMirror);
+            removedPrims.push_back(shMirror);
+        }
+    }
+
+    _shMirrorsByInstancer.erase(instancerPath);
+    
+    if (!removedPrims.empty()) {
+        _SendPrimsRemoved(removedPrims);
+    }
+}
+
+void 
+WireframeSelectionHighlightSceneIndex::_CreateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
+{
+    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
+
+    if (_shMirrorsByInstancer.find(instancerPath) != _shMirrorsByInstancer.end()) {
+        _RemoveShMirrorsForInstancer(instancerPath);
+    }
+
+    SdfPathSet newShMirrors;
+    HdSceneIndexObserver::AddedPrimEntries addedPrims;
+    _CollectSelectionHighlightPaths(instancerPath, newShMirrors, addedPrims);
+
+    _shMirrorsByInstancer[instancerPath] = newShMirrors;
+    for (const auto& shMirror : newShMirrors) {
+        if (_shMirrorsUseCount.find(shMirror) == _shMirrorsUseCount.end()) {
+            _shMirrorsUseCount[shMirror] = 1;
+        } else {
+            TF_AXIOM(_shMirrorsUseCount.find(shMirror) != _shMirrorsUseCount.end());
+            TF_AXIOM(_shMirrorsUseCount[shMirror] > 0);
+            _shMirrorsUseCount[shMirror]++;
+        }
+    }
+
+    if (!addedPrims.empty()) {
+        _SendPrimsAdded(addedPrims);
+    }
+}
+
 }

From 6062073b5d4d56af45e3ccdd283a470adddf8e58 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 15:10:33 -0400
Subject: [PATCH 022/112] Minor cleanup

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 23 +++++++++++--------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 4ddd4ba84c..f9effc5818 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -92,12 +92,13 @@ const std::string selectionHighlightMirrorTag = "_SelectionHighlight";
 
 SdfPath _GetSelectionHighlightMirrorPathFromOriginal(const SdfPath& originalPath)
 {
-    return originalPath.GetParentPath().AppendElementString(originalPath.GetElementString() + selectionHighlightMirrorTag);
+    return originalPath.ReplaceName(TfToken(originalPath.GetName() + selectionHighlightMirrorTag));
 }
 
 SdfPath _GetOriginalPathFromSelectionHighlightMirror(const SdfPath& mirrorPath)
 {
-    return mirrorPath.GetParentPath().AppendElementString(mirrorPath.GetElementString().substr(0, mirrorPath.GetElementString().size() - selectionHighlightMirrorTag.size()));
+    const std::string primName = mirrorPath.GetName();
+    return mirrorPath.ReplaceName(TfToken(primName.substr(0, primName.size() - selectionHighlightMirrorTag.size())));
 }
 
 VtBoolArray _GetSelectionHighlightMask(const HdInstancerTopologySchema& originalInstancerTopology, const HdSelectionsSchema& selections) 
@@ -118,13 +119,15 @@ VtBoolArray _GetSelectionHighlightMask(const HdInstancerTopologySchema& original
 
     for (size_t iSelection = 0; iSelection < selections.GetNumElements(); iSelection++) {
         HdSelectionSchema selection = selections.GetElement(iSelection);
-        // See something.cpp for comment mentioning that currently only fully selected is supported.
+        // Instancer is expected to be marked "fully selected" even if only certain instances are selected,
+        // based on USD's _AddToSelection function in selectionSceneIndexObserver.cpp :
+        // https://github.com/PixarAnimationStudios/OpenUSD/blob/f7b8a021ce3d13f91a0211acf8a64a8b780524df/pxr/imaging/hdx/selectionSceneIndexObserver.cpp#L212-L251
         if (!selection.GetFullySelected() || !selection.GetFullySelected()->GetTypedValue(0)) {
             continue;
         }
         if (!selection.GetNestedInstanceIndices()) {
             // We have a selection that has no instances, which means the whole instancer is selected :
-            // this overrides any individual instance selection.
+            // this overrides any instances selection.
             return originalInstancerTopology.GetMask()->GetTypedValue(0);
         }
         HdInstanceIndicesVectorSchema nestedInstanceIndices = selection.GetNestedInstanceIndices();
@@ -220,12 +223,8 @@ bool _IsPrototype(const HdSceneIndexPrim& prim)
     return instancedBy.IsDefined();
 }
 
-bool _IsPropagatedPrototype(const HdSceneIndexPrim& prim)
-{
-    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
-    return instancedBy.IsDefined() && instancedBy.GetPrototypeRoots() && !instancedBy.GetPrototypeRoots()->GetTypedValue(0).empty();
-}
-
+// Similar to USD's _RerootingSceneIndexPathDataSource :
+// https://github.com/PixarAnimationStudios/OpenUSD/blob/f7b8a021ce3d13f91a0211acf8a64a8b780524df/pxr/usdImaging/usdImaging/rerootingSceneIndex.cpp#L35
 class _SelectionHighlightRepathingPathDataSource : public HdPathDataSource
 {
 public:
@@ -271,6 +270,8 @@ class _SelectionHighlightRepathingPathDataSource : public HdPathDataSource
     Fvp::WireframeSelectionHighlightSceneIndex const * const _inputSceneIndex;
 };
 
+// Similar to USD's _RerootingSceneIndexPathArrayDataSource :
+// https://github.com/PixarAnimationStudios/OpenUSD/blob/f7b8a021ce3d13f91a0211acf8a64a8b780524df/pxr/usdImaging/usdImaging/rerootingSceneIndex.cpp#L86
 class _SelectionHighlightRepathingPathArrayDataSource : public HdPathArrayDataSource
 {
 public:
@@ -320,6 +321,8 @@ class _SelectionHighlightRepathingPathArrayDataSource : public HdPathArrayDataSo
     Fvp::WireframeSelectionHighlightSceneIndex const * const _inputSceneIndex;
 };
 
+// Similar to USD's _RerootingSceneIndexContainerDataSource :
+// https://github.com/PixarAnimationStudios/OpenUSD/blob/f7b8a021ce3d13f91a0211acf8a64a8b780524df/pxr/usdImaging/usdImaging/rerootingSceneIndex.cpp#L172
 class _SelectionHighlightRepathingContainerDataSource : public HdContainerDataSource
 {
 public:

From fc0baff84bdf061de4e72a62f868edc96377e929 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 15:26:47 -0400
Subject: [PATCH 023/112] Renaming methods and variables

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 96 +++++++++----------
 ...fvpWireframeSelectionHighlightSceneIndex.h | 13 ++-
 2 files changed, 54 insertions(+), 55 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index f9effc5818..02b109aa84 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -411,7 +411,7 @@ WireframeSelectionHighlightSceneIndex(
 
         HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPrimPath);
         if (_IsInstancerWithSelections(currPrim)) {
-            _CreateShMirrorsForInstancer(currPrimPath);
+            _CreateSelectionHighlightMirrorsForInstancer(currPrimPath);
         }
 
         for (const auto& childPath : inputSceneIndex->GetChildPrimPaths(currPrimPath)) {
@@ -432,9 +432,9 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
     
     // Is this prim part of a selection highlight mirror hierarchy?
     // If so, then we are dealing with a point instancer or instance selection.
-    SdfPath shMirrorAncestorPath = _FindSelectionHighlightMirrorAncestor(primPath);
-    if (!shMirrorAncestorPath.IsEmpty()) {
-        SdfPath originalPrimPath = primPath.ReplacePrefix(shMirrorAncestorPath, _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestorPath));
+    SdfPath selectionHighlightMirrorAncestor = _FindSelectionHighlightMirrorAncestor(primPath);
+    if (!selectionHighlightMirrorAncestor.IsEmpty()) {
+        SdfPath originalPrimPath = primPath.ReplacePrefix(selectionHighlightMirrorAncestor, _GetOriginalPathFromSelectionHighlightMirror(selectionHighlightMirrorAncestor));
         HdSceneIndexPrim shPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
         if (shPrim.dataSource) {
             shPrim.dataSource = _SelectionHighlightRepathingContainerDataSource::New(shPrim.dataSource, this);
@@ -456,7 +456,7 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         // prim (even though it should already not be drawn due to being under an instancer, this is an additional safety? to confirm)
         if (_IsPrototype(prim)) {
             // Prototype selection
-            if (_selection->IsFullySelected(primPath) || _highlightedProtoPaths.find(primPath) != _highlightedProtoPaths.end()) {
+            if (_selection->IsFullySelected(primPath) || _highlightedPrototypePaths.find(primPath) != _highlightedPrototypePaths.end()) {
                 prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
             }
         } else {
@@ -472,12 +472,12 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
 SdfPathVector
 WireframeSelectionHighlightSceneIndex::GetChildPrimPaths(const SdfPath &primPath) const
 {
-    SdfPath shMirrorAncestor = _FindSelectionHighlightMirrorAncestor(primPath);
-    if (!shMirrorAncestor.IsEmpty()) {
-        SdfPath originalShMirrorAncestor = _GetOriginalPathFromSelectionHighlightMirror(shMirrorAncestor);
-        auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath.ReplacePrefix(shMirrorAncestor, originalShMirrorAncestor));
+    SdfPath selectionHighlightMirrorAncestor = _FindSelectionHighlightMirrorAncestor(primPath);
+    if (!selectionHighlightMirrorAncestor.IsEmpty()) {
+        SdfPath originalAncestorPath = _GetOriginalPathFromSelectionHighlightMirror(selectionHighlightMirrorAncestor);
+        auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath.ReplacePrefix(selectionHighlightMirrorAncestor, originalAncestorPath));
         for (auto& childPath : childPaths) {
-            childPath = childPath.ReplacePrefix(originalShMirrorAncestor, shMirrorAncestor);
+            childPath = childPath.ReplacePrefix(originalAncestorPath, selectionHighlightMirrorAncestor);
         }
         return childPaths;
     }
@@ -486,7 +486,7 @@ WireframeSelectionHighlightSceneIndex::GetChildPrimPaths(const SdfPath &primPath
     SdfPathVector additionalChildPaths;
     for (const auto& childPath : childPaths) {
         SdfPath shPath = _GetSelectionHighlightMirrorPathFromOriginal(childPath);
-        if (_shMirrorsUseCount.find(shPath) != _shMirrorsUseCount.end()) {
+        if (_selectionHighlightMirrorUseCounters.find(shPath) != _selectionHighlightMirrorUseCounters.end()) {
             additionalChildPaths.push_back(shPath);
         }
     }
@@ -548,7 +548,7 @@ WireframeSelectionHighlightSceneIndex::_PrimsAdded(
         // New proto subprim : handled automatically
         // New proto : means an instancer has changed -> should be reflected automatically?
         if (_IsInstancerWithSelections(GetInputSceneIndex()->GetPrim(entry.primPath))) {
-            _CreateShMirrorsForInstancer(entry.primPath);
+            _CreateSelectionHighlightMirrorsForInstancer(entry.primPath);
         }
     }
     _SendPrimsAdded(newEntries);
@@ -603,9 +603,9 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
                                 newLocators.append(HdLegacyDisplayStyleSchema::GetDefaultLocator());
                                 dirtiedSelectedMeshProtos.push_back({propagatedPrimPath, newLocators});
                                 if (HdSelectionsSchema::GetFromParent(entryPrim.dataSource).IsDefined()) {
-                                    _highlightedProtoPaths.insert(propagatedPrimPath);
+                                    _highlightedPrototypePaths.insert(propagatedPrimPath);
                                 } else {
-                                    _highlightedProtoPaths.erase(propagatedPrimPath);
+                                    _highlightedPrototypePaths.erase(propagatedPrimPath);
                                 }
                             }
                             foundPropagatedProtos = true;
@@ -639,9 +639,9 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
         if (entry.dirtyLocators.Contains(HdSelectionsSchema::GetDefaultLocator())) {
             HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(entry.primPath);
             if (_IsInstancerWithSelections(prim)) {
-                _CreateShMirrorsForInstancer(entry.primPath);
+                _CreateSelectionHighlightMirrorsForInstancer(entry.primPath);
             } else if (prim.primType == HdPrimTypeTokens->instancer) {
-                _RemoveShMirrorsForInstancer(entry.primPath);
+                _RemoveSelectionHighlightMirrorsForInstancer(entry.primPath);
             }
             // TODO : Forward dirtiness to SH mirrors masks
         }
@@ -679,7 +679,7 @@ WireframeSelectionHighlightSceneIndex::_PrimsRemoved(
         // New proto subprim : handled automatically
         // New proto : means an instancer has changed -> should be reflected automatically?
         if (_IsInstancerWithSelections(GetInputSceneIndex()->GetPrim(entry.primPath))) {
-            _RemoveShMirrorsForInstancer(entry.primPath);
+            _RemoveSelectionHighlightMirrorsForInstancer(entry.primPath);
         }
     }
 
@@ -725,7 +725,7 @@ WireframeSelectionHighlightSceneIndex::GetSelectionHighlightPath(const SdfPath&
     auto ancestorsRange = path.GetAncestorsRange();
     for (auto ancestor : ancestorsRange) {
         const SdfPath mirrorPath = _GetSelectionHighlightMirrorPathFromOriginal(ancestor);
-        if (_shMirrorsUseCount.find(mirrorPath) != _shMirrorsUseCount.end()) {
+        if (_selectionHighlightMirrorUseCounters.find(mirrorPath) != _selectionHighlightMirrorUseCounters.end()) {
             return path.ReplacePrefix(ancestor, mirrorPath);
         }
     }
@@ -737,7 +737,7 @@ WireframeSelectionHighlightSceneIndex::_FindSelectionHighlightMirrorAncestor(con
 {
     auto ancestorsRange = path.GetAncestorsRange();
     for (auto ancestor : ancestorsRange) {
-        if (_shMirrorsUseCount.find(ancestor) != _shMirrorsUseCount.end()) {
+        if (_selectionHighlightMirrorUseCounters.find(ancestor) != _selectionHighlightMirrorUseCounters.end()) {
             return ancestor;
         }
     }
@@ -745,7 +745,7 @@ WireframeSelectionHighlightSceneIndex::_FindSelectionHighlightMirrorAncestor(con
 }
 
 void
-WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims)
+WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightMirrors(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrors, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims)
 {
     // This should never be called on selection highlight prims, only on original prims
     TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
@@ -755,17 +755,17 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightPaths(const PXR
         HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(originalPrim.dataSource);
         auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
         for (const auto& protoRootPath : protoRootPaths) {
-            _CollectSelectionHighlightPaths(protoRootPath, outSelectionHighlightMirrorPaths, outAddedPrims);
+            _CollectSelectionHighlightMirrors(protoRootPath, outSelectionHighlightMirrors, outAddedPrims);
         }
         return;
     }
     
     SdfPath selectionHighlightPrimPath = _GetSelectionHighlightMirrorPathFromOriginal(originalPrimPath);
     
-    if (outSelectionHighlightMirrorPaths.find(selectionHighlightPrimPath) != outSelectionHighlightMirrorPaths.end()) {
+    if (outSelectionHighlightMirrors.find(selectionHighlightPrimPath) != outSelectionHighlightMirrors.end()) {
         return;
     }
-    outSelectionHighlightMirrorPaths.insert(selectionHighlightPrimPath);
+    outSelectionHighlightMirrors.insert(selectionHighlightPrimPath);
 
     SdfPathVector affectedOriginalPrimPaths;
     std::stack<SdfPath> pathsToTraverse({originalPrimPath});
@@ -795,32 +795,32 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightPaths(const PXR
     }
 
     for (const auto& affectedOriginalPrimPath : affectedOriginalPrimPaths) {
-        _CollectSelectionHighlightPaths(affectedOriginalPrimPath, outSelectionHighlightMirrorPaths, outAddedPrims);
+        _CollectSelectionHighlightMirrors(affectedOriginalPrimPath, outSelectionHighlightMirrors, outAddedPrims);
     }
 }
 
 void 
-WireframeSelectionHighlightSceneIndex::_RemoveShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
+WireframeSelectionHighlightSceneIndex::_RemoveSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
 {
     TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
 
     HdSceneIndexObserver::RemovedPrimEntries removedPrims;
 
-    SdfPathSet oldShMirrors;
-    if (_shMirrorsByInstancer.find(instancerPath) != _shMirrorsByInstancer.end()) {
-        oldShMirrors = _shMirrorsByInstancer.at(instancerPath);
+    SdfPathSet oldSelectionHighlightMirrors;
+    if (_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end()) {
+        oldSelectionHighlightMirrors = _selectionHighlightMirrorsByInstancer.at(instancerPath);
     }
-    for (const auto& shMirror : oldShMirrors) {
-        TF_AXIOM(_shMirrorsUseCount.find(shMirror) != _shMirrorsUseCount.end());
-        TF_AXIOM(_shMirrorsUseCount[shMirror] > 0);
-        _shMirrorsUseCount[shMirror]--;
-        if (_shMirrorsUseCount[shMirror] == 0) {
-            _shMirrorsUseCount.erase(shMirror);
-            removedPrims.push_back(shMirror);
+    for (const auto& selectionHighlightMirror : oldSelectionHighlightMirrors) {
+        TF_AXIOM(_selectionHighlightMirrorUseCounters.find(selectionHighlightMirror) != _selectionHighlightMirrorUseCounters.end());
+        TF_AXIOM(_selectionHighlightMirrorUseCounters[selectionHighlightMirror] > 0);
+        _selectionHighlightMirrorUseCounters[selectionHighlightMirror]--;
+        if (_selectionHighlightMirrorUseCounters[selectionHighlightMirror] == 0) {
+            _selectionHighlightMirrorUseCounters.erase(selectionHighlightMirror);
+            removedPrims.push_back(selectionHighlightMirror);
         }
     }
 
-    _shMirrorsByInstancer.erase(instancerPath);
+    _selectionHighlightMirrorsByInstancer.erase(instancerPath);
     
     if (!removedPrims.empty()) {
         _SendPrimsRemoved(removedPrims);
@@ -828,26 +828,26 @@ WireframeSelectionHighlightSceneIndex::_RemoveShMirrorsForInstancer(const PXR_NS
 }
 
 void 
-WireframeSelectionHighlightSceneIndex::_CreateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
+WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
 {
     TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
 
-    if (_shMirrorsByInstancer.find(instancerPath) != _shMirrorsByInstancer.end()) {
-        _RemoveShMirrorsForInstancer(instancerPath);
+    if (_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end()) {
+        _RemoveSelectionHighlightMirrorsForInstancer(instancerPath);
     }
 
-    SdfPathSet newShMirrors;
+    SdfPathSet newSelectionHighlightMirrors;
     HdSceneIndexObserver::AddedPrimEntries addedPrims;
-    _CollectSelectionHighlightPaths(instancerPath, newShMirrors, addedPrims);
+    _CollectSelectionHighlightMirrors(instancerPath, newSelectionHighlightMirrors, addedPrims);
 
-    _shMirrorsByInstancer[instancerPath] = newShMirrors;
-    for (const auto& shMirror : newShMirrors) {
-        if (_shMirrorsUseCount.find(shMirror) == _shMirrorsUseCount.end()) {
-            _shMirrorsUseCount[shMirror] = 1;
+    _selectionHighlightMirrorsByInstancer[instancerPath] = newSelectionHighlightMirrors;
+    for (const auto& selectionHighlightMirror : newSelectionHighlightMirrors) {
+        if (_selectionHighlightMirrorUseCounters.find(selectionHighlightMirror) == _selectionHighlightMirrorUseCounters.end()) {
+            _selectionHighlightMirrorUseCounters[selectionHighlightMirror] = 1;
         } else {
-            TF_AXIOM(_shMirrorsUseCount.find(shMirror) != _shMirrorsUseCount.end());
-            TF_AXIOM(_shMirrorsUseCount[shMirror] > 0);
-            _shMirrorsUseCount[shMirror]++;
+            TF_AXIOM(_selectionHighlightMirrorUseCounters.find(selectionHighlightMirror) != _selectionHighlightMirrorUseCounters.end());
+            TF_AXIOM(_selectionHighlightMirrorUseCounters[selectionHighlightMirror] > 0);
+            _selectionHighlightMirrorUseCounters[selectionHighlightMirror]++;
         }
     }
 
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 1ebafc121c..ed17368cfa 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -114,18 +114,17 @@ class WireframeSelectionHighlightSceneIndex
     std::set<PXR_NS::SdfPath> _excludedSceneRoots;
     PXR_NS::HdContainerDataSourceHandle _HighlightSelectedPrim(const PXR_NS::HdContainerDataSourceHandle& dataSource, const PXR_NS::SdfPath& primPath, const PXR_NS::HdContainerDataSourceHandle& highlightDataSource) const;
 
-    void _CollectSelectionHighlightPaths(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrorPaths, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims);
-    void _RemoveShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
-    void _CreateShMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
-
     PXR_NS::SdfPath _FindSelectionHighlightMirrorAncestor(const PXR_NS::SdfPath& path) const;
+    void _CollectSelectionHighlightMirrors(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrors, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims);
+    void _RemoveSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
+    void _CreateSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
 
     const SelectionConstPtr   _selection;
     const std::shared_ptr<WireframeColorInterface> _wireframeColorInterface;
 
-    std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _shMirrorsByInstancer;
-    std::unordered_map<PXR_NS::SdfPath, size_t, PXR_NS::SdfPath::Hash> _shMirrorsUseCount;
-    std::set<PXR_NS::SdfPath> _highlightedProtoPaths;
+    std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _selectionHighlightMirrorsByInstancer;
+    std::unordered_map<PXR_NS::SdfPath, size_t, PXR_NS::SdfPath::Hash> _selectionHighlightMirrorUseCounters;
+    std::set<PXR_NS::SdfPath> _highlightedPrototypePaths;
 };
 
 }

From 3d9ed94e8b6992e8229d12cc72e7fa7e2e727810 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 15:45:32 -0400
Subject: [PATCH 024/112] Cleanup GetChildPrimPaths, PrimsAdded and
 PrimsRemoved

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 44 ++++++++-----------
 1 file changed, 18 insertions(+), 26 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 02b109aa84..494328a8e5 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -435,17 +435,17 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
     SdfPath selectionHighlightMirrorAncestor = _FindSelectionHighlightMirrorAncestor(primPath);
     if (!selectionHighlightMirrorAncestor.IsEmpty()) {
         SdfPath originalPrimPath = primPath.ReplacePrefix(selectionHighlightMirrorAncestor, _GetOriginalPathFromSelectionHighlightMirror(selectionHighlightMirrorAncestor));
-        HdSceneIndexPrim shPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
-        if (shPrim.dataSource) {
-            shPrim.dataSource = _SelectionHighlightRepathingContainerDataSource::New(shPrim.dataSource, this);
+        HdSceneIndexPrim selectionHighlightPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
+        if (selectionHighlightPrim.dataSource) {
+            selectionHighlightPrim.dataSource = _SelectionHighlightRepathingContainerDataSource::New(selectionHighlightPrim.dataSource, this);
         }
-        if (shPrim.primType == HdPrimTypeTokens->mesh) {
-            shPrim.dataSource = _HighlightSelectedPrim(shPrim.dataSource, originalPrimPath, sRefinedWireDisplayStyleDataSource);
+        if (selectionHighlightPrim.primType == HdPrimTypeTokens->mesh) {
+            selectionHighlightPrim.dataSource = _HighlightSelectedPrim(selectionHighlightPrim.dataSource, originalPrimPath, sRefinedWireDisplayStyleDataSource);
         }
-        if (shPrim.primType == HdPrimTypeTokens->instancer) {
-            shPrim.dataSource = _GetSelectionHighlightInstancerDataSource(shPrim.dataSource);
+        if (selectionHighlightPrim.primType == HdPrimTypeTokens->instancer) {
+            selectionHighlightPrim.dataSource = _GetSelectionHighlightInstancerDataSource(selectionHighlightPrim.dataSource);
         }
-        return shPrim;
+        return selectionHighlightPrim;
     }
     
     // We may be dealing with a prototype selection, a regular selection, or no selection at all.
@@ -472,26 +472,28 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
 SdfPathVector
 WireframeSelectionHighlightSceneIndex::GetChildPrimPaths(const SdfPath &primPath) const
 {
+    // When within a selection highlight mirror hierarchy, query the corresponding original prim
     SdfPath selectionHighlightMirrorAncestor = _FindSelectionHighlightMirrorAncestor(primPath);
     if (!selectionHighlightMirrorAncestor.IsEmpty()) {
-        SdfPath originalAncestorPath = _GetOriginalPathFromSelectionHighlightMirror(selectionHighlightMirrorAncestor);
-        auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath.ReplacePrefix(selectionHighlightMirrorAncestor, originalAncestorPath));
+        SdfPath originalAncestor = _GetOriginalPathFromSelectionHighlightMirror(selectionHighlightMirrorAncestor);
+        auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath.ReplacePrefix(selectionHighlightMirrorAncestor, originalAncestor));
         for (auto& childPath : childPaths) {
-            childPath = childPath.ReplacePrefix(originalAncestorPath, selectionHighlightMirrorAncestor);
+            childPath = childPath.ReplacePrefix(originalAncestor, selectionHighlightMirrorAncestor);
         }
         return childPaths;
     }
 
+    // When outside a selection highlight mirror hierarchy, add each child's corresponding
+    // selection highlight mirror, if there is one.
     auto childPaths = GetInputSceneIndex()->GetChildPrimPaths(primPath);
     SdfPathVector additionalChildPaths;
     for (const auto& childPath : childPaths) {
-        SdfPath shPath = _GetSelectionHighlightMirrorPathFromOriginal(childPath);
-        if (_selectionHighlightMirrorUseCounters.find(shPath) != _selectionHighlightMirrorUseCounters.end()) {
-            additionalChildPaths.push_back(shPath);
+        SdfPath selectionHighlightPath = _GetSelectionHighlightMirrorPathFromOriginal(childPath);
+        if (_selectionHighlightMirrorUseCounters.find(selectionHighlightPath) != _selectionHighlightMirrorUseCounters.end()) {
+            additionalChildPaths.push_back(selectionHighlightPath);
         }
     }
     childPaths.insert(childPaths.end(), additionalChildPaths.begin(), additionalChildPaths.end());
-
     return childPaths;
 }
 
@@ -541,17 +543,12 @@ WireframeSelectionHighlightSceneIndex::_PrimsAdded(
     TF_DEBUG(FVP_WIREFRAME_SELECTION_HIGHLIGHT_SCENE_INDEX)
         .Msg("WireframeSelectionHighlightSceneIndex::_PrimsAdded() called.\n");
 
-    auto newEntries = entries;
+    _SendPrimsAdded(entries);
     for (const auto& entry : entries) {
-        // TODO : Check if instancer with selections, or if an instancee whose instancer(s) have selections?
-        // Maybe only need new instancers with selections?
-        // New proto subprim : handled automatically
-        // New proto : means an instancer has changed -> should be reflected automatically?
         if (_IsInstancerWithSelections(GetInputSceneIndex()->GetPrim(entry.primPath))) {
             _CreateSelectionHighlightMirrorsForInstancer(entry.primPath);
         }
     }
-    _SendPrimsAdded(newEntries);
 }
 
 void
@@ -674,15 +671,10 @@ WireframeSelectionHighlightSceneIndex::_PrimsRemoved(
         .Msg("WireframeSelectionHighlightSceneIndex::_PrimsRemoved() called.\n");
 
     for (const auto& entry : entries) {
-        // TODO : Check if instancer with selections, or if an instancee whose instancer(s) have selections?
-        // Maybe only need new instancers with selections?
-        // New proto subprim : handled automatically
-        // New proto : means an instancer has changed -> should be reflected automatically?
         if (_IsInstancerWithSelections(GetInputSceneIndex()->GetPrim(entry.primPath))) {
             _RemoveSelectionHighlightMirrorsForInstancer(entry.primPath);
         }
     }
-
     _SendPrimsRemoved(entries);
 }
 

From bdb3596dd8edbb5d0e3a7cd60ceacbf5c37867f2 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 15:50:48 -0400
Subject: [PATCH 025/112] Change access of maps

---
 .../sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 494328a8e5..b093bb387d 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -804,9 +804,9 @@ WireframeSelectionHighlightSceneIndex::_RemoveSelectionHighlightMirrorsForInstan
     }
     for (const auto& selectionHighlightMirror : oldSelectionHighlightMirrors) {
         TF_AXIOM(_selectionHighlightMirrorUseCounters.find(selectionHighlightMirror) != _selectionHighlightMirrorUseCounters.end());
-        TF_AXIOM(_selectionHighlightMirrorUseCounters[selectionHighlightMirror] > 0);
+        TF_AXIOM(_selectionHighlightMirrorUseCounters.at(selectionHighlightMirror) > 0);
         _selectionHighlightMirrorUseCounters[selectionHighlightMirror]--;
-        if (_selectionHighlightMirrorUseCounters[selectionHighlightMirror] == 0) {
+        if (_selectionHighlightMirrorUseCounters.at(selectionHighlightMirror) == 0) {
             _selectionHighlightMirrorUseCounters.erase(selectionHighlightMirror);
             removedPrims.push_back(selectionHighlightMirror);
         }
@@ -838,7 +838,7 @@ WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightMirrorsForInstan
             _selectionHighlightMirrorUseCounters[selectionHighlightMirror] = 1;
         } else {
             TF_AXIOM(_selectionHighlightMirrorUseCounters.find(selectionHighlightMirror) != _selectionHighlightMirrorUseCounters.end());
-            TF_AXIOM(_selectionHighlightMirrorUseCounters[selectionHighlightMirror] > 0);
+            TF_AXIOM(_selectionHighlightMirrorUseCounters.at(selectionHighlightMirror) > 0);
             _selectionHighlightMirrorUseCounters[selectionHighlightMirror]++;
         }
     }

From 0c074047abcf1f3e017fef0d4ff2f1c583203eb1 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 28 May 2024 17:08:15 -0400
Subject: [PATCH 026/112] Propagate selection data sources to prototypes

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 47 +------------------
 ...fvpWireframeSelectionHighlightSceneIndex.h |  1 -
 .../sceneIndex/registration.cpp               | 39 ++++++++++++++-
 3 files changed, 38 insertions(+), 49 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index b093bb387d..91db000947 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -456,7 +456,7 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         // prim (even though it should already not be drawn due to being under an instancer, this is an additional safety? to confirm)
         if (_IsPrototype(prim)) {
             // Prototype selection
-            if (_selection->IsFullySelected(primPath) || _highlightedPrototypePaths.find(primPath) != _highlightedPrototypePaths.end()) {
+            if (_selection->IsFullySelected(primPath)) {
                 prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
             }
         } else {
@@ -574,51 +574,6 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
         }
     }
 
-    HdSceneIndexObserver::DirtiedPrimEntries dirtiedSelectedMeshProtos;
-    for (const auto& entry : entries) {
-        HdSceneIndexPrim entryPrim = GetInputSceneIndex()->GetPrim(entry.primPath);
-        if (!entry.dirtyLocators.Contains(HdSelectionsSchema::GetDefaultLocator())) {
-            continue;
-        }
-        auto ancestorsRange = entry.primPath.GetAncestorsRange();
-        bool foundPropagatedProtos = false;
-        for (const auto& ancestorPath : ancestorsRange) {
-            HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(ancestorPath);
-            UsdImagingUsdPrimInfoSchema usdPrimInfo = UsdImagingUsdPrimInfoSchema::GetFromParent(currPrim.dataSource);
-            if (usdPrimInfo.IsDefined()) {
-                auto propagatedProtosDataSource = usdPrimInfo.GetPiPropagatedPrototypes();
-                if (propagatedProtosDataSource) {
-                    auto propagatedProtoNames = propagatedProtosDataSource->GetNames();
-                    for (const auto& propagatedProtoName : propagatedProtoNames) {
-                        auto propagatedProtoPathDataSource = HdTypedSampledDataSource<SdfPath>::Cast(propagatedProtosDataSource->Get(propagatedProtoName));
-                        if (propagatedProtoPathDataSource) {
-                            SdfPath propagatedProtoPath = propagatedProtoPathDataSource->GetTypedValue(0);
-                            SdfPath propagatedPrimPath = entry.primPath.ReplacePrefix(ancestorPath, propagatedProtoPath);
-                            HdSceneIndexPrim propagatedPrim = GetInputSceneIndex()->GetPrim(propagatedPrimPath);
-                            if (propagatedPrim.primType == HdPrimTypeTokens->mesh) {
-                                auto newLocators = HdDataSourceLocatorSet(entry.dirtyLocators);
-                                newLocators.append(HdLegacyDisplayStyleSchema::GetDefaultLocator());
-                                dirtiedSelectedMeshProtos.push_back({propagatedPrimPath, newLocators});
-                                if (HdSelectionsSchema::GetFromParent(entryPrim.dataSource).IsDefined()) {
-                                    _highlightedPrototypePaths.insert(propagatedPrimPath);
-                                } else {
-                                    _highlightedPrototypePaths.erase(propagatedPrimPath);
-                                }
-                            }
-                            foundPropagatedProtos = true;
-                        }
-                    }
-                }
-            }
-            if (foundPropagatedProtos) {
-                break;
-            }
-        }
-    }
-    if (!dirtiedSelectedMeshProtos.empty()) {
-        _SendPrimsDirtied(dirtiedSelectedMeshProtos);
-    }
-
     HdSceneIndexObserver::DirtiedPrimEntries dirtiedSelectionHighlightPrims;
     for (const auto& entry : entries) {
         auto selectionHighlightPath = GetSelectionHighlightPath(entry.primPath);
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index ed17368cfa..ebd2b9c2b0 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -124,7 +124,6 @@ class WireframeSelectionHighlightSceneIndex
 
     std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _selectionHighlightMirrorsByInstancer;
     std::unordered_map<PXR_NS::SdfPath, size_t, PXR_NS::SdfPath::Hash> _selectionHighlightMirrorUseCounters;
-    std::set<PXR_NS::SdfPath> _highlightedPrototypePaths;
 };
 
 }
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
index 111290cc06..c2613306c2 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
@@ -27,6 +27,7 @@
 
 #include <pxr/imaging/hd/dataSourceTypeDefs.h>
 #include <pxr/imaging/hd/instanceIndicesSchema.h>
+#include <pxr/imaging/hd/legacyDisplayStyleSchema.h>
 #include <pxr/imaging/hd/prefixingSceneIndex.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
 #include <pxr/imaging/hd/sceneIndexPlugin.h>
@@ -34,6 +35,7 @@
 #include <pxr/imaging/hd/selectionSchema.h>
 #include <pxr/imaging/hd/selectionsSchema.h>
 #include <pxr/imaging/hd/renderDelegate.h>
+#include <pxr/usdImaging/usdImaging/usdPrimInfoSchema.h>
 #include <pxr/usd/sdf/path.h>
 
 #if defined(MAYAHYDRALIB_MAYAUSDAPI_ENABLED)
@@ -152,8 +154,41 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
             selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
             selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
         }
-        Fvp::PrimSelectionInfo primSelection {primPath, selectionDataSource};
-        return Fvp::PrimSelectionInfoVector({primSelection});
+        Fvp::PrimSelectionInfo basePrimSelection {primPath, selectionDataSource};
+        Fvp::PrimSelectionInfoVector primSelections({basePrimSelection});
+
+        // Propagate selection to propagated prototypes
+        auto ancestorsRange = primPath.GetAncestorsRange();
+        for (const auto& ancestorPath : ancestorsRange) {
+            HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(ancestorPath);
+            UsdImagingUsdPrimInfoSchema usdPrimInfo = UsdImagingUsdPrimInfoSchema::GetFromParent(currPrim.dataSource);
+            if (!usdPrimInfo.IsDefined()) {
+                continue;
+            }
+            auto propagatedProtosDataSource = usdPrimInfo.GetPiPropagatedPrototypes();
+            if (!propagatedProtosDataSource) {
+                continue;
+            }
+            auto propagatedProtoNames = propagatedProtosDataSource->GetNames();
+            for (const auto& propagatedProtoName : propagatedProtoNames) {
+                auto propagatedProtoPathDataSource = HdTypedSampledDataSource<SdfPath>::Cast(propagatedProtosDataSource->Get(propagatedProtoName));
+                if (propagatedProtoPathDataSource) {
+                    SdfPath propagatedProtoPath = propagatedProtoPathDataSource->GetTypedValue(0);
+                    SdfPath propagatedPrimPath = primPath.ReplacePrefix(ancestorPath, propagatedProtoPath);
+                    HdSceneIndexPrim propagatedPrim = GetInputSceneIndex()->GetPrim(propagatedPrimPath);
+                    // This check controls which types of prims have their selection data source propagated. Currently we skip
+                    // instancers so that selecting an instancer A that is both drawing geometry but also prototyped and propagated
+                    // for another instancer B will only mark the geometry-drawing instancer A as selected. This can be changed.
+                    // For now (2024/05/28), this only affects selection highlighting.
+                    if (propagatedPrim.primType != HdPrimTypeTokens->instancer) {
+                        primSelections.push_back({propagatedPrimPath, selectionDataSource});
+                    }
+                }
+            }
+            break; // We found propagated prototypes, exit now to avoid propagating selection to prototypes of other parents 
+        }
+
+        return primSelections;
     }
 
     const Ufe::Path& GetSceneIndexAppPath() const { return _sceneIndexAppPath; }

From 96cdaebb7769c7010ed38f7ca7bf71c21cbb89d6 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 29 May 2024 10:37:40 -0400
Subject: [PATCH 027/112] Refactor _PrimsDirtied

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 70 +++++++++----------
 1 file changed, 32 insertions(+), 38 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 91db000947..5d651dfe51 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -559,62 +559,56 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
     TF_DEBUG(FVP_WIREFRAME_SELECTION_HIGHLIGHT_SCENE_INDEX)
         .Msg("WireframeSelectionHighlightSceneIndex::_PrimsDirtied() called.\n");
 
-    HdSceneIndexObserver::DirtiedPrimEntries highlightEntries;
+    HdSceneIndexObserver::DirtiedPrimEntries dirtiedPrims;
+    SdfPathVector selectedInstancers;
+    SdfPathVector deselectedInstancers;
     for (const auto& entry : entries) {
-        // If the dirtied prim is excluded, don't provide selection
-        // highlighting for it.
-        if (! _IsExcluded(entry.primPath) && 
-            entry.dirtyLocators.Contains(
-                HdSelectionsSchema::GetDefaultLocator())) {
+        if (_IsExcluded(entry.primPath)) {
+            // If the dirtied prim is excluded, don't provide selection
+            // highlighting for it.
+            continue;
+        }
+
+        if (entry.dirtyLocators.Contains(HdSelectionsSchema::GetDefaultLocator())) {
             TF_DEBUG(FVP_WIREFRAME_SELECTION_HIGHLIGHT_SCENE_INDEX)
                 .Msg("    %s selections locator dirty.\n", entry.primPath.GetText());
+            
+            HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(entry.primPath);
+            
             // All mesh prims recursively under the selection dirty prim have a
             // dirty wireframe selection highlight.
-            _DirtySelectionHighlightRecursive(entry.primPath, &highlightEntries);
-        }
-    }
+            _DirtySelectionHighlightRecursive(entry.primPath, &dirtiedPrims);
 
-    HdSceneIndexObserver::DirtiedPrimEntries dirtiedSelectionHighlightPrims;
-    for (const auto& entry : entries) {
-        auto selectionHighlightPath = GetSelectionHighlightPath(entry.primPath);
-        if (selectionHighlightPath != entry.primPath) {
-            dirtiedSelectionHighlightPrims.emplace_back(selectionHighlightPath, entry.dirtyLocators);
-        }
-    }
-    if (!dirtiedSelectionHighlightPrims.empty()) {
-        _SendPrimsDirtied(dirtiedSelectionHighlightPrims);
-    }
+            auto selectionHighlightPath = GetSelectionHighlightPath(entry.primPath);
+            if (selectionHighlightPath != entry.primPath) {
+                dirtiedPrims.emplace_back(selectionHighlightPath, entry.dirtyLocators);
+                _DirtySelectionHighlightRecursive(entry.primPath, &dirtiedPrims);
+            }
 
-    HdSceneIndexObserver::AddedPrimEntries newSelectionHighlightPrims;
-    HdSceneIndexObserver::RemovedPrimEntries removedSelectionHighlightPrims;
-    for (const auto& entry : entries) {
-        if (entry.dirtyLocators.Contains(HdSelectionsSchema::GetDefaultLocator())) {
-            HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(entry.primPath);
             if (_IsInstancerWithSelections(prim)) {
-                _CreateSelectionHighlightMirrorsForInstancer(entry.primPath);
+                selectedInstancers.push_back(entry.primPath);
             } else if (prim.primType == HdPrimTypeTokens->instancer) {
-                _RemoveSelectionHighlightMirrorsForInstancer(entry.primPath);
+                deselectedInstancers.push_back(entry.primPath);
             }
-            // TODO : Forward dirtiness to SH mirrors masks
         }
     }
-    if (!newSelectionHighlightPrims.empty())
-        _SendPrimsAdded(newSelectionHighlightPrims);
-    if (!removedSelectionHighlightPrims.empty()) {
-        _SendPrimsRemoved(removedSelectionHighlightPrims);
-    }
-
 
-    if (!highlightEntries.empty()) {
+    if (!dirtiedPrims.empty()) {
         // Append all incoming dirty entries.
-        highlightEntries.reserve(highlightEntries.size()+entries.size());
-        highlightEntries.insert(
-            highlightEntries.end(), entries.begin(), entries.end());
-        _SendPrimsDirtied(highlightEntries);
+        dirtiedPrims.reserve(dirtiedPrims.size() + entries.size());
+        dirtiedPrims.insert(dirtiedPrims.end(), entries.begin(), entries.end());
+        _SendPrimsDirtied(dirtiedPrims);
     }
     else {
         _SendPrimsDirtied(entries);
     }
+
+    for (const auto& selectedInstancer : selectedInstancers) {
+        _CreateSelectionHighlightMirrorsForInstancer(selectedInstancer);
+    }
+    for (const auto& deselectedInstancer : deselectedInstancers) {
+        _RemoveSelectionHighlightMirrorsForInstancer(deselectedInstancer);
+    }
 }
 
 void

From aa2cc1bce7bab89f6738a6444ae8c18851a72aa1 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 29 May 2024 11:47:36 -0400
Subject: [PATCH 028/112] Handle prototype ancestor selection

---
 .../fvpWireframeSelectionHighlightSceneIndex.cpp | 16 ++++++++++++++--
 lib/flowViewport/selection/fvpSelection.cpp      |  4 ++--
 lib/flowViewport/selection/fvpSelection.h        |  5 +++--
 3 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 5d651dfe51..03c9e395b9 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -456,8 +456,20 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         // prim (even though it should already not be drawn due to being under an instancer, this is an additional safety? to confirm)
         if (_IsPrototype(prim)) {
             // Prototype selection
-            if (_selection->IsFullySelected(primPath)) {
-                prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
+            HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+            if (instancedBy.IsDefined() && instancedBy.GetPrototypeRoots() && !instancedBy.GetPrototypeRoots()->GetTypedValue(0).empty()) {
+                auto protoRoots = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
+                for (const auto& protoRoot : protoRoots) {
+                    if (_selection->HasFullySelectedAncestorInclusive(primPath, protoRoot)) {
+                        prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
+                        break;
+                    }
+                }
+            }
+            else {
+                if (_selection->HasFullySelectedAncestorInclusive(primPath)) {
+                    prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
+                }
             }
         } else {
             // Regular selection
diff --git a/lib/flowViewport/selection/fvpSelection.cpp b/lib/flowViewport/selection/fvpSelection.cpp
index 03c4e1cba2..e6b2c67488 100644
--- a/lib/flowViewport/selection/fvpSelection.cpp
+++ b/lib/flowViewport/selection/fvpSelection.cpp
@@ -128,13 +128,13 @@ bool Selection::IsFullySelected(const SdfPath& primPath) const
     return _pathToState.find(primPath) != _pathToState.end();
 }
 
-bool Selection::HasFullySelectedAncestorInclusive(const SdfPath& primPath) const
+bool Selection::HasFullySelectedAncestorInclusive(const SdfPath& primPath, const SdfPath& topmostAncestor/* = SdfPath::AbsoluteRootPath()*/) const
 {
     // FLOW_VIEWPORT_TODO  Prefix tree would be much higher performance
     // than iterating over the whole selection, especially for a large
     // selection.  PPT, 13-Sep-2023.
     for(const auto& entry : _pathToState) {
-        if (primPath.HasPrefix(entry.first)) {
+        if (primPath.HasPrefix(entry.first) && entry.first.HasPrefix(topmostAncestor)) {
             return true;
         }
     }
diff --git a/lib/flowViewport/selection/fvpSelection.h b/lib/flowViewport/selection/fvpSelection.h
index 32e2780735..02814d459f 100644
--- a/lib/flowViewport/selection/fvpSelection.h
+++ b/lib/flowViewport/selection/fvpSelection.h
@@ -71,9 +71,10 @@ class Selection
     bool IsFullySelected(const PXR_NS::SdfPath& primPath) const;
 
     // Returns true if the argument is itself selected, or any of its ancestors
-    // is selected.
+    // is selected, up to the specified topmost ancestor. By default, the topmost
+    // ancestor is set to the absolute root path, so that all ancestors are considered.
     FVP_API
-    bool HasFullySelectedAncestorInclusive(const PXR_NS::SdfPath& primPath) const;
+    bool HasFullySelectedAncestorInclusive(const PXR_NS::SdfPath& primPath, const PXR_NS::SdfPath& topmostAncestor = PXR_NS::SdfPath::AbsoluteRootPath()) const;
 
     FVP_API
     PXR_NS::SdfPathVector GetFullySelectedPaths() const;

From 09483d3bf64d6db54bcebff5b429b78c74bcb103 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 29 May 2024 17:35:55 -0400
Subject: [PATCH 029/112] Highlight instancers if ancestor is highlighted

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 263 +++++++++++++++---
 ...fvpWireframeSelectionHighlightSceneIndex.h |   7 +
 lib/flowViewport/selection/fvpSelection.cpp   |  14 +
 lib/flowViewport/selection/fvpSelection.h     |   3 +
 4 files changed, 251 insertions(+), 36 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 03c9e395b9..0e34b71b65 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -190,6 +190,16 @@ SdfPathVector _GetInstancingRelatedPaths(const HdSceneIndexPrim& prim)
     return instancingRelatedPaths;
 }
 
+VtArray<SdfPath> _GetPrototypeRoots(const HdSceneIndexPrim& prim)
+{
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+    if (!instancedBy.IsDefined() || !instancedBy.GetPrototypeRoots()) {
+        return {};
+    }
+
+    return instancedBy.GetPrototypeRoots()->GetTypedValue(0);
+}
+
 bool _IsInstancerWithSelections(const HdSceneIndexPrim& prim)
 {
     if (prim.primType != HdPrimTypeTokens->instancer) {
@@ -406,16 +416,26 @@ WireframeSelectionHighlightSceneIndex(
 
     std::stack<SdfPath> pathsToTraverse({ SdfPath::AbsoluteRootPath() });
     while (!pathsToTraverse.empty()) {
-        SdfPath currPrimPath = pathsToTraverse.top();
+        SdfPath currPath = pathsToTraverse.top();
         pathsToTraverse.pop();
 
-        HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPrimPath);
-        if (_IsInstancerWithSelections(currPrim)) {
-            _CreateSelectionHighlightMirrorsForInstancer(currPrimPath);
+        HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
+        if (currPrim.primType == HdPrimTypeTokens->instancer) {
+            auto roots = _GetPrototypeRoots(currPrim);
+            if (roots.empty()) {
+                roots.push_back(SdfPath::AbsoluteRootPath());
+            }
+            for (const auto& root : roots) {
+                auto selectedAncestors = _selection->FindFullySelectedAncestorsInclusive(currPath, root);
+                for (const auto& selectedAncestor : selectedAncestors) {
+                    _AddSelectionHighlightMirrorsUsageForInstancer(currPath, selectedAncestor);
+                }
+            }
         }
-
-        for (const auto& childPath : inputSceneIndex->GetChildPrimPaths(currPrimPath)) {
-            pathsToTraverse.push(childPath);
+        else {
+            for (const auto& childPath : inputSceneIndex->GetChildPrimPaths(currPath)) {
+                pathsToTraverse.push(childPath);
+            }
         }
     }
 }
@@ -501,7 +521,8 @@ WireframeSelectionHighlightSceneIndex::GetChildPrimPaths(const SdfPath &primPath
     SdfPathVector additionalChildPaths;
     for (const auto& childPath : childPaths) {
         SdfPath selectionHighlightPath = _GetSelectionHighlightMirrorPathFromOriginal(childPath);
-        if (_selectionHighlightMirrorUseCounters.find(selectionHighlightPath) != _selectionHighlightMirrorUseCounters.end()) {
+        if (_selectionHighlightMirrorUseCounters.find(selectionHighlightPath) != _selectionHighlightMirrorUseCounters.end() 
+            && _selectionHighlightMirrorUseCounters.at(selectionHighlightPath) > 0) {
             additionalChildPaths.push_back(selectionHighlightPath);
         }
     }
@@ -557,8 +578,18 @@ WireframeSelectionHighlightSceneIndex::_PrimsAdded(
 
     _SendPrimsAdded(entries);
     for (const auto& entry : entries) {
-        if (_IsInstancerWithSelections(GetInputSceneIndex()->GetPrim(entry.primPath))) {
-            _CreateSelectionHighlightMirrorsForInstancer(entry.primPath);
+        HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(entry.primPath);
+        if (prim.primType == HdPrimTypeTokens->instancer) {
+            auto roots = _GetPrototypeRoots(prim);
+            if (roots.empty()) {
+                roots.push_back(SdfPath::AbsoluteRootPath());
+            }
+            for (const auto& root : roots) {
+                auto selectedAncestors = _selection->FindFullySelectedAncestorsInclusive(entry.primPath, root);
+                for (const auto& selectedAncestor : selectedAncestors) {
+                    _AddSelectionHighlightMirrorsUsageForInstancer(entry.primPath, selectedAncestor);
+                }
+            }
         }
     }
 }
@@ -572,8 +603,8 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
         .Msg("WireframeSelectionHighlightSceneIndex::_PrimsDirtied() called.\n");
 
     HdSceneIndexObserver::DirtiedPrimEntries dirtiedPrims;
-    SdfPathVector selectedInstancers;
-    SdfPathVector deselectedInstancers;
+    std::vector<std::pair<SdfPath, SdfPath>> selectedInstancerHighlightUsages;
+    std::vector<std::pair<SdfPath, SdfPath>> deselectedInstancerHighlightUsages;
     for (const auto& entry : entries) {
         if (_IsExcluded(entry.primPath)) {
             // If the dirtied prim is excluded, don't provide selection
@@ -597,10 +628,28 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
                 _DirtySelectionHighlightRecursive(entry.primPath, &dirtiedPrims);
             }
 
-            if (_IsInstancerWithSelections(prim)) {
-                selectedInstancers.push_back(entry.primPath);
-            } else if (prim.primType == HdPrimTypeTokens->instancer) {
-                deselectedInstancers.push_back(entry.primPath);
+            HdSelectionsSchema selectionsSchema = HdSelectionsSchema::GetFromParent(prim.dataSource);
+            bool isSelected = selectionsSchema.IsDefined() && selectionsSchema.GetNumElements() > 0;
+
+            std::stack<SdfPath> pathsToTraverse({entry.primPath});
+            while (!pathsToTraverse.empty()) {
+                SdfPath currPath = pathsToTraverse.top();
+                pathsToTraverse.pop();
+
+                HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
+                
+                if (currPrim.primType == HdPrimTypeTokens->instancer) {
+                    if (isSelected) {
+                        selectedInstancerHighlightUsages.push_back({currPath,entry.primPath});
+                    } else {
+                        deselectedInstancerHighlightUsages.push_back({currPath,entry.primPath});
+                    }
+                }
+                else if (!_IsPrototype(currPrim)) {
+                    for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
+                        pathsToTraverse.push(childPath);
+                    }
+                }
             }
         }
     }
@@ -615,11 +664,11 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
         _SendPrimsDirtied(entries);
     }
 
-    for (const auto& selectedInstancer : selectedInstancers) {
-        _CreateSelectionHighlightMirrorsForInstancer(selectedInstancer);
+    for (const auto& selectedInstancerHighlightUsage : selectedInstancerHighlightUsages) {
+        _AddSelectionHighlightMirrorsUsageForInstancer(selectedInstancerHighlightUsage.first, selectedInstancerHighlightUsage.second);
     }
-    for (const auto& deselectedInstancer : deselectedInstancers) {
-        _RemoveSelectionHighlightMirrorsForInstancer(deselectedInstancer);
+    for (const auto& deselectedInstancerHighlightUsage : deselectedInstancerHighlightUsages) {
+        _RemoveSelectionHighlightMirrorsUsageForInstancer(deselectedInstancerHighlightUsage.first, deselectedInstancerHighlightUsage.second);
     }
 }
 
@@ -632,8 +681,12 @@ WireframeSelectionHighlightSceneIndex::_PrimsRemoved(
         .Msg("WireframeSelectionHighlightSceneIndex::_PrimsRemoved() called.\n");
 
     for (const auto& entry : entries) {
-        if (_IsInstancerWithSelections(GetInputSceneIndex()->GetPrim(entry.primPath))) {
-            _RemoveSelectionHighlightMirrorsForInstancer(entry.primPath);
+        auto instancerPathsCopy = _selectionHighlightMirrorsByInstancer;
+        for (const auto& selectionHighlightMirrorsForInstancer : instancerPathsCopy) {
+            auto instancerPath = selectionHighlightMirrorsForInstancer.first;
+            if (instancerPath.HasPrefix(entry.primPath)) {
+                _DeleteSelectionHighlightMirrorsUsageForInstancer(instancerPath);
+            }
         }
     }
     _SendPrimsRemoved(entries);
@@ -678,7 +731,8 @@ WireframeSelectionHighlightSceneIndex::GetSelectionHighlightPath(const SdfPath&
     auto ancestorsRange = path.GetAncestorsRange();
     for (auto ancestor : ancestorsRange) {
         const SdfPath mirrorPath = _GetSelectionHighlightMirrorPathFromOriginal(ancestor);
-        if (_selectionHighlightMirrorUseCounters.find(mirrorPath) != _selectionHighlightMirrorUseCounters.end()) {
+        if (_selectionHighlightMirrorUseCounters.find(mirrorPath) != _selectionHighlightMirrorUseCounters.end()
+            && _selectionHighlightMirrorUseCounters.at(mirrorPath) > 0) {
             return path.ReplacePrefix(ancestor, mirrorPath);
         }
     }
@@ -690,7 +744,8 @@ WireframeSelectionHighlightSceneIndex::_FindSelectionHighlightMirrorAncestor(con
 {
     auto ancestorsRange = path.GetAncestorsRange();
     for (auto ancestor : ancestorsRange) {
-        if (_selectionHighlightMirrorUseCounters.find(ancestor) != _selectionHighlightMirrorUseCounters.end()) {
+        if (_selectionHighlightMirrorUseCounters.find(ancestor) != _selectionHighlightMirrorUseCounters.end() 
+            && _selectionHighlightMirrorUseCounters.at(ancestor) > 0) {
             return ancestor;
         }
     }
@@ -781,32 +836,168 @@ WireframeSelectionHighlightSceneIndex::_RemoveSelectionHighlightMirrorsForInstan
 }
 
 void 
-WireframeSelectionHighlightSceneIndex::_CreateSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
+WireframeSelectionHighlightSceneIndex::_UpdateSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
 {
     TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
 
+    HdSceneIndexObserver::RemovedPrimEntries removedPrims;
     if (_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end()) {
-        _RemoveSelectionHighlightMirrorsForInstancer(instancerPath);
+        removedPrims = _DecrementSelectionHighlightMirrorsForInstancer(instancerPath);
     }
 
-    SdfPathSet newSelectionHighlightMirrors;
+    SdfPathSet selectionHighlightMirrors;
     HdSceneIndexObserver::AddedPrimEntries addedPrims;
-    _CollectSelectionHighlightMirrors(instancerPath, newSelectionHighlightMirrors, addedPrims);
+    _CollectSelectionHighlightMirrors(instancerPath, selectionHighlightMirrors, addedPrims);
 
-    _selectionHighlightMirrorsByInstancer[instancerPath] = newSelectionHighlightMirrors;
-    for (const auto& selectionHighlightMirror : newSelectionHighlightMirrors) {
-        if (_selectionHighlightMirrorUseCounters.find(selectionHighlightMirror) == _selectionHighlightMirrorUseCounters.end()) {
-            _selectionHighlightMirrorUseCounters[selectionHighlightMirror] = 1;
-        } else {
-            TF_AXIOM(_selectionHighlightMirrorUseCounters.find(selectionHighlightMirror) != _selectionHighlightMirrorUseCounters.end());
-            TF_AXIOM(_selectionHighlightMirrorUseCounters.at(selectionHighlightMirror) > 0);
-            _selectionHighlightMirrorUseCounters[selectionHighlightMirror]++;
+    _selectionHighlightMirrorsByInstancer[instancerPath] = selectionHighlightMirrors;
+
+    _IncrementSelectionHighlightMirrorsForInstancer(instancerPath);
+
+    SdfPathSet removedAndAddedPrims;
+    for (const auto& removedPrim : removedPrims) {
+        for (const auto& addedPrim : addedPrims) {
+            if (removedPrim.primPath == addedPrim.primPath) {
+                removedAndAddedPrims.insert(removedPrim.primPath);
+            }
         }
     }
+    removedPrims.erase(std::remove_if(removedPrims.begin(), removedPrims.end(), 
+        [&removedAndAddedPrims](const HdSceneIndexObserver::RemovedPrimEntry& removedPrim) -> bool { 
+        return removedAndAddedPrims.find(removedPrim.primPath) != removedAndAddedPrims.end(); 
+    }));
+    addedPrims.erase(std::remove_if(addedPrims.begin(), addedPrims.end(), 
+        [&removedAndAddedPrims](const HdSceneIndexObserver::AddedPrimEntry& addedPrim) -> bool { 
+        return removedAndAddedPrims.find(addedPrim.primPath) != removedAndAddedPrims.end(); 
+    }));
 
+    if (!removedPrims.empty()) {
+        _SendPrimsRemoved(removedPrims);
+    }
     if (!addedPrims.empty()) {
         _SendPrimsAdded(addedPrims);
     }
 }
 
+HdSceneIndexObserver::RemovedPrimEntries
+WireframeSelectionHighlightSceneIndex::_DecrementSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
+{
+    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
+    TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
+
+    HdSceneIndexObserver::RemovedPrimEntries removedPrims;
+
+    SdfPathSet selectionHighlightMirrors = _selectionHighlightMirrorsByInstancer.at(instancerPath);
+    for (const auto& selectionHighlightMirror : selectionHighlightMirrors) {
+        TF_AXIOM(_selectionHighlightMirrorUseCounters.find(selectionHighlightMirror) != _selectionHighlightMirrorUseCounters.end());
+        TF_AXIOM(_selectionHighlightMirrorUseCounters.at(selectionHighlightMirror) > 0);
+        _selectionHighlightMirrorUseCounters[selectionHighlightMirror]--;
+        if (_selectionHighlightMirrorUseCounters.at(selectionHighlightMirror) == 0) {
+            removedPrims.push_back(selectionHighlightMirror);
+        }
+    }
+    
+    return removedPrims;
+}
+
+void
+WireframeSelectionHighlightSceneIndex::_IncrementSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
+{
+    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
+    TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
+    for (const auto& selectionHighlightMirror : _selectionHighlightMirrorsByInstancer.at(instancerPath)) {
+        _selectionHighlightMirrorUseCounters[selectionHighlightMirror]++;
+    }
+}
+
+void
+WireframeSelectionHighlightSceneIndex::_RemoveSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath, const SdfPath& userPath)
+{
+    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
+    TF_AXIOM(_instancerHighlightUsers.find(instancerPath) != _instancerHighlightUsers.end());
+    TF_AXIOM(_instancerHighlightUsers.at(instancerPath).find(userPath) != _instancerHighlightUsers.at(instancerPath).end());
+    TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
+
+    std::cout << "Removing usage for " << instancerPath.GetString() << std::endl;
+
+    HdSceneIndexObserver::RemovedPrimEntries removedPrims;
+    for (const auto& selectionHighlightMirror : _selectionHighlightMirrorsByInstancer[instancerPath]) {
+        TF_AXIOM(_selectionHighlightMirrorUseCounters[selectionHighlightMirror] > 0);
+        _selectionHighlightMirrorUseCounters[selectionHighlightMirror]--;
+        if (_selectionHighlightMirrorUseCounters[selectionHighlightMirror] == 0) {
+            removedPrims.push_back(selectionHighlightMirror);
+        }
+    }
+
+    _instancerHighlightUsers[instancerPath].erase(userPath);
+    if (_instancerHighlightUsers[instancerPath].empty()) {
+        _selectionHighlightMirrorsByInstancer.erase(instancerPath);
+    }
+    
+    if (!removedPrims.empty()) {
+        _SendPrimsRemoved(removedPrims);
+    }
+}
+
+void
+WireframeSelectionHighlightSceneIndex::_DeleteSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath)
+{
+    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
+    TF_AXIOM(_instancerHighlightUsers.find(instancerPath) != _instancerHighlightUsers.end());
+    TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
+
+    std::cout << "Removing usage for " << instancerPath.GetString() << std::endl;
+
+    HdSceneIndexObserver::RemovedPrimEntries removedPrims;
+    for (const auto& selectionHighlightMirror : _selectionHighlightMirrorsByInstancer[instancerPath]) {
+        TF_AXIOM(_selectionHighlightMirrorUseCounters[selectionHighlightMirror] > 0);
+        _selectionHighlightMirrorUseCounters[selectionHighlightMirror]--;
+        if (_selectionHighlightMirrorUseCounters[selectionHighlightMirror] == 0) {
+            removedPrims.push_back(selectionHighlightMirror);
+        }
+    }
+
+    _instancerHighlightUsers[instancerPath].clear();
+    _selectionHighlightMirrorsByInstancer.erase(instancerPath);
+    
+    if (!removedPrims.empty()) {
+        _SendPrimsRemoved(removedPrims);
+    }
+}
+
+void
+WireframeSelectionHighlightSceneIndex::_AddSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath, const SdfPath& userPath)
+{
+    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
+    
+    std::cout << "Adding usage for " << instancerPath.GetString() << std::endl;
+
+    if (_instancerHighlightUsers[instancerPath].find(userPath) != _instancerHighlightUsers[instancerPath].end()) {
+        return;
+    }
+
+    _instancerHighlightUsers[instancerPath].insert(userPath);
+    if (_selectionHighlightMirrorsByInstancer.find(instancerPath) == _selectionHighlightMirrorsByInstancer.end()) {
+        SdfPathSet selectionHighlightMirrors;
+        HdSceneIndexObserver::AddedPrimEntries addedPrims;
+        _CollectSelectionHighlightMirrors(instancerPath, selectionHighlightMirrors, addedPrims);
+
+        _selectionHighlightMirrorsByInstancer[instancerPath] = selectionHighlightMirrors;
+        for (const auto& selectionHighlightMirror : _selectionHighlightMirrorsByInstancer[instancerPath]) {
+            _selectionHighlightMirrorUseCounters[selectionHighlightMirror]++;
+        }
+
+        // addedPrims.erase(std::remove_if(addedPrims.begin(), addedPrims.end(), [this](const HdSceneIndexObserver::AddedPrimEntry entry) -> bool {
+        //     return _selectionHighlightMirrorUseCounters[entry.primPath] != 1;
+        // }));
+        if (!addedPrims.empty()) {
+            _SendPrimsAdded(addedPrims);
+        }
+    }
+    else {
+        for (const auto& selectionHighlightMirror : _selectionHighlightMirrorsByInstancer[instancerPath]) {
+            _selectionHighlightMirrorUseCounters[selectionHighlightMirror]++;
+        }
+    }
+}
+
 }
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index ebd2b9c2b0..813133ad5e 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -118,11 +118,18 @@ class WireframeSelectionHighlightSceneIndex
     void _CollectSelectionHighlightMirrors(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrors, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims);
     void _RemoveSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
     void _CreateSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
+    void _UpdateSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
+    PXR_NS::HdSceneIndexObserver::RemovedPrimEntries _DecrementSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
+    void _IncrementSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
+    void _RemoveSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);
+    void _DeleteSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath);
+    void _AddSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);
 
     const SelectionConstPtr   _selection;
     const std::shared_ptr<WireframeColorInterface> _wireframeColorInterface;
 
     std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _selectionHighlightMirrorsByInstancer;
+    std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _instancerHighlightUsers;
     std::unordered_map<PXR_NS::SdfPath, size_t, PXR_NS::SdfPath::Hash> _selectionHighlightMirrorUseCounters;
 };
 
diff --git a/lib/flowViewport/selection/fvpSelection.cpp b/lib/flowViewport/selection/fvpSelection.cpp
index e6b2c67488..32a9206e50 100644
--- a/lib/flowViewport/selection/fvpSelection.cpp
+++ b/lib/flowViewport/selection/fvpSelection.cpp
@@ -141,6 +141,20 @@ bool Selection::HasFullySelectedAncestorInclusive(const SdfPath& primPath, const
     return false;
 }
 
+SdfPathVector Selection::FindFullySelectedAncestorsInclusive(const SdfPath& primPath, const SdfPath& topmostAncestor/* = SdfPath::AbsoluteRootPath()*/) const
+{
+    // FLOW_VIEWPORT_TODO  Prefix tree would be much higher performance
+    // than iterating over the whole selection, especially for a large
+    // selection.  PPT, 13-Sep-2023.
+    SdfPathVector fullySelectedAncestors;
+    for(const auto& entry : _pathToState) {
+        if (primPath.HasPrefix(entry.first) && entry.first.HasPrefix(topmostAncestor)) {
+            fullySelectedAncestors.push_back(entry.first);
+        }
+    }
+    return fullySelectedAncestors;
+}
+
 SdfPathVector Selection::GetFullySelectedPaths() const
 {
     SdfPathVector fullySelectedPaths;
diff --git a/lib/flowViewport/selection/fvpSelection.h b/lib/flowViewport/selection/fvpSelection.h
index 02814d459f..6c2dd735dc 100644
--- a/lib/flowViewport/selection/fvpSelection.h
+++ b/lib/flowViewport/selection/fvpSelection.h
@@ -76,6 +76,9 @@ class Selection
     FVP_API
     bool HasFullySelectedAncestorInclusive(const PXR_NS::SdfPath& primPath, const PXR_NS::SdfPath& topmostAncestor = PXR_NS::SdfPath::AbsoluteRootPath()) const;
 
+    FVP_API
+    PXR_NS::SdfPathVector FindFullySelectedAncestorsInclusive(const PXR_NS::SdfPath& primPath, const PXR_NS::SdfPath& topmostAncestor = PXR_NS::SdfPath::AbsoluteRootPath()) const;
+
     FVP_API
     PXR_NS::SdfPathVector GetFullySelectedPaths() const;
 

From e98c6015ee5115c860f108c4286a2d2058a4bca6 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 29 May 2024 17:43:22 -0400
Subject: [PATCH 030/112] Fix dirtying issue with selection highlight not
 following prims

---
 .../fvpWireframeSelectionHighlightSceneIndex.cpp          | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 0e34b71b65..be481eba70 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -612,6 +612,11 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
             continue;
         }
 
+        auto selectionHighlightPath = GetSelectionHighlightPath(entry.primPath);
+        if (selectionHighlightPath != entry.primPath) {
+            dirtiedPrims.emplace_back(selectionHighlightPath, entry.dirtyLocators);
+        }
+
         if (entry.dirtyLocators.Contains(HdSelectionsSchema::GetDefaultLocator())) {
             TF_DEBUG(FVP_WIREFRAME_SELECTION_HIGHLIGHT_SCENE_INDEX)
                 .Msg("    %s selections locator dirty.\n", entry.primPath.GetText());
@@ -621,10 +626,7 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
             // All mesh prims recursively under the selection dirty prim have a
             // dirty wireframe selection highlight.
             _DirtySelectionHighlightRecursive(entry.primPath, &dirtiedPrims);
-
-            auto selectionHighlightPath = GetSelectionHighlightPath(entry.primPath);
             if (selectionHighlightPath != entry.primPath) {
-                dirtiedPrims.emplace_back(selectionHighlightPath, entry.dirtyLocators);
                 _DirtySelectionHighlightRecursive(entry.primPath, &dirtiedPrims);
             }
 

From 791552a95c1f7d48d5e26a93a2c2aaaa82ec8ae6 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 29 May 2024 17:45:02 -0400
Subject: [PATCH 031/112] Remove obsolete methods

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 102 ------------------
 ...fvpWireframeSelectionHighlightSceneIndex.h |   5 -
 2 files changed, 107 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index be481eba70..c61ca6e266 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -809,108 +809,6 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightMirrors(const P
     }
 }
 
-void 
-WireframeSelectionHighlightSceneIndex::_RemoveSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
-{
-    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
-
-    HdSceneIndexObserver::RemovedPrimEntries removedPrims;
-
-    SdfPathSet oldSelectionHighlightMirrors;
-    if (_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end()) {
-        oldSelectionHighlightMirrors = _selectionHighlightMirrorsByInstancer.at(instancerPath);
-    }
-    for (const auto& selectionHighlightMirror : oldSelectionHighlightMirrors) {
-        TF_AXIOM(_selectionHighlightMirrorUseCounters.find(selectionHighlightMirror) != _selectionHighlightMirrorUseCounters.end());
-        TF_AXIOM(_selectionHighlightMirrorUseCounters.at(selectionHighlightMirror) > 0);
-        _selectionHighlightMirrorUseCounters[selectionHighlightMirror]--;
-        if (_selectionHighlightMirrorUseCounters.at(selectionHighlightMirror) == 0) {
-            _selectionHighlightMirrorUseCounters.erase(selectionHighlightMirror);
-            removedPrims.push_back(selectionHighlightMirror);
-        }
-    }
-
-    _selectionHighlightMirrorsByInstancer.erase(instancerPath);
-    
-    if (!removedPrims.empty()) {
-        _SendPrimsRemoved(removedPrims);
-    }
-}
-
-void 
-WireframeSelectionHighlightSceneIndex::_UpdateSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
-{
-    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
-
-    HdSceneIndexObserver::RemovedPrimEntries removedPrims;
-    if (_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end()) {
-        removedPrims = _DecrementSelectionHighlightMirrorsForInstancer(instancerPath);
-    }
-
-    SdfPathSet selectionHighlightMirrors;
-    HdSceneIndexObserver::AddedPrimEntries addedPrims;
-    _CollectSelectionHighlightMirrors(instancerPath, selectionHighlightMirrors, addedPrims);
-
-    _selectionHighlightMirrorsByInstancer[instancerPath] = selectionHighlightMirrors;
-
-    _IncrementSelectionHighlightMirrorsForInstancer(instancerPath);
-
-    SdfPathSet removedAndAddedPrims;
-    for (const auto& removedPrim : removedPrims) {
-        for (const auto& addedPrim : addedPrims) {
-            if (removedPrim.primPath == addedPrim.primPath) {
-                removedAndAddedPrims.insert(removedPrim.primPath);
-            }
-        }
-    }
-    removedPrims.erase(std::remove_if(removedPrims.begin(), removedPrims.end(), 
-        [&removedAndAddedPrims](const HdSceneIndexObserver::RemovedPrimEntry& removedPrim) -> bool { 
-        return removedAndAddedPrims.find(removedPrim.primPath) != removedAndAddedPrims.end(); 
-    }));
-    addedPrims.erase(std::remove_if(addedPrims.begin(), addedPrims.end(), 
-        [&removedAndAddedPrims](const HdSceneIndexObserver::AddedPrimEntry& addedPrim) -> bool { 
-        return removedAndAddedPrims.find(addedPrim.primPath) != removedAndAddedPrims.end(); 
-    }));
-
-    if (!removedPrims.empty()) {
-        _SendPrimsRemoved(removedPrims);
-    }
-    if (!addedPrims.empty()) {
-        _SendPrimsAdded(addedPrims);
-    }
-}
-
-HdSceneIndexObserver::RemovedPrimEntries
-WireframeSelectionHighlightSceneIndex::_DecrementSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
-{
-    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
-    TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
-
-    HdSceneIndexObserver::RemovedPrimEntries removedPrims;
-
-    SdfPathSet selectionHighlightMirrors = _selectionHighlightMirrorsByInstancer.at(instancerPath);
-    for (const auto& selectionHighlightMirror : selectionHighlightMirrors) {
-        TF_AXIOM(_selectionHighlightMirrorUseCounters.find(selectionHighlightMirror) != _selectionHighlightMirrorUseCounters.end());
-        TF_AXIOM(_selectionHighlightMirrorUseCounters.at(selectionHighlightMirror) > 0);
-        _selectionHighlightMirrorUseCounters[selectionHighlightMirror]--;
-        if (_selectionHighlightMirrorUseCounters.at(selectionHighlightMirror) == 0) {
-            removedPrims.push_back(selectionHighlightMirror);
-        }
-    }
-    
-    return removedPrims;
-}
-
-void
-WireframeSelectionHighlightSceneIndex::_IncrementSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath)
-{
-    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
-    TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
-    for (const auto& selectionHighlightMirror : _selectionHighlightMirrorsByInstancer.at(instancerPath)) {
-        _selectionHighlightMirrorUseCounters[selectionHighlightMirror]++;
-    }
-}
-
 void
 WireframeSelectionHighlightSceneIndex::_RemoveSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath, const SdfPath& userPath)
 {
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 813133ad5e..2e56012622 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -116,11 +116,6 @@ class WireframeSelectionHighlightSceneIndex
 
     PXR_NS::SdfPath _FindSelectionHighlightMirrorAncestor(const PXR_NS::SdfPath& path) const;
     void _CollectSelectionHighlightMirrors(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrors, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims);
-    void _RemoveSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
-    void _CreateSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
-    void _UpdateSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
-    PXR_NS::HdSceneIndexObserver::RemovedPrimEntries _DecrementSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
-    void _IncrementSelectionHighlightMirrorsForInstancer(const PXR_NS::SdfPath& instancerPath);
     void _RemoveSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);
     void _DeleteSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath);
     void _AddSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);

From d8b2aa70c08ab89058583e2556323cc14758fe56 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 30 May 2024 00:04:36 -0400
Subject: [PATCH 032/112] Cleanup

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 22 +++++++------------
 ...fvpWireframeSelectionHighlightSceneIndex.h |  6 ++---
 2 files changed, 11 insertions(+), 17 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index c61ca6e266..b3b3365a97 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -428,7 +428,7 @@ WireframeSelectionHighlightSceneIndex(
             for (const auto& root : roots) {
                 auto selectedAncestors = _selection->FindFullySelectedAncestorsInclusive(currPath, root);
                 for (const auto& selectedAncestor : selectedAncestors) {
-                    _AddSelectionHighlightMirrorsUsageForInstancer(currPath, selectedAncestor);
+                    _AddInstancerHighlightUser(currPath, selectedAncestor);
                 }
             }
         }
@@ -587,7 +587,7 @@ WireframeSelectionHighlightSceneIndex::_PrimsAdded(
             for (const auto& root : roots) {
                 auto selectedAncestors = _selection->FindFullySelectedAncestorsInclusive(entry.primPath, root);
                 for (const auto& selectedAncestor : selectedAncestors) {
-                    _AddSelectionHighlightMirrorsUsageForInstancer(entry.primPath, selectedAncestor);
+                    _AddInstancerHighlightUser(entry.primPath, selectedAncestor);
                 }
             }
         }
@@ -667,10 +667,10 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
     }
 
     for (const auto& selectedInstancerHighlightUsage : selectedInstancerHighlightUsages) {
-        _AddSelectionHighlightMirrorsUsageForInstancer(selectedInstancerHighlightUsage.first, selectedInstancerHighlightUsage.second);
+        _AddInstancerHighlightUser(selectedInstancerHighlightUsage.first, selectedInstancerHighlightUsage.second);
     }
     for (const auto& deselectedInstancerHighlightUsage : deselectedInstancerHighlightUsages) {
-        _RemoveSelectionHighlightMirrorsUsageForInstancer(deselectedInstancerHighlightUsage.first, deselectedInstancerHighlightUsage.second);
+        _RemoveInstancerHighlightUser(deselectedInstancerHighlightUsage.first, deselectedInstancerHighlightUsage.second);
     }
 }
 
@@ -687,7 +687,7 @@ WireframeSelectionHighlightSceneIndex::_PrimsRemoved(
         for (const auto& selectionHighlightMirrorsForInstancer : instancerPathsCopy) {
             auto instancerPath = selectionHighlightMirrorsForInstancer.first;
             if (instancerPath.HasPrefix(entry.primPath)) {
-                _DeleteSelectionHighlightMirrorsUsageForInstancer(instancerPath);
+                _DeleteInstancerHighlight(instancerPath);
             }
         }
     }
@@ -810,15 +810,13 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightMirrors(const P
 }
 
 void
-WireframeSelectionHighlightSceneIndex::_RemoveSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath, const SdfPath& userPath)
+WireframeSelectionHighlightSceneIndex::_RemoveInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const SdfPath& userPath)
 {
     TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
     TF_AXIOM(_instancerHighlightUsers.find(instancerPath) != _instancerHighlightUsers.end());
     TF_AXIOM(_instancerHighlightUsers.at(instancerPath).find(userPath) != _instancerHighlightUsers.at(instancerPath).end());
     TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
 
-    std::cout << "Removing usage for " << instancerPath.GetString() << std::endl;
-
     HdSceneIndexObserver::RemovedPrimEntries removedPrims;
     for (const auto& selectionHighlightMirror : _selectionHighlightMirrorsByInstancer[instancerPath]) {
         TF_AXIOM(_selectionHighlightMirrorUseCounters[selectionHighlightMirror] > 0);
@@ -839,14 +837,12 @@ WireframeSelectionHighlightSceneIndex::_RemoveSelectionHighlightMirrorsUsageForI
 }
 
 void
-WireframeSelectionHighlightSceneIndex::_DeleteSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath)
+WireframeSelectionHighlightSceneIndex::_DeleteInstancerHighlight(const PXR_NS::SdfPath& instancerPath)
 {
     TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
     TF_AXIOM(_instancerHighlightUsers.find(instancerPath) != _instancerHighlightUsers.end());
     TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
 
-    std::cout << "Removing usage for " << instancerPath.GetString() << std::endl;
-
     HdSceneIndexObserver::RemovedPrimEntries removedPrims;
     for (const auto& selectionHighlightMirror : _selectionHighlightMirrorsByInstancer[instancerPath]) {
         TF_AXIOM(_selectionHighlightMirrorUseCounters[selectionHighlightMirror] > 0);
@@ -865,12 +861,10 @@ WireframeSelectionHighlightSceneIndex::_DeleteSelectionHighlightMirrorsUsageForI
 }
 
 void
-WireframeSelectionHighlightSceneIndex::_AddSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath, const SdfPath& userPath)
+WireframeSelectionHighlightSceneIndex::_AddInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const SdfPath& userPath)
 {
     TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
     
-    std::cout << "Adding usage for " << instancerPath.GetString() << std::endl;
-
     if (_instancerHighlightUsers[instancerPath].find(userPath) != _instancerHighlightUsers[instancerPath].end()) {
         return;
     }
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 2e56012622..9ae7ca2b4d 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -116,9 +116,9 @@ class WireframeSelectionHighlightSceneIndex
 
     PXR_NS::SdfPath _FindSelectionHighlightMirrorAncestor(const PXR_NS::SdfPath& path) const;
     void _CollectSelectionHighlightMirrors(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrors, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims);
-    void _RemoveSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);
-    void _DeleteSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath);
-    void _AddSelectionHighlightMirrorsUsageForInstancer(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);
+    void _AddInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);
+    void _RemoveInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);
+    void _DeleteInstancerHighlight(const PXR_NS::SdfPath& instancerPath);
 
     const SelectionConstPtr   _selection;
     const std::shared_ptr<WireframeColorInterface> _wireframeColorInterface;

From 93d176d218db7110a77204f7765335cafb4c4f50 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 30 May 2024 00:06:21 -0400
Subject: [PATCH 033/112] Reorder methods to build selection highlight mirror
 graph

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 68 +++++++++----------
 1 file changed, 34 insertions(+), 34 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index b3b3365a97..fdce68d5c1 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -809,6 +809,40 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightMirrors(const P
     }
 }
 
+void
+WireframeSelectionHighlightSceneIndex::_AddInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const SdfPath& userPath)
+{
+    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
+    
+    if (_instancerHighlightUsers[instancerPath].find(userPath) != _instancerHighlightUsers[instancerPath].end()) {
+        return;
+    }
+
+    _instancerHighlightUsers[instancerPath].insert(userPath);
+    if (_selectionHighlightMirrorsByInstancer.find(instancerPath) == _selectionHighlightMirrorsByInstancer.end()) {
+        SdfPathSet selectionHighlightMirrors;
+        HdSceneIndexObserver::AddedPrimEntries addedPrims;
+        _CollectSelectionHighlightMirrors(instancerPath, selectionHighlightMirrors, addedPrims);
+
+        _selectionHighlightMirrorsByInstancer[instancerPath] = selectionHighlightMirrors;
+        for (const auto& selectionHighlightMirror : _selectionHighlightMirrorsByInstancer[instancerPath]) {
+            _selectionHighlightMirrorUseCounters[selectionHighlightMirror]++;
+        }
+
+        // addedPrims.erase(std::remove_if(addedPrims.begin(), addedPrims.end(), [this](const HdSceneIndexObserver::AddedPrimEntry entry) -> bool {
+        //     return _selectionHighlightMirrorUseCounters[entry.primPath] != 1;
+        // }));
+        if (!addedPrims.empty()) {
+            _SendPrimsAdded(addedPrims);
+        }
+    }
+    else {
+        for (const auto& selectionHighlightMirror : _selectionHighlightMirrorsByInstancer[instancerPath]) {
+            _selectionHighlightMirrorUseCounters[selectionHighlightMirror]++;
+        }
+    }
+}
+
 void
 WireframeSelectionHighlightSceneIndex::_RemoveInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const SdfPath& userPath)
 {
@@ -860,38 +894,4 @@ WireframeSelectionHighlightSceneIndex::_DeleteInstancerHighlight(const PXR_NS::S
     }
 }
 
-void
-WireframeSelectionHighlightSceneIndex::_AddInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const SdfPath& userPath)
-{
-    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
-    
-    if (_instancerHighlightUsers[instancerPath].find(userPath) != _instancerHighlightUsers[instancerPath].end()) {
-        return;
-    }
-
-    _instancerHighlightUsers[instancerPath].insert(userPath);
-    if (_selectionHighlightMirrorsByInstancer.find(instancerPath) == _selectionHighlightMirrorsByInstancer.end()) {
-        SdfPathSet selectionHighlightMirrors;
-        HdSceneIndexObserver::AddedPrimEntries addedPrims;
-        _CollectSelectionHighlightMirrors(instancerPath, selectionHighlightMirrors, addedPrims);
-
-        _selectionHighlightMirrorsByInstancer[instancerPath] = selectionHighlightMirrors;
-        for (const auto& selectionHighlightMirror : _selectionHighlightMirrorsByInstancer[instancerPath]) {
-            _selectionHighlightMirrorUseCounters[selectionHighlightMirror]++;
-        }
-
-        // addedPrims.erase(std::remove_if(addedPrims.begin(), addedPrims.end(), [this](const HdSceneIndexObserver::AddedPrimEntry entry) -> bool {
-        //     return _selectionHighlightMirrorUseCounters[entry.primPath] != 1;
-        // }));
-        if (!addedPrims.empty()) {
-            _SendPrimsAdded(addedPrims);
-        }
-    }
-    else {
-        for (const auto& selectionHighlightMirror : _selectionHighlightMirrorsByInstancer[instancerPath]) {
-            _selectionHighlightMirrorUseCounters[selectionHighlightMirror]++;
-        }
-    }
-}
-
 }

From ddae9ab541f3baec9e22c73e4eabf88372017e08 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 30 May 2024 00:22:17 -0400
Subject: [PATCH 034/112] Cleanup

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 41 +++++--------------
 1 file changed, 10 insertions(+), 31 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index fdce68d5c1..07011746d2 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -200,15 +200,6 @@ VtArray<SdfPath> _GetPrototypeRoots(const HdSceneIndexPrim& prim)
     return instancedBy.GetPrototypeRoots()->GetTypedValue(0);
 }
 
-bool _IsInstancerWithSelections(const HdSceneIndexPrim& prim)
-{
-    if (prim.primType != HdPrimTypeTokens->instancer) {
-        return false;
-    }
-    auto selections = HdSelectionsSchema::GetFromParent(prim.dataSource);
-    return selections.IsDefined() && selections.GetNumElements() > 0;
-}
-
 bool _IsInstancingRoot(const HdSceneIndexPrim& prim, const SdfPath& primPath)
 {
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
@@ -683,13 +674,15 @@ WireframeSelectionHighlightSceneIndex::_PrimsRemoved(
         .Msg("WireframeSelectionHighlightSceneIndex::_PrimsRemoved() called.\n");
 
     for (const auto& entry : entries) {
-        auto instancerPathsCopy = _selectionHighlightMirrorsByInstancer;
-        for (const auto& selectionHighlightMirrorsForInstancer : instancerPathsCopy) {
-            auto instancerPath = selectionHighlightMirrorsForInstancer.first;
-            if (instancerPath.HasPrefix(entry.primPath)) {
-                _DeleteInstancerHighlight(instancerPath);
+        SdfPathVector instancerHighlightsToDelete;
+        for (const auto& selectionHighlightMirrorsForInstancer : _selectionHighlightMirrorsByInstancer) {
+            if (selectionHighlightMirrorsForInstancer.first.HasPrefix(entry.primPath)) {
+                instancerHighlightsToDelete.push_back(selectionHighlightMirrorsForInstancer.first);
             }
         }
+        for (const auto& instancerHighlightToDelete : instancerHighlightsToDelete) {
+            _DeleteInstancerHighlight(instancerHighlightToDelete);
+        }
     }
     _SendPrimsRemoved(entries);
 }
@@ -829,9 +822,6 @@ WireframeSelectionHighlightSceneIndex::_AddInstancerHighlightUser(const PXR_NS::
             _selectionHighlightMirrorUseCounters[selectionHighlightMirror]++;
         }
 
-        // addedPrims.erase(std::remove_if(addedPrims.begin(), addedPrims.end(), [this](const HdSceneIndexObserver::AddedPrimEntry entry) -> bool {
-        //     return _selectionHighlightMirrorUseCounters[entry.primPath] != 1;
-        // }));
         if (!addedPrims.empty()) {
             _SendPrimsAdded(addedPrims);
         }
@@ -877,20 +867,9 @@ WireframeSelectionHighlightSceneIndex::_DeleteInstancerHighlight(const PXR_NS::S
     TF_AXIOM(_instancerHighlightUsers.find(instancerPath) != _instancerHighlightUsers.end());
     TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
 
-    HdSceneIndexObserver::RemovedPrimEntries removedPrims;
-    for (const auto& selectionHighlightMirror : _selectionHighlightMirrorsByInstancer[instancerPath]) {
-        TF_AXIOM(_selectionHighlightMirrorUseCounters[selectionHighlightMirror] > 0);
-        _selectionHighlightMirrorUseCounters[selectionHighlightMirror]--;
-        if (_selectionHighlightMirrorUseCounters[selectionHighlightMirror] == 0) {
-            removedPrims.push_back(selectionHighlightMirror);
-        }
-    }
-
-    _instancerHighlightUsers[instancerPath].clear();
-    _selectionHighlightMirrorsByInstancer.erase(instancerPath);
-    
-    if (!removedPrims.empty()) {
-        _SendPrimsRemoved(removedPrims);
+    auto instancerHighlightUsers = _instancerHighlightUsers[instancerPath];
+    for (const auto& instancerHighlightUser : instancerHighlightUsers) {
+        _RemoveInstancerHighlightUser(instancerPath, instancerHighlightUser);
     }
 }
 

From 35b73ebb5c0e0180ba3c77515d033ecb42297845 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 30 May 2024 00:42:29 -0400
Subject: [PATCH 035/112] Fix prim dirtying for masks and selection highlights

---
 .../sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 07011746d2..5dc92fb0ce 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -613,12 +613,16 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
                 .Msg("    %s selections locator dirty.\n", entry.primPath.GetText());
             
             HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(entry.primPath);
+
+            if (prim.primType == HdPrimTypeTokens->instancer) {
+                dirtiedPrims.emplace_back(selectionHighlightPath, HdInstancerTopologySchema::GetDefaultLocator().Append(HdInstancerTopologySchemaTokens->mask));
+            }
             
             // All mesh prims recursively under the selection dirty prim have a
             // dirty wireframe selection highlight.
             _DirtySelectionHighlightRecursive(entry.primPath, &dirtiedPrims);
             if (selectionHighlightPath != entry.primPath) {
-                _DirtySelectionHighlightRecursive(entry.primPath, &dirtiedPrims);
+                _DirtySelectionHighlightRecursive(selectionHighlightPath, &dirtiedPrims);
             }
 
             HdSelectionsSchema selectionsSchema = HdSelectionsSchema::GetFromParent(prim.dataSource);

From 94a1b695bf2b94b96be527763d0bf98b70f3b631 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 30 May 2024 00:43:35 -0400
Subject: [PATCH 036/112] Avoid accumulating values in maps indefinitely

---
 .../sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp     | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 5dc92fb0ce..7a07228564 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -850,12 +850,14 @@ WireframeSelectionHighlightSceneIndex::_RemoveInstancerHighlightUser(const PXR_N
         TF_AXIOM(_selectionHighlightMirrorUseCounters[selectionHighlightMirror] > 0);
         _selectionHighlightMirrorUseCounters[selectionHighlightMirror]--;
         if (_selectionHighlightMirrorUseCounters[selectionHighlightMirror] == 0) {
+            _selectionHighlightMirrorUseCounters.erase(selectionHighlightMirror);
             removedPrims.push_back(selectionHighlightMirror);
         }
     }
 
     _instancerHighlightUsers[instancerPath].erase(userPath);
     if (_instancerHighlightUsers[instancerPath].empty()) {
+        _instancerHighlightUsers.erase(instancerPath);
         _selectionHighlightMirrorsByInstancer.erase(instancerPath);
     }
     

From c816975204317d305dd4108add55f5d34c294281 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 30 May 2024 00:49:23 -0400
Subject: [PATCH 037/112] Extract out common code for creating instancer
 highlight into a method

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 37 +++++++++----------
 ...fvpWireframeSelectionHighlightSceneIndex.h |  1 +
 2 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 7a07228564..49d23a01f1 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -412,16 +412,7 @@ WireframeSelectionHighlightSceneIndex(
 
         HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
         if (currPrim.primType == HdPrimTypeTokens->instancer) {
-            auto roots = _GetPrototypeRoots(currPrim);
-            if (roots.empty()) {
-                roots.push_back(SdfPath::AbsoluteRootPath());
-            }
-            for (const auto& root : roots) {
-                auto selectedAncestors = _selection->FindFullySelectedAncestorsInclusive(currPath, root);
-                for (const auto& selectedAncestor : selectedAncestors) {
-                    _AddInstancerHighlightUser(currPath, selectedAncestor);
-                }
-            }
+            _CreateInstancerHighlightsForInstancer(currPrim, currPath);
         }
         else {
             for (const auto& childPath : inputSceneIndex->GetChildPrimPaths(currPath)) {
@@ -571,16 +562,7 @@ WireframeSelectionHighlightSceneIndex::_PrimsAdded(
     for (const auto& entry : entries) {
         HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(entry.primPath);
         if (prim.primType == HdPrimTypeTokens->instancer) {
-            auto roots = _GetPrototypeRoots(prim);
-            if (roots.empty()) {
-                roots.push_back(SdfPath::AbsoluteRootPath());
-            }
-            for (const auto& root : roots) {
-                auto selectedAncestors = _selection->FindFullySelectedAncestorsInclusive(entry.primPath, root);
-                for (const auto& selectedAncestor : selectedAncestors) {
-                    _AddInstancerHighlightUser(entry.primPath, selectedAncestor);
-                }
-            }
+            _CreateInstancerHighlightsForInstancer(prim, entry.primPath);
         }
     }
 }
@@ -879,4 +861,19 @@ WireframeSelectionHighlightSceneIndex::_DeleteInstancerHighlight(const PXR_NS::S
     }
 }
 
+void
+WireframeSelectionHighlightSceneIndex::_CreateInstancerHighlightsForInstancer(const HdSceneIndexPrim& instancerPrim, const SdfPath& instancerPath)
+{
+    auto roots = _GetPrototypeRoots(instancerPrim);
+    if (roots.empty()) {
+        roots.push_back(SdfPath::AbsoluteRootPath());
+    }
+    for (const auto& root : roots) {
+        auto selectedAncestors = _selection->FindFullySelectedAncestorsInclusive(instancerPath, root);
+        for (const auto& selectedAncestor : selectedAncestors) {
+            _AddInstancerHighlightUser(instancerPath, selectedAncestor);
+        }
+    }
+}
+
 }
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 9ae7ca2b4d..a2646d1c4d 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -119,6 +119,7 @@ class WireframeSelectionHighlightSceneIndex
     void _AddInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);
     void _RemoveInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);
     void _DeleteInstancerHighlight(const PXR_NS::SdfPath& instancerPath);
+    void _CreateInstancerHighlightsForInstancer(const PXR_NS::HdSceneIndexPrim& instancerPrim, const PXR_NS::SdfPath& instancerPath);
 
     const SelectionConstPtr   _selection;
     const std::shared_ptr<WireframeColorInterface> _wireframeColorInterface;

From 330347688e6fc9614268e3688a803eab8f5b0caa Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 30 May 2024 00:53:15 -0400
Subject: [PATCH 038/112] Bring back original wireframe highlight color code

---
 .../sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 49d23a01f1..eb71863770 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -517,13 +517,9 @@ HdContainerDataSourceHandle WireframeSelectionHighlightSceneIndex::_HighlightSel
 {
     //Always edit its override wireframe color
     auto edited = HdContainerDataSourceEditor(dataSource);
-
-    // TODO HYDRA-1047 : Handle the different wireframe selection highlight colors
-    GfVec4f wireframeColor;
-    ColorPreferences::getInstance().getColor(FvpColorPreferencesTokens->wireframeSelection, wireframeColor);
     edited.Set(HdPrimvarsSchema::GetDefaultLocator().Append(_primVarsTokens->overrideWireframeColor),
                         Fvp::PrimvarDataSource::New(
-                            HdRetainedTypedSampledDataSource<VtVec4fArray>::New(VtVec4fArray{wireframeColor}),
+                            HdRetainedTypedSampledDataSource<VtVec4fArray>::New(VtVec4fArray{_wireframeColorInterface->getWireframeColor(primPath)}),
                             HdPrimvarSchemaTokens->constant,
                             HdPrimvarSchemaTokens->color));
     

From d0875fddc654095b2b9438a220bd5fd302a3607c Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 30 May 2024 10:55:22 -0400
Subject: [PATCH 039/112] Add comments to document certain behaviors

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 89 ++++++++++++-------
 ...fvpWireframeSelectionHighlightSceneIndex.h | 14 ++-
 .../sceneIndex/registration.cpp               |  7 +-
 3 files changed, 74 insertions(+), 36 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index eb71863770..6e1e69fac8 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -411,6 +411,11 @@ WireframeSelectionHighlightSceneIndex(
         pathsToTraverse.pop();
 
         HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
+
+        // We only want to create highlights for "top-level" instancers (i.e. instancers that are not children
+        // of another instancer), as these are the ones that are drawn. Nested instancers will be drawn
+        // through another top-level instancer. Thus, we do not process child prims once we hit an instancer,
+        // so that only top-level ones are considered.
         if (currPrim.primType == HdPrimTypeTokens->instancer) {
             _CreateInstancerHighlightsForInstancer(currPrim, currPath);
         }
@@ -439,44 +444,36 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         SdfPath originalPrimPath = primPath.ReplacePrefix(selectionHighlightMirrorAncestor, _GetOriginalPathFromSelectionHighlightMirror(selectionHighlightMirrorAncestor));
         HdSceneIndexPrim selectionHighlightPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
         if (selectionHighlightPrim.dataSource) {
+            // Repath the data sources to the selection highlight mirror hierarchy
             selectionHighlightPrim.dataSource = _SelectionHighlightRepathingContainerDataSource::New(selectionHighlightPrim.dataSource, this);
-        }
-        if (selectionHighlightPrim.primType == HdPrimTypeTokens->mesh) {
-            selectionHighlightPrim.dataSource = _HighlightSelectedPrim(selectionHighlightPrim.dataSource, originalPrimPath, sRefinedWireDisplayStyleDataSource);
-        }
-        if (selectionHighlightPrim.primType == HdPrimTypeTokens->instancer) {
-            selectionHighlightPrim.dataSource = _GetSelectionHighlightInstancerDataSource(selectionHighlightPrim.dataSource);
+
+            // Use prim type-specific data source overrides
+            if (selectionHighlightPrim.primType == HdPrimTypeTokens->instancer) {
+                selectionHighlightPrim.dataSource = _GetSelectionHighlightInstancerDataSource(selectionHighlightPrim.dataSource);
+            }
+            else if (selectionHighlightPrim.primType == HdPrimTypeTokens->mesh) {
+                selectionHighlightPrim.dataSource = _HighlightSelectedPrim(selectionHighlightPrim.dataSource, originalPrimPath, sRefinedWireDisplayStyleDataSource);
+            }
         }
         return selectionHighlightPrim;
     }
     
-    // We may be dealing with a prototype selection, a regular selection, or no selection at all.
+    // We are dealing with a prototype selection, a regular selection, or no selection at all.
     HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
     if (prim.primType == HdPrimTypeTokens->mesh) {
         // Note : in the USD data model, the original prims that get propagated as prototypes have their original prim types erased.
-        // Only the resulting propagated prototypes keep the original prim type. Presumably this is to avoid drawing the original
-        // prim (even though it should already not be drawn due to being under an instancer, this is an additional safety? to confirm)
-        if (_IsPrototype(prim)) {
-            // Prototype selection
-            HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
-            if (instancedBy.IsDefined() && instancedBy.GetPrototypeRoots() && !instancedBy.GetPrototypeRoots()->GetTypedValue(0).empty()) {
-                auto protoRoots = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
-                for (const auto& protoRoot : protoRoots) {
-                    if (_selection->HasFullySelectedAncestorInclusive(primPath, protoRoot)) {
-                        prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
-                        break;
-                    }
-                }
-            }
-            else {
-                if (_selection->HasFullySelectedAncestorInclusive(primPath)) {
-                    prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
-                }
-            }
-        } else {
-            // Regular selection
-            if (_selection->HasFullySelectedAncestorInclusive(primPath)) {
+        // Only the resulting propagated prototypes keep the original prim type.
+
+        // We want to constrain the selected ancestor lookup to the propagated prototype only, if it is one.
+        auto roots = _GetPrototypeRoots(prim);
+        // If it is not a propagated prototype, consider the whole hierarchy.
+        if (roots.empty()) {
+            roots.push_back(SdfPath::AbsoluteRootPath());
+        }
+        for (const auto& root : roots) {
+            if (_selection->HasFullySelectedAncestorInclusive(primPath, root)) {
                 prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
+                break;
             }
         }
     }
@@ -574,6 +571,7 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
     HdSceneIndexObserver::DirtiedPrimEntries dirtiedPrims;
     std::vector<std::pair<SdfPath, SdfPath>> selectedInstancerHighlightUsages;
     std::vector<std::pair<SdfPath, SdfPath>> deselectedInstancerHighlightUsages;
+
     for (const auto& entry : entries) {
         if (_IsExcluded(entry.primPath)) {
             // If the dirtied prim is excluded, don't provide selection
@@ -581,6 +579,7 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
             continue;
         }
 
+        // Propagate dirtiness to selection highlight prim
         auto selectionHighlightPath = GetSelectionHighlightPath(entry.primPath);
         if (selectionHighlightPath != entry.primPath) {
             dirtiedPrims.emplace_back(selectionHighlightPath, entry.dirtyLocators);
@@ -592,6 +591,7 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
             
             HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(entry.primPath);
 
+            // Selection was changed on an instancer, so dirty its selection highlight mirror's instancerTopology mask.
             if (prim.primType == HdPrimTypeTokens->instancer) {
                 dirtiedPrims.emplace_back(selectionHighlightPath, HdInstancerTopologySchema::GetDefaultLocator().Append(HdInstancerTopologySchemaTokens->mask));
             }
@@ -606,13 +606,23 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
             HdSelectionsSchema selectionsSchema = HdSelectionsSchema::GetFromParent(prim.dataSource);
             bool isSelected = selectionsSchema.IsDefined() && selectionsSchema.GetNumElements() > 0;
 
+            // Update child instancer highlights for ancestor-based selection highlighting
             std::stack<SdfPath> pathsToTraverse({entry.primPath});
             while (!pathsToTraverse.empty()) {
                 SdfPath currPath = pathsToTraverse.top();
                 pathsToTraverse.pop();
 
                 HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
+
+                // Skip processing of prototypes nested under the prim's hierarchy, as we consider prototype hierarchies to be separate.
+                if (_IsPrototype(currPrim) && _IsInstancingRoot(currPrim, currPath) && currPath != entry.primPath) {
+                    continue;
+                }
                 
+                // We only want to consider highlights for "top-level" instancers (i.e. instancers that are not children
+                // of another instancer), as these are the ones that are drawn. Nested instancers will be drawn
+                // through another top-level instancer. Thus, we do not process child prims once we hit an instancer,
+                // so that only top-level ones are considered.
                 if (currPrim.primType == HdPrimTypeTokens->instancer) {
                     if (isSelected) {
                         selectedInstancerHighlightUsages.push_back({currPath,entry.primPath});
@@ -620,7 +630,7 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
                         deselectedInstancerHighlightUsages.push_back({currPath,entry.primPath});
                     }
                 }
-                else if (!_IsPrototype(currPrim)) {
+                else {
                     for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
                         pathsToTraverse.push(childPath);
                     }
@@ -736,6 +746,10 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightMirrors(const P
     TF_AXIOM(_FindSelectionHighlightMirrorAncestor(originalPrimPath).IsEmpty());
 
     HdSceneIndexPrim originalPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
+
+    // If this is a prototype sub-prim, redirect the call to the prototype root, so that the prototype root
+    // becomes the actual selection highlight mirror. The instancing-related paths of the instancer will be
+    // processed as part of the children traversal later down this method.
     if (!_IsInstancingRoot(originalPrim, originalPrimPath)) {
         HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(originalPrim.dataSource);
         auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
@@ -752,6 +766,8 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightMirrors(const P
     }
     outSelectionHighlightMirrors.insert(selectionHighlightPrimPath);
 
+    // Traverse the children of this prim to find the child instancers, and add its instancing-related
+    // paths so we can process them and create selection highlight mirrors for them as well.
     SdfPathVector affectedOriginalPrimPaths;
     std::stack<SdfPath> pathsToTraverse({originalPrimPath});
     while (!pathsToTraverse.empty()) {
@@ -769,13 +785,18 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightMirrors(const P
 
         outAddedPrims.push_back({currPath.ReplacePrefix(originalPrimPath, selectionHighlightPrimPath), currPrim.primType});
 
+        // We only want to create highlights for "top-level" instancers (i.e. instancers that are not children
+        // of another instancer), as these are the ones that are drawn. Nested instancers will be drawn
+        // through another top-level instancer. Thus, we do not process child prims once we hit an instancer,
+        // so that only top-level ones are considered.
         if (currPrim.primType == HdPrimTypeTokens->instancer) {
             SdfPathVector instancingRelatedPaths = _GetInstancingRelatedPaths(currPrim);
             affectedOriginalPrimPaths.insert(affectedOriginalPrimPaths.end(), instancingRelatedPaths.begin(), instancingRelatedPaths.end());
         }
-
-        for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
-            pathsToTraverse.push(childPath);
+        else {
+            for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
+                pathsToTraverse.push(childPath);
+            }
         }
     }
 
@@ -861,10 +882,12 @@ void
 WireframeSelectionHighlightSceneIndex::_CreateInstancerHighlightsForInstancer(const HdSceneIndexPrim& instancerPrim, const SdfPath& instancerPath)
 {
     auto roots = _GetPrototypeRoots(instancerPrim);
+    // If there are no prototype roots, consider the whole hierarchy
     if (roots.empty()) {
         roots.push_back(SdfPath::AbsoluteRootPath());
     }
     for (const auto& root : roots) {
+        // Ancestors include the instancer itself
         auto selectedAncestors = _selection->FindFullySelectedAncestorsInclusive(instancerPath, root);
         for (const auto& selectedAncestor : selectedAncestors) {
             _AddInstancerHighlightUser(instancerPath, selectedAncestor);
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index a2646d1c4d..42badde512 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -124,9 +124,21 @@ class WireframeSelectionHighlightSceneIndex
     const SelectionConstPtr   _selection;
     const std::shared_ptr<WireframeColorInterface> _wireframeColorInterface;
 
+    // Maps an instancer's path to its required selection highlight mirror paths.
     std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _selectionHighlightMirrorsByInstancer;
-    std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _instancerHighlightUsers;
+
+    // "Ref-counting" of selection highlight mirror prims, which are shared across instancer highlights.
     std::unordered_map<PXR_NS::SdfPath, size_t, PXR_NS::SdfPath::Hash> _selectionHighlightMirrorUseCounters;
+
+    // Tracks which prims contributes to using this instancer's selection highlight.
+    // Why? Suppose the following scenario : we have two selections that each would lead to highlighting the same instancer.
+    // Since both would increment the use counts of the instancer's corresponding selection highlight mirrors, we would
+    // need to also decrement the use counts symetrically. However, what happens if we receive a PrimRemoved notification
+    // on a parent prim (of all contributing selected prims and the instancer itself)? We couldn't just decrement the
+    // instancer's selection highlight mirrors by one, or they could end up never being removed. However, we would have
+    // no way of knowing how many times this instancer actually uses its selection highlight mirrors. Keeping track of
+    // which selected prims contribute to the instancer's highlight solves this problem.
+    std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _instancerHighlightUsers;
 };
 
 }
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
index c2613306c2..11108defe2 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
@@ -59,6 +59,8 @@
 
 namespace {
 
+const std::string digits = "0123456789";
+
 // Pixar macros won't work without PXR_NS.
 PXR_NAMESPACE_USING_DIRECTIVE
 using namespace Ufe;
@@ -131,13 +133,14 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
         TF_AXIOM(appPath.nbSegments() == 2);
         const auto& secondSegment = appPath.getSegments()[1];
         for (const auto& pathComponent : secondSegment) {
-            if (pathComponent.string().find_first_not_of("0123456789") == std::string::npos) {
+            // This should only be able to occur on the last component
+            if (pathComponent.string().find_first_not_of(digits) == std::string::npos) {
                 continue;
             }
             primPath = primPath.AppendChild(TfToken(pathComponent.string()));
         }
         const auto lastComponentString = secondSegment.components().back().string();
-        bool lastComponentIsNumeric = lastComponentString.find_first_not_of("0123456789") == std::string::npos;
+        bool lastComponentIsNumeric = lastComponentString.find_first_not_of(digits) == std::string::npos;
         HdDataSourceBaseHandle selectionDataSource;
         if (lastComponentIsNumeric) {
             HdInstanceIndicesSchema::Builder instanceIndicesBuilder;

From 4134e78bea79b7e537352695c8c1e1fdd81fd44d Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 30 May 2024 11:55:29 -0400
Subject: [PATCH 040/112] Extract out traversal method

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 121 +++++++-----------
 ...fvpWireframeSelectionHighlightSceneIndex.h |   2 +
 2 files changed, 51 insertions(+), 72 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 6e1e69fac8..989fbce355 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -405,26 +405,14 @@ WireframeSelectionHighlightSceneIndex(
 {
     TF_AXIOM(_wireframeColorInterface);
 
-    std::stack<SdfPath> pathsToTraverse({ SdfPath::AbsoluteRootPath() });
-    while (!pathsToTraverse.empty()) {
-        SdfPath currPath = pathsToTraverse.top();
-        pathsToTraverse.pop();
-
-        HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
-
-        // We only want to create highlights for "top-level" instancers (i.e. instancers that are not children
-        // of another instancer), as these are the ones that are drawn. Nested instancers will be drawn
-        // through another top-level instancer. Thus, we do not process child prims once we hit an instancer,
-        // so that only top-level ones are considered.
-        if (currPrim.primType == HdPrimTypeTokens->instancer) {
-            _CreateInstancerHighlightsForInstancer(currPrim, currPath);
-        }
-        else {
-            for (const auto& childPath : inputSceneIndex->GetChildPrimPaths(currPath)) {
-                pathsToTraverse.push(childPath);
-            }
+    auto operation = [this](const SdfPath& primPath, const HdSceneIndexPrim& prim) -> bool {
+        if (prim.primType == HdPrimTypeTokens->instancer) {
+            _CreateInstancerHighlightsForInstancer(prim, primPath);
+            return false; // Only create highlights for top-level instancers
         }
-    }
+        return true;
+    };
+    _ForEachPrimInHierarchy(SdfPath::AbsoluteRootPath(), operation);
 }
 
 HdSceneIndexPrim
@@ -607,35 +595,18 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
             bool isSelected = selectionsSchema.IsDefined() && selectionsSchema.GetNumElements() > 0;
 
             // Update child instancer highlights for ancestor-based selection highlighting
-            std::stack<SdfPath> pathsToTraverse({entry.primPath});
-            while (!pathsToTraverse.empty()) {
-                SdfPath currPath = pathsToTraverse.top();
-                pathsToTraverse.pop();
-
-                HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
-
-                // Skip processing of prototypes nested under the prim's hierarchy, as we consider prototype hierarchies to be separate.
-                if (_IsPrototype(currPrim) && _IsInstancingRoot(currPrim, currPath) && currPath != entry.primPath) {
-                    continue;
-                }
-                
-                // We only want to consider highlights for "top-level" instancers (i.e. instancers that are not children
-                // of another instancer), as these are the ones that are drawn. Nested instancers will be drawn
-                // through another top-level instancer. Thus, we do not process child prims once we hit an instancer,
-                // so that only top-level ones are considered.
-                if (currPrim.primType == HdPrimTypeTokens->instancer) {
+            auto operation = [&](const SdfPath& primPath, const HdSceneIndexPrim& prim) -> bool {
+                if (prim.primType == HdPrimTypeTokens->instancer) {
                     if (isSelected) {
-                        selectedInstancerHighlightUsages.push_back({currPath,entry.primPath});
+                        selectedInstancerHighlightUsages.push_back({primPath,entry.primPath});
                     } else {
-                        deselectedInstancerHighlightUsages.push_back({currPath,entry.primPath});
-                    }
-                }
-                else {
-                    for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
-                        pathsToTraverse.push(childPath);
+                        deselectedInstancerHighlightUsages.push_back({primPath,entry.primPath});
                     }
+                    return false; // Only update direct/immediate instancer children
                 }
-            }
+                return true;
+            };
+            _ForEachPrimInHierarchy(entry.primPath, operation);
         }
     }
 
@@ -726,6 +697,32 @@ WireframeSelectionHighlightSceneIndex::GetSelectionHighlightPath(const SdfPath&
     return path;
 }
 
+void
+WireframeSelectionHighlightSceneIndex::_ForEachPrimInHierarchy(
+    const PXR_NS::SdfPath& hierarchyRoot, 
+    const std::function<bool(const PXR_NS::SdfPath&, const PXR_NS::HdSceneIndexPrim&)>& operation
+)
+{
+    std::stack<SdfPath> pathsToTraverse({hierarchyRoot});
+    while (!pathsToTraverse.empty()) {
+        SdfPath currPath = pathsToTraverse.top();
+        pathsToTraverse.pop();
+
+        HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
+
+        // Skip processing of prototypes nested under the hierarchy, as we consider prototype hierarchies to be separate.
+        if (_IsPrototype(currPrim) && _IsInstancingRoot(currPrim, currPath) && currPath != hierarchyRoot) {
+            continue;
+        }
+        
+        if (operation(currPath, currPrim)) {
+            for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
+                pathsToTraverse.push(childPath);
+            }
+        }
+    }
+}
+
 SdfPath
 WireframeSelectionHighlightSceneIndex::_FindSelectionHighlightMirrorAncestor(const SdfPath& path) const
 {
@@ -769,36 +766,16 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightMirrors(const P
     // Traverse the children of this prim to find the child instancers, and add its instancing-related
     // paths so we can process them and create selection highlight mirrors for them as well.
     SdfPathVector affectedOriginalPrimPaths;
-    std::stack<SdfPath> pathsToTraverse({originalPrimPath});
-    while (!pathsToTraverse.empty()) {
-        SdfPath currPath = pathsToTraverse.top();
-        pathsToTraverse.pop();
-
-        HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
-
-        // Skip processing of prototypes nested under the prim's hierarchy, as prototypes should be processed by
-        // traversing the instancing-related paths of instancers and instancees. And if they aren't, then it means
-        // the prototype is either not instanced in the first place, or is part of a different instancing hierarchy.
-        if (_IsPrototype(currPrim) && _IsInstancingRoot(currPrim, currPath) && currPath != originalPrimPath) {
-            continue;
-        }
-
-        outAddedPrims.push_back({currPath.ReplacePrefix(originalPrimPath, selectionHighlightPrimPath), currPrim.primType});
-
-        // We only want to create highlights for "top-level" instancers (i.e. instancers that are not children
-        // of another instancer), as these are the ones that are drawn. Nested instancers will be drawn
-        // through another top-level instancer. Thus, we do not process child prims once we hit an instancer,
-        // so that only top-level ones are considered.
-        if (currPrim.primType == HdPrimTypeTokens->instancer) {
-            SdfPathVector instancingRelatedPaths = _GetInstancingRelatedPaths(currPrim);
+    auto operation = [&](const SdfPath& primPath, const HdSceneIndexPrim& prim) -> bool {
+        outAddedPrims.push_back({primPath.ReplacePrefix(originalPrimPath, selectionHighlightPrimPath), prim.primType});
+        if (prim.primType == HdPrimTypeTokens->instancer) {
+            SdfPathVector instancingRelatedPaths = _GetInstancingRelatedPaths(prim);
             affectedOriginalPrimPaths.insert(affectedOriginalPrimPaths.end(), instancingRelatedPaths.begin(), instancingRelatedPaths.end());
+            return false; // We have found an instancer, don't process its children (nested instancers will be processed through the instancing-related paths).
         }
-        else {
-            for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
-                pathsToTraverse.push(childPath);
-            }
-        }
-    }
+        return true;
+    };
+    _ForEachPrimInHierarchy(originalPrimPath, operation);
 
     for (const auto& affectedOriginalPrimPath : affectedOriginalPrimPaths) {
         _CollectSelectionHighlightMirrors(affectedOriginalPrimPath, outSelectionHighlightMirrors, outAddedPrims);
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 42badde512..637b0b4d77 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -27,6 +27,7 @@
 #include <pxr/usdImaging/usdImaging/rerootingSceneIndex.h>
 #include <pxr/usd/sdf/path.h>
 
+#include <functional>
 #include <set>
 #include <unordered_map>
 
@@ -114,6 +115,7 @@ class WireframeSelectionHighlightSceneIndex
     std::set<PXR_NS::SdfPath> _excludedSceneRoots;
     PXR_NS::HdContainerDataSourceHandle _HighlightSelectedPrim(const PXR_NS::HdContainerDataSourceHandle& dataSource, const PXR_NS::SdfPath& primPath, const PXR_NS::HdContainerDataSourceHandle& highlightDataSource) const;
 
+    void _ForEachPrimInHierarchy(const PXR_NS::SdfPath& hierarchyRoot, const std::function<bool(const PXR_NS::SdfPath&, const PXR_NS::HdSceneIndexPrim&)>& operation);
     PXR_NS::SdfPath _FindSelectionHighlightMirrorAncestor(const PXR_NS::SdfPath& path) const;
     void _CollectSelectionHighlightMirrors(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrors, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims);
     void _AddInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);

From 33d6d6a11253e8dc736ccc3d1750ab5e43ae1aea Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 30 May 2024 13:45:51 -0400
Subject: [PATCH 041/112] Adjust comment

---
 .../sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h   | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 637b0b4d77..97e621a803 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -137,9 +137,9 @@ class WireframeSelectionHighlightSceneIndex
     // Since both would increment the use counts of the instancer's corresponding selection highlight mirrors, we would
     // need to also decrement the use counts symetrically. However, what happens if we receive a PrimRemoved notification
     // on a parent prim (of all contributing selected prims and the instancer itself)? We couldn't just decrement the
-    // instancer's selection highlight mirrors by one, or they could end up never being removed. However, we would have
-    // no way of knowing how many times this instancer actually uses its selection highlight mirrors. Keeping track of
-    // which selected prims contribute to the instancer's highlight solves this problem.
+    // instancer's selection highlight mirrors by one, or they could end up floating around in memory forever. However, 
+    // we would have no way of knowing how many times this instancer actually uses its selection highlight mirrors. 
+    // Keeping track of which selected prims contribute to the instancer's highlight solves this problem.
     std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _instancerHighlightUsers;
 };
 

From 29550e90f1523fa0545e4a4a15bf2bb9f37f56e4 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 30 May 2024 13:51:14 -0400
Subject: [PATCH 042/112] Only highlight instancers through ancestors for
 non-prototypes

---
 .../fvpWireframeSelectionHighlightSceneIndex.cpp          | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 989fbce355..7146ba1907 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -606,7 +606,9 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
                 }
                 return true;
             };
-            _ForEachPrimInHierarchy(entry.primPath, operation);
+            if (!_IsPrototype(prim)) {
+                _ForEachPrimInHierarchy(entry.primPath, operation);
+            }
         }
     }
 
@@ -714,7 +716,7 @@ WireframeSelectionHighlightSceneIndex::_ForEachPrimInHierarchy(
         if (_IsPrototype(currPrim) && _IsInstancingRoot(currPrim, currPath) && currPath != hierarchyRoot) {
             continue;
         }
-        
+
         if (operation(currPath, currPrim)) {
             for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
                 pathsToTraverse.push(childPath);
@@ -816,7 +818,6 @@ WireframeSelectionHighlightSceneIndex::_AddInstancerHighlightUser(const PXR_NS::
 void
 WireframeSelectionHighlightSceneIndex::_RemoveInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const SdfPath& userPath)
 {
-    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
     TF_AXIOM(_instancerHighlightUsers.find(instancerPath) != _instancerHighlightUsers.end());
     TF_AXIOM(_instancerHighlightUsers.at(instancerPath).find(userPath) != _instancerHighlightUsers.at(instancerPath).end());
     TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
@@ -845,7 +846,6 @@ WireframeSelectionHighlightSceneIndex::_RemoveInstancerHighlightUser(const PXR_N
 void
 WireframeSelectionHighlightSceneIndex::_DeleteInstancerHighlight(const PXR_NS::SdfPath& instancerPath)
 {
-    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
     TF_AXIOM(_instancerHighlightUsers.find(instancerPath) != _instancerHighlightUsers.end());
     TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
 

From 6ea665e58920b5bedd492a0d4906ad903a0c5fb9 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Thu, 30 May 2024 14:02:58 -0400
Subject: [PATCH 043/112] Small check to avoid dirtying needlessly

---
 .../sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 7146ba1907..6dbbd7078d 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -580,7 +580,7 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
             HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(entry.primPath);
 
             // Selection was changed on an instancer, so dirty its selection highlight mirror's instancerTopology mask.
-            if (prim.primType == HdPrimTypeTokens->instancer) {
+            if (prim.primType == HdPrimTypeTokens->instancer && selectionHighlightPath != entry.primPath) {
                 dirtiedPrims.emplace_back(selectionHighlightPath, HdInstancerTopologySchema::GetDefaultLocator().Append(HdInstancerTopologySchemaTokens->mask));
             }
             

From 602f5297a53699597c0d131687a54b168a4c4c87 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Fri, 31 May 2024 15:26:58 -0400
Subject: [PATCH 044/112] Rebuild instancer highlights

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 47 +++++++++++++++----
 ...fvpWireframeSelectionHighlightSceneIndex.h |  1 +
 2 files changed, 39 insertions(+), 9 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 6dbbd7078d..7075fb78b1 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -557,8 +557,9 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
         .Msg("WireframeSelectionHighlightSceneIndex::_PrimsDirtied() called.\n");
 
     HdSceneIndexObserver::DirtiedPrimEntries dirtiedPrims;
-    std::vector<std::pair<SdfPath, SdfPath>> selectedInstancerHighlightUsages;
-    std::vector<std::pair<SdfPath, SdfPath>> deselectedInstancerHighlightUsages;
+    std::vector<SdfPath> instancerHighlightsToRebuild;
+    std::vector<std::pair<SdfPath, SdfPath>> instancerHighlightUsersToAdd;
+    std::vector<std::pair<SdfPath, SdfPath>> instancerHighlightUsersToRemove;
 
     for (const auto& entry : entries) {
         if (_IsExcluded(entry.primPath)) {
@@ -573,7 +574,14 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
             dirtiedPrims.emplace_back(selectionHighlightPath, entry.dirtyLocators);
         }
 
-        if (entry.dirtyLocators.Contains(HdSelectionsSchema::GetDefaultLocator())) {
+        if (entry.dirtyLocators.Intersects(HdInstancerTopologySchema::GetDefaultLocator())) {
+            // We do not need to check for instancedBy dirtying : if an instancedBy data source is dirtied,
+            // then either a new instancer was added, which will be handled in _PrimsAdded, either an
+            // existing instancer's instancerTopology data source was dirtied. 
+            instancerHighlightsToRebuild.push_back(entry.primPath);
+        }
+        
+        if (entry.dirtyLocators.Intersects(HdSelectionsSchema::GetDefaultLocator())) {
             TF_DEBUG(FVP_WIREFRAME_SELECTION_HIGHLIGHT_SCENE_INDEX)
                 .Msg("    %s selections locator dirty.\n", entry.primPath.GetText());
             
@@ -598,9 +606,9 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
             auto operation = [&](const SdfPath& primPath, const HdSceneIndexPrim& prim) -> bool {
                 if (prim.primType == HdPrimTypeTokens->instancer) {
                     if (isSelected) {
-                        selectedInstancerHighlightUsages.push_back({primPath,entry.primPath});
+                        instancerHighlightUsersToAdd.push_back({primPath,entry.primPath});
                     } else {
-                        deselectedInstancerHighlightUsages.push_back({primPath,entry.primPath});
+                        instancerHighlightUsersToRemove.push_back({primPath,entry.primPath});
                     }
                     return false; // Only update direct/immediate instancer children
                 }
@@ -622,11 +630,14 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
         _SendPrimsDirtied(entries);
     }
 
-    for (const auto& selectedInstancerHighlightUsage : selectedInstancerHighlightUsages) {
-        _AddInstancerHighlightUser(selectedInstancerHighlightUsage.first, selectedInstancerHighlightUsage.second);
+    for (const auto& instancerHighlightToRebuild : instancerHighlightsToRebuild) {
+        _RebuildInstancerHighlight(instancerHighlightToRebuild);
+    }
+    for (const auto& instancerHighlightUserToAdd : instancerHighlightUsersToAdd) {
+        _AddInstancerHighlightUser(instancerHighlightUserToAdd.first, instancerHighlightUserToAdd.second);
     }
-    for (const auto& deselectedInstancerHighlightUsage : deselectedInstancerHighlightUsages) {
-        _RemoveInstancerHighlightUser(deselectedInstancerHighlightUsage.first, deselectedInstancerHighlightUsage.second);
+    for (const auto& instancerHighlightUserToRemove : instancerHighlightUsersToRemove) {
+        _RemoveInstancerHighlightUser(instancerHighlightUserToRemove.first, instancerHighlightUserToRemove.second);
     }
 }
 
@@ -843,6 +854,24 @@ WireframeSelectionHighlightSceneIndex::_RemoveInstancerHighlightUser(const PXR_N
     }
 }
 
+void
+WireframeSelectionHighlightSceneIndex::_RebuildInstancerHighlight(const PXR_NS::SdfPath& instancerPath)
+{
+    TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
+    TF_AXIOM(_instancerHighlightUsers.find(instancerPath) != _instancerHighlightUsers.end());
+    TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
+
+    auto instancerHighlightUsers = _instancerHighlightUsers[instancerPath];
+    
+    for (const auto& instancerHighlightUser : instancerHighlightUsers) {
+        _RemoveInstancerHighlightUser(instancerPath, instancerHighlightUser);
+    }
+
+    for (const auto& instancerHighlightUser : instancerHighlightUsers) {
+        _AddInstancerHighlightUser(instancerPath, instancerHighlightUser);
+    }
+}
+
 void
 WireframeSelectionHighlightSceneIndex::_DeleteInstancerHighlight(const PXR_NS::SdfPath& instancerPath)
 {
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 97e621a803..9fc0ccc3b9 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -120,6 +120,7 @@ class WireframeSelectionHighlightSceneIndex
     void _CollectSelectionHighlightMirrors(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrors, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims);
     void _AddInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);
     void _RemoveInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);
+    void _RebuildInstancerHighlight(const PXR_NS::SdfPath& instancerPath);
     void _DeleteInstancerHighlight(const PXR_NS::SdfPath& instancerPath);
     void _CreateInstancerHighlightsForInstancer(const PXR_NS::HdSceneIndexPrim& instancerPrim, const PXR_NS::SdfPath& instancerPath);
 

From fa4cf280e933d21e3b01f9eb750c2e8d05a250e9 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Fri, 31 May 2024 15:40:17 -0400
Subject: [PATCH 045/112] Update existing selection highlighting doc

---
 doc/selectionHighlightingArchitecture.md | 28 +++++++++++++-----------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index 4168f08252..e35fb78c28 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -8,7 +8,7 @@ supports Hydra rendering in this repository as the Flow Viewport Toolkit (name
 subject to change).
 
 This document will describe the state of Flow Viewport Toolkit selection
-highlighting as of 21-Sep-2023.
+highlighting as of 31-May-2024.
 
 ## Behavior
 
@@ -18,8 +18,9 @@ are shown differently in the viewport for ease of understanding.
 
 An application will provide a way to select an object, or to select components
 of an object.  For example, for a mesh object, these components may be points,
-edges, or faces.  At time of writing, only object selection highlighting is
-supported, and selection highlighting of components is unimplemented.
+edges, or faces.  Currently, only object selection highlighting and USD point
+instancing highlighting of meshes are supported.  Selection highlighting of
+components is unimplemented.
 
 ## Selection: Application versus Hydra
 
@@ -27,7 +28,8 @@ The application maintains an edit-friendly version of the scene.  This scene is
 translated into a Hydra scene by scene indices.  Correspondingly, there are two
 versions of the selection, one in the application, with objects and their paths
 described with application-specific classes, and a version of the selection in
-the Hydra scene, described as prims and their `SdfPath`s
+the Hydra scene, described as prims and their `SdfPath`s, as well as their
+associated selection data sources.
 
 ## Requirements
 
@@ -45,8 +47,8 @@ Requirements for selection highlighting are:
   highlight appearance.
 
 - It must be possible to let a data injecting data model provide prims to Hydra
-  that already contain selection highlighting.  At time of writing
-  (19-Sep-2023), this is true of Maya native Dag data, where selection
+  that already contain selection highlighting.  Currently,
+  this is true of Maya native Dag data, where selection
   highlighting is done by OGS.
 
 ## Selection Highlighting Styles
@@ -59,7 +61,7 @@ special way, e.g. object contour, modified object color, or object overlay.
 
 The former approach is handled by having a plugin provide a selection
 highlighting filtering scene index to the Flow Viewport Toolkit, and is the
-topic of this document at time of writing (20-Sep-2023).  The
+topic of this document at time of writing.  The
 latter is handled by having a plugin provide a selection highlighting 
 task to the Flow Viewport Toolkit, and is currently unimplemented.
 
@@ -68,7 +70,7 @@ task to the Flow Viewport Toolkit, and is currently unimplemented.
 A selection highlighting plugin that provides added geometry to scene must
 provide the following services:
 
-- A way to translate the application's selection path(s) into Hydra paths:
+- A way to translate the application's selection path(s) into Hydra paths and data sources:
     - So that the appropriate prims in Hydra can be dirtied on selection change.
     - So that selected prims in Hydra can have a data source added.
   This is embodied in a **Path interface**.
@@ -83,8 +85,8 @@ provide the following services:
 ### Selection Change
 
 This
-[selection change code](../lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp#L150-L167)
-shows the use of the *Path Interface*, through the *SceneIndexPath()* method,
+[selection change code](../lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp#L151-L170)
+shows the use of the *Path Interface*, through the *ConvertUfeSelectionToHydra()* method,
 called on the input scene index.  The path interface allows the selection scene
 index to translate selected application paths to selected Hydra scene index
 paths.
@@ -92,7 +94,7 @@ paths.
 ### Wireframe Selection Highlighting
 
 This
-[wireframe selection highlighting code](../lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp#L76-L97)
+[wireframe selection highlighting code](../lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp#L462-L465)
 shows the use of the *Selection*, through the
 *HasFullySelectedAncestorInclusive()* method, called on the input selection.
 The selection allows a selection highlighting filtering scene index to query
@@ -178,7 +180,7 @@ index is optional.
 
 The object modeling is the following:
 - **Selection**: builtin provided by the Flow Viewport Toolkit.
-    - Encapsulates the Hydra selection as scene index paths.
+    - Encapsulates the Hydra selection as scene index paths and selection data sources.
     - Is shared by the selection scene index and all selection highlighting
       scene indices.
 - **Selection scene index**: builtin provided by the Flow Viewport Toolkit.
@@ -232,7 +234,7 @@ class Selection{
 }
 
 class PathInterface{
-+SceneIndexPath(Ufe::Path) SdfPath
++ConvertUfeSelectionToHydra(Ufe::Path) SdfPath
 }
 
 class SelectionSceneIndex

From 1fe6d04ec5eb3ac9532571606121e1e85c01b15e Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Fri, 31 May 2024 18:13:00 -0400
Subject: [PATCH 046/112] Start documenting point instancing selection
 highlighting

---
 doc/selectionHighlightingArchitecture.md | 74 ++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index e35fb78c28..d2b6281ca4 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -289,3 +289,77 @@ WireframeSelectionHighlightSceneIndex o-- Selection : Read
   propagate across scene index inputs, so that if a Maya Dag ancestor is
   selected, a USD descendant's appearance can change.  This is the same
   situation as global transformation and visibility.
+
+## Mesh point instancing selection highlighting
+
+We currently support selection highlighting for point instancing of meshes
+for the three different point instancing selection modes :
+- Point Instancer
+- Instance
+- Prototype
+
+Here is an overview of how selection highlighting for point instancing
+is implemented. We'll be using USD as the source data model, which has
+some idiosyncracies of its own (which we'll go over when needed), but 
+the vast majority of it is Hydra-based.
+
+### Point instancing data sources
+
+In Hydra, a point instancer is represented as a prim of type instancer,
+with an `instancerTopology` data source. This data source contains three
+inner data sources :
+- The `prototypes` data source, of type `VtArray<SdfPath>`, lists the paths
+to each prototype this point instancer instances.
+- The `instanceIndices` data source, a vector data source where each element
+data source (`i0, i1, i2, etc.`) is of type `VtArray<int>` and contains
+which instances correspond to which prototype. For example, if `i1` contains
+`0, 3`, then the first and fourth instances will be using the second prototype.
+- The `mask` data source, of type `VtArray<bool>`, which can optionally be used
+to show/hide specific instances (e.g. if the 3rd element of the mask is `false`,
+then the 3rd instance will be hidden). If this array is empty, all prims will be
+shown.
+
+Per-instance data is specified using primvar data sources, namely :
+- hydra:instanceTranslations
+- hydra:instanceRotations
+- hydra:instanceScales
+- hydra:instanceTransforms
+Where the corresponding primvarValue data source lists the instance-specific data.
+Note that while the first three are 3-dimensional vectors and `hydra:instanceTransforms`
+is a 4x4 matrix, they can all be used simultaneously (internally, they will all be
+converted to 4x4 matrices, and then multiplied together).
+
+On the other end of instancing, prototypes have an `instancedBy` data source.
+This data source contains up to two inner data sources :
+- (required) : The `paths` data source, of type `VtArray<SdfPath>`, lists the paths
+to each instancer that instances this prototype.
+- (optional) : When a sub-hierarchy is prototyped, the `prototypeRoots`, of type 
+`VtArray<SdfPath>`, lists the paths to the roots of the sub-hierarchies that are being 
+prototyped. For example, if we are instancing an xform that has a child mesh,
+then the prototype xform and mesh prims will each have the same instancedBy data source,
+where the `paths` data source will point to the instancers that use this prototype, and
+where the `prototypeRoots` will point to the xform prim.
+
+Some notes about the behavioral impacts of the hierarchical location of prims :
+- Prims that are rooted under an instancer will not be drawn unless instanced
+- Prototypes that are instanced will still be drawn as if they were not instanced
+(i.e. the instances will be drawn in addition to the base prim itself), unless as 
+mentioned they are rooted under an instancer.
+
+### Nested instancers
+
+It is possible for an instancer itself to be instanced by another, and thus have both the
+`instancerTopology` and the `instancedBy` data sources. Note that this does not preclude
+such a prototyped instancer from also drawing geometry itself. If the prototyped instancer 
+is a child of the instancing instancer, then yes, such a nested instancer will not draw by
+itself, and will be instance-drawn through the parent instancer. However, if the prototyped
+instancer has no parent instancer, but it is instanced by another instancer somewhere else
+in the hierarchy, then both the prototyped instancer will draw as if it were by itself, but
+also be instance-drawn by the other instancer.
+
+This nesting and composition of instancers is what leads to most of the complexity of point
+instancing selection highlighting. Using the `instancerTopology/prototypes`, the
+`instancedBy/paths`, and in some cases the `instancedBy/prototypeRoots`, we can view such
+networks of instancers as a graph to be traversed.
+
+### Implementation for point instancer and instance selection
\ No newline at end of file

From 260d658a33a963e4239c82a607284a14a4e317e7 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Fri, 31 May 2024 19:27:00 -0400
Subject: [PATCH 047/112] Add doc paragraph on nested/composed instancers

---
 doc/selectionHighlightingArchitecture.md | 25 +++++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index d2b6281ca4..4ad8e01a77 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -362,4 +362,27 @@ instancing selection highlighting. Using the `instancerTopology/prototypes`, the
 `instancedBy/paths`, and in some cases the `instancedBy/prototypeRoots`, we can view such
 networks of instancers as a graph to be traversed.
 
-### Implementation for point instancer and instance selection
\ No newline at end of file
+### Implementation for point instancer and instance selection
+
+This section will focus on selection highlighting when trying to highlight point instancers
+as a whole or specific instances, as these require a more complicated workflow. Unlike standard
+selection, we cannot simply override instanced meshes to use the `refinedWireOnSurf`/`wireOnSurf`
+HdReprs, as that would lead to highlighting all instances of the prototype all the time. Instead, 
+we opt for the following approach : when an instancer is selected (entirely or only certain instances), 
+we will create a mirror of the instancing network it is a part of. This mirror network includes 
+everything from the most deeply buried prims to the topmost instancers; anything that this instancer 
+affects or is affected by, including itself. In practice, this means that each prototype will have a 
+corresponding mirror prim for selection highlighting, that will be located alongside it as a sibling. 
+This way, any parent transforms affecting the original prim will also affect the selection highlight 
+mirror prim.
+
+Note that in the case where a prototype is not a single prim but a sub-hierarchy, we only need to 
+create a single *explicit* selection highlight mirror for the whole hierarchy; the child prims of 
+the selection highlight mirror will simply be pulled from the corresponding original prim, and thus
+implicitly be selection highlight mirrors as well.
+
+Something to be aware of is that a nested/composed instancer is not necessarily directly selected, 
+as it is not necessarily a prototype root itself. If an instancer is a child prim of another prim 
+that is itself instanced by another instancer, these instancers are still composed together, but 
+will not point to each other directly. Such cases are an example of when we need to use the 
+`instancedBy/prototypeRoots` data source to properly construct the mirror network of instancers.

From f70324b0501b4e9ca125ca32670e12c45877b61c Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Fri, 31 May 2024 19:36:30 -0400
Subject: [PATCH 048/112] Doc corrections

---
 doc/selectionHighlightingArchitecture.md | 31 ++++++++++++------------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index 4ad8e01a77..b5e7d8e150 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -303,9 +303,9 @@ is implemented. We'll be using USD as the source data model, which has
 some idiosyncracies of its own (which we'll go over when needed), but 
 the vast majority of it is Hydra-based.
 
-### Point instancing data sources
+### Scene index structure
 
-In Hydra, a point instancer is represented as a prim of type instancer,
+In Hydra, a point instancer is represented as a prim of type `instancer`,
 with an `instancerTopology` data source. This data source contains three
 inner data sources :
 - The `prototypes` data source, of type `VtArray<SdfPath>`, lists the paths
@@ -316,7 +316,7 @@ which instances correspond to which prototype. For example, if `i1` contains
 `0, 3`, then the first and fourth instances will be using the second prototype.
 - The `mask` data source, of type `VtArray<bool>`, which can optionally be used
 to show/hide specific instances (e.g. if the 3rd element of the mask is `false`,
-then the 3rd instance will be hidden). If this array is empty, all prims will be
+then the 3rd instance will be hidden). If this array is empty, all instances will be
 shown.
 
 Per-instance data is specified using primvar data sources, namely :
@@ -324,19 +324,20 @@ Per-instance data is specified using primvar data sources, namely :
 - hydra:instanceRotations
 - hydra:instanceScales
 - hydra:instanceTransforms
+
 Where the corresponding primvarValue data source lists the instance-specific data.
 Note that while the first three are 3-dimensional vectors and `hydra:instanceTransforms`
 is a 4x4 matrix, they can all be used simultaneously (internally, they will all be
 converted to 4x4 matrices, and then multiplied together).
 
-On the other end of instancing, prototypes have an `instancedBy` data source.
+On the other end of instancing, prototype prims have an `instancedBy` data source.
 This data source contains up to two inner data sources :
 - (required) : The `paths` data source, of type `VtArray<SdfPath>`, lists the paths
 to each instancer that instances this prototype.
 - (optional) : When a sub-hierarchy is prototyped, the `prototypeRoots`, of type 
 `VtArray<SdfPath>`, lists the paths to the roots of the sub-hierarchies that are being 
 prototyped. For example, if we are instancing an xform that has a child mesh,
-then the prototype xform and mesh prims will each have the same instancedBy data source,
+then the prototype xform and mesh prims will each have the same `instancedBy` data source,
 where the `paths` data source will point to the instancers that use this prototype, and
 where the `prototypeRoots` will point to the xform prim.
 
@@ -371,18 +372,18 @@ HdReprs, as that would lead to highlighting all instances of the prototype all t
 we opt for the following approach : when an instancer is selected (entirely or only certain instances), 
 we will create a mirror of the instancing network it is a part of. This mirror network includes 
 everything from the most deeply buried prims to the topmost instancers; anything that this instancer 
-affects or is affected by, including itself. In practice, this means that each prototype will have a 
-corresponding mirror prim for selection highlighting, that will be located alongside it as a sibling. 
-This way, any parent transforms affecting the original prim will also affect the selection highlight 
-mirror prim.
+affects or is affected by, including itself. In practice, this means that each prototype and each 
+top-level instancer will have a corresponding mirror prim for selection highlighting, that will be 
+located alongside it as a sibling. This way, any parent transforms affecting the original prim will 
+also affect the selection highlight mirror prim.
 
 Note that in the case where a prototype is not a single prim but a sub-hierarchy, we only need to 
-create a single *explicit* selection highlight mirror for the whole hierarchy; the child prims of 
-the selection highlight mirror will simply be pulled from the corresponding original prim, and thus
-implicitly be selection highlight mirrors as well.
+create a single *explicit* selection highlight mirror for the whole prototype sub-hierarchy; the 
+child prims of the selection highlight mirror will simply be pulled from the corresponding original 
+prim, and thus implicitly be selection highlight mirrors as well.
 
 Something to be aware of is that a nested/composed instancer is not necessarily directly selected, 
 as it is not necessarily a prototype root itself. If an instancer is a child prim of another prim 
-that is itself instanced by another instancer, these instancers are still composed together, but 
-will not point to each other directly. Such cases are an example of when we need to use the 
-`instancedBy/prototypeRoots` data source to properly construct the mirror network of instancers.
+that is itself selected or instanced by another instancer, these instancers are still composed 
+together, but will not point to each other directly. Such cases are an example of when we need to 
+use the `instancedBy/prototypeRoots` data source to properly construct the mirror network of instancers.

From dde120d962767f07a2c9084dfd3291c230ad28ec Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 3 Jun 2024 00:01:08 -0400
Subject: [PATCH 049/112] Correct comment

---
 .../sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 7075fb78b1..a44713df59 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -446,7 +446,7 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         return selectionHighlightPrim;
     }
     
-    // We are dealing with a prototype selection, a regular selection, or no selection at all.
+    // We are dealing with a mesh prototype selection, a regular selection, or no selection at all.
     HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(primPath);
     if (prim.primType == HdPrimTypeTokens->mesh) {
         // Note : in the USD data model, the original prims that get propagated as prototypes have their original prim types erased.

From 683eab424e438996f7a282d74cb1227284d0a79d Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 3 Jun 2024 00:01:20 -0400
Subject: [PATCH 050/112] Add doc to describe current behaviors

---
 doc/selectionHighlightingArchitecture.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index b5e7d8e150..1bff70c5a9 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -387,3 +387,13 @@ as it is not necessarily a prototype root itself. If an instancer is a child pri
 that is itself selected or instanced by another instancer, these instancers are still composed 
 together, but will not point to each other directly. Such cases are an example of when we need to 
 use the `instancedBy/prototypeRoots` data source to properly construct the mirror network of instancers.
+
+Of note are the following selection highlighting scenarios and their corresponding behaviors :
+- Selecting a point instancer in its entirety
+  - If the instancer is a top-level instancer, all instances it draws WILL be highlighted
+  - If the instancer is a prototype, instances of itself drawn by other instancers will NOT be highlighted
+- Selecting specific instances of point instancer
+  - If the instancer is a top-level instancer, the selected instances it draws WILL be highlighted
+  - If the instancer is a prototype, the instances it would indirectly draw through instances of itself drawn by other instancers will NOT be highlighted
+- Selecting a parent prim of a point instancer
+  - (same as selecting a point instancer in its entirety)

From ffab6ce34891786fa907abd04c47efdd03b587ee Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 3 Jun 2024 11:12:20 -0400
Subject: [PATCH 051/112] Update behavior to be more consistent and update
 comments

---
 .../fvpWireframeSelectionHighlightSceneIndex.cpp   | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index a44713df59..6c370c0c03 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -408,7 +408,6 @@ WireframeSelectionHighlightSceneIndex(
     auto operation = [this](const SdfPath& primPath, const HdSceneIndexPrim& prim) -> bool {
         if (prim.primType == HdPrimTypeTokens->instancer) {
             _CreateInstancerHighlightsForInstancer(prim, primPath);
-            return false; // Only create highlights for top-level instancers
         }
         return true;
     };
@@ -432,11 +431,12 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         SdfPath originalPrimPath = primPath.ReplacePrefix(selectionHighlightMirrorAncestor, _GetOriginalPathFromSelectionHighlightMirror(selectionHighlightMirrorAncestor));
         HdSceneIndexPrim selectionHighlightPrim = GetInputSceneIndex()->GetPrim(originalPrimPath);
         if (selectionHighlightPrim.dataSource) {
-            // Repath the data sources to the selection highlight mirror hierarchy
+            // Redirects paths within data sources to their corresponding selection highlight mirror paths (when there is one)
             selectionHighlightPrim.dataSource = _SelectionHighlightRepathingContainerDataSource::New(selectionHighlightPrim.dataSource, this);
 
             // Use prim type-specific data source overrides
             if (selectionHighlightPrim.primType == HdPrimTypeTokens->instancer) {
+                // Handles setting the mask for instance-specific highlighting
                 selectionHighlightPrim.dataSource = _GetSelectionHighlightInstancerDataSource(selectionHighlightPrim.dataSource);
             }
             else if (selectionHighlightPrim.primType == HdPrimTypeTokens->mesh) {
@@ -471,7 +471,7 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
 SdfPathVector
 WireframeSelectionHighlightSceneIndex::GetChildPrimPaths(const SdfPath &primPath) const
 {
-    // When within a selection highlight mirror hierarchy, query the corresponding original prim
+    // When within a selection highlight mirror hierarchy, query the corresponding original prim's children
     SdfPath selectionHighlightMirrorAncestor = _FindSelectionHighlightMirrorAncestor(primPath);
     if (!selectionHighlightMirrorAncestor.IsEmpty()) {
         SdfPath originalAncestor = _GetOriginalPathFromSelectionHighlightMirror(selectionHighlightMirrorAncestor);
@@ -575,9 +575,10 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
         }
 
         if (entry.dirtyLocators.Intersects(HdInstancerTopologySchema::GetDefaultLocator())) {
+            // An instancer was changed; rebuild its selection highlight.
             // We do not need to check for instancedBy dirtying : if an instancedBy data source is dirtied,
             // then either a new instancer was added, which will be handled in _PrimsAdded, either an
-            // existing instancer's instancerTopology data source was dirtied. 
+            // existing instancer's instancerTopology data source was dirtied., which is handled here.
             instancerHighlightsToRebuild.push_back(entry.primPath);
         }
         
@@ -587,7 +588,8 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
             
             HdSceneIndexPrim prim = GetInputSceneIndex()->GetPrim(entry.primPath);
 
-            // Selection was changed on an instancer, so dirty its selection highlight mirror's instancerTopology mask.
+            // Selection was changed on an instancer, so dirty its selection highlight mirror's instancerTopology mask
+            // to update which instances are highlighted in the case of instance selection.
             if (prim.primType == HdPrimTypeTokens->instancer && selectionHighlightPath != entry.primPath) {
                 dirtiedPrims.emplace_back(selectionHighlightPath, HdInstancerTopologySchema::GetDefaultLocator().Append(HdInstancerTopologySchemaTokens->mask));
             }
@@ -603,6 +605,7 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
             bool isSelected = selectionsSchema.IsDefined() && selectionsSchema.GetNumElements() > 0;
 
             // Update child instancer highlights for ancestor-based selection highlighting
+            // (i.e. selecting one or more of an instancer's parents should highlight the instancer)
             auto operation = [&](const SdfPath& primPath, const HdSceneIndexPrim& prim) -> bool {
                 if (prim.primType == HdPrimTypeTokens->instancer) {
                     if (isSelected) {
@@ -610,7 +613,6 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
                     } else {
                         instancerHighlightUsersToRemove.push_back({primPath,entry.primPath});
                     }
-                    return false; // Only update direct/immediate instancer children
                 }
                 return true;
             };

From 17c65eaa393452f1d680ff70d7c63640e43eb702 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 3 Jun 2024 11:38:10 -0400
Subject: [PATCH 052/112] Add images to documentation

---
 doc/images/instanceTranslations.png      | Bin 0 -> 2076 bytes
 doc/images/instancedBy.png               | Bin 0 -> 1307 bytes
 doc/images/instancerTopology.png         | Bin 0 -> 1737 bytes
 doc/selectionHighlightingArchitecture.md |  39 +++++++++++++++++------
 4 files changed, 30 insertions(+), 9 deletions(-)
 create mode 100644 doc/images/instanceTranslations.png
 create mode 100644 doc/images/instancedBy.png
 create mode 100644 doc/images/instancerTopology.png

diff --git a/doc/images/instanceTranslations.png b/doc/images/instanceTranslations.png
new file mode 100644
index 0000000000000000000000000000000000000000..e154d700c4e539eb90469b998926a62f0b3d6552
GIT binary patch
literal 2076
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
GLSTXyC;bip

literal 0
HcmV?d00001

diff --git a/doc/images/instancedBy.png b/doc/images/instancedBy.png
new file mode 100644
index 0000000000000000000000000000000000000000..c1071e4e18957da0be83375c67856c82841e6094
GIT binary patch
literal 1307
zcmV+$1?2jPP)<h;3K|Lk000e1NJLTq004jh001%w1^@s6lswb500001b5ch_0Itp)
z=>Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D1h7d&K~#8N?VLS&
zqdXADXWwIpBcz2gSFjG@ieisI#Sylk@*!}!ZAvKi0$W<w*mp)BMqmj<oF|EpetG-^
zkA#q!(IEI+{_*ni@((h}@}K^nNt7G_iIW2$aUSLXZ*OmU%g^iUtKRZaLVc-VICn5=
zOE|PIhg;LYRcO<vVjrKjYqU&^-5I+5AL`rkkO8)wyX|~pgzjC=|BeXgn=_ox_-cA!
z^*kVA$9W0xIXTSv1dW^)PR!aq)o{67<f~N$5_W2}oldM7aSV8C>M=Os_T#?m?W%IU
zUu|6GvJtku(l!s{UtrjusYyJ3d%|AEiFXdLbauG&U7$mYL5(8JpNw-n<wOab3(OWY
z!YE^y%%MhIBd-Ahu4V*cnYiyu_}V4EU?7d%z0BC~0BCEVXIuxUva`NXbqDH|jS5B?
z9Bl!8_Z!ARKv}6;j4==c^*ByeCxOQ4&pDq!hxYn{Fb?Qoh9{2R2)NO8b~YLv&?u85
zRAmRXFX3yqgsQa4BxIwesGSx#RxGT#!>C;-+p)1P0XN{-2ZnV7?oWRuCXD;O5wdv~
z@VxWaP@}uKaqV0O<a~aEMrVMzbM|666JNV0b7F)61GZxLA1WwI+{Uel{l6UmpMkh`
z&<lHHFAxG<hv0DA$Q2sOEDT4s-Jr`xEbME?VA}cUaZCbGR0R!x)wf9b;s7v{FHFgz
z*SCFif~`p)rDSsnz;qinXeqPMd_hkz<s}AfT@To>vfVSz!v1g!dk%o(9owaHfk9bf
z(8QeniL3>@6S{k8s{xwknlnIJsN2$(1KttD?R+9<fW*leAaQa4Bu);1#K{4WI0p^@
zdd6S`DPs9PL*xvQIFZ~2(&*)I>jiMGp5IMh%%J;n5_hB-MBhMjWmtdG7AD)g4P{q%
z^76rsY~)DaW!NU73^12|rQ9p+F1gqxD-%BXcqvP#Lqq}KlYSAeT)f2BMxZQxK;oYR
ze282eAWI*Vs4f9UvSlYs-NMr0cgw|YHf8Ap64fO@6e`uvgcz?}ypWYwammtY5Z7J6
zmwi?IxWqpP$UH@sgA*rbfW*lGkT^L25+?^h;v^OTdnDmKb@yPNIZUtTpFqFAuQ>yJ
z3DydwnXvWw96%0MW%LNJWafMNWSi8&-m%tyl7d6({(_<U2}Q4uY4nE%`{V5wVYNdG
zRn^XDvma{Fd;7N(T>X)65LcOPn?6^lyd6;n@X5gh19rm`tQTp_R{M77oSK$zyCveV
zx_`jGBG}(A+Qx>kY`z-VM(G+i-IlLEYh|v_6)tZ_6ae@EeR43CO-r;Kt9@C8*+IRX
z6JA$fnR`XBuV2(QIZbN}XjH3_38hg;U8CslfxF(HJ)bLF-p+G?P-tcF?iImmRLT*H
zuj$fY?35Ym510fl375B{x&(OT;2BB<oUQi#kh;DV!M=X^RwLV}g{jle&aCxkPhS-w
z@^)000H+-6VC?Lb!OW_wPNFRl@2Trv5$x;NV%4#4B#J9^J%d{R%#6Q3d-_TfLptWR
zyq)FX9XzfG{vQ2$hCBxd;#ez!ZL%DkI5`6(P7Z*?$pMf!IRFwT2SCyQ{0|N4nG9ce
Ru)zQT002ovPDHLkV1j?tWK{qF

literal 0
HcmV?d00001

diff --git a/doc/images/instancerTopology.png b/doc/images/instancerTopology.png
new file mode 100644
index 0000000000000000000000000000000000000000..c81cab5008a79a9db0726f4f13fd44ca39e3efb0
GIT binary patch
literal 1737
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

literal 0
HcmV?d00001

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index 1bff70c5a9..9c82d7ef74 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -290,24 +290,25 @@ WireframeSelectionHighlightSceneIndex o-- Selection : Read
   selected, a USD descendant's appearance can change.  This is the same
   situation as global transformation and visibility.
 
-## Mesh point instancing selection highlighting
+## Mesh point instancing wireframe selection highlighting
 
-We currently support selection highlighting for point instancing of meshes
+We currently support wireframe selection highlighting for point instancing of meshes
 for the three different point instancing selection modes :
 - Point Instancer
 - Instance
 - Prototype
 
-Here is an overview of how selection highlighting for point instancing
-is implemented. We'll be using USD as the source data model, which has
-some idiosyncracies of its own (which we'll go over when needed), but 
-the vast majority of it is Hydra-based.
+Here is an overview of point instancing in Hydra, and how we implement wireframe 
+selection highlighting for it.
 
 ### Scene index structure
 
 In Hydra, a point instancer is represented as a prim of type `instancer`,
-with an `instancerTopology` data source. This data source contains three
-inner data sources :
+with an `instancerTopology` data source. 
+
+![instancerTopology data source](images/instancerTopology.png)
+
+This data source contains three inner data sources :
 - The `prototypes` data source, of type `VtArray<SdfPath>`, lists the paths
 to each prototype this point instancer instances.
 - The `instanceIndices` data source, a vector data source where each element
@@ -319,18 +320,27 @@ to show/hide specific instances (e.g. if the 3rd element of the mask is `false`,
 then the 3rd instance will be hidden). If this array is empty, all instances will be
 shown.
 
+---
+
 Per-instance data is specified using primvar data sources, namely :
 - hydra:instanceTranslations
 - hydra:instanceRotations
 - hydra:instanceScales
 - hydra:instanceTransforms
 
+![instanceTranslations primvar data source](images/instanceTranslations.png)
+
 Where the corresponding primvarValue data source lists the instance-specific data.
 Note that while the first three are 3-dimensional vectors and `hydra:instanceTransforms`
 is a 4x4 matrix, they can all be used simultaneously (internally, they will all be
 converted to 4x4 matrices, and then multiplied together).
 
+---
+
 On the other end of instancing, prototype prims have an `instancedBy` data source.
+
+![instancedBy data source](images/instancedBy.png)
+
 This data source contains up to two inner data sources :
 - (required) : The `paths` data source, of type `VtArray<SdfPath>`, lists the paths
 to each instancer that instances this prototype.
@@ -341,13 +351,15 @@ then the prototype xform and mesh prims will each have the same `instancedBy` da
 where the `paths` data source will point to the instancers that use this prototype, and
 where the `prototypeRoots` will point to the xform prim.
 
+---
+
 Some notes about the behavioral impacts of the hierarchical location of prims :
 - Prims that are rooted under an instancer will not be drawn unless instanced
 - Prototypes that are instanced will still be drawn as if they were not instanced
 (i.e. the instances will be drawn in addition to the base prim itself), unless as 
 mentioned they are rooted under an instancer.
 
-### Nested instancers
+### Nested/Composed instancers
 
 It is possible for an instancer itself to be instanced by another, and thus have both the
 `instancerTopology` and the `instancedBy` data sources. Note that this does not preclude
@@ -397,3 +409,12 @@ Of note are the following selection highlighting scenarios and their correspondi
   - If the instancer is a prototype, the instances it would indirectly draw through instances of itself drawn by other instancers will NOT be highlighted
 - Selecting a parent prim of a point instancer
   - (same as selecting a point instancer in its entirety)
+
+### Code overview
+
+This section is to briefly explain some of the less immediately clear code structures used in the
+implementation. 
+
+### Current limitations
+
+- Wireframe colors for lead/active selection are unsupported
\ No newline at end of file

From ae3539c46b0207fbdbd972f94c5eea1aa4887df5 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 3 Jun 2024 11:42:30 -0400
Subject: [PATCH 053/112] Clarify nesting and composition of instancers

---
 doc/selectionHighlightingArchitecture.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index 9c82d7ef74..6ad5f85b32 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -371,9 +371,10 @@ in the hierarchy, then both the prototyped instancer will draw as if it were by
 also be instance-drawn by the other instancer.
 
 This nesting and composition of instancers is what leads to most of the complexity of point
-instancing selection highlighting. Using the `instancerTopology/prototypes`, the
-`instancedBy/paths`, and in some cases the `instancedBy/prototypeRoots`, we can view such
-networks of instancers as a graph to be traversed.
+instancing selection highlighting. We can view such nesting and composition of instancers as 
+graphs, with the vertices being the instancer prims, and the edges being the paths contained 
+in the `instancerTopology/prototypes`, `instancedBy/paths` and `instancedBy/prototypeRoots` 
+data sources.
 
 ### Implementation for point instancer and instance selection
 

From 19dbb98fb237e7804bfe231d89f026e33be983a7 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 3 Jun 2024 12:00:04 -0400
Subject: [PATCH 054/112] Add scene structure examples

---
 doc/selectionHighlightingArchitecture.md | 44 ++++++++++++++++++++++--
 1 file changed, 41 insertions(+), 3 deletions(-)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index 6ad5f85b32..bb28c25ef3 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -383,23 +383,61 @@ as a whole or specific instances, as these require a more complicated workflow.
 selection, we cannot simply override instanced meshes to use the `refinedWireOnSurf`/`wireOnSurf`
 HdReprs, as that would lead to highlighting all instances of the prototype all the time. Instead, 
 we opt for the following approach : when an instancer is selected (entirely or only certain instances), 
-we will create a mirror of the instancing network it is a part of. This mirror network includes 
+we will create a mirror of the instancing graph it is a part of. This mirror graph includes 
 everything from the most deeply buried prims to the topmost instancers; anything that this instancer 
 affects or is affected by, including itself. In practice, this means that each prototype and each 
 top-level instancer will have a corresponding mirror prim for selection highlighting, that will be 
 located alongside it as a sibling. This way, any parent transforms affecting the original prim will 
 also affect the selection highlight mirror prim.
 
+For example, given the following scene structure : 
+```
+Root
+|__TopInstancer
+   |__NestedInstancer
+      |__Prototype
+```
+the resulting scene structure with selection highlighting would become :
+```
+Root
+|__TopInstancer
+|  |__NestedInstancer
+|  |  |__Prototype
+|  |  |__Prototype_SelectionHighlight
+|  |__NestedInstancer_SelectionHighlight
+|__TopInstancer_SelectionHighlight
+```
+where `TopInstancer_SelectionHighlight` would instance `NestedInstancer_SelectionHighlight`, which would in turn instance `Prototype_SelectionHighlight`.
+
 Note that in the case where a prototype is not a single prim but a sub-hierarchy, we only need to 
 create a single *explicit* selection highlight mirror for the whole prototype sub-hierarchy; the 
 child prims of the selection highlight mirror will simply be pulled from the corresponding original 
 prim, and thus implicitly be selection highlight mirrors as well.
 
-Something to be aware of is that a nested/composed instancer is not necessarily directly selected, 
+Another thing to be aware of is that a nested/composed instancer is not necessarily directly selected, 
 as it is not necessarily a prototype root itself. If an instancer is a child prim of another prim 
 that is itself selected or instanced by another instancer, these instancers are still composed 
 together, but will not point to each other directly. Such cases are an example of when we need to 
-use the `instancedBy/prototypeRoots` data source to properly construct the mirror network of instancers.
+use the `instancedBy/prototypeRoots` data source to properly construct the mirror graph of instancers.
+
+An example of this is the following :
+```
+Root
+|__TopInstancer
+   |__Prototype
+      |__ChildInstancer
+```
+for which we end up with :
+```
+Root
+|__TopInstancer
+|  |__Prototype
+|  |  |__ChildInstancer
+|  |__Prototype_SelectionHighlight
+|     |__ChildInstancer
+|__TopInstancer_SelectionHighlight
+```
+where `TopInstancer_SelectionHighlight` instances `Prototype_SelectionHighlight`, which implicitly draws the selection highlight version of `ChildInstancer`.
 
 Of note are the following selection highlighting scenarios and their corresponding behaviors :
 - Selecting a point instancer in its entirety

From 385baef58aef3340a5605eb94ceb0a723daa31d2 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 3 Jun 2024 16:33:39 -0400
Subject: [PATCH 055/112] Add test for point instancer selection highlight

---
 .../mayaUsd/render/mayaToHydra/CMakeLists.txt |   1 +
 .../render/mayaToHydra/cpp/CMakeLists.txt     |   1 +
 .../testPointInstancingWireframeHighlight.cpp | 195 ++++++++++++++++++
 .../testPointInstancingWireframeHighlight.py  |  36 ++++
 .../nestedAndComposedPointInstancers.usda     |  86 ++++++++
 5 files changed, 319 insertions(+)
 create mode 100644 test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
 create mode 100644 test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
 create mode 100644 test/testSamples/testPointInstancingWireframeHighlight/nestedAndComposedPointInstancers.usda

diff --git a/test/lib/mayaUsd/render/mayaToHydra/CMakeLists.txt b/test/lib/mayaUsd/render/mayaToHydra/CMakeLists.txt
index f54ee68148..dcf81505d5 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/CMakeLists.txt
+++ b/test/lib/mayaUsd/render/mayaToHydra/CMakeLists.txt
@@ -59,6 +59,7 @@ set(INTERACTIVE_TEST_SCRIPT_FILES
     cpp/testUsdNativeInstancePicking.py
     cpp/testUsdPickKind.py
     cpp/testNurbsSurfaces.py
+    cpp/testPointInstancingWireframeHighlight.py
 )
 
 #Add this test only if the MayaUsd_FOUND (so also MAYAUSDAPI_LIBRARY) has been found during compile time.
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/CMakeLists.txt b/test/lib/mayaUsd/render/mayaToHydra/cpp/CMakeLists.txt
index 98112fdee9..2d96417632 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/CMakeLists.txt
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/CMakeLists.txt
@@ -40,6 +40,7 @@ target_sources(${TARGET_NAME}
         testUsdPointInstancePicking.cpp
         testUsdPicking.cpp
         testNurbsSurfaces.cpp
+        testPointInstancingWireframeHighlight.cpp
 )
 
 # -----------------------------------------------------------------------------
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
new file mode 100644
index 0000000000..eb32830398
--- /dev/null
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -0,0 +1,195 @@
+
+#include "testUtils.h"
+#include "ufe/pathSegment.h"
+#include "ufe/sceneItem.h"
+#include "ufe/selection.h"
+
+#include <mayaHydraLib/mayaHydra.h>
+
+#include <flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h>
+#include <flowViewport/sceneIndex/fvpMergingSceneIndex.h>
+
+#include <pxr/base/tf/token.h>
+#include <pxr/base/vt/array.h>
+#include <pxr/imaging/hd/instancedBySchema.h>
+#include <pxr/imaging/hd/instancerTopologySchema.h>
+#include <pxr/imaging/hd/legacyDisplayStyleSchema.h>
+#include <pxr/imaging/hd/sceneDelegate.h>
+#include <pxr/imaging/hd/sceneIndex.h>
+#include <pxr/imaging/hd/sceneIndexPrimView.h>
+#include <pxr/imaging/hdx/selectionSceneIndexObserver.h>
+#include <pxr/imaging/hd/tokens.h>
+#include <pxr/usd/sdf/path.h>
+
+#include <ufe/pathString.h>
+#include <ufe/hierarchy.h>
+#include <ufe/globalSelection.h>
+#include <ufe/observableSelection.h>
+
+#include <gtest/gtest.h>
+
+PXR_NAMESPACE_USING_DIRECTIVE
+using namespace MayaHydra;
+
+namespace {
+
+const std::string selectionHighlightTag = "_SelectionHighlight";
+
+const std::string stagePathSegment = "|nestedAndComposedPointInstancers|nestedAndComposedPointInstancersShape";
+
+SdfPath getSelectionHighlightMirrorPathFromOriginal(const SdfPath& originalPath)
+{
+    return originalPath.ReplaceName(TfToken(originalPath.GetName() + selectionHighlightTag));
+}
+
+// SdfPath getOriginalPathFromSelectionHighlightMirror(const SdfPath& mirrorPath)
+// {
+//     const std::string primName = mirrorPath.GetName();
+//     return mirrorPath.ReplaceName(TfToken(primName.substr(0, primName.size() - selectionHighlightTag.size())));
+// }
+
+TfToken getReprToken(const HdSceneIndexPrim& prim)
+{
+    HdLegacyDisplayStyleSchema displayStyle = HdLegacyDisplayStyleSchema::GetFromParent(prim.dataSource);
+    if (!displayStyle.IsDefined() || !displayStyle.GetReprSelector()) {
+        return {};
+    }
+    auto reprSelectors = displayStyle.GetReprSelector()->GetTypedValue(0);
+    EXPECT_EQ(reprSelectors.size(), 1u);
+    return reprSelectors.empty() ? TfToken() : reprSelectors.front();
+}
+
+VtArray<SdfPath> getPrototypeRoots(const HdSceneIndexPrim& prim)
+{
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+    return instancedBy.IsDefined() && instancedBy.GetPrototypeRoots() 
+        ? instancedBy.GetPrototypeRoots()->GetTypedValue(0) 
+        : VtArray<SdfPath>({SdfPath::AbsoluteRootPath()});
+}
+
+void assertSelectionHighlightCorrectness(const HdSceneIndexBaseRefPtr& sceneIndex, const SdfPath& primPath)
+{
+    HdSceneIndexPrimView view(sceneIndex, primPath);
+    for (auto it = view.begin(); it != view.end(); ++it) {
+        const SdfPath& currPath = *it;
+        HdSceneIndexPrim currPrim = sceneIndex->GetPrim(currPath);
+
+        VtArray<SdfPath> prototypeRoots = getPrototypeRoots(currPrim);
+        bool isInSamePrototypeHierarchy = std::find_if(prototypeRoots.begin(), prototypeRoots.end(), [primPath](const auto& prototypeRoot) -> bool {
+            return primPath.HasPrefix(prototypeRoot);
+        }) != prototypeRoots.end();
+        if (!isInSamePrototypeHierarchy) {
+            it.SkipDescendants();
+            continue;
+        }
+
+        HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(currPrim.dataSource);
+        if (instancerTopology.IsDefined()) {
+            ASSERT_NE(instancerTopology.GetPrototypes(), nullptr);
+            auto prototypePaths = instancerTopology.GetPrototypes()->GetTypedValue(0);
+            ASSERT_GE(prototypePaths.size(), 1u);
+            for (const auto& prototypePath : prototypePaths) {
+                auto prototypeName = prototypePath.GetElementString();
+                ASSERT_EQ(prototypeName.substr(prototypeName.size() - selectionHighlightTag.size()), selectionHighlightTag);
+                assertSelectionHighlightCorrectness(sceneIndex, prototypePath);
+            }
+            it.SkipDescendants();
+            continue;
+        }
+
+        if (currPrim.primType == HdPrimTypeTokens->mesh) {
+            EXPECT_EQ(getReprToken(currPrim), HdReprTokens->refinedWire);
+        }
+    }
+}
+
+bool findSelectionHighlightMirrorsPredicate(const HdSceneIndexBasePtr& sceneIndex, const SdfPath& primPath)
+{
+    return primPath.GetElementString().find(selectionHighlightTag) != std::string::npos;
+}
+
+bool findMeshPrimsPredicate(const HdSceneIndexBasePtr& sceneIndex, const SdfPath& primPath)
+{
+    return sceneIndex->GetPrim(primPath).primType == HdPrimTypeTokens->mesh;
+}
+
+} // namespace
+
+TEST(PointInstancingWireframeHighlight, pointInstancer)
+{
+    const SceneIndicesVector& terminalSceneIndices = GetTerminalSceneIndices();
+    ASSERT_FALSE(terminalSceneIndices.empty());
+    SceneIndexInspector inspector(terminalSceneIndices.front());
+
+    auto isFvpMergingSceneIndexPredicate = SceneIndexDisplayNamePred("Flow Viewport Merging Scene Index");
+    auto fvpMergingSceneIndex = TfDynamic_cast<Fvp::MergingSceneIndexRefPtr>(
+        findSceneIndexInTree(terminalSceneIndices.front(), isFvpMergingSceneIndexPredicate));
+
+    auto ufeSelection = Ufe::GlobalSelection::get();
+
+    HdxSelectionSceneIndexObserver selectionObserver;
+    selectionObserver.SetSceneIndex(terminalSceneIndices.front());
+
+    auto topInstancerPath = Ufe::PathString::path(stagePathSegment + "," + "/Root/TopInstancerXform/TopInstancer");
+    auto secondInstancerPath = Ufe::PathString::path(stagePathSegment + "," + "/Root/SecondInstancer");
+    auto thirdInstancerPath = Ufe::PathString::path(stagePathSegment + "," + "/Root/ThirdInstancer");
+    auto fourthInstancerPath = Ufe::PathString::path(stagePathSegment + "," + "/Root/FourthInstancer");
+
+    auto topInstancerItem = Ufe::Hierarchy::createItem(topInstancerPath);
+    auto secondInstancerItem = Ufe::Hierarchy::createItem(secondInstancerPath);
+    auto thirdInstancerItem = Ufe::Hierarchy::createItem(thirdInstancerPath);
+    auto fourthInstancerItem = Ufe::Hierarchy::createItem(fourthInstancerPath);
+
+    // Initial state : ensure nothing is highlighted
+    ufeSelection->clear();
+
+    auto selectionHighlightMirrors = inspector.FindPrims(findSelectionHighlightMirrorsPredicate);
+    EXPECT_TRUE(selectionHighlightMirrors.empty());
+
+    auto meshPrims = inspector.FindPrims(findMeshPrimsPredicate);
+    for (const auto& meshPrim : meshPrims) {
+        EXPECT_EQ(getReprToken(meshPrim.prim), HdReprTokens->refined);
+    }
+
+    // Select point instancers directly
+    auto testInstancerDirectFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
+        ufeSelection->replaceWith(instancerItem);
+
+        auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(instancerPath);
+        ASSERT_EQ(instancerHydraSelections.size(), 1u);
+    
+        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerHydraSelections.front().primPath));
+    
+        ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().size(), 1u);
+        ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().front(), instancerHydraSelections.front().primPath);
+    };
+    
+    testInstancerDirectFn(topInstancerItem, topInstancerPath);
+    testInstancerDirectFn(secondInstancerItem, secondInstancerPath);
+    testInstancerDirectFn(thirdInstancerItem, thirdInstancerPath);
+    testInstancerDirectFn(fourthInstancerItem, fourthInstancerPath);
+    
+    // Select point instancer ancestors
+    auto testInstancerIndirectFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
+        // This is not an actual selection, we use it to get the Hydra path
+        auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(instancerPath);
+        ASSERT_EQ(instancerHydraSelections.size(), 1u);
+    
+        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerHydraSelections.front().primPath));
+    };
+
+    // Select TopInstancer's parent : only TopInstancer should be highlighted
+    auto topInstancerParentPath = Ufe::PathString::path(stagePathSegment + "," + "/Root/TopInstancerXform");
+    auto topInstancerParentItem = Ufe::Hierarchy::createItem(topInstancerParentPath);
+    ufeSelection->replaceWith(topInstancerParentItem);
+    testInstancerIndirectFn(topInstancerItem, topInstancerPath);
+
+    // Select Root : all instancers should be highlighted
+    auto rootPath = Ufe::PathString::path(stagePathSegment + "," + "/Root");
+    auto rootItem = Ufe::Hierarchy::createItem(rootPath);
+    ufeSelection->replaceWith(rootItem);
+    testInstancerIndirectFn(topInstancerItem, topInstancerPath);
+    testInstancerIndirectFn(secondInstancerItem, secondInstancerPath);
+    testInstancerIndirectFn(thirdInstancerItem, thirdInstancerPath);
+    testInstancerIndirectFn(fourthInstancerItem, fourthInstancerPath);
+}
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
new file mode 100644
index 0000000000..051bc5d117
--- /dev/null
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
@@ -0,0 +1,36 @@
+import maya.cmds as cmds
+import fixturesUtils
+import mtohUtils
+import mayaUtils
+import testUtils
+from testUtils import PluginLoaded
+
+class TestPointInstancingWireframeHighlight(mtohUtils.MayaHydraBaseTestCase):
+    # MayaHydraBaseTestCase.setUpClass requirement.
+    _file = __file__
+
+    def loadUsdScene(self):
+        import usdUtils
+        usdScenePath = testUtils.getTestScene('testPointInstancingWireframeHighlight', 'nestedAndComposedPointInstancers.usda')
+        usdUtils.createStageFromFile(usdScenePath)
+        #self.setHdStormRenderer()
+        #cmds.refresh()
+
+    def setUp(self):
+        super(TestPointInstancingWireframeHighlight, self).setUp()
+        self.loadUsdScene()
+        #cmds.refresh()
+
+    def test_PointInstancerSelection(self):
+        with PluginLoaded('mayaHydraCppTests'):
+            cmds.mayaHydraCppTest(
+                f="PointInstancingWireframeHighlight.pointInstancer")
+            
+    def test_InstanceSelection(self):
+        pass
+
+    def test_PrototypeSelection(self):
+        pass
+
+if __name__ == '__main__':
+    fixturesUtils.runTests(globals())
diff --git a/test/testSamples/testPointInstancingWireframeHighlight/nestedAndComposedPointInstancers.usda b/test/testSamples/testPointInstancingWireframeHighlight/nestedAndComposedPointInstancers.usda
new file mode 100644
index 0000000000..9257ebf4b7
--- /dev/null
+++ b/test/testSamples/testPointInstancingWireframeHighlight/nestedAndComposedPointInstancers.usda
@@ -0,0 +1,86 @@
+#usda 1.0
+(
+    defaultPrim = "Root"
+    metersPerUnit = 0.01
+    upAxis = "Z"
+)
+
+def Xform "Root"
+{
+    def Xform "TopInstancerXform"
+    {
+        def PointInstancer "TopInstancer"
+        {
+            point3f[] positions = [(0, 0, 6), (0, 0, 8)]
+            int[] protoIndices = [0, 0]
+            rel prototypes = [
+
+                </Root/TopInstancerXform/TopInstancer/prototypes/NestedInstancerXform>,
+            ]
+
+            def "prototypes"
+            {
+                def Xform "NestedInstancerXform"
+                {
+                    def PointInstancer "NestedInstancer"
+                    {
+                        point3f[] positions = [(1, 0, 0), (-1, 0, 0)]
+                        int[] protoIndices = [0, 1]
+                        rel prototypes = [
+                            </Root/TopInstancerXform/TopInstancer/prototypes/NestedInstancerXform/NestedInstancer/prototypes/RedCube>,
+                            </Root/TopInstancerXform/TopInstancer/prototypes/NestedInstancerXform/NestedInstancer/prototypes/BluePyramid>,
+                        ]
+
+                        def "prototypes"
+                        {
+                            def "RedCube" (
+                                prepend references = @./CubeModel.usda@
+                                variants = {
+                                    string shadingVariant = "Red"
+                                }
+                            )
+                            {
+                            }
+                            def "BluePyramid" (
+                                prepend references = @./PyramidModel.usda@
+                                variants = {
+                                    string shadingVariant = "Blue"
+                                }
+                            )
+                            {
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    def PointInstancer "SecondInstancer"
+    {
+        point3f[] positions = [(0, 0, -4), (0, 2, -4)]
+        int[] protoIndices = [0, 0]
+        rel prototypes = [
+            </Root/TopInstancerXform>,
+        ]
+    }
+
+    def PointInstancer "ThirdInstancer"
+    {
+        point3f[] positions = [(0, 0, -8), (0, 2, -8)]
+        int[] protoIndices = [0, 0]
+        rel prototypes = [
+            </Root/TopInstancerXform>,
+        ]
+    }
+
+    def PointInstancer "FourthInstancer"
+    {
+        point3f[] positions = [(0, 0, -12), (0, 2, -12)]
+        int[] protoIndices = [0, 0]
+        rel prototypes = [
+            </Root/TopInstancerXform>,
+        ]
+    }
+}
+

From e6c73707f00a3e6a03dd9f37f77615f6fedfe51f Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 3 Jun 2024 16:41:36 -0400
Subject: [PATCH 056/112] Ensure other instancers are not highlight when
 selecting top instancer ancestor

---
 .../testPointInstancingWireframeHighlight.cpp | 34 +++++++++++++------
 1 file changed, 23 insertions(+), 11 deletions(-)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index eb32830398..dc5d601f4f 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -152,7 +152,7 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     }
 
     // Select point instancers directly
-    auto testInstancerDirectFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
+    auto testInstancerDirectHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
         ufeSelection->replaceWith(instancerItem);
 
         auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(instancerPath);
@@ -164,32 +164,44 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
         ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().front(), instancerHydraSelections.front().primPath);
     };
     
-    testInstancerDirectFn(topInstancerItem, topInstancerPath);
-    testInstancerDirectFn(secondInstancerItem, secondInstancerPath);
-    testInstancerDirectFn(thirdInstancerItem, thirdInstancerPath);
-    testInstancerDirectFn(fourthInstancerItem, fourthInstancerPath);
+    testInstancerDirectHighlightFn(topInstancerItem, topInstancerPath);
+    testInstancerDirectHighlightFn(secondInstancerItem, secondInstancerPath);
+    testInstancerDirectHighlightFn(thirdInstancerItem, thirdInstancerPath);
+    testInstancerDirectHighlightFn(fourthInstancerItem, fourthInstancerPath);
     
     // Select point instancer ancestors
-    auto testInstancerIndirectFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
+    auto testInstancerIndirectHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
         // This is not an actual selection, we use it to get the Hydra path
         auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(instancerPath);
         ASSERT_EQ(instancerHydraSelections.size(), 1u);
     
         assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerHydraSelections.front().primPath));
     };
+    auto testInstancerNoHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
+        // This is not an actual selection, we use it to get the Hydra path
+        auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(instancerPath);
+        ASSERT_EQ(instancerHydraSelections.size(), 1u);
+    
+        HdSceneIndexPrim selectionHighlightMirrorPrim = inspector.GetSceneIndex()->GetPrim(
+            getSelectionHighlightMirrorPathFromOriginal(instancerHydraSelections.front().primPath));
+        ASSERT_EQ(selectionHighlightMirrorPrim.primType, TfToken());
+    };
 
     // Select TopInstancer's parent : only TopInstancer should be highlighted
     auto topInstancerParentPath = Ufe::PathString::path(stagePathSegment + "," + "/Root/TopInstancerXform");
     auto topInstancerParentItem = Ufe::Hierarchy::createItem(topInstancerParentPath);
     ufeSelection->replaceWith(topInstancerParentItem);
-    testInstancerIndirectFn(topInstancerItem, topInstancerPath);
+    testInstancerIndirectHighlightFn(topInstancerItem, topInstancerPath);
+    testInstancerNoHighlightFn(secondInstancerItem, secondInstancerPath);
+    testInstancerNoHighlightFn(thirdInstancerItem, thirdInstancerPath);
+    testInstancerNoHighlightFn(fourthInstancerItem, fourthInstancerPath);
 
     // Select Root : all instancers should be highlighted
     auto rootPath = Ufe::PathString::path(stagePathSegment + "," + "/Root");
     auto rootItem = Ufe::Hierarchy::createItem(rootPath);
     ufeSelection->replaceWith(rootItem);
-    testInstancerIndirectFn(topInstancerItem, topInstancerPath);
-    testInstancerIndirectFn(secondInstancerItem, secondInstancerPath);
-    testInstancerIndirectFn(thirdInstancerItem, thirdInstancerPath);
-    testInstancerIndirectFn(fourthInstancerItem, fourthInstancerPath);
+    testInstancerIndirectHighlightFn(topInstancerItem, topInstancerPath);
+    testInstancerIndirectHighlightFn(secondInstancerItem, secondInstancerPath);
+    testInstancerIndirectHighlightFn(thirdInstancerItem, thirdInstancerPath);
+    testInstancerIndirectHighlightFn(fourthInstancerItem, fourthInstancerPath);
 }

From 3572020ae71b94d3d412406c141610e39291f92f Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 3 Jun 2024 17:25:14 -0400
Subject: [PATCH 057/112] Add instance highlight test

---
 .../testPointInstancingWireframeHighlight.cpp | 62 +++++++++++++++++++
 .../testPointInstancingWireframeHighlight.py  |  4 +-
 2 files changed, 65 insertions(+), 1 deletion(-)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index dc5d601f4f..4bcc078c4c 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -205,3 +205,65 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     testInstancerIndirectHighlightFn(thirdInstancerItem, thirdInstancerPath);
     testInstancerIndirectHighlightFn(fourthInstancerItem, fourthInstancerPath);
 }
+
+TEST(PointInstancingWireframeHighlight, instance)
+{
+    const SceneIndicesVector& terminalSceneIndices = GetTerminalSceneIndices();
+    ASSERT_FALSE(terminalSceneIndices.empty());
+    SceneIndexInspector inspector(terminalSceneIndices.front());
+
+    auto isFvpMergingSceneIndexPredicate = SceneIndexDisplayNamePred("Flow Viewport Merging Scene Index");
+    auto fvpMergingSceneIndex = TfDynamic_cast<Fvp::MergingSceneIndexRefPtr>(
+        findSceneIndexInTree(terminalSceneIndices.front(), isFvpMergingSceneIndexPredicate));
+
+    auto ufeSelection = Ufe::GlobalSelection::get();
+
+    HdxSelectionSceneIndexObserver selectionObserver;
+    selectionObserver.SetSceneIndex(terminalSceneIndices.front());
+
+    auto topInstancerFirstInstancePath = Ufe::PathString::path(stagePathSegment + "," + "/Root/TopInstancerXform/TopInstancer/0");
+    auto secondInstancerSecondInstancePath = Ufe::PathString::path(stagePathSegment + "," + "/Root/SecondInstancer/1");
+
+    auto topInstancerFirstInstanceItem = Ufe::Hierarchy::createItem(topInstancerFirstInstancePath);
+    auto secondInstancerSecondInstanceItem = Ufe::Hierarchy::createItem(secondInstancerSecondInstancePath);
+
+    // Initial state : ensure nothing is highlighted
+    ufeSelection->clear();
+
+    auto selectionHighlightMirrors = inspector.FindPrims(findSelectionHighlightMirrorsPredicate);
+    EXPECT_TRUE(selectionHighlightMirrors.empty());
+
+    auto meshPrims = inspector.FindPrims(findMeshPrimsPredicate);
+    for (const auto& meshPrim : meshPrims) {
+        EXPECT_EQ(getReprToken(meshPrim.prim), HdReprTokens->refined);
+    }
+
+    // Select instances
+    auto testInstanceHighlightFn = [&](const Ufe::SceneItem::Ptr& instanceItem, const Ufe::Path& instancePath) -> void {
+        ufeSelection->replaceWith(instanceItem);
+
+        auto instanceHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(instancePath);
+        ASSERT_EQ(instanceHydraSelections.size(), 1u);
+    
+        auto instancerPrimPath = instanceHydraSelections.front().primPath;
+        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
+    
+        ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().size(), 1u);
+        ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().front(), instancerPrimPath);
+
+        HdSceneIndexPrim instancerHighlightPrim = inspector.GetSceneIndex()->GetPrim(getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
+        HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(instancerHighlightPrim.dataSource);
+        ASSERT_TRUE(instancerTopology.IsDefined());
+        ASSERT_NE(instancerTopology.GetMask(), nullptr);
+        auto mask = instancerTopology.GetMask()->GetTypedValue(0);
+        ASSERT_FALSE(mask.empty());
+
+        auto selectedInstanceIndex = std::stoi(instancePath.getSegments().back().components().back().string());
+        for (size_t iMask = 0; iMask < mask.size(); iMask++) {
+            EXPECT_EQ(mask[iMask], iMask == selectedInstanceIndex);
+        }
+    };
+    
+    testInstanceHighlightFn(topInstancerFirstInstanceItem, topInstancerFirstInstancePath);
+    testInstanceHighlightFn(secondInstancerSecondInstanceItem, secondInstancerSecondInstancePath);
+}
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
index 051bc5d117..f166a81085 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
@@ -27,7 +27,9 @@ def test_PointInstancerSelection(self):
                 f="PointInstancingWireframeHighlight.pointInstancer")
             
     def test_InstanceSelection(self):
-        pass
+        with PluginLoaded('mayaHydraCppTests'):
+            cmds.mayaHydraCppTest(
+                f="PointInstancingWireframeHighlight.instance")
 
     def test_PrototypeSelection(self):
         pass

From 9374da957e03fc9cc314130c0f3d00a857fbc61e Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 11:34:42 -0400
Subject: [PATCH 058/112] Delete USD stage

---
 .../nestedAndComposedPointInstancers.usda     | 86 -------------------
 1 file changed, 86 deletions(-)
 delete mode 100644 test/testSamples/testPointInstancingWireframeHighlight/nestedAndComposedPointInstancers.usda

diff --git a/test/testSamples/testPointInstancingWireframeHighlight/nestedAndComposedPointInstancers.usda b/test/testSamples/testPointInstancingWireframeHighlight/nestedAndComposedPointInstancers.usda
deleted file mode 100644
index 9257ebf4b7..0000000000
--- a/test/testSamples/testPointInstancingWireframeHighlight/nestedAndComposedPointInstancers.usda
+++ /dev/null
@@ -1,86 +0,0 @@
-#usda 1.0
-(
-    defaultPrim = "Root"
-    metersPerUnit = 0.01
-    upAxis = "Z"
-)
-
-def Xform "Root"
-{
-    def Xform "TopInstancerXform"
-    {
-        def PointInstancer "TopInstancer"
-        {
-            point3f[] positions = [(0, 0, 6), (0, 0, 8)]
-            int[] protoIndices = [0, 0]
-            rel prototypes = [
-
-                </Root/TopInstancerXform/TopInstancer/prototypes/NestedInstancerXform>,
-            ]
-
-            def "prototypes"
-            {
-                def Xform "NestedInstancerXform"
-                {
-                    def PointInstancer "NestedInstancer"
-                    {
-                        point3f[] positions = [(1, 0, 0), (-1, 0, 0)]
-                        int[] protoIndices = [0, 1]
-                        rel prototypes = [
-                            </Root/TopInstancerXform/TopInstancer/prototypes/NestedInstancerXform/NestedInstancer/prototypes/RedCube>,
-                            </Root/TopInstancerXform/TopInstancer/prototypes/NestedInstancerXform/NestedInstancer/prototypes/BluePyramid>,
-                        ]
-
-                        def "prototypes"
-                        {
-                            def "RedCube" (
-                                prepend references = @./CubeModel.usda@
-                                variants = {
-                                    string shadingVariant = "Red"
-                                }
-                            )
-                            {
-                            }
-                            def "BluePyramid" (
-                                prepend references = @./PyramidModel.usda@
-                                variants = {
-                                    string shadingVariant = "Blue"
-                                }
-                            )
-                            {
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    def PointInstancer "SecondInstancer"
-    {
-        point3f[] positions = [(0, 0, -4), (0, 2, -4)]
-        int[] protoIndices = [0, 0]
-        rel prototypes = [
-            </Root/TopInstancerXform>,
-        ]
-    }
-
-    def PointInstancer "ThirdInstancer"
-    {
-        point3f[] positions = [(0, 0, -8), (0, 2, -8)]
-        int[] protoIndices = [0, 0]
-        rel prototypes = [
-            </Root/TopInstancerXform>,
-        ]
-    }
-
-    def PointInstancer "FourthInstancer"
-    {
-        point3f[] positions = [(0, 0, -12), (0, 2, -12)]
-        int[] protoIndices = [0, 0]
-        rel prototypes = [
-            </Root/TopInstancerXform>,
-        ]
-    }
-}
-

From 10a438085458296d96b2a0c1e5c19929d94f8fd8 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 11:35:10 -0400
Subject: [PATCH 059/112] Fix USD stage

---
 .../CubeModel.usda                            | 191 ++++++++++++++++++
 .../NestedAndComposedPointInstancers.usda     |  86 ++++++++
 .../PyramidModel.usda                         | 109 ++++++++++
 3 files changed, 386 insertions(+)
 create mode 100644 test/testSamples/testPointInstancingWireframeHighlight/CubeModel.usda
 create mode 100644 test/testSamples/testPointInstancingWireframeHighlight/NestedAndComposedPointInstancers.usda
 create mode 100644 test/testSamples/testPointInstancingWireframeHighlight/PyramidModel.usda

diff --git a/test/testSamples/testPointInstancingWireframeHighlight/CubeModel.usda b/test/testSamples/testPointInstancingWireframeHighlight/CubeModel.usda
new file mode 100644
index 0000000000..36289c3015
--- /dev/null
+++ b/test/testSamples/testPointInstancingWireframeHighlight/CubeModel.usda
@@ -0,0 +1,191 @@
+#usda 1.0
+(
+    defaultPrim = "CubeModel"
+    metersPerUnit = 0.01
+    upAxis = "Z"
+)
+
+def Xform "CubeModel" (
+    assetInfo = {
+        asset identifier = @./CubeModel.usda@
+        string name = "CubeModel"
+    }
+    kind = "component"
+    variants = {
+        string shadingVariant = "Red"
+    }
+    add variantSets = "shadingVariant"
+)
+{
+    def Xform "Geom"
+    {
+        def Mesh "Cube"
+        {
+            float3[] extent = [(-0.5, -0.5, -0.5), (0.5, 0.5, 0.5)]
+            int[] faceVertexCounts = [4, 4, 4, 4, 4, 4]
+            int[] faceVertexIndices = [0, 1, 3, 2, 2, 3, 5, 4, 4, 5, 7, 6, 6, 7, 1, 0, 1, 7, 5, 3, 6, 0, 2, 4]
+            point3f[] points = [(-0.5, -0.5, 0.5), (0.5, -0.5, 0.5), (-0.5, 0.5, 0.5), (0.5, 0.5, 0.5), (-0.5, 0.5, -0.5), (0.5, 0.5, -0.5), (-0.5, -0.5, -0.5), (0.5, -0.5, -0.5)]
+            uniform token subdivisionScheme = "none"
+        }
+    }
+    variantSet "shadingVariant" = {
+        "Blue" {
+            over "Geom"
+            {
+                over "Cube" (
+                    prepend apiSchemas = ["MaterialBindingAPI"]
+                )
+                {
+                    rel material:binding = </CubeModel/Materials/BlueMaterial>
+                    color3f[] primvars:displayColor = [(0, 0, 1)]
+                }
+            }
+
+        }
+        "Green" {
+            over "Geom"
+            {
+                over "Cube" (
+                    prepend apiSchemas = ["MaterialBindingAPI"]
+                )
+                {
+                    rel material:binding = </CubeModel/Materials/GreenMaterial>
+                    color3f[] primvars:displayColor = [(0, 1, 0)]
+                }
+            }
+
+        }
+        "Indigo" {
+            over "Geom"
+            {
+                over "Cube" (
+                    prepend apiSchemas = ["MaterialBindingAPI"]
+                )
+                {
+                    rel material:binding = </CubeModel/Materials/IndigoMaterial>
+                    color3f[] primvars:displayColor = [(0.294, 0, 0.51)]
+                }
+            }
+
+        }
+        "Orange" {
+            over "Geom"
+            {
+                over "Cube" (
+                    prepend apiSchemas = ["MaterialBindingAPI"]
+                )
+                {
+                    rel material:binding = </CubeModel/Materials/OrangeMaterial>
+                    color3f[] primvars:displayColor = [(1, 0.498, 0)]
+                }
+            }
+
+        }
+        "Red" {
+            over "Geom"
+            {
+                over "Cube" (
+                    prepend apiSchemas = ["MaterialBindingAPI"]
+                )
+                {
+                    rel material:binding = </CubeModel/Materials/RedMaterial>
+                    color3f[] primvars:displayColor = [(1, 0, 0)]
+                }
+            }
+
+        }
+        "Violet" {
+            over "Geom"
+            {
+                over "Cube" (
+                    prepend apiSchemas = ["MaterialBindingAPI"]
+                )
+                {
+                    rel material:binding = </CubeModel/Materials/VioletMaterial>
+                    color3f[] primvars:displayColor = [(0.58, 0, 0.827)]
+                }
+            }
+
+        }
+        "Yellow" {
+            over "Geom"
+            {
+                over "Cube" (
+                    prepend apiSchemas = ["MaterialBindingAPI"]
+                )
+                {
+                    rel material:binding = </CubeModel/Materials/YellowMaterial>
+                    color3f[] primvars:displayColor = [(1, 1, 0)]
+                }
+            }
+
+        }
+    }
+
+    def Scope "Materials"
+    {
+        def Material "BlueMaterial" (
+            prepend specializes = </CubeModel/Materials/BaseMaterial>
+        )
+        {
+            color3f inputs:diffuseColor = (0, 0, 1)
+        }
+
+        def Material "BaseMaterial"
+        {
+            color3f inputs:diffuseColor = (0.18, 0.18, 0.18)
+            token outputs:surface.connect = </CubeModel/Materials/BaseMaterial/PreviewSurface.outputs:surface>
+
+            def Shader "PreviewSurface"
+            {
+                uniform token info:id = "UsdPreviewSurface"
+                color3f inputs:diffuseColor.connect = </CubeModel/Materials/BaseMaterial.inputs:diffuseColor>
+                float inputs:roughness = 1
+                token outputs:surface
+            }
+        }
+
+        def Material "GreenMaterial" (
+            prepend specializes = </CubeModel/Materials/BaseMaterial>
+        )
+        {
+            color3f inputs:diffuseColor = (0, 1, 0)
+        }
+
+        def Material "IndigoMaterial" (
+            prepend specializes = </CubeModel/Materials/BaseMaterial>
+        )
+        {
+            color3f inputs:diffuseColor = (0.294, 0, 0.51)
+        }
+
+        def Material "OrangeMaterial" (
+            prepend specializes = </CubeModel/Materials/BaseMaterial>
+        )
+        {
+            color3f inputs:diffuseColor = (1, 0.498, 0)
+        }
+
+        def Material "RedMaterial" (
+            prepend specializes = </CubeModel/Materials/BaseMaterial>
+        )
+        {
+            color3f inputs:diffuseColor = (1, 0, 0)
+        }
+
+        def Material "VioletMaterial" (
+            prepend specializes = </CubeModel/Materials/BaseMaterial>
+        )
+        {
+            color3f inputs:diffuseColor = (0.58, 0, 0.827)
+        }
+
+        def Material "YellowMaterial" (
+            prepend specializes = </CubeModel/Materials/BaseMaterial>
+        )
+        {
+            color3f inputs:diffuseColor = (1, 1, 0)
+        }
+    }
+}
+
diff --git a/test/testSamples/testPointInstancingWireframeHighlight/NestedAndComposedPointInstancers.usda b/test/testSamples/testPointInstancingWireframeHighlight/NestedAndComposedPointInstancers.usda
new file mode 100644
index 0000000000..9257ebf4b7
--- /dev/null
+++ b/test/testSamples/testPointInstancingWireframeHighlight/NestedAndComposedPointInstancers.usda
@@ -0,0 +1,86 @@
+#usda 1.0
+(
+    defaultPrim = "Root"
+    metersPerUnit = 0.01
+    upAxis = "Z"
+)
+
+def Xform "Root"
+{
+    def Xform "TopInstancerXform"
+    {
+        def PointInstancer "TopInstancer"
+        {
+            point3f[] positions = [(0, 0, 6), (0, 0, 8)]
+            int[] protoIndices = [0, 0]
+            rel prototypes = [
+
+                </Root/TopInstancerXform/TopInstancer/prototypes/NestedInstancerXform>,
+            ]
+
+            def "prototypes"
+            {
+                def Xform "NestedInstancerXform"
+                {
+                    def PointInstancer "NestedInstancer"
+                    {
+                        point3f[] positions = [(1, 0, 0), (-1, 0, 0)]
+                        int[] protoIndices = [0, 1]
+                        rel prototypes = [
+                            </Root/TopInstancerXform/TopInstancer/prototypes/NestedInstancerXform/NestedInstancer/prototypes/RedCube>,
+                            </Root/TopInstancerXform/TopInstancer/prototypes/NestedInstancerXform/NestedInstancer/prototypes/BluePyramid>,
+                        ]
+
+                        def "prototypes"
+                        {
+                            def "RedCube" (
+                                prepend references = @./CubeModel.usda@
+                                variants = {
+                                    string shadingVariant = "Red"
+                                }
+                            )
+                            {
+                            }
+                            def "BluePyramid" (
+                                prepend references = @./PyramidModel.usda@
+                                variants = {
+                                    string shadingVariant = "Blue"
+                                }
+                            )
+                            {
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    def PointInstancer "SecondInstancer"
+    {
+        point3f[] positions = [(0, 0, -4), (0, 2, -4)]
+        int[] protoIndices = [0, 0]
+        rel prototypes = [
+            </Root/TopInstancerXform>,
+        ]
+    }
+
+    def PointInstancer "ThirdInstancer"
+    {
+        point3f[] positions = [(0, 0, -8), (0, 2, -8)]
+        int[] protoIndices = [0, 0]
+        rel prototypes = [
+            </Root/TopInstancerXform>,
+        ]
+    }
+
+    def PointInstancer "FourthInstancer"
+    {
+        point3f[] positions = [(0, 0, -12), (0, 2, -12)]
+        int[] protoIndices = [0, 0]
+        rel prototypes = [
+            </Root/TopInstancerXform>,
+        ]
+    }
+}
+
diff --git a/test/testSamples/testPointInstancingWireframeHighlight/PyramidModel.usda b/test/testSamples/testPointInstancingWireframeHighlight/PyramidModel.usda
new file mode 100644
index 0000000000..ae32847b8e
--- /dev/null
+++ b/test/testSamples/testPointInstancingWireframeHighlight/PyramidModel.usda
@@ -0,0 +1,109 @@
+#usda 1.0
+(
+    defaultPrim = "PyramidModel"
+    metersPerUnit = 0.01
+    upAxis = "Z"
+)
+
+def Xform "PyramidModel" (
+    assetInfo = {
+        asset identifier = @./PyramidModel.usda@
+        string name = "PyramidModel"
+    }
+    kind = "component"
+    variants = {
+        string shadingVariant = "Red"
+    }
+    add variantSets = "shadingVariant"
+)
+{
+    def Xform "Geom"
+    {
+        def Mesh "Pyramid"
+        {
+            float3[] extent = [(-0.70710677, -0.35355338, -0.70710677), (0.70710677, 0.35355338, 0.70710677)]
+            int[] faceVertexCounts = [4, 3, 3, 3, 3]
+            int[] faceVertexIndices = [0, 3, 2, 1, 0, 1, 4, 1, 2, 4, 2, 3, 4, 3, 0, 4]
+            point3f[] points = [(9.272585e-8, -0.35355338, -0.70710677), (-0.70710677, -0.35355338, -6.181724e-8), (-3.090862e-8, -0.35355338, 0.70710677), (0.70710677, -0.35355338, 0), (0, 0.35355338, 0)]
+        }
+    }
+    variantSet "shadingVariant" = {
+        "Blue" {
+            over "Geom"
+            {
+                over "Pyramid" (
+                    prepend apiSchemas = ["MaterialBindingAPI"]
+                )
+                {
+                    rel material:binding = </PyramidModel/Materials/BlueMaterial>
+                    color3f[] primvars:displayColor = [(0, 0, 1)]
+                }
+            }
+
+        }
+        "Green" {
+            over "Geom"
+            {
+                over "Pyramid" (
+                    prepend apiSchemas = ["MaterialBindingAPI"]
+                )
+                {
+                    rel material:binding = </PyramidModel/Materials/GreenMaterial>
+                    color3f[] primvars:displayColor = [(0, 1, 0)]
+                }
+            }
+
+        }
+        "Red" {
+            over "Geom"
+            {
+                over "Pyramid" (
+                    prepend apiSchemas = ["MaterialBindingAPI"]
+                )
+                {
+                    rel material:binding = </PyramidModel/Materials/RedMaterial>
+                    color3f[] primvars:displayColor = [(1, 0, 0)]
+                }
+            }
+
+        }
+    }
+
+    def Scope "Materials"
+    {
+        def Material "BaseMaterial"
+        {
+            color3f inputs:diffuseColor = (0.18, 0.18, 0.18)
+            token outputs:surface.connect = </PyramidModel/Materials/BaseMaterial/PreviewSurface.outputs:surface>
+
+            def Shader "PreviewSurface"
+            {
+                uniform token info:id = "UsdPreviewSurface"
+                color3f inputs:diffuseColor.connect = </PyramidModel/Materials/BaseMaterial.inputs:diffuseColor>
+                float inputs:roughness = 1
+                token outputs:surface
+            }
+        }
+
+        def Material "BlueMaterial" (
+            prepend specializes = </PyramidModel/Materials/BaseMaterial>
+        )
+        {
+            color3f inputs:diffuseColor = (0, 0, 1)
+        }
+
+        def Material "GreenMaterial" (
+            prepend specializes = </PyramidModel/Materials/BaseMaterial>
+        )
+        {
+            color3f inputs:diffuseColor = (0, 1, 0)
+        }
+
+        def Material "RedMaterial" (
+            prepend specializes = </PyramidModel/Materials/BaseMaterial>
+        )
+        {
+            color3f inputs:diffuseColor = (1, 0, 0)
+        }
+    }
+}

From 3e1cd52f40936222cfe8c16e6a3637535e5366b7 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 12:35:30 -0400
Subject: [PATCH 060/112] Fix point instancer and instance tests

---
 .../testPointInstancingWireframeHighlight.cpp | 42 ++++++++++++-------
 .../testPointInstancingWireframeHighlight.py  | 13 ++++--
 .../CubeModel.usda                            |  1 -
 .../NestedAndComposedPointInstancers.usda     |  1 -
 4 files changed, 36 insertions(+), 21 deletions(-)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index 4bcc078c4c..d623813ffc 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -1,8 +1,5 @@
 
 #include "testUtils.h"
-#include "ufe/pathSegment.h"
-#include "ufe/sceneItem.h"
-#include "ufe/selection.h"
 
 #include <mayaHydraLib/mayaHydra.h>
 
@@ -16,11 +13,16 @@
 #include <pxr/imaging/hd/legacyDisplayStyleSchema.h>
 #include <pxr/imaging/hd/sceneDelegate.h>
 #include <pxr/imaging/hd/sceneIndex.h>
+#include <pxr/imaging/hd/sceneIndexObserver.h>
 #include <pxr/imaging/hd/sceneIndexPrimView.h>
 #include <pxr/imaging/hdx/selectionSceneIndexObserver.h>
 #include <pxr/imaging/hd/tokens.h>
 #include <pxr/usd/sdf/path.h>
+#include <pxr/imaging/hd/utils.h>
 
+#include "ufe/pathSegment.h"
+#include "ufe/sceneItem.h"
+#include "ufe/selection.h"
 #include <ufe/pathString.h>
 #include <ufe/hierarchy.h>
 #include <ufe/globalSelection.h>
@@ -28,6 +30,8 @@
 
 #include <gtest/gtest.h>
 
+#include <string>
+
 PXR_NAMESPACE_USING_DIRECTIVE
 using namespace MayaHydra;
 
@@ -35,7 +39,7 @@ namespace {
 
 const std::string selectionHighlightTag = "_SelectionHighlight";
 
-const std::string stagePathSegment = "|nestedAndComposedPointInstancers|nestedAndComposedPointInstancersShape";
+const std::string stagePathSegment = "|NestedAndComposedPointInstancers|NestedAndComposedPointInstancersShape";
 
 SdfPath getSelectionHighlightMirrorPathFromOriginal(const SdfPath& originalPath)
 {
@@ -48,14 +52,14 @@ SdfPath getSelectionHighlightMirrorPathFromOriginal(const SdfPath& originalPath)
 //     return mirrorPath.ReplaceName(TfToken(primName.substr(0, primName.size() - selectionHighlightTag.size())));
 // }
 
-TfToken getReprToken(const HdSceneIndexPrim& prim)
+TfToken getRefinedReprToken(const HdSceneIndexPrim& prim)
 {
     HdLegacyDisplayStyleSchema displayStyle = HdLegacyDisplayStyleSchema::GetFromParent(prim.dataSource);
     if (!displayStyle.IsDefined() || !displayStyle.GetReprSelector()) {
         return {};
     }
     auto reprSelectors = displayStyle.GetReprSelector()->GetTypedValue(0);
-    EXPECT_EQ(reprSelectors.size(), 1u);
+    EXPECT_EQ(reprSelectors.size(), 3u); // refined, unrefined, points
     return reprSelectors.empty() ? TfToken() : reprSelectors.front();
 }
 
@@ -98,7 +102,7 @@ void assertSelectionHighlightCorrectness(const HdSceneIndexBaseRefPtr& sceneInde
         }
 
         if (currPrim.primType == HdPrimTypeTokens->mesh) {
-            EXPECT_EQ(getReprToken(currPrim), HdReprTokens->refinedWire);
+            EXPECT_EQ(getRefinedReprToken(currPrim), HdReprTokens->refinedWire);
         }
     }
 }
@@ -148,7 +152,9 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
 
     auto meshPrims = inspector.FindPrims(findMeshPrimsPredicate);
     for (const auto& meshPrim : meshPrims) {
-        EXPECT_EQ(getReprToken(meshPrim.prim), HdReprTokens->refined);
+        HdLegacyDisplayStyleSchema displayStyle = HdLegacyDisplayStyleSchema::GetFromParent(meshPrim.prim.dataSource);
+        EXPECT_TRUE(displayStyle.IsDefined());
+        EXPECT_FALSE(displayStyle.GetReprSelector());
     }
 
     // Select point instancers directly
@@ -157,11 +163,13 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
 
         auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(instancerPath);
         ASSERT_EQ(instancerHydraSelections.size(), 1u);
-    
-        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerHydraSelections.front().primPath));
+        auto instancerPrimPath = instancerHydraSelections.front().primPath;
     
         ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().size(), 1u);
-        ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().front(), instancerHydraSelections.front().primPath);
+        ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().front(), instancerPrimPath);
+
+        ASSERT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
+        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
     };
     
     testInstancerDirectHighlightFn(topInstancerItem, topInstancerPath);
@@ -175,6 +183,7 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
         auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(instancerPath);
         ASSERT_EQ(instancerHydraSelections.size(), 1u);
     
+        ASSERT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
         assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerHydraSelections.front().primPath));
     };
     auto testInstancerNoHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
@@ -235,7 +244,9 @@ TEST(PointInstancingWireframeHighlight, instance)
 
     auto meshPrims = inspector.FindPrims(findMeshPrimsPredicate);
     for (const auto& meshPrim : meshPrims) {
-        EXPECT_EQ(getReprToken(meshPrim.prim), HdReprTokens->refined);
+        HdLegacyDisplayStyleSchema displayStyle = HdLegacyDisplayStyleSchema::GetFromParent(meshPrim.prim.dataSource);
+        EXPECT_TRUE(displayStyle.IsDefined());
+        EXPECT_FALSE(displayStyle.GetReprSelector());
     }
 
     // Select instances
@@ -244,13 +255,14 @@ TEST(PointInstancingWireframeHighlight, instance)
 
         auto instanceHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(instancePath);
         ASSERT_EQ(instanceHydraSelections.size(), 1u);
-    
         auto instancerPrimPath = instanceHydraSelections.front().primPath;
-        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
-    
+
         ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().size(), 1u);
         ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().front(), instancerPrimPath);
 
+        ASSERT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
+        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
+
         HdSceneIndexPrim instancerHighlightPrim = inspector.GetSceneIndex()->GetPrim(getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
         HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(instancerHighlightPrim.dataSource);
         ASSERT_TRUE(instancerTopology.IsDefined());
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
index f166a81085..ac506d7662 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
@@ -11,7 +11,7 @@ class TestPointInstancingWireframeHighlight(mtohUtils.MayaHydraBaseTestCase):
 
     def loadUsdScene(self):
         import usdUtils
-        usdScenePath = testUtils.getTestScene('testPointInstancingWireframeHighlight', 'nestedAndComposedPointInstancers.usda')
+        usdScenePath = testUtils.getTestScene('testPointInstancingWireframeHighlight', 'NestedAndComposedPointInstancers.usda')
         usdUtils.createStageFromFile(usdScenePath)
         #self.setHdStormRenderer()
         #cmds.refresh()
@@ -19,7 +19,7 @@ def loadUsdScene(self):
     def setUp(self):
         super(TestPointInstancingWireframeHighlight, self).setUp()
         self.loadUsdScene()
-        #cmds.refresh()
+        cmds.refresh(force=True)
 
     def test_PointInstancerSelection(self):
         with PluginLoaded('mayaHydraCppTests'):
@@ -31,8 +31,13 @@ def test_InstanceSelection(self):
             cmds.mayaHydraCppTest(
                 f="PointInstancingWireframeHighlight.instance")
 
-    def test_PrototypeSelection(self):
-        pass
+    # def test_PrototypeSelection(self):
+    #     with PluginLoaded('mayaHydraCppTests'):
+    #         cmds.refresh(force=True)
+    #         import time
+    #         time.sleep(10)
+    #         cmds.mayaHydraCppTest(
+    #             f="PointInstancingWireframeHighlight.prototype")
 
 if __name__ == '__main__':
     fixturesUtils.runTests(globals())
diff --git a/test/testSamples/testPointInstancingWireframeHighlight/CubeModel.usda b/test/testSamples/testPointInstancingWireframeHighlight/CubeModel.usda
index 36289c3015..5916d4f1eb 100644
--- a/test/testSamples/testPointInstancingWireframeHighlight/CubeModel.usda
+++ b/test/testSamples/testPointInstancingWireframeHighlight/CubeModel.usda
@@ -188,4 +188,3 @@ def Xform "CubeModel" (
         }
     }
 }
-
diff --git a/test/testSamples/testPointInstancingWireframeHighlight/NestedAndComposedPointInstancers.usda b/test/testSamples/testPointInstancingWireframeHighlight/NestedAndComposedPointInstancers.usda
index 9257ebf4b7..0b1d759398 100644
--- a/test/testSamples/testPointInstancingWireframeHighlight/NestedAndComposedPointInstancers.usda
+++ b/test/testSamples/testPointInstancingWireframeHighlight/NestedAndComposedPointInstancers.usda
@@ -83,4 +83,3 @@ def Xform "Root"
         ]
     }
 }
-

From 48434143af3549441626a7b9881ed9037180852d Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 12:43:41 -0400
Subject: [PATCH 061/112] Add prototype selection test

---
 .../testPointInstancingWireframeHighlight.cpp | 61 +++++++++++++++++++
 .../testPointInstancingWireframeHighlight.py  | 11 ++--
 2 files changed, 65 insertions(+), 7 deletions(-)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index d623813ffc..85cd914649 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -279,3 +279,64 @@ TEST(PointInstancingWireframeHighlight, instance)
     testInstanceHighlightFn(topInstancerFirstInstanceItem, topInstancerFirstInstancePath);
     testInstanceHighlightFn(secondInstancerSecondInstanceItem, secondInstancerSecondInstancePath);
 }
+
+TEST(PointInstancingWireframeHighlight, prototype)
+{
+    const SceneIndicesVector& terminalSceneIndices = GetTerminalSceneIndices();
+    ASSERT_FALSE(terminalSceneIndices.empty());
+    SceneIndexInspector inspector(terminalSceneIndices.front());
+
+    auto isFvpMergingSceneIndexPredicate = SceneIndexDisplayNamePred("Flow Viewport Merging Scene Index");
+    auto fvpMergingSceneIndex = TfDynamic_cast<Fvp::MergingSceneIndexRefPtr>(
+        findSceneIndexInTree(terminalSceneIndices.front(), isFvpMergingSceneIndexPredicate));
+
+    auto ufeSelection = Ufe::GlobalSelection::get();
+
+    HdxSelectionSceneIndexObserver selectionObserver;
+    selectionObserver.SetSceneIndex(terminalSceneIndices.front());
+
+    auto prototypePath = Ufe::PathString::path(stagePathSegment + "," + "/Root/TopInstancerXform/TopInstancer/prototypes/NestedInstancerXform/NestedInstancer/prototypes/RedCube/Geom/Cube");
+    auto prototypeParentPath = Ufe::PathString::path(stagePathSegment + "," + "/Root/TopInstancerXform/TopInstancer/prototypes/NestedInstancerXform/NestedInstancer/prototypes/RedCube");
+
+    auto prototypeItem = Ufe::Hierarchy::createItem(prototypePath);
+    auto prototypeParentItem = Ufe::Hierarchy::createItem(prototypeParentPath);
+
+    // Initial state : ensure nothing is highlighted
+    ufeSelection->clear();
+
+    auto selectionHighlightMirrors = inspector.FindPrims(findSelectionHighlightMirrorsPredicate);
+    EXPECT_TRUE(selectionHighlightMirrors.empty());
+
+    auto meshPrims = inspector.FindPrims(findMeshPrimsPredicate);
+    for (const auto& meshPrim : meshPrims) {
+        HdLegacyDisplayStyleSchema displayStyle = HdLegacyDisplayStyleSchema::GetFromParent(meshPrim.prim.dataSource);
+        EXPECT_TRUE(displayStyle.IsDefined());
+        EXPECT_FALSE(displayStyle.GetReprSelector());
+    }
+
+    // Select prototype
+    auto testPrototypeHighlightFn = [&](const Ufe::SceneItem::Ptr& prototypeItem, const Ufe::Path& prototypePath) -> void {
+        ufeSelection->replaceWith(prototypeItem);
+
+        auto prototypeHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(prototypePath);
+        // Original prim + 4 propagated prototypes
+        ASSERT_EQ(prototypeHydraSelections.size(), 1u + 4u);
+
+        ASSERT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
+        for (const auto& prototypeSelection : prototypeHydraSelections) {
+            HdSceneIndexPrimView view(inspector.GetSceneIndex(), prototypeSelection.primPath);
+            for (auto it = view.begin(); it != view.end(); ++it) {
+                HdSceneIndexPrim prim = inspector.GetSceneIndex()->GetPrim(*it);
+                if (prim.primType == HdPrimTypeTokens->mesh) {
+                    EXPECT_EQ(getRefinedReprToken(prim), HdReprTokens->refinedWireOnSurf);
+                }
+            }
+        }
+    
+        // Original prim + 4 propagated prototypes
+        ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().size(), 1u + 4u);
+    };
+    
+    testPrototypeHighlightFn(prototypeItem, prototypePath);
+    testPrototypeHighlightFn(prototypeParentItem, prototypeParentPath);
+}
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
index ac506d7662..11d6fe7035 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
@@ -31,13 +31,10 @@ def test_InstanceSelection(self):
             cmds.mayaHydraCppTest(
                 f="PointInstancingWireframeHighlight.instance")
 
-    # def test_PrototypeSelection(self):
-    #     with PluginLoaded('mayaHydraCppTests'):
-    #         cmds.refresh(force=True)
-    #         import time
-    #         time.sleep(10)
-    #         cmds.mayaHydraCppTest(
-    #             f="PointInstancingWireframeHighlight.prototype")
+    def test_PrototypeSelection(self):
+        with PluginLoaded('mayaHydraCppTests'):
+            cmds.mayaHydraCppTest(
+                f="PointInstancingWireframeHighlight.prototype")
 
 if __name__ == '__main__':
     fixturesUtils.runTests(globals())

From 2715c47ca90da0c28cc17dbf70ead7086567fbbf Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 13:04:53 -0400
Subject: [PATCH 062/112] Cleanup test files

---
 .../testPointInstancingWireframeHighlight.cpp | 35 +++++++++++--------
 .../testPointInstancingWireframeHighlight.py  | 18 +++++++---
 2 files changed, 35 insertions(+), 18 deletions(-)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index 85cd914649..9c721ed6a1 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -1,10 +1,24 @@
 
+// Copyright 2024 Autodesk
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
 #include "testUtils.h"
 
 #include <mayaHydraLib/mayaHydra.h>
 
-#include <flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h>
 #include <flowViewport/sceneIndex/fvpMergingSceneIndex.h>
+#include <flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h>
 
 #include <pxr/base/tf/token.h>
 #include <pxr/base/vt/array.h>
@@ -15,18 +29,17 @@
 #include <pxr/imaging/hd/sceneIndex.h>
 #include <pxr/imaging/hd/sceneIndexObserver.h>
 #include <pxr/imaging/hd/sceneIndexPrimView.h>
-#include <pxr/imaging/hdx/selectionSceneIndexObserver.h>
 #include <pxr/imaging/hd/tokens.h>
+#include <pxr/imaging/hdx/selectionSceneIndexObserver.h>
 #include <pxr/usd/sdf/path.h>
-#include <pxr/imaging/hd/utils.h>
 
-#include "ufe/pathSegment.h"
-#include "ufe/sceneItem.h"
-#include "ufe/selection.h"
-#include <ufe/pathString.h>
-#include <ufe/hierarchy.h>
 #include <ufe/globalSelection.h>
+#include <ufe/hierarchy.h>
 #include <ufe/observableSelection.h>
+#include <ufe/pathSegment.h>
+#include <ufe/pathString.h>
+#include <ufe/selection.h>
+#include <ufe/sceneItem.h>
 
 #include <gtest/gtest.h>
 
@@ -46,12 +59,6 @@ SdfPath getSelectionHighlightMirrorPathFromOriginal(const SdfPath& originalPath)
     return originalPath.ReplaceName(TfToken(originalPath.GetName() + selectionHighlightTag));
 }
 
-// SdfPath getOriginalPathFromSelectionHighlightMirror(const SdfPath& mirrorPath)
-// {
-//     const std::string primName = mirrorPath.GetName();
-//     return mirrorPath.ReplaceName(TfToken(primName.substr(0, primName.size() - selectionHighlightTag.size())));
-// }
-
 TfToken getRefinedReprToken(const HdSceneIndexPrim& prim)
 {
     HdLegacyDisplayStyleSchema displayStyle = HdLegacyDisplayStyleSchema::GetFromParent(prim.dataSource);
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
index 11d6fe7035..71b10475d8 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.py
@@ -1,7 +1,20 @@
+# Copyright 2024 Autodesk
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
 import maya.cmds as cmds
 import fixturesUtils
 import mtohUtils
-import mayaUtils
 import testUtils
 from testUtils import PluginLoaded
 
@@ -13,13 +26,10 @@ def loadUsdScene(self):
         import usdUtils
         usdScenePath = testUtils.getTestScene('testPointInstancingWireframeHighlight', 'NestedAndComposedPointInstancers.usda')
         usdUtils.createStageFromFile(usdScenePath)
-        #self.setHdStormRenderer()
-        #cmds.refresh()
 
     def setUp(self):
         super(TestPointInstancingWireframeHighlight, self).setUp()
         self.loadUsdScene()
-        cmds.refresh(force=True)
 
     def test_PointInstancerSelection(self):
         with PluginLoaded('mayaHydraCppTests'):

From 4664d9995c0c80291aba8adec87e9bc6f8ed268c Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 14:49:51 -0400
Subject: [PATCH 063/112] Minor doc correction

---
 doc/selectionHighlightingArchitecture.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index bb28c25ef3..6712f2f0c1 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -18,7 +18,7 @@ are shown differently in the viewport for ease of understanding.
 
 An application will provide a way to select an object, or to select components
 of an object.  For example, for a mesh object, these components may be points,
-edges, or faces.  Currently, only object selection highlighting and USD point
+edges, or faces.  Currently, only object selection highlighting and point
 instancing highlighting of meshes are supported.  Selection highlighting of
 components is unimplemented.
 

From 50170303dd46a277196834e98747cf033163fa68 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 14:59:51 -0400
Subject: [PATCH 064/112] Use TfSmallVector for PrimSelectionInfoVector

---
 lib/flowViewport/sceneIndex/fvpPathInterface.h | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpPathInterface.h b/lib/flowViewport/sceneIndex/fvpPathInterface.h
index 21df8c7be9..c0490a2fef 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterface.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterface.h
@@ -40,8 +40,7 @@ struct PrimSelectionInfo
     PXR_NS::HdDataSourceBaseHandle selectionDataSource;
 };
 
-// TODO : Use TfSmallVector for perf?
-using PrimSelectionInfoVector = std::vector<PrimSelectionInfo>;
+using PrimSelectionInfoVector = PXR_NS::TfSmallVector<PrimSelectionInfo, 8>;
 
 /// \class PathInterface
 ///
@@ -57,7 +56,6 @@ class PathInterface
     //! If no such path exists, an empty SdfPath should be returned.
     //! \return scene index path.
     FVP_API
-    // TODO : Use TfSmallVector for perf?
     virtual PrimSelectionInfoVector ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const = 0;
 
 protected:

From fe8db0557b615d1ddb51b2ecdbe54434b5550bd7 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 15:01:40 -0400
Subject: [PATCH 065/112] Rename ConvertUfeSelectionToHydra

---
 doc/selectionHighlightingArchitecture.md           |  4 ++--
 .../fvpBlockPrimRemovalPropagationSceneIndex.h     |  4 ++--
 .../sceneIndex/fvpMergingSceneIndex.cpp            |  4 ++--
 lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h |  2 +-
 lib/flowViewport/sceneIndex/fvpPathInterface.h     |  2 +-
 .../sceneIndex/fvpPathInterfaceSceneIndex.h        |  2 +-
 .../sceneIndex/fvpSelectionSceneIndex.cpp          | 14 +++++++-------
 .../sceneIndex/fvpSelectionSceneIndex.h            |  2 +-
 .../hydraExtensions/mhLeadObjectPathTracker.cpp    |  6 +++---
 .../sceneIndex/mayaHydraSceneIndex.cpp             |  4 ++--
 .../sceneIndex/mayaHydraSceneIndex.h               |  2 +-
 .../hydraExtensions/sceneIndex/registration.cpp    |  2 +-
 .../render/mayaToHydra/cpp/testHydraPrim.cpp       |  2 +-
 .../mayaToHydra/cpp/testMergingSceneIndex.cpp      |  6 +++---
 .../render/mayaToHydra/cpp/testPathInterface.cpp   |  2 +-
 .../cpp/testPointInstancingWireframeHighlight.cpp  | 10 +++++-----
 .../mayaToHydra/cpp/testSelectionSceneIndex.cpp    |  6 +++---
 .../mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp |  2 +-
 .../render/mayaToHydra/cpp/testUsdPicking.cpp      |  2 +-
 .../cpp/testUsdPointInstancePicking.cpp            |  2 +-
 .../testWireframeSelectionHighlightSceneIndex.cpp  | 10 +++++-----
 21 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index 6712f2f0c1..f15ca6effd 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -86,7 +86,7 @@ provide the following services:
 
 This
 [selection change code](../lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp#L151-L170)
-shows the use of the *Path Interface*, through the *ConvertUfeSelectionToHydra()* method,
+shows the use of the *Path Interface*, through the *ConvertUfePathToHydraSelections()* method,
 called on the input scene index.  The path interface allows the selection scene
 index to translate selected application paths to selected Hydra scene index
 paths.
@@ -234,7 +234,7 @@ class Selection{
 }
 
 class PathInterface{
-+ConvertUfeSelectionToHydra(Ufe::Path) SdfPath
++ConvertUfePathToHydraSelections(Ufe::Path) SdfPath
 }
 
 class SelectionSceneIndex
diff --git a/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h b/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
index af90328f33..bc8e7e1125 100644
--- a/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
@@ -70,8 +70,8 @@ class BlockPrimRemovalPropagationSceneIndex : public PXR_NS::HdSingleInputFilter
 
     //from PathInterface
     FVP_API
-    PrimSelectionInfoVector ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const override{
-        return _pathInterface->ConvertUfeSelectionToHydra(appPath);
+    PrimSelectionInfoVector ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override{
+        return _pathInterface->ConvertUfePathToHydraSelections(appPath);
     }
 
 protected:
diff --git a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
index 86b8f96540..ea9df0d028 100644
--- a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
@@ -35,7 +35,7 @@ MergingSceneIndex::MergingSceneIndex() : HdMergingSceneIndex()
         .Msg("MergingSceneIndex::MergingSceneIndex() called.\n");
 }
 
-PrimSelectionInfoVector MergingSceneIndex::ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const
+PrimSelectionInfoVector MergingSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const
 {
     // FLOW_VIEWPORT_TODO  May be able to use a caching scheme for app path to
     // scene index path conversion using the run-time ID of the UFE path, as it
@@ -51,7 +51,7 @@ PrimSelectionInfoVector MergingSceneIndex::ConvertUfeSelectionToHydra(const Ufe:
         // scene we know whether it supports the PathInterface or not.
         auto pathInterface = dynamic_cast<const PathInterface*>(&*inputScene);
         if (pathInterface) {
-            auto primSelections = pathInterface->ConvertUfeSelectionToHydra(appPath);
+            auto primSelections = pathInterface->ConvertUfePathToHydraSelections(appPath);
             if (!primSelections.empty()) {
                 return primSelections;
             }
diff --git a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
index d9d8e11edf..d974a93c53 100644
--- a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
@@ -41,7 +41,7 @@ class MergingSceneIndex
     static MergingSceneIndexRefPtr New();
 
     FVP_API
-    PrimSelectionInfoVector ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const override;
+    PrimSelectionInfoVector ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override;
 
 private:
     MergingSceneIndex();
diff --git a/lib/flowViewport/sceneIndex/fvpPathInterface.h b/lib/flowViewport/sceneIndex/fvpPathInterface.h
index c0490a2fef..49b11a7d47 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterface.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterface.h
@@ -56,7 +56,7 @@ class PathInterface
     //! If no such path exists, an empty SdfPath should be returned.
     //! \return scene index path.
     FVP_API
-    virtual PrimSelectionInfoVector ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const = 0;
+    virtual PrimSelectionInfoVector ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const = 0;
 
 protected:
 
diff --git a/lib/flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h b/lib/flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h
index 0afc682480..854aaa4b10 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h
@@ -27,7 +27,7 @@ namespace FVP_NS_DEF {
 ///
 /// A simple pass-through filtering scene index that adds support for the path
 /// interface.  Derived classes need only implement the 
-/// PathInterface::ConvertUfeSelectionToHydra() virtual.
+/// PathInterface::ConvertUfePathToHydraSelections() virtual.
 ///
 class PathInterfaceSceneIndexBase 
     : public PXR_NS::HdSingleInputFilteringSceneIndexBase
diff --git a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
index 567bfcc34e..a659431823 100644
--- a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
@@ -155,7 +155,7 @@ SelectionSceneIndex::AddSelection(const Ufe::Path& appPath)
         .Msg("SelectionSceneIndex::AddSelection(const Ufe::Path& %s) called.\n", Ufe::PathString::string(appPath).c_str());
 
     // Call our input scene index to convert the application path to scene index paths.
-    auto primSelections = ConvertUfeSelectionToHydra(appPath);
+    auto primSelections = ConvertUfePathToHydraSelections(appPath);
 
     for (const auto& primSelection : primSelections) {
         TF_DEBUG(FVP_SELECTION_SCENE_INDEX)
@@ -176,7 +176,7 @@ void SelectionSceneIndex::RemoveSelection(const Ufe::Path& appPath)
 
     // Call our input scene index to convert the application path to a scene
     // index path.
-    auto primSelections = ConvertUfeSelectionToHydra(appPath);
+    auto primSelections = ConvertUfePathToHydraSelections(appPath);
 
     for (const auto& primSelection : primSelections) {
         if (_selection->Remove(primSelection.primPath)) {
@@ -225,13 +225,13 @@ void SelectionSceneIndex::ReplaceSelection(const Ufe::Selection& selection)
     _selection->Clear();
 
     PrimSelectionInfoVector sceneIndexSn;
-    // This .reserve() call is mostly a heuristic : the ConvertUfeSelectionToHydra API allows one UFE path
+    // This .reserve() call is mostly a heuristic : the ConvertUfePathToHydraSelections API allows one UFE path
     // to map to any number of SdfPaths (0 to infinity). However, in most cases, it is likely to map to 
     // one SdfPath, so we reserve space accordingly. (2024/05/27)
     sceneIndexSn.reserve(selection.size());
     for (const auto& snItem : selection) {
         // Call our input scene index to convert the application path to scene index paths.
-        auto primSelections = ConvertUfeSelectionToHydra(snItem->path());
+        auto primSelections = ConvertUfePathToHydraSelections(snItem->path());
 
         if (primSelections.empty()) {
             continue;
@@ -259,12 +259,12 @@ bool SelectionSceneIndex::HasFullySelectedAncestorInclusive(const SdfPath& primP
     return _selection->HasFullySelectedAncestorInclusive(primPath);
 }
 
-PrimSelectionInfoVector SelectionSceneIndex::ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const
+PrimSelectionInfoVector SelectionSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const
 {
-    auto primSelections = _inputSceneIndexPathInterface->ConvertUfeSelectionToHydra(appPath);
+    auto primSelections = _inputSceneIndexPathInterface->ConvertUfePathToHydraSelections(appPath);
 
     if (primSelections.empty()) {
-        TF_WARN("SelectionSceneIndex::ConvertUfeSelectionToHydra(%s) returned no path, Hydra selection will be incorrect", Ufe::PathString::string(appPath).c_str());
+        TF_WARN("SelectionSceneIndex::ConvertUfePathToHydraSelections(%s) returned no path, Hydra selection will be incorrect", Ufe::PathString::string(appPath).c_str());
     }
 
     return primSelections;
diff --git a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
index bcc7088bb4..fcd91e9cc0 100644
--- a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
@@ -117,7 +117,7 @@ class SelectionSceneIndex final
     //! and warns about empty return paths.
     //@{
     FVP_API
-    PrimSelectionInfoVector ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const override;
+    PrimSelectionInfoVector ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override;
     //@}
 
     FVP_API
diff --git a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
index 83bbbc4af7..472d40ced3 100644
--- a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
+++ b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
@@ -84,7 +84,7 @@ MhLeadObjectPathTracker::MhLeadObjectPathTracker(const HdSceneIndexBaseRefPtr& s
         //_leadObjectPrimPath can be empty with a valid _leadObjectUfePath when the lead object is in a data producer scene index not yet added to the merging scene index
         //This is fixed at some point by calling updatePrimPath()
         // TODO : Handle multiple lead prim paths
-        auto hydraSelections = _pathInterface->ConvertUfeSelectionToHydra(_leadObjectUfePath);
+        auto hydraSelections = _pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath);
         _leadObjectPrimPath = hydraSelections.empty() ? SdfPath() : hydraSelections.front().primPath;
     }
 
@@ -117,7 +117,7 @@ void MhLeadObjectPathTracker::setLeadObjectUfePath(const Ufe::Path& newLeadObjec
 
     _leadObjectUfePath  = newLeadObjectUfePath;
     // TODO : Handle multiple lead prim paths
-    auto hydraSelections = _pathInterface->ConvertUfeSelectionToHydra(_leadObjectUfePath);
+    auto hydraSelections = _pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath);
     _leadObjectPrimPath = hydraSelections.empty() ? SdfPath() : hydraSelections.front().primPath;
 
     // Dirty the previous lead object
@@ -131,7 +131,7 @@ void MhLeadObjectPathTracker::updatePrimPath()
    // Update the lead object prim path in case it was not valid yet
     if ( (_leadObjectUfePath.size() > 0) && _leadObjectPrimPath.IsEmpty()) {
         // TODO : Handle multiple lead prim paths
-        auto hydraSelections = _pathInterface->ConvertUfeSelectionToHydra(_leadObjectUfePath);
+        auto hydraSelections = _pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath);
         _leadObjectPrimPath = hydraSelections.empty() ? SdfPath() : hydraSelections.front().primPath;
     }
 }
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
index 780c520c35..784cdaa8be 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
@@ -648,10 +648,10 @@ VtValue MayaHydraSceneIndex::CreateMayaDefaultMaterial()
     return VtValue(networkMap);
 }
 
-Fvp::PrimSelectionInfoVector MayaHydraSceneIndex::ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const
+Fvp::PrimSelectionInfoVector MayaHydraSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const
 {
     TF_DEBUG(MAYAHYDRALIB_SCENE_INDEX)
-        .Msg("MayaHydraSceneIndex::ConvertUfeSelectionToHydra(const Ufe::Path& %s) called.\n", Ufe::PathString::string(appPath).c_str());
+        .Msg("MayaHydraSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& %s) called.\n", Ufe::PathString::string(appPath).c_str());
 
     // We only handle Maya objects, so if the UFE path is not a Maya object,
     // early out with failure.
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h
index c70626f84f..157e71c215 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h
@@ -202,7 +202,7 @@ class MAYAHYDRALIB_API MayaHydraSceneIndex : public HdRetainedSceneIndex, public
 
     void SetDefaultMaterial(bool useDefMaterial);
 
-    Fvp::PrimSelectionInfoVector ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const override;
+    Fvp::PrimSelectionInfoVector ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override;
 
     // Common function to return templated sample types
     template <typename T, typename Getter>
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
index 11108defe2..7b146b3f76 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
@@ -111,7 +111,7 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
             inputSceneIndex, sceneIndexPathPrefix, sceneIndexAppPath));
     }
 
-    Fvp::PrimSelectionInfoVector ConvertUfeSelectionToHydra(const Ufe::Path& appPath) const override
+    Fvp::PrimSelectionInfoVector ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override
     {
         // We only handle USD objects, so if the UFE path is not a USD object,
         // early out with failure.
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
index 91e260a807..13a5d0471e 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
@@ -39,7 +39,7 @@ TEST(TestHydraPrim, fromAppPath)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto primSelections = snSi->ConvertUfeSelectionToHydra(appPath);
+    const auto primSelections = snSi->ConvertUfePathToHydraSelections(appPath);
 
     ASSERT_EQ(primSelections.size(), 1u);
     ASSERT_FALSE(primSelections.front().primPath.IsEmpty());
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
index 5caf51b81d..00b30e2bfc 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
@@ -69,7 +69,7 @@ TEST(FlowViewport, mergingSceneIndex)
 
     // The Maya data producer scene index supports the path interface.  Ask it
     // to translate the application path into a scene index path.
-    auto primSelections = mayaSi->ConvertUfeSelectionToHydra(mayaPath);
+    auto primSelections = mayaSi->ConvertUfePathToHydraSelections(mayaPath);
     ASSERT_EQ(primSelections.size(), 1u);
 
     // Regardless of prefix, the scene index path tail component will match the
@@ -87,7 +87,7 @@ TEST(FlowViewport, mergingSceneIndex)
 
     // Flow Viewport merging scene index must give the same scene index path
     // answer as the Maya data producer scene index.
-    auto mergingSiSelections = mergingSi->ConvertUfeSelectionToHydra(mayaPath);
+    auto mergingSiSelections = mergingSi->ConvertUfePathToHydraSelections(mayaPath);
     ASSERT_EQ(mergingSiSelections.size(), 1u);
     ASSERT_EQ(mergingSiSelections.front().primPath, primSelections.front().primPath);
 }
@@ -108,7 +108,7 @@ TEST(FlowViewport, mergingSceneIndexAddRemove)
         producers.begin(), producers.end(), isMayaProducerSceneIndex);
     auto mayaSi = TfDynamic_cast<PXR_NS::MayaHydraSceneIndexRefPtr>(*found);
     auto mayaPath = Ufe::PathString::path("|aSphere");
-    auto primSelections = mayaSi->ConvertUfeSelectionToHydra(mayaPath);
+    auto primSelections = mayaSi->ConvertUfePathToHydraSelections(mayaPath);
     ASSERT_EQ(primSelections.size(), 1u);
 
     // With Maya scene index in the merging scene index, the sphere prim has
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
index 439942bffd..7d624705db 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
@@ -38,7 +38,7 @@ SdfPath getArgSceneIndexPath(const Fvp::SelectionSceneIndexRefPtr& snSi)
     const auto mayaPath = Ufe::PathString::path(argv[0]);
 
     // Translate the application path into a scene index path.
-    auto primSelections = snSi->ConvertUfeSelectionToHydra(mayaPath);
+    auto primSelections = snSi->ConvertUfePathToHydraSelections(mayaPath);
     return primSelections.empty() ? SdfPath() : primSelections.front().primPath;
 }
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index 9c721ed6a1..37416aabcf 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -168,7 +168,7 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     auto testInstancerDirectHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
         ufeSelection->replaceWith(instancerItem);
 
-        auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(instancerPath);
+        auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(instancerPath);
         ASSERT_EQ(instancerHydraSelections.size(), 1u);
         auto instancerPrimPath = instancerHydraSelections.front().primPath;
     
@@ -187,7 +187,7 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     // Select point instancer ancestors
     auto testInstancerIndirectHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
         // This is not an actual selection, we use it to get the Hydra path
-        auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(instancerPath);
+        auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(instancerPath);
         ASSERT_EQ(instancerHydraSelections.size(), 1u);
     
         ASSERT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
@@ -195,7 +195,7 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     };
     auto testInstancerNoHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
         // This is not an actual selection, we use it to get the Hydra path
-        auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(instancerPath);
+        auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(instancerPath);
         ASSERT_EQ(instancerHydraSelections.size(), 1u);
     
         HdSceneIndexPrim selectionHighlightMirrorPrim = inspector.GetSceneIndex()->GetPrim(
@@ -260,7 +260,7 @@ TEST(PointInstancingWireframeHighlight, instance)
     auto testInstanceHighlightFn = [&](const Ufe::SceneItem::Ptr& instanceItem, const Ufe::Path& instancePath) -> void {
         ufeSelection->replaceWith(instanceItem);
 
-        auto instanceHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(instancePath);
+        auto instanceHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(instancePath);
         ASSERT_EQ(instanceHydraSelections.size(), 1u);
         auto instancerPrimPath = instanceHydraSelections.front().primPath;
 
@@ -325,7 +325,7 @@ TEST(PointInstancingWireframeHighlight, prototype)
     auto testPrototypeHighlightFn = [&](const Ufe::SceneItem::Ptr& prototypeItem, const Ufe::Path& prototypePath) -> void {
         ufeSelection->replaceWith(prototypeItem);
 
-        auto prototypeHydraSelections = fvpMergingSceneIndex->ConvertUfeSelectionToHydra(prototypePath);
+        auto prototypeHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(prototypePath);
         // Original prim + 4 propagated prototypes
         ASSERT_EQ(prototypeHydraSelections.size(), 1u + 4u);
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
index 8799029af1..384cf6daff 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
@@ -61,7 +61,7 @@ TEST(FlowViewport, selectionSceneIndex)
 
     // The sphere prim in the Hydra scene index scene has no selection data
     // source.  First, translate the application path into a scene index path.
-    const auto sceneIndexPath = selectionSi->ConvertUfeSelectionToHydra(mayaPath).front().primPath;
+    const auto sceneIndexPath = selectionSi->ConvertUfePathToHydraSelections(mayaPath).front().primPath;
     ASSERT_EQ(sceneIndexPath.GetName(), mayaPath.back().string());
 
     // Next, check that there is no selections data source on the prim.
@@ -104,7 +104,7 @@ TEST(FlowViewport, selectionSceneIndex)
     // The shape under the sphere transform is not selected, but it has a
     // selected ancestor.
     auto mayaShapePath = Ufe::PathString::path("|aSphere|aSphereShape");
-    const auto sceneIndexShapePath = selectionSi->ConvertUfeSelectionToHydra(mayaShapePath).front().primPath;
+    const auto sceneIndexShapePath = selectionSi->ConvertUfePathToHydraSelections(mayaShapePath).front().primPath;
 
     auto sphereShapePrim = sceneIndices.front()->GetPrim(sceneIndexShapePath);
     ASSERT_TRUE(sphereShapePrim.dataSource);
@@ -153,7 +153,7 @@ TEST(FlowViewport, selectionSceneIndexDirty)
     MSelectionList sphereSn;
     sphereSn.add("|aSphere");
     const auto mayaPath = Ufe::PathString::path("|aSphere");
-    const auto primSelections = selectionSi->ConvertUfeSelectionToHydra(mayaPath);
+    const auto primSelections = selectionSi->ConvertUfePathToHydraSelections(mayaPath);
     ASSERT_EQ(primSelections.size(), 1u);
     const auto sceneIndexPath = primSelections.front().primPath;
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
index 59819bd923..d47463cadf 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
@@ -27,7 +27,7 @@ TEST(TestUsdAnim, timeVaryingTransform)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto primSelections = snSi->ConvertUfeSelectionToHydra(cubePath);
+    const auto primSelections = snSi->ConvertUfePathToHydraSelections(cubePath);
     ASSERT_EQ(primSelections.size(), 1u);
     const auto cubeSiPath = primSelections.front().primPath;
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
index 7d3af32000..0673bf925a 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
@@ -53,7 +53,7 @@ TEST(TestUsdPicking, pick)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto primSelections = snSi->ConvertUfeSelectionToHydra(selected);
+    const auto primSelections = snSi->ConvertUfePathToHydraSelections(selected);
     ASSERT_EQ(primSelections.size(), 1u);
     const auto sceneIndexPath = primSelections.front().primPath;
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
index 2494a4a9b1..4fbe5da726 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
@@ -51,7 +51,7 @@ TEST(TestUsdPointInstancePicking, pickPointInstance)
     const auto selectionSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(selectionSi);
 
-    const auto primSelections = selectionSi->ConvertUfeSelectionToHydra(marker);
+    const auto primSelections = selectionSi->ConvertUfePathToHydraSelections(marker);
     ASSERT_EQ(primSelections.size(), 1u);
     const auto sceneIndexPath = primSelections.front().primPath;
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
index 3d442fc48c..2c185358d9 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
@@ -161,10 +161,10 @@ TEST(FlowViewport, wireframeSelectionHighlightSceneIndexDirty)
     sn->append(sphereItem);
 
     // Find the sphere in the Hydra scene index scene.
-    auto sphereSelections = mergingSi->ConvertUfeSelectionToHydra(spherePath);
+    auto sphereSelections = mergingSi->ConvertUfePathToHydraSelections(spherePath);
     ASSERT_EQ(sphereSelections.size(), 1u);
     auto sphereSiPath = sphereSelections.front().primPath;
-    auto cubeSelections = mergingSi->ConvertUfeSelectionToHydra(scParentPath + "cube");
+    auto cubeSelections = mergingSi->ConvertUfePathToHydraSelections(scParentPath + "cube");
     ASSERT_EQ(cubeSelections.size(), 1u);
     auto cubeSiPath = cubeSelections.front().primPath;
 
@@ -195,13 +195,13 @@ TEST(FlowViewport, wireframeSelectionHighlightSceneIndexDirty)
 
     sn->replaceWith(newSn);
 
-    auto ccSelections = mergingSi->ConvertUfeSelectionToHydra(ccParentPath);
+    auto ccSelections = mergingSi->ConvertUfePathToHydraSelections(ccParentPath);
     ASSERT_EQ(ccSelections.size(), 1u);
     auto ccSiPath = ccSelections.front().primPath;
-    auto coneSelections = mergingSi->ConvertUfeSelectionToHydra(ccParentPath + "cone");
+    auto coneSelections = mergingSi->ConvertUfePathToHydraSelections(ccParentPath + "cone");
     ASSERT_EQ(coneSelections.size(), 1u);
     auto coneSiPath = coneSelections.front().primPath;
-    auto cylinderSelections = mergingSi->ConvertUfeSelectionToHydra(ccParentPath + "cylinder");
+    auto cylinderSelections = mergingSi->ConvertUfePathToHydraSelections(ccParentPath + "cylinder");
     ASSERT_EQ(cylinderSelections.size(), 1u);
     auto cylinderSiPath = cylinderSelections.front().primPath;
 

From 40849dd8185d903b08de57b48c7586190dc3cbf8 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 15:07:58 -0400
Subject: [PATCH 066/112] Add comment on FindFullySelectedAncestorsInclusive

---
 lib/flowViewport/selection/fvpSelection.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/lib/flowViewport/selection/fvpSelection.h b/lib/flowViewport/selection/fvpSelection.h
index 6c2dd735dc..55dcd1c700 100644
--- a/lib/flowViewport/selection/fvpSelection.h
+++ b/lib/flowViewport/selection/fvpSelection.h
@@ -76,6 +76,10 @@ class Selection
     FVP_API
     bool HasFullySelectedAncestorInclusive(const PXR_NS::SdfPath& primPath, const PXR_NS::SdfPath& topmostAncestor = PXR_NS::SdfPath::AbsoluteRootPath()) const;
 
+    // Returns the paths to all fully selected ancestors of the prim up to the specified
+    // topmost ancestor. If the prim is itself selected, its path will also be returned.
+    // By default, the topmost ancestor is set to the absolute root path, so that all 
+    // ancestors are considered.
     FVP_API
     PXR_NS::SdfPathVector FindFullySelectedAncestorsInclusive(const PXR_NS::SdfPath& primPath, const PXR_NS::SdfPath& topmostAncestor = PXR_NS::SdfPath::AbsoluteRootPath()) const;
 

From b8f9484a583fe840a8b9e2b2dee292e687950448 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 15:09:44 -0400
Subject: [PATCH 067/112] Remove no longer used code

---
 lib/flowViewport/selection/fvpSelection.cpp | 21 ---------------------
 1 file changed, 21 deletions(-)

diff --git a/lib/flowViewport/selection/fvpSelection.cpp b/lib/flowViewport/selection/fvpSelection.cpp
index 32a9206e50..e80f2e8b76 100644
--- a/lib/flowViewport/selection/fvpSelection.cpp
+++ b/lib/flowViewport/selection/fvpSelection.cpp
@@ -44,27 +44,6 @@
 
 PXR_NAMESPACE_USING_DIRECTIVE
 
-namespace {
-
-using namespace Fvp;
-
-class SelectionSchemaFullySelectedBuilder {
-public:
-    SelectionSchemaFullySelectedBuilder() {
-        _builder.SetFullySelected(
-            HdRetainedTypedSampledDataSource<bool>::New(true));
-    }
-
-    HdContainerDataSourceHandle Build() { return _builder.Build(); }
-
-private:
-    HdSelectionSchema::Builder _builder;
-};
-
-SelectionSchemaFullySelectedBuilder selectionBuilder;
-
-}
-
 namespace FVP_NS_DEF {
 
 HdDataSourceBaseHandle 

From 59b5949e4447954a1fa4b2ae8d74bf4c4681a091 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 15:15:09 -0400
Subject: [PATCH 068/112] Accumulate selection dirtied notifs

---
 .../sceneIndex/fvpSelectionSceneIndex.cpp          | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
index a659431823..6c290fd861 100644
--- a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
@@ -43,6 +43,7 @@
 #include "flowViewport/debugCodes.h"
 
 #include "pxr/imaging/hd/retainedDataSource.h"
+#include <pxr/imaging/hd/sceneIndexObserver.h>
 #include "pxr/imaging/hd/selectionSchema.h"
 #include "pxr/imaging/hd/selectionsSchema.h"
 
@@ -154,7 +155,7 @@ SelectionSceneIndex::AddSelection(const Ufe::Path& appPath)
     TF_DEBUG(FVP_SELECTION_SCENE_INDEX)
         .Msg("SelectionSceneIndex::AddSelection(const Ufe::Path& %s) called.\n", Ufe::PathString::string(appPath).c_str());
 
-    // Call our input scene index to convert the application path to scene index paths.
+    // Call our input scene index to convert the application path to scene index paths and selection data sources.
     auto primSelections = ConvertUfePathToHydraSelections(appPath);
 
     for (const auto& primSelection : primSelections) {
@@ -162,11 +163,13 @@ SelectionSceneIndex::AddSelection(const Ufe::Path& appPath)
             .Msg("    Adding %s to the Hydra selection.\n", primSelection.primPath.GetText());
     }
 
+    HdSceneIndexObserver::DirtiedPrimEntries dirtiedPrims;
     for (const auto& primSelection : primSelections) {
         if (_selection->Add(primSelection)) {
-            _SendPrimsDirtied({{primSelection.primPath, selectionsSchemaDefaultLocator}});
+            dirtiedPrims.emplace_back(primSelection.primPath, selectionsSchemaDefaultLocator);
         }
     }
+    _SendPrimsDirtied(dirtiedPrims);
 }
 
 void SelectionSceneIndex::RemoveSelection(const Ufe::Path& appPath)
@@ -174,15 +177,16 @@ void SelectionSceneIndex::RemoveSelection(const Ufe::Path& appPath)
     TF_DEBUG(FVP_SELECTION_SCENE_INDEX)
         .Msg("SelectionSceneIndex::RemoveSelection(const Ufe::Path& %s) called.\n", Ufe::PathString::string(appPath).c_str());
 
-    // Call our input scene index to convert the application path to a scene
-    // index path.
+    // Call our input scene index to convert the application path to scene index paths and selection data sources.
     auto primSelections = ConvertUfePathToHydraSelections(appPath);
 
+    HdSceneIndexObserver::DirtiedPrimEntries dirtiedPrims;
     for (const auto& primSelection : primSelections) {
         if (_selection->Remove(primSelection.primPath)) {
-            _SendPrimsDirtied({{primSelection.primPath, selectionsSchemaDefaultLocator}});
+            dirtiedPrims.emplace_back(primSelection.primPath, selectionsSchemaDefaultLocator);
         }
     }
+    _SendPrimsDirtied(dirtiedPrims);
 }
 
 void

From e39560615a2d227ccf4be9c1febd55dcd3801f5c Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 15:43:48 -0400
Subject: [PATCH 069/112] Allow multiple prim paths for the lead UFE object

---
 .../mhLeadObjectPathTracker.cpp               | 49 ++++++++++++-------
 .../hydraExtensions/mhLeadObjectPathTracker.h |  6 +--
 .../mhWireframeColorInterfaceImp.cpp          |  2 +-
 .../mhDirtyLeadObjectSceneIndex.cpp           | 11 +++--
 .../sceneIndex/mhDirtyLeadObjectSceneIndex.h  |  3 +-
 lib/mayaHydra/mayaPlugin/renderOverride.cpp   |  2 +-
 6 files changed, 45 insertions(+), 28 deletions(-)

diff --git a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
index 472d40ced3..cfbb912bcc 100644
--- a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
+++ b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
@@ -22,6 +22,9 @@
 #include <flowViewport/colorPreferences/fvpColorPreferencesTokens.h>
 #include <flowViewport/selection/fvpSelection.h>
 
+//Pixar headers
+#include <pxr/usd/sdf/path.h>
+
 //ufe
 #include <ufe/globalSelection.h>
 #include <ufe/observableSelection.h>
@@ -65,6 +68,15 @@ class GlobalSelectionChangedObs : public Ufe::Observer
             MayaHydra::MhLeadObjectPathTracker& _leadObjectPathTracker;
     };
 
+void pushHydraSelectionsToPathVector(const Fvp::PrimSelectionInfoVector& hydraSelections, SdfPathVector& outPathVector)
+{
+    for (const auto& hydraSelection : hydraSelections) {
+        if (!hydraSelection.primPath.IsEmpty()) {
+            outPathVector.push_back(hydraSelection.primPath);
+        }
+    }
+}
+
 }
 namespace MAYAHYDRA_NS_DEF {
 
@@ -81,11 +93,10 @@ MhLeadObjectPathTracker::MhLeadObjectPathTracker(const HdSceneIndexBaseRefPtr& s
         const Ufe::Selection& selection = *(ufeSelection);
         auto leadObjectSceneItem = selection.back();//get last selected
         _leadObjectUfePath = leadObjectSceneItem->path();
-        //_leadObjectPrimPath can be empty with a valid _leadObjectUfePath when the lead object is in a data producer scene index not yet added to the merging scene index
-        //This is fixed at some point by calling updatePrimPath()
-        // TODO : Handle multiple lead prim paths
+        //_leadObjectPrimPaths can be empty with a valid _leadObjectUfePath when the lead object is in a data producer scene index not yet added to the merging scene index
+        //This is fixed at some point by calling updatePrimPaths()
         auto hydraSelections = _pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath);
-        _leadObjectPrimPath = hydraSelections.empty() ? SdfPath() : hydraSelections.front().primPath;
+        pushHydraSelectionsToPathVector(hydraSelections, _leadObjectPrimPaths);
     }
 
    // Add ourself as an observer to the selection
@@ -99,11 +110,16 @@ MhLeadObjectPathTracker::~MhLeadObjectPathTracker()
     _ufeSelectionObserver = nullptr;
 }
 
-bool MhLeadObjectPathTracker::isLeadObject(const PXR_NS::SdfPath& primPath) const
+bool MhLeadObjectPathTracker::isLeadPrim(const PXR_NS::SdfPath& primPath) const
 {
-    //_leadObjectPrimPath can be a hierarchy path, so we need to check if the primPath is a prefix
-    //of the lead object prim path
-    return primPath.HasPrefix(_leadObjectPrimPath);
+    //_leadObjectPrimPaths can be hierarchy paths, so we need to check if the primPath is a prefix
+    //of a lead object prim path
+    for (const auto& leadObjectPrimPath : _leadObjectPrimPaths) {
+        if (primPath.HasPrefix(leadObjectPrimPath)) {
+            return true;
+        }
+    }
+    return false;
 }
 
 void MhLeadObjectPathTracker::setLeadObjectUfePath(const Ufe::Path& newLeadObjectUfePath)
@@ -113,26 +129,25 @@ void MhLeadObjectPathTracker::setLeadObjectUfePath(const Ufe::Path& newLeadObjec
        return;
     }
     
-    auto oldLeadObjectPrimPath = _leadObjectPrimPath;
+    auto oldLeadObjectPrimPaths = _leadObjectPrimPaths;
 
     _leadObjectUfePath  = newLeadObjectUfePath;
-    // TODO : Handle multiple lead prim paths
     auto hydraSelections = _pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath);
-    _leadObjectPrimPath = hydraSelections.empty() ? SdfPath() : hydraSelections.front().primPath;
+    _leadObjectPrimPaths.clear();
+    pushHydraSelectionsToPathVector(hydraSelections, _leadObjectPrimPaths);
 
     // Dirty the previous lead object
     if(_dirtyLeadObjectSceneIndex){
-        _dirtyLeadObjectSceneIndex->dirtyLeadObjectRelatedPrims(oldLeadObjectPrimPath, _leadObjectPrimPath);
+        _dirtyLeadObjectSceneIndex->dirtyLeadObjectRelatedPrims(oldLeadObjectPrimPaths, _leadObjectPrimPaths);
     }
 }
 
-void MhLeadObjectPathTracker::updatePrimPath() 
+void MhLeadObjectPathTracker::updatePrimPaths() 
 { 
-   // Update the lead object prim path in case it was not valid yet
-    if ( (_leadObjectUfePath.size() > 0) && _leadObjectPrimPath.IsEmpty()) {
-        // TODO : Handle multiple lead prim paths
+   // Update the lead object prim paths in case it was not valid yet
+    if ( (_leadObjectUfePath.size() > 0) && _leadObjectPrimPaths.empty()) {
         auto hydraSelections = _pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath);
-        _leadObjectPrimPath = hydraSelections.empty() ? SdfPath() : hydraSelections.front().primPath;
+        pushHydraSelectionsToPathVector(hydraSelections, _leadObjectPrimPaths);
     }
 }
 
diff --git a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.h b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.h
index 28e9e48b7f..d49c1a023d 100644
--- a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.h
+++ b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.h
@@ -47,7 +47,7 @@ class MhLeadObjectPathTracker
     ~MhLeadObjectPathTracker();
 
     MAYAHYDRALIB_API
-    bool isLeadObject(const PXR_NS::SdfPath& primPath) const;
+    bool isLeadPrim(const PXR_NS::SdfPath& primPath) const;
     
     MAYAHYDRALIB_API
     Ufe::Path getLeadObjectUfePath() const {return _leadObjectUfePath;}
@@ -56,11 +56,11 @@ class MhLeadObjectPathTracker
     void setLeadObjectUfePath(const Ufe::Path& newLeadObjectUfePath);
 
     MAYAHYDRALIB_API
-    void updatePrimPath(); // For example : this is called after the data producer scene indices are loaded
+    void updatePrimPaths(); // For example : this is called after the data producer scene indices are loaded
 
 private:
     const Fvp::PathInterface* const _pathInterface {nullptr};
-    PXR_NS::SdfPath                 _leadObjectPrimPath;
+    PXR_NS::SdfPathVector           _leadObjectPrimPaths;
     Ufe::Observer::Ptr              _ufeSelectionObserver {nullptr};
     Ufe::Path                       _leadObjectUfePath;
     const MhDirtyLeadObjectSceneIndexRefPtr _dirtyLeadObjectSceneIndex;
diff --git a/lib/mayaHydra/hydraExtensions/mhWireframeColorInterfaceImp.cpp b/lib/mayaHydra/hydraExtensions/mhWireframeColorInterfaceImp.cpp
index 68473bf23a..2526d2afe1 100644
--- a/lib/mayaHydra/hydraExtensions/mhWireframeColorInterfaceImp.cpp
+++ b/lib/mayaHydra/hydraExtensions/mhWireframeColorInterfaceImp.cpp
@@ -53,7 +53,7 @@ MhWireframeColorInterfaceImp::MhWireframeColorInterfaceImp(const std::shared_ptr
 MhWireframeColorInterfaceImp::SelectionState MhWireframeColorInterfaceImp::_getSelectionState(const PXR_NS::SdfPath& primPath)const
 {
     if (_selection->HasFullySelectedAncestorInclusive(primPath)){
-        return (_leadObjectPathTracker->isLeadObject(primPath)) ? kLead : kActive;
+        return (_leadObjectPathTracker->isLeadPrim(primPath)) ? kLead : kActive;
     }
     
     return kDormant;
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.cpp
index ec98572adc..3dfa350f10 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.cpp
@@ -20,6 +20,7 @@
 // Hydra headers
 #include <pxr/imaging/hd/tokens.h>
 #include <pxr/imaging/hd/primvarsSchema.h>
+#include <pxr/usd/sdf/path.h>
 
 PXR_NAMESPACE_USING_DIRECTIVE
 
@@ -40,15 +41,15 @@ namespace {
                                                          };
 }
 
-void MhDirtyLeadObjectSceneIndex::dirtyLeadObjectRelatedPrims(const SdfPath& previousLeadObjectPath, const SdfPath& currentLeadObjectPath)
+void MhDirtyLeadObjectSceneIndex::dirtyLeadObjectRelatedPrims(const SdfPathVector& previousLeadObjectPrimPaths, const SdfPathVector& currentLeadObjectPrimPaths)
 {
     // Each SdfPath could be a hierarchy path, so we need to get the children prim paths
     HdSceneIndexObserver::DirtiedPrimEntries dirtiedPrimEntries;
-    if (! previousLeadObjectPath.IsEmpty()) {
-        _AddDirtyPathRecursively(previousLeadObjectPath, dirtiedPrimEntries);
+    for (const auto& previousLeadObjectPrimPath : previousLeadObjectPrimPaths) {
+        _AddDirtyPathRecursively(previousLeadObjectPrimPath, dirtiedPrimEntries);
     }
-    if (!currentLeadObjectPath.IsEmpty()) {
-        _AddDirtyPathRecursively(currentLeadObjectPath, dirtiedPrimEntries);
+    for (const auto& currentLeadObjectPrimPath : currentLeadObjectPrimPaths) {
+        _AddDirtyPathRecursively(currentLeadObjectPrimPath, dirtiedPrimEntries);
     }
 
     if (! dirtiedPrimEntries.empty()){
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.h b/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.h
index 9ac549ace7..67580b121a 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.h
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.h
@@ -25,6 +25,7 @@
 
 //Usd/Hydra headers
 #include <pxr/imaging/hd/filteringSceneIndex.h>
+#include <pxr/usd/sdf/path.h>
 
 
 namespace MAYAHYDRA_NS_DEF {
@@ -60,7 +61,7 @@ class MhDirtyLeadObjectSceneIndex : public PXR_NS::HdSingleInputFilteringSceneIn
     ~MhDirtyLeadObjectSceneIndex() override = default;
 
     MAYAHYDRALIB_API
-    void dirtyLeadObjectRelatedPrims(const PXR_NS::SdfPath& previousLeadObjectPath, const PXR_NS::SdfPath& currentLeadObjectPath);
+    void dirtyLeadObjectRelatedPrims(const PXR_NS::SdfPathVector& previousLeadObjectPrimPaths, const PXR_NS::SdfPathVector& currentLeadObjectPrimPaths);
 
 protected:
     
diff --git a/lib/mayaHydra/mayaPlugin/renderOverride.cpp b/lib/mayaHydra/mayaPlugin/renderOverride.cpp
index f0454fa268..144916ac48 100644
--- a/lib/mayaHydra/mayaPlugin/renderOverride.cpp
+++ b/lib/mayaHydra/mayaPlugin/renderOverride.cpp
@@ -1041,7 +1041,7 @@ MStatus MtohRenderOverride::Render(
             }
             //Update the leadObjectTacker in case it could not find the current lead object which could be in a custom data producer scene index or a maya usd proxy shape scene index
             if (_leadObjectPathTracker){
-                _leadObjectPathTracker->updatePrimPath();
+                _leadObjectPathTracker->updatePrimPaths();
             }
         }
     }

From 174c6a9e8cfb4edb4d2eab852282ecc115d73f04 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 15:44:56 -0400
Subject: [PATCH 070/112] Revert data producer example

---
 .../fvpDataProducerSceneIndexExample.cpp      | 35 ++++---------------
 1 file changed, 7 insertions(+), 28 deletions(-)

diff --git a/lib/flowViewport/API/samples/fvpDataProducerSceneIndexExample.cpp b/lib/flowViewport/API/samples/fvpDataProducerSceneIndexExample.cpp
index a87f377096..56a0e22eec 100644
--- a/lib/flowViewport/API/samples/fvpDataProducerSceneIndexExample.cpp
+++ b/lib/flowViewport/API/samples/fvpDataProducerSceneIndexExample.cpp
@@ -21,10 +21,6 @@
 
 //Local headers
 #include "fvpDataProducerSceneIndexExample.h"
-#include <pxr/base/gf/matrix4d.h>
-#include <pxr/base/gf/vec3d.h>
-#include <pxr/base/gf/vec3f.h>
-#include <pxr/usd/sdf/path.h>
 
 #ifdef CODE_COVERAGE_WORKAROUND
 #include <flowViewport/fvpUtils.h>
@@ -227,26 +223,13 @@ void DataProducerSceneIndexExample::_AddAllPrims()
 void DataProducerSceneIndexExample::_AddAllPrimsWithInstancing()
 {
     static const bool instancing = true;
-    GfMatrix4d instanceeTransform;
-    instanceeTransform.SetTranslate(GfVec3d(1.67, 1.67, 1.67));
+
     //Copy the main cube primitive in the array, we will update only the SdfPath and the transform, all others attributes are identical
-    SdfPath cubePath = _cubeRootPath.AppendElementString("_mesh");
-    HdRetainedSceneIndex::AddedPrimEntry cubePrimEntry = _CreateCubePrim(cubePath, _currentCubeGridParams._halfSize, 
+    HdRetainedSceneIndex::AddedPrimEntry cubePrimEntry = _CreateCubePrim(_cubeRootPath, _currentCubeGridParams._halfSize, 
                                                                         _currentCubeGridParams._color, _currentCubeGridParams._opacity, 
-                                                                        instanceeTransform, instancing);
-    const HdDataSourceBaseHandle cubeRootInstancedByData =
-            HdInstancedBySchema::Builder()
-            .SetPaths(HdRetainedTypedSampledDataSource<VtArray<SdfPath>>::New(VtArray<SdfPath>({ _instancerPath })))
-            .SetPrototypeRoots(HdRetainedTypedSampledDataSource<VtArray<SdfPath>>::New(VtArray<SdfPath>({ _cubeRootPath })))
-            .Build();
-    HdRetainedSceneIndex::AddedPrimEntry cubeRoot;
-    cubeRoot.primPath = _cubeRootPath;
-    cubeRoot.dataSource = HdRetainedContainerDataSource::New(
-        HdInstancedBySchema::GetSchemaToken(), cubeRootInstancedByData
-    );
+                                                                        _currentCubeGridParams._initalTransform, instancing);
 
     //Add the cube to the retained scene index
-    _retainedSceneIndex->AddPrims({cubeRoot});
     _retainedSceneIndex->AddPrims({cubePrimEntry});
 
     const size_t totalSize = _currentCubeGridParams._numLevelsX * _currentCubeGridParams._numLevelsY * _currentCubeGridParams._numLevelsZ;
@@ -275,7 +258,7 @@ void DataProducerSceneIndexExample::_AddAllPrimsWithInstancing()
                         prototypeIndices[index] = index;
 
                         //Update translation
-                        matrices[index].SetTranslate(initTrans + (GfCompMult(_currentCubeGridParams._deltaTrans, GfVec3f(x + 2,y + 2,z + 2))));
+                        matrices[index].SetTranslate(initTrans + (GfCompMult(_currentCubeGridParams._deltaTrans, GfVec3f(x,y,z))));
 					}
 				}
 			}
@@ -284,9 +267,6 @@ void DataProducerSceneIndexExample::_AddAllPrimsWithInstancing()
 
     //Add new prims to the scene index
     PrototypeInstancing::createInstancer(_instancerPath, _cubeRootPath, prototypeIndices, matrices, _retainedSceneIndex);
-    //SdfPath cubePath = _instancerPath.AppendElementString("MyCube");
-    //auto cube = _CreateCubePrim(cubePath, 2, GfVec3f(1, 0, 0), 1.0, GfMatrix4d(1), false);
-    //_retainedSceneIndex->AddPrims({cube});
 }
 
 void DataProducerSceneIndexExample::_AddAllPrimsNoInstancing()
@@ -514,10 +494,9 @@ HdRetainedSceneIndex::AddedPrimEntry DataProducerSceneIndexExample::_CreateCubeP
     addedPrim.primType      = HdPrimTypeTokens->mesh;
     if (instanced){
 
-        const HdDataSourceBaseHandle cubeInstancedByData =
+        const HdDataSourceBaseHandle instancedByData =
             HdInstancedBySchema::Builder()
             .SetPaths(HdRetainedTypedSampledDataSource<VtArray<SdfPath>>::New(VtArray<SdfPath>({ _instancerPath })))
-            .SetPrototypeRoots(HdRetainedTypedSampledDataSource<VtArray<SdfPath>>::New(VtArray<SdfPath>({ _cubeRootPath })))
             .Build();
 
         addedPrim.dataSource = HdRetainedContainerDataSource::New(
@@ -544,8 +523,8 @@ HdRetainedSceneIndex::AddedPrimEntry DataProducerSceneIndexExample::_CreateCubeP
                         HdPrimvarsSchemaTokens->primvars,
                         primvarsDs,
 
-                        HdInstancedBySchema::GetSchemaToken(),
-                        cubeInstancedByData
+                        HdInstancedBySchema::GetSchemaToken(), //Add the instancer path in the HdInstancedBySchema
+                        instancedByData
                     );
     }else{
 

From fb90a6af37763ccf001a61b97a27fd833d1f4948 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 16:09:17 -0400
Subject: [PATCH 071/112] Various cleanups

---
 lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp      | 1 -
 lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp    | 6 +-----
 lib/flowViewport/selection/fvpSelection.cpp               | 2 --
 test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp | 4 ++--
 .../render/mayaToHydra/cpp/testMergingSceneIndex.cpp      | 7 ++++---
 .../mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp  | 1 +
 .../render/mayaToHydra/cpp/testSelectionSceneIndex.cpp    | 8 ++++++--
 7 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
index ea9df0d028..55ff3f67a9 100644
--- a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
@@ -14,7 +14,6 @@
 //
 
 #include "flowViewport/sceneIndex/fvpMergingSceneIndex.h"
-#include "flowViewport/sceneIndex/fvpPathInterface.h"
 
 #include "flowViewport/debugCodes.h"
 
diff --git a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
index 6c290fd861..b7dbbdf18e 100644
--- a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
@@ -229,12 +229,8 @@ void SelectionSceneIndex::ReplaceSelection(const Ufe::Selection& selection)
     _selection->Clear();
 
     PrimSelectionInfoVector sceneIndexSn;
-    // This .reserve() call is mostly a heuristic : the ConvertUfePathToHydraSelections API allows one UFE path
-    // to map to any number of SdfPaths (0 to infinity). However, in most cases, it is likely to map to 
-    // one SdfPath, so we reserve space accordingly. (2024/05/27)
-    sceneIndexSn.reserve(selection.size());
     for (const auto& snItem : selection) {
-        // Call our input scene index to convert the application path to scene index paths.
+        // Call our input scene index to convert the application path to scene index paths and selection data sources.
         auto primSelections = ConvertUfePathToHydraSelections(snItem->path());
 
         if (primSelections.empty()) {
diff --git a/lib/flowViewport/selection/fvpSelection.cpp b/lib/flowViewport/selection/fvpSelection.cpp
index e80f2e8b76..312871c127 100644
--- a/lib/flowViewport/selection/fvpSelection.cpp
+++ b/lib/flowViewport/selection/fvpSelection.cpp
@@ -37,9 +37,7 @@
 //
 
 #include "flowViewport/selection/fvpSelection.h"
-#include "flowViewport/sceneIndex/fvpPathInterface.h"
 
-#include "pxr/imaging/hd/selectionSchema.h"
 #include "pxr/imaging/hd/selectionsSchema.h"
 
 PXR_NAMESPACE_USING_DIRECTIVE
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
index 13a5d0471e..93c4a90f8b 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
@@ -40,7 +40,7 @@ TEST(TestHydraPrim, fromAppPath)
     ASSERT_TRUE(snSi);
 
     const auto primSelections = snSi->ConvertUfePathToHydraSelections(appPath);
-
     ASSERT_EQ(primSelections.size(), 1u);
-    ASSERT_FALSE(primSelections.front().primPath.IsEmpty());
+    const auto sceneIndexPath = primSelections.front().primPath;
+    ASSERT_FALSE(sceneIndexPath.IsEmpty());
 }
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
index 00b30e2bfc..250e3c842e 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
@@ -71,10 +71,11 @@ TEST(FlowViewport, mergingSceneIndex)
     // to translate the application path into a scene index path.
     auto primSelections = mayaSi->ConvertUfePathToHydraSelections(mayaPath);
     ASSERT_EQ(primSelections.size(), 1u);
+    auto sceneIndexPath = primSelections.front().primPath;
 
     // Regardless of prefix, the scene index path tail component will match the
     // Maya node name
-    ASSERT_EQ(primSelections.front().primPath.GetName(), mayaPath.back().string());
+    ASSERT_EQ(sceneIndexPath.GetName(), mayaPath.back().string());
 
     // If we ask the terminal scene index for a prim at that path, there must be
     // one.  Prims that exist have a non-null data source.
@@ -82,14 +83,14 @@ TEST(FlowViewport, mergingSceneIndex)
     auto nonExistentPrim = sceneIndices.front()->GetPrim(nonExistentPrimPath);
     ASSERT_FALSE(nonExistentPrim.dataSource);
     
-    auto spherePrim = sceneIndices.front()->GetPrim(primSelections.front().primPath);
+    auto spherePrim = sceneIndices.front()->GetPrim(sceneIndexPath);
     ASSERT_TRUE(spherePrim.dataSource);
 
     // Flow Viewport merging scene index must give the same scene index path
     // answer as the Maya data producer scene index.
     auto mergingSiSelections = mergingSi->ConvertUfePathToHydraSelections(mayaPath);
     ASSERT_EQ(mergingSiSelections.size(), 1u);
-    ASSERT_EQ(mergingSiSelections.front().primPath, primSelections.front().primPath);
+    ASSERT_EQ(mergingSiSelections.front().primPath, sceneIndexPath);
 }
 
 TEST(FlowViewport, mergingSceneIndexAddRemove)
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
index 7d624705db..c66082f82c 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
@@ -39,6 +39,7 @@ SdfPath getArgSceneIndexPath(const Fvp::SelectionSceneIndexRefPtr& snSi)
 
     // Translate the application path into a scene index path.
     auto primSelections = snSi->ConvertUfePathToHydraSelections(mayaPath);
+    EXPECT_GE(primSelections.size(), 1u);
     return primSelections.empty() ? SdfPath() : primSelections.front().primPath;
 }
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
index 384cf6daff..7790c2cd36 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
@@ -61,7 +61,9 @@ TEST(FlowViewport, selectionSceneIndex)
 
     // The sphere prim in the Hydra scene index scene has no selection data
     // source.  First, translate the application path into a scene index path.
-    const auto sceneIndexPath = selectionSi->ConvertUfePathToHydraSelections(mayaPath).front().primPath;
+    const auto primSelections = selectionSi->ConvertUfePathToHydraSelections(mayaPath);
+    ASSERT_EQ(primSelections.size(), 1u);
+    const auto sceneIndexPath = primSelections.front().primPath;
     ASSERT_EQ(sceneIndexPath.GetName(), mayaPath.back().string());
 
     // Next, check that there is no selections data source on the prim.
@@ -104,7 +106,9 @@ TEST(FlowViewport, selectionSceneIndex)
     // The shape under the sphere transform is not selected, but it has a
     // selected ancestor.
     auto mayaShapePath = Ufe::PathString::path("|aSphere|aSphereShape");
-    const auto sceneIndexShapePath = selectionSi->ConvertUfePathToHydraSelections(mayaShapePath).front().primPath;
+    const auto shapePrimSelections = selectionSi->ConvertUfePathToHydraSelections(mayaShapePath);
+    ASSERT_EQ(shapePrimSelections.size(), 1u);
+    const auto sceneIndexShapePath = shapePrimSelections.front().primPath;
 
     auto sphereShapePrim = sceneIndices.front()->GetPrim(sceneIndexShapePath);
     ASSERT_TRUE(sphereShapePrim.dataSource);

From cae452fd833488422753f8d1a94d31219ac6920e Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 16:27:56 -0400
Subject: [PATCH 072/112] Clean wireframe scene index header

---
 ...fvpWireframeSelectionHighlightSceneIndex.h | 31 +++++++++++++++----
 1 file changed, 25 insertions(+), 6 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 9fc0ccc3b9..4a93728d3d 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -24,7 +24,6 @@
 #include <pxr/imaging/hd/filteringSceneIndex.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
 #include <pxr/imaging/hd/sceneIndex.h>
-#include <pxr/usdImaging/usdImaging/rerootingSceneIndex.h>
 #include <pxr/usd/sdf/path.h>
 
 #include <functional>
@@ -76,6 +75,8 @@ class WireframeSelectionHighlightSceneIndex
     FVP_API
     void addExcludedSceneRoot(const PXR_NS::SdfPath& sceneRoot);
 
+    // Returns the corresponding selection highlight mirror path, if one exists.
+    // Otherwise, returns the given path as-is.
     FVP_API
     PXR_NS::SdfPath GetSelectionHighlightPath(const PXR_NS::SdfPath& path) const;
 
@@ -105,28 +106,46 @@ class WireframeSelectionHighlightSceneIndex
 
 private:
 
+    bool _IsExcluded(const PXR_NS::SdfPath& sceneRoot) const;
+
     void _DirtySelectionHighlightRecursive(
         const PXR_NS::SdfPath&                            primPath, 
         PXR_NS::HdSceneIndexObserver::DirtiedPrimEntries* highlightEntries
     );
 
-    bool _IsExcluded(const PXR_NS::SdfPath& sceneRoot) const;
-
-    std::set<PXR_NS::SdfPath> _excludedSceneRoots;
-    PXR_NS::HdContainerDataSourceHandle _HighlightSelectedPrim(const PXR_NS::HdContainerDataSourceHandle& dataSource, const PXR_NS::SdfPath& primPath, const PXR_NS::HdContainerDataSourceHandle& highlightDataSource) const;
+    PXR_NS::HdContainerDataSourceHandle _HighlightSelectedPrim(
+        const PXR_NS::HdContainerDataSourceHandle& dataSource, 
+        const PXR_NS::SdfPath& primPath, 
+        const PXR_NS::HdContainerDataSourceHandle& highlightDataSource
+    ) const;
 
     void _ForEachPrimInHierarchy(const PXR_NS::SdfPath& hierarchyRoot, const std::function<bool(const PXR_NS::SdfPath&, const PXR_NS::HdSceneIndexPrim&)>& operation);
+
     PXR_NS::SdfPath _FindSelectionHighlightMirrorAncestor(const PXR_NS::SdfPath& path) const;
-    void _CollectSelectionHighlightMirrors(const PXR_NS::SdfPath& originalPrimPath, PXR_NS::SdfPathSet& outSelectionHighlightMirrors, PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims);
+
+    void _CollectSelectionHighlightMirrors(
+        const PXR_NS::SdfPath& originalPrimPath, 
+        PXR_NS::SdfPathSet& outSelectionHighlightMirrors, 
+        PXR_NS::HdSceneIndexObserver::AddedPrimEntries& outAddedPrims
+    );
     void _AddInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);
     void _RemoveInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const PXR_NS::SdfPath& userPath);
     void _RebuildInstancerHighlight(const PXR_NS::SdfPath& instancerPath);
     void _DeleteInstancerHighlight(const PXR_NS::SdfPath& instancerPath);
+
     void _CreateInstancerHighlightsForInstancer(const PXR_NS::HdSceneIndexPrim& instancerPrim, const PXR_NS::SdfPath& instancerPath);
 
+    std::set<PXR_NS::SdfPath> _excludedSceneRoots;
+
     const SelectionConstPtr   _selection;
     const std::shared_ptr<WireframeColorInterface> _wireframeColorInterface;
 
+    // The following three data members (_selectionHighlightMirrorsByInstancer, _selectionHighlightMirrorUseCounters and 
+    // _instancerHighlightUsers) hold the data required to properly manage the selection highlight mirror graph/hierarchy.
+    // A potential idea to support multiple wireframe colors for point instancer and instance selections could be to use
+    // a different mirror hierarchy for each color; in such a case, we could wrap these data members in a struct, and have 
+    // one instance of this new struct for each differently colored selection highlight mirror hierarchy.
+
     // Maps an instancer's path to its required selection highlight mirror paths.
     std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _selectionHighlightMirrorsByInstancer;
 

From 8b7e9aedd755e06ecd8975db6f0b17b2e23fdf46 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 16:51:55 -0400
Subject: [PATCH 073/112] Header cleanups

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 29 ++-----------------
 ...fvpWireframeSelectionHighlightSceneIndex.h |  3 --
 .../mhLeadObjectPathTracker.cpp               |  3 --
 .../mhDirtyLeadObjectSceneIndex.cpp           |  1 -
 .../sceneIndex/mhDirtyLeadObjectSceneIndex.h  |  1 -
 .../sceneIndex/registration.cpp               |  1 -
 6 files changed, 3 insertions(+), 35 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 6c370c0c03..070798768f 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -16,44 +16,21 @@
 
 #include "flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h"
 #include "flowViewport/selection/fvpSelection.h"
-#include "flowViewport/colorPreferences/fvpColorPreferences.h"
-#include "flowViewport/colorPreferences/fvpColorPreferencesTokens.h"
 #include "flowViewport/fvpUtils.h"
 
 #include "flowViewport/debugCodes.h"
-#include "fvpWireframeSelectionHighlightSceneIndex.h"
-
-#include <pxr/base/gf/matrix4d.h>
-#include <pxr/base/gf/vec4f.h>
-#include <pxr/base/tf/diagnosticLite.h>
-#include <pxr/base/vt/array.h>
-#include <pxr/base/vt/types.h>
-#include <pxr/imaging/hd/dataSource.h>
-#include <pxr/imaging/hd/dataSourceLocator.h>
-#include <pxr/imaging/hd/dataSourceTypeDefs.h>
+
 #include <pxr/imaging/hd/instancedBySchema.h>
+#include <pxr/imaging/hd/instanceIndicesSchema.h>
 #include <pxr/imaging/hd/instancerTopologySchema.h>
 #include <pxr/imaging/hd/legacyDisplayStyleSchema.h>
 #include <pxr/imaging/hd/overlayContainerDataSource.h>
 #include <pxr/imaging/hd/containerDataSourceEditor.h>
-#include <pxr/imaging/hd/primOriginSchema.h>
-#include <pxr/imaging/hd/retainedDataSource.h>
-#include <pxr/imaging/hd/sceneIndex.h>
-#include <pxr/imaging/hd/sceneIndexObserver.h>
-#include <pxr/imaging/hd/schemaTypeDefs.h>
 #include <pxr/imaging/hd/selectionSchema.h>
 #include <pxr/imaging/hd/tokens.h>
 #include <pxr/imaging/hd/selectionsSchema.h>
-#include <pxr/imaging/hd/instanceIndicesSchema.h>
-#include <pxr/imaging/hd/xformSchema.h>
-#include <pxr/usd/sdf/path.h>
-#include <pxr/usdImaging/usdImaging/rerootingSceneIndex.h>
-#include <pxr/usdImaging/usdImaging/usdPrimInfoSchema.h>
-#include <algorithm>
-#include <numeric>
+
 #include <stack>
-#include <iostream>
-#include <mutex>
 
 PXR_NAMESPACE_USING_DIRECTIVE
 
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 4a93728d3d..23d0645974 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -20,11 +20,8 @@
 #include "flowViewport/sceneIndex/fvpSceneIndexUtils.h"
 #include "flowViewport/fvpWireframeColorInterface.h"
 
-#include <pxr/imaging/hd/dataSource.h>
 #include <pxr/imaging/hd/filteringSceneIndex.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
-#include <pxr/imaging/hd/sceneIndex.h>
-#include <pxr/usd/sdf/path.h>
 
 #include <functional>
 #include <set>
diff --git a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
index cfbb912bcc..430124b902 100644
--- a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
+++ b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
@@ -22,9 +22,6 @@
 #include <flowViewport/colorPreferences/fvpColorPreferencesTokens.h>
 #include <flowViewport/selection/fvpSelection.h>
 
-//Pixar headers
-#include <pxr/usd/sdf/path.h>
-
 //ufe
 #include <ufe/globalSelection.h>
 #include <ufe/observableSelection.h>
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.cpp
index 3dfa350f10..a98b92a1ca 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.cpp
@@ -20,7 +20,6 @@
 // Hydra headers
 #include <pxr/imaging/hd/tokens.h>
 #include <pxr/imaging/hd/primvarsSchema.h>
-#include <pxr/usd/sdf/path.h>
 
 PXR_NAMESPACE_USING_DIRECTIVE
 
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.h b/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.h
index 67580b121a..22d4fd3e7a 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.h
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mhDirtyLeadObjectSceneIndex.h
@@ -25,7 +25,6 @@
 
 //Usd/Hydra headers
 #include <pxr/imaging/hd/filteringSceneIndex.h>
-#include <pxr/usd/sdf/path.h>
 
 
 namespace MAYAHYDRA_NS_DEF {
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
index 7b146b3f76..0ceb1a7907 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
@@ -27,7 +27,6 @@
 
 #include <pxr/imaging/hd/dataSourceTypeDefs.h>
 #include <pxr/imaging/hd/instanceIndicesSchema.h>
-#include <pxr/imaging/hd/legacyDisplayStyleSchema.h>
 #include <pxr/imaging/hd/prefixingSceneIndex.h>
 #include <pxr/imaging/hd/retainedDataSource.h>
 #include <pxr/imaging/hd/sceneIndexPlugin.h>

From 69c850d2e834b612bbaff2bb716316b1b8760246 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 16:56:37 -0400
Subject: [PATCH 074/112] Remove SdfPath forward declaration

---
 lib/flowViewport/sceneIndex/fvpPathInterface.h | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpPathInterface.h b/lib/flowViewport/sceneIndex/fvpPathInterface.h
index 49b11a7d47..10bfaab8b0 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterface.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterface.h
@@ -28,10 +28,6 @@ UFE_NS_DEF {
 class Path;
 }
 
-PXR_NAMESPACE_OPEN_SCOPE
-class SdfPath;
-PXR_NAMESPACE_CLOSE_SCOPE
-
 namespace FVP_NS_DEF {
 
 struct PrimSelectionInfo

From f6e1738eae446b4f60834dd4592592b56c615f42 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 17:02:47 -0400
Subject: [PATCH 075/112] Fix Linux warning

---
 .../mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index 37416aabcf..8f030e69dd 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -277,7 +277,7 @@ TEST(PointInstancingWireframeHighlight, instance)
         auto mask = instancerTopology.GetMask()->GetTypedValue(0);
         ASSERT_FALSE(mask.empty());
 
-        auto selectedInstanceIndex = std::stoi(instancePath.getSegments().back().components().back().string());
+        size_t selectedInstanceIndex = std::stoul(instancePath.getSegments().back().components().back().string());
         for (size_t iMask = 0; iMask < mask.size(); iMask++) {
             EXPECT_EQ(mask[iMask], iMask == selectedInstanceIndex);
         }

From 359877fc36c196abab719f5e1c555c93046f347e Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 17:08:14 -0400
Subject: [PATCH 076/112] Rename instancerHighlightUsers

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 22 +++++++++----------
 ...fvpWireframeSelectionHighlightSceneIndex.h |  4 ++--
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 070798768f..14b22506b5 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -779,11 +779,11 @@ WireframeSelectionHighlightSceneIndex::_AddInstancerHighlightUser(const PXR_NS::
 {
     TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
     
-    if (_instancerHighlightUsers[instancerPath].find(userPath) != _instancerHighlightUsers[instancerPath].end()) {
+    if (_instancerHighlightUsersByInstancer[instancerPath].find(userPath) != _instancerHighlightUsersByInstancer[instancerPath].end()) {
         return;
     }
 
-    _instancerHighlightUsers[instancerPath].insert(userPath);
+    _instancerHighlightUsersByInstancer[instancerPath].insert(userPath);
     if (_selectionHighlightMirrorsByInstancer.find(instancerPath) == _selectionHighlightMirrorsByInstancer.end()) {
         SdfPathSet selectionHighlightMirrors;
         HdSceneIndexObserver::AddedPrimEntries addedPrims;
@@ -808,8 +808,8 @@ WireframeSelectionHighlightSceneIndex::_AddInstancerHighlightUser(const PXR_NS::
 void
 WireframeSelectionHighlightSceneIndex::_RemoveInstancerHighlightUser(const PXR_NS::SdfPath& instancerPath, const SdfPath& userPath)
 {
-    TF_AXIOM(_instancerHighlightUsers.find(instancerPath) != _instancerHighlightUsers.end());
-    TF_AXIOM(_instancerHighlightUsers.at(instancerPath).find(userPath) != _instancerHighlightUsers.at(instancerPath).end());
+    TF_AXIOM(_instancerHighlightUsersByInstancer.find(instancerPath) != _instancerHighlightUsersByInstancer.end());
+    TF_AXIOM(_instancerHighlightUsersByInstancer.at(instancerPath).find(userPath) != _instancerHighlightUsersByInstancer.at(instancerPath).end());
     TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
 
     HdSceneIndexObserver::RemovedPrimEntries removedPrims;
@@ -822,9 +822,9 @@ WireframeSelectionHighlightSceneIndex::_RemoveInstancerHighlightUser(const PXR_N
         }
     }
 
-    _instancerHighlightUsers[instancerPath].erase(userPath);
-    if (_instancerHighlightUsers[instancerPath].empty()) {
-        _instancerHighlightUsers.erase(instancerPath);
+    _instancerHighlightUsersByInstancer[instancerPath].erase(userPath);
+    if (_instancerHighlightUsersByInstancer[instancerPath].empty()) {
+        _instancerHighlightUsersByInstancer.erase(instancerPath);
         _selectionHighlightMirrorsByInstancer.erase(instancerPath);
     }
     
@@ -837,10 +837,10 @@ void
 WireframeSelectionHighlightSceneIndex::_RebuildInstancerHighlight(const PXR_NS::SdfPath& instancerPath)
 {
     TF_AXIOM(GetInputSceneIndex()->GetPrim(instancerPath).primType == HdPrimTypeTokens->instancer);
-    TF_AXIOM(_instancerHighlightUsers.find(instancerPath) != _instancerHighlightUsers.end());
+    TF_AXIOM(_instancerHighlightUsersByInstancer.find(instancerPath) != _instancerHighlightUsersByInstancer.end());
     TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
 
-    auto instancerHighlightUsers = _instancerHighlightUsers[instancerPath];
+    auto instancerHighlightUsers = _instancerHighlightUsersByInstancer[instancerPath];
     
     for (const auto& instancerHighlightUser : instancerHighlightUsers) {
         _RemoveInstancerHighlightUser(instancerPath, instancerHighlightUser);
@@ -854,10 +854,10 @@ WireframeSelectionHighlightSceneIndex::_RebuildInstancerHighlight(const PXR_NS::
 void
 WireframeSelectionHighlightSceneIndex::_DeleteInstancerHighlight(const PXR_NS::SdfPath& instancerPath)
 {
-    TF_AXIOM(_instancerHighlightUsers.find(instancerPath) != _instancerHighlightUsers.end());
+    TF_AXIOM(_instancerHighlightUsersByInstancer.find(instancerPath) != _instancerHighlightUsersByInstancer.end());
     TF_AXIOM(_selectionHighlightMirrorsByInstancer.find(instancerPath) != _selectionHighlightMirrorsByInstancer.end());
 
-    auto instancerHighlightUsers = _instancerHighlightUsers[instancerPath];
+    auto instancerHighlightUsers = _instancerHighlightUsersByInstancer[instancerPath];
     for (const auto& instancerHighlightUser : instancerHighlightUsers) {
         _RemoveInstancerHighlightUser(instancerPath, instancerHighlightUser);
     }
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 23d0645974..4094cde39d 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -138,7 +138,7 @@ class WireframeSelectionHighlightSceneIndex
     const std::shared_ptr<WireframeColorInterface> _wireframeColorInterface;
 
     // The following three data members (_selectionHighlightMirrorsByInstancer, _selectionHighlightMirrorUseCounters and 
-    // _instancerHighlightUsers) hold the data required to properly manage the selection highlight mirror graph/hierarchy.
+    // _instancerHighlightUsersByInstancer) hold the data required to properly manage the selection highlight mirror graph/hierarchy.
     // A potential idea to support multiple wireframe colors for point instancer and instance selections could be to use
     // a different mirror hierarchy for each color; in such a case, we could wrap these data members in a struct, and have 
     // one instance of this new struct for each differently colored selection highlight mirror hierarchy.
@@ -157,7 +157,7 @@ class WireframeSelectionHighlightSceneIndex
     // instancer's selection highlight mirrors by one, or they could end up floating around in memory forever. However, 
     // we would have no way of knowing how many times this instancer actually uses its selection highlight mirrors. 
     // Keeping track of which selected prims contribute to the instancer's highlight solves this problem.
-    std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _instancerHighlightUsers;
+    std::unordered_map<PXR_NS::SdfPath, PXR_NS::SdfPathSet, PXR_NS::SdfPath::Hash> _instancerHighlightUsersByInstancer;
 };
 
 }

From 5e7a22a3e61f235896aaf6511b4bba9cbc5b4b1b Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 17:17:00 -0400
Subject: [PATCH 077/112] Fix disrespected axiom

---
 .../fvpWireframeSelectionHighlightSceneIndex.cpp       | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 14b22506b5..9d4d703367 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -551,8 +551,9 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
             dirtiedPrims.emplace_back(selectionHighlightPath, entry.dirtyLocators);
         }
 
-        if (entry.dirtyLocators.Intersects(HdInstancerTopologySchema::GetDefaultLocator())) {
-            // An instancer was changed; rebuild its selection highlight.
+        if (entry.dirtyLocators.Intersects(HdInstancerTopologySchema::GetDefaultLocator())
+            && _selectionHighlightMirrorsByInstancer.find(entry.primPath) != _selectionHighlightMirrorsByInstancer.end()) {
+            // An instancer with a selection highlight was changed; rebuild its selection highlight.
             // We do not need to check for instancedBy dirtying : if an instancedBy data source is dirtied,
             // then either a new instancer was added, which will be handled in _PrimsAdded, either an
             // existing instancer's instancerTopology data source was dirtied., which is handled here.
@@ -631,8 +632,9 @@ WireframeSelectionHighlightSceneIndex::_PrimsRemoved(
     for (const auto& entry : entries) {
         SdfPathVector instancerHighlightsToDelete;
         for (const auto& selectionHighlightMirrorsForInstancer : _selectionHighlightMirrorsByInstancer) {
-            if (selectionHighlightMirrorsForInstancer.first.HasPrefix(entry.primPath)) {
-                instancerHighlightsToDelete.push_back(selectionHighlightMirrorsForInstancer.first);
+            SdfPath instancerPath = selectionHighlightMirrorsForInstancer.first;
+            if (instancerPath.HasPrefix(entry.primPath)) {
+                instancerHighlightsToDelete.push_back(instancerPath);
             }
         }
         for (const auto& instancerHighlightToDelete : instancerHighlightsToDelete) {

From 828dfaff4b7a944d5821bdfaade367a6f33494cd Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 17:41:18 -0400
Subject: [PATCH 078/112] Cleanup test and add some comments

---
 .../testPointInstancingWireframeHighlight.cpp | 28 +++++++++----------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index 8f030e69dd..f652bddf58 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -18,20 +18,13 @@
 #include <mayaHydraLib/mayaHydra.h>
 
 #include <flowViewport/sceneIndex/fvpMergingSceneIndex.h>
-#include <flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h>
 
-#include <pxr/base/tf/token.h>
-#include <pxr/base/vt/array.h>
 #include <pxr/imaging/hd/instancedBySchema.h>
 #include <pxr/imaging/hd/instancerTopologySchema.h>
 #include <pxr/imaging/hd/legacyDisplayStyleSchema.h>
-#include <pxr/imaging/hd/sceneDelegate.h>
-#include <pxr/imaging/hd/sceneIndex.h>
-#include <pxr/imaging/hd/sceneIndexObserver.h>
 #include <pxr/imaging/hd/sceneIndexPrimView.h>
 #include <pxr/imaging/hd/tokens.h>
 #include <pxr/imaging/hdx/selectionSceneIndexObserver.h>
-#include <pxr/usd/sdf/path.h>
 
 #include <ufe/globalSelection.h>
 #include <ufe/hierarchy.h>
@@ -43,8 +36,6 @@
 
 #include <gtest/gtest.h>
 
-#include <string>
-
 PXR_NAMESPACE_USING_DIRECTIVE
 using namespace MayaHydra;
 
@@ -78,6 +69,9 @@ VtArray<SdfPath> getPrototypeRoots(const HdSceneIndexPrim& prim)
         : VtArray<SdfPath>({SdfPath::AbsoluteRootPath()});
 }
 
+// This method takes in a path to a prim in a selection highlight hierarchy and ensures that 
+// the selection highlight graph is structured properly, and that the leaf mesh prims have
+// the proper display style.
 void assertSelectionHighlightCorrectness(const HdSceneIndexBaseRefPtr& sceneIndex, const SdfPath& primPath)
 {
     HdSceneIndexPrimView view(sceneIndex, primPath);
@@ -141,6 +135,7 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     HdxSelectionSceneIndexObserver selectionObserver;
     selectionObserver.SetSceneIndex(terminalSceneIndices.front());
 
+    // Create this test's selected scene items
     auto topInstancerPath = Ufe::PathString::path(stagePathSegment + "," + "/Root/TopInstancerXform/TopInstancer");
     auto secondInstancerPath = Ufe::PathString::path(stagePathSegment + "," + "/Root/SecondInstancer");
     auto thirdInstancerPath = Ufe::PathString::path(stagePathSegment + "," + "/Root/ThirdInstancer");
@@ -155,13 +150,13 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     ufeSelection->clear();
 
     auto selectionHighlightMirrors = inspector.FindPrims(findSelectionHighlightMirrorsPredicate);
-    EXPECT_TRUE(selectionHighlightMirrors.empty());
+    EXPECT_TRUE(selectionHighlightMirrors.empty()); // No selection highlight mirrors
 
     auto meshPrims = inspector.FindPrims(findMeshPrimsPredicate);
     for (const auto& meshPrim : meshPrims) {
         HdLegacyDisplayStyleSchema displayStyle = HdLegacyDisplayStyleSchema::GetFromParent(meshPrim.prim.dataSource);
         EXPECT_TRUE(displayStyle.IsDefined());
-        EXPECT_FALSE(displayStyle.GetReprSelector());
+        EXPECT_FALSE(displayStyle.GetReprSelector()); // No specific repr is defined
     }
 
     // Select point instancers directly
@@ -237,6 +232,7 @@ TEST(PointInstancingWireframeHighlight, instance)
     HdxSelectionSceneIndexObserver selectionObserver;
     selectionObserver.SetSceneIndex(terminalSceneIndices.front());
 
+    // Create this test's selected scene items
     auto topInstancerFirstInstancePath = Ufe::PathString::path(stagePathSegment + "," + "/Root/TopInstancerXform/TopInstancer/0");
     auto secondInstancerSecondInstancePath = Ufe::PathString::path(stagePathSegment + "," + "/Root/SecondInstancer/1");
 
@@ -247,13 +243,13 @@ TEST(PointInstancingWireframeHighlight, instance)
     ufeSelection->clear();
 
     auto selectionHighlightMirrors = inspector.FindPrims(findSelectionHighlightMirrorsPredicate);
-    EXPECT_TRUE(selectionHighlightMirrors.empty());
+    EXPECT_TRUE(selectionHighlightMirrors.empty()); // No selection highlight mirrors
 
     auto meshPrims = inspector.FindPrims(findMeshPrimsPredicate);
     for (const auto& meshPrim : meshPrims) {
         HdLegacyDisplayStyleSchema displayStyle = HdLegacyDisplayStyleSchema::GetFromParent(meshPrim.prim.dataSource);
         EXPECT_TRUE(displayStyle.IsDefined());
-        EXPECT_FALSE(displayStyle.GetReprSelector());
+        EXPECT_FALSE(displayStyle.GetReprSelector()); // No specific repr is defined
     }
 
     // Select instances
@@ -302,6 +298,7 @@ TEST(PointInstancingWireframeHighlight, prototype)
     HdxSelectionSceneIndexObserver selectionObserver;
     selectionObserver.SetSceneIndex(terminalSceneIndices.front());
 
+    // Create this test's selected scene items
     auto prototypePath = Ufe::PathString::path(stagePathSegment + "," + "/Root/TopInstancerXform/TopInstancer/prototypes/NestedInstancerXform/NestedInstancer/prototypes/RedCube/Geom/Cube");
     auto prototypeParentPath = Ufe::PathString::path(stagePathSegment + "," + "/Root/TopInstancerXform/TopInstancer/prototypes/NestedInstancerXform/NestedInstancer/prototypes/RedCube");
 
@@ -312,13 +309,13 @@ TEST(PointInstancingWireframeHighlight, prototype)
     ufeSelection->clear();
 
     auto selectionHighlightMirrors = inspector.FindPrims(findSelectionHighlightMirrorsPredicate);
-    EXPECT_TRUE(selectionHighlightMirrors.empty());
+    EXPECT_TRUE(selectionHighlightMirrors.empty()); // No selection highlight mirrors
 
     auto meshPrims = inspector.FindPrims(findMeshPrimsPredicate);
     for (const auto& meshPrim : meshPrims) {
         HdLegacyDisplayStyleSchema displayStyle = HdLegacyDisplayStyleSchema::GetFromParent(meshPrim.prim.dataSource);
         EXPECT_TRUE(displayStyle.IsDefined());
-        EXPECT_FALSE(displayStyle.GetReprSelector());
+        EXPECT_FALSE(displayStyle.GetReprSelector()); // No specific repr is defined
     }
 
     // Select prototype
@@ -329,6 +326,7 @@ TEST(PointInstancingWireframeHighlight, prototype)
         // Original prim + 4 propagated prototypes
         ASSERT_EQ(prototypeHydraSelections.size(), 1u + 4u);
 
+        // Ensure meshes use the correct display style
         ASSERT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
         for (const auto& prototypeSelection : prototypeHydraSelections) {
             HdSceneIndexPrimView view(inspector.GetSceneIndex(), prototypeSelection.primPath);

From b0ac20c16e60f735d2c9c5a75933373a47037723 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 17:45:22 -0400
Subject: [PATCH 079/112] Better document the USD conversion of UFE to Hydra
 paths

---
 lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
index 0ceb1a7907..65e4d0978a 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
@@ -127,21 +127,24 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
         // The scene index path is composed of 2 parts, in order:
         // 1) The scene index path prefix, which is fixed on construction.
         // 2) The second segment of the UFE path, with each UFE path component
-        //    becoming an SdfPath component.
+        //    becoming an SdfPath component. If the last component is a number,
+        //    then we are dealing with an instance selection.
         SdfPath primPath = _sceneIndexPathPrefix;
         TF_AXIOM(appPath.nbSegments() == 2);
         const auto& secondSegment = appPath.getSegments()[1];
         for (const auto& pathComponent : secondSegment) {
-            // This should only be able to occur on the last component
+            // This should only occur on the last component, if we have an instance selection
             if (pathComponent.string().find_first_not_of(digits) == std::string::npos) {
                 continue;
             }
             primPath = primPath.AppendChild(TfToken(pathComponent.string()));
         }
+
         const auto lastComponentString = secondSegment.components().back().string();
         bool lastComponentIsNumeric = lastComponentString.find_first_not_of(digits) == std::string::npos;
         HdDataSourceBaseHandle selectionDataSource;
         if (lastComponentIsNumeric) {
+            // Instance selection
             HdInstanceIndicesSchema::Builder instanceIndicesBuilder;
             instanceIndicesBuilder.SetInstancer(HdRetainedTypedSampledDataSource<SdfPath>::New(primPath));
             instanceIndicesBuilder.SetInstanceIndices(HdRetainedTypedSampledDataSource<VtArray<int>>::New({std::stoi(lastComponentString)}));
@@ -152,6 +155,7 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
             selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
         }
         else {
+            // Full prim selection
             HdSelectionSchema::Builder selectionBuilder;
             selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
             selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());

From d8fe091febe6c8ec469cb6a4865c784fbcb4063f Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 17:49:29 -0400
Subject: [PATCH 080/112] Update current limitations

---
 doc/selectionHighlightingArchitecture.md | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index f15ca6effd..994c3e0e05 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -449,11 +449,8 @@ Of note are the following selection highlighting scenarios and their correspondi
 - Selecting a parent prim of a point instancer
   - (same as selecting a point instancer in its entirety)
 
-### Code overview
-
-This section is to briefly explain some of the less immediately clear code structures used in the
-implementation. 
-
 ### Current limitations
 
-- Wireframe colors for lead/active selection are unsupported
\ No newline at end of file
+- The wireframe colors for point instancer & instance selections might not always be correct (with 
+  respect to the lead/active selection colors). However, prototype selections should be using the 
+  correct colors.
\ No newline at end of file

From 5c12b280ddd4602406171973fbbe6c2467f4cbf6 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 17:59:43 -0400
Subject: [PATCH 081/112] Add comments in wireframe scene index

---
 .../fvpWireframeSelectionHighlightSceneIndex.cpp       | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 9d4d703367..26bea73588 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -78,6 +78,9 @@ SdfPath _GetOriginalPathFromSelectionHighlightMirror(const SdfPath& mirrorPath)
     return mirrorPath.ReplaceName(TfToken(primName.substr(0, primName.size() - selectionHighlightMirrorTag.size())));
 }
 
+// Computes the mask to use for an instancer's selection highlight mirror
+// based on the instancer's topology and its selections. This allows
+// highlighting only specific instances in the case of instance selections.
 VtBoolArray _GetSelectionHighlightMask(const HdInstancerTopologySchema& originalInstancerTopology, const HdSelectionsSchema& selections) 
 {
     if (!selections.IsDefined()) {
@@ -119,6 +122,8 @@ VtBoolArray _GetSelectionHighlightMask(const HdInstancerTopologySchema& original
     return selectionHighlightMask;
 }
 
+// Returns the overall data source for an instancer's selection highlight mirror.
+// This replaces the mask data source and blocks the selections data source.
 HdContainerDataSourceHandle _GetSelectionHighlightInstancerDataSource(const HdContainerDataSourceHandle& originalDataSource)
 {
     HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(originalDataSource);
@@ -138,6 +143,8 @@ HdContainerDataSourceHandle _GetSelectionHighlightInstancerDataSource(const HdCo
     return editedDataSource.Finish();
 }
 
+// Returns all paths related to instancing for this prim; this is analogous to getting the edges
+// connected to the given vertex (in this case a prim) of an instancing graph.
 SdfPathVector _GetInstancingRelatedPaths(const HdSceneIndexPrim& prim)
 {
     HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(prim.dataSource);
@@ -177,6 +184,7 @@ VtArray<SdfPath> _GetPrototypeRoots(const HdSceneIndexPrim& prim)
     return instancedBy.GetPrototypeRoots()->GetTypedValue(0);
 }
 
+// This method is essentially "is not a prototype sub-prim".
 bool _IsInstancingRoot(const HdSceneIndexPrim& prim, const SdfPath& primPath)
 {
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
@@ -630,6 +638,8 @@ WireframeSelectionHighlightSceneIndex::_PrimsRemoved(
         .Msg("WireframeSelectionHighlightSceneIndex::_PrimsRemoved() called.\n");
 
     for (const auto& entry : entries) {
+        // Collect and delete instancer highlights for all instancers rooted under the removed prim
+        // (or if the removed prim is an instancer itself and has a highlight)
         SdfPathVector instancerHighlightsToDelete;
         for (const auto& selectionHighlightMirrorsForInstancer : _selectionHighlightMirrorsByInstancer) {
             SdfPath instancerPath = selectionHighlightMirrorsForInstancer.first;

From 0321f2bc303aea8b04fa769e7bf322af015422e6 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 19:08:31 -0400
Subject: [PATCH 082/112] Work around non-const schema getters for USD versions
 before 24.05

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 21 +++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 26bea73588..7a17801e8d 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -83,17 +83,30 @@ SdfPath _GetOriginalPathFromSelectionHighlightMirror(const SdfPath& mirrorPath)
 // highlighting only specific instances in the case of instance selections.
 VtBoolArray _GetSelectionHighlightMask(const HdInstancerTopologySchema& originalInstancerTopology, const HdSelectionsSchema& selections) 
 {
+    // Schema getters were made const in USD 24.05 (specifically Hydra API version 66).
+    // We work around this for previous versions by const casting.
+    VtBoolArray originalMask = 
+#if HD_API_VERSION < 66
+    const_cast<HdInstancerTopologySchema&>(originalInstancerTopology).GetMask()->GetTypedValue(0);
+#else
+    originalInstancerTopology.GetMask()->GetTypedValue(0);
+#endif
+
     if (!selections.IsDefined()) {
-        return originalInstancerTopology.GetMask()->GetTypedValue(0);
+        return originalMask;
     }
 
     size_t nbInstances = 0;
-    auto instanceIndices = originalInstancerTopology.GetInstanceIndices();
+    auto instanceIndices = 
+#if HD_API_VERSION < 66
+    const_cast<HdInstancerTopologySchema&>(originalInstancerTopology).GetInstanceIndices();
+#else
+    originalInstancerTopology.GetInstanceIndices();
+#endif
     for (size_t iInstanceIndex = 0; iInstanceIndex < instanceIndices.GetNumElements(); iInstanceIndex++) {
         auto protoInstances = instanceIndices.GetElement(iInstanceIndex)->GetTypedValue(0);
         nbInstances += protoInstances.size();
     }
-    VtBoolArray originalMask = originalInstancerTopology.GetMask()->GetTypedValue(0);
     TF_AXIOM(originalMask.empty() || originalMask.size() == nbInstances);
     VtBoolArray selectionHighlightMask(nbInstances, false);
 
@@ -108,7 +121,7 @@ VtBoolArray _GetSelectionHighlightMask(const HdInstancerTopologySchema& original
         if (!selection.GetNestedInstanceIndices()) {
             // We have a selection that has no instances, which means the whole instancer is selected :
             // this overrides any instances selection.
-            return originalInstancerTopology.GetMask()->GetTypedValue(0);
+            return originalMask;
         }
         HdInstanceIndicesVectorSchema nestedInstanceIndices = selection.GetNestedInstanceIndices();
         for (size_t iInstanceIndices = 0; iInstanceIndices < nestedInstanceIndices.GetNumElements(); iInstanceIndices++) {

From 73c0b29ecb953fd67d98159b678772a1b81741c4 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 4 Jun 2024 19:55:38 -0400
Subject: [PATCH 083/112] Update test to compare selected paths from scene
 index observer and intended selections + adjust asserts vs expects

---
 .../testPointInstancingWireframeHighlight.cpp | 35 +++++++++++--------
 1 file changed, 21 insertions(+), 14 deletions(-)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index f652bddf58..2abff92277 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -36,6 +36,8 @@
 
 #include <gtest/gtest.h>
 
+#include <algorithm>
+
 PXR_NAMESPACE_USING_DIRECTIVE
 using namespace MayaHydra;
 
@@ -92,10 +94,11 @@ void assertSelectionHighlightCorrectness(const HdSceneIndexBaseRefPtr& sceneInde
         if (instancerTopology.IsDefined()) {
             ASSERT_NE(instancerTopology.GetPrototypes(), nullptr);
             auto prototypePaths = instancerTopology.GetPrototypes()->GetTypedValue(0);
-            ASSERT_GE(prototypePaths.size(), 1u);
+            EXPECT_GE(prototypePaths.size(), 1u);
             for (const auto& prototypePath : prototypePaths) {
                 auto prototypeName = prototypePath.GetElementString();
-                ASSERT_EQ(prototypeName.substr(prototypeName.size() - selectionHighlightTag.size()), selectionHighlightTag);
+                ASSERT_GT(prototypeName.size(), selectionHighlightTag.size());
+                EXPECT_EQ(prototypeName.substr(prototypeName.size() - selectionHighlightTag.size()), selectionHighlightTag);
                 assertSelectionHighlightCorrectness(sceneIndex, prototypePath);
             }
             it.SkipDescendants();
@@ -168,9 +171,9 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
         auto instancerPrimPath = instancerHydraSelections.front().primPath;
     
         ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().size(), 1u);
-        ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().front(), instancerPrimPath);
+        EXPECT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().front(), instancerPrimPath);
 
-        ASSERT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
+        EXPECT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
         assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
     };
     
@@ -185,7 +188,7 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
         auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(instancerPath);
         ASSERT_EQ(instancerHydraSelections.size(), 1u);
     
-        ASSERT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
+        EXPECT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
         assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerHydraSelections.front().primPath));
     };
     auto testInstancerNoHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
@@ -195,7 +198,7 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     
         HdSceneIndexPrim selectionHighlightMirrorPrim = inspector.GetSceneIndex()->GetPrim(
             getSelectionHighlightMirrorPathFromOriginal(instancerHydraSelections.front().primPath));
-        ASSERT_EQ(selectionHighlightMirrorPrim.primType, TfToken());
+        EXPECT_EQ(selectionHighlightMirrorPrim.primType, TfToken());
     };
 
     // Select TopInstancer's parent : only TopInstancer should be highlighted
@@ -261,9 +264,9 @@ TEST(PointInstancingWireframeHighlight, instance)
         auto instancerPrimPath = instanceHydraSelections.front().primPath;
 
         ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().size(), 1u);
-        ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().front(), instancerPrimPath);
+        EXPECT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().front(), instancerPrimPath);
 
-        ASSERT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
+        EXPECT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
         assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
 
         HdSceneIndexPrim instancerHighlightPrim = inspector.GetSceneIndex()->GetPrim(getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
@@ -271,7 +274,7 @@ TEST(PointInstancingWireframeHighlight, instance)
         ASSERT_TRUE(instancerTopology.IsDefined());
         ASSERT_NE(instancerTopology.GetMask(), nullptr);
         auto mask = instancerTopology.GetMask()->GetTypedValue(0);
-        ASSERT_FALSE(mask.empty());
+        EXPECT_FALSE(mask.empty());
 
         size_t selectedInstanceIndex = std::stoul(instancePath.getSegments().back().components().back().string());
         for (size_t iMask = 0; iMask < mask.size(); iMask++) {
@@ -324,10 +327,10 @@ TEST(PointInstancingWireframeHighlight, prototype)
 
         auto prototypeHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(prototypePath);
         // Original prim + 4 propagated prototypes
-        ASSERT_EQ(prototypeHydraSelections.size(), 1u + 4u);
+        EXPECT_EQ(prototypeHydraSelections.size(), 1u + 4u);
 
         // Ensure meshes use the correct display style
-        ASSERT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
+        EXPECT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
         for (const auto& prototypeSelection : prototypeHydraSelections) {
             HdSceneIndexPrimView view(inspector.GetSceneIndex(), prototypeSelection.primPath);
             for (auto it = view.begin(); it != view.end(); ++it) {
@@ -337,9 +340,13 @@ TEST(PointInstancingWireframeHighlight, prototype)
                 }
             }
         }
-    
-        // Original prim + 4 propagated prototypes
-        ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().size(), 1u + 4u);
+
+        auto selectedPrimPaths = selectionObserver.GetSelection()->GetAllSelectedPrimPaths();
+        ASSERT_EQ(selectedPrimPaths.size(), prototypeHydraSelections.size());
+        for (const auto& prototypeHydraSelection : prototypeHydraSelections) {
+            auto foundSelectedPrimPath = std::find(selectedPrimPaths.begin(), selectedPrimPaths.end(), prototypeHydraSelection.primPath);
+            EXPECT_NE(foundSelectedPrimPath, selectedPrimPaths.end());
+        }
     };
     
     testPrototypeHighlightFn(prototypeItem, prototypePath);

From cd3cccbffc928c378bd1e8e488f0de86050e69a7 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 01:21:39 -0400
Subject: [PATCH 084/112] Add images of selection highlight results

---
 doc/images/instanceSelectionHighlight.png       | Bin 0 -> 35868 bytes
 doc/images/pointInstancerSelectionHighlight.png | Bin 0 -> 36285 bytes
 doc/images/prototypeSelectionHighlight.png      | Bin 0 -> 43988 bytes
 doc/selectionHighlightingArchitecture.md        |  13 +++++++++++--
 4 files changed, 11 insertions(+), 2 deletions(-)
 create mode 100644 doc/images/instanceSelectionHighlight.png
 create mode 100644 doc/images/pointInstancerSelectionHighlight.png
 create mode 100644 doc/images/prototypeSelectionHighlight.png

diff --git a/doc/images/instanceSelectionHighlight.png b/doc/images/instanceSelectionHighlight.png
new file mode 100644
index 0000000000000000000000000000000000000000..7c0faa96dc6257a0bdd413c0fffcbe6757e54c54
GIT binary patch
literal 35868
zcmXV12Q(XA)Th*_*lNXYt(y7UEm5PiwOXnuifC;yqG*XxZS2uf)K*(-)t;eZ)vhfe
z1hH3b5x(^MzLS%aaZcX5@7;Uf`~80RCi01)F8vMe8)Rf;^p75D8<UY;Qz9cHkD{R>
zeY2Njn@V~ihZ*Z?l9dnftdl-aI%*hbkdalz(_PqICw->%d}sk9BV*|N_ayJ}D1Jpo
z7G3p7TjQDk%k5U$X$3t~Y%?Q+SmL$!03qG$+6>eho;TiGs^7fcLH;m_z%5Ma!Lri5
z`Jp)Ey-p)oNB>*A(&Le7B}2~0VpM9FB?}j&hB6NomuiSU^{cER*i`Td;p%v{_Ioqw
z(e%A(YWMAPGbAAZJLg(fT7DipF)^2tk(p`T3<B7LE{NDG;@P~zfkpO_#cIGlCxNI!
zNSReis1CMAs{38V9NFT!W!c-UGJ|@(j&?&bi0SXz2WF5X@A^BCC7Xl2{H#idrvkYY
z!$}R`PgYcX2Od160hZ2e2m0R(>2=EfN6o8jV9(oF<%@yktXqL5!v-;&I^AnSjgL@!
zet0Goy}yk5+x9z`q2=dtS1~*wFMH0fpc=WXQdXPNVA~t~uoFgrTHKlA^7}|&XK%=K
zW;q<|f124C%x|uhxqJ!Nd70V(is2gJm3TPQ$gqtn+PFyB;IHJFOj_oD_*T-MTOY&O
zt*t-tv|fWhEl#~Y-nwUaPTf|;t;mRBb&qi%^On7;2o!Kju+jJPtc<}9_yq&OPK77_
z7$k~}@!fjv*%<-2tMwu-({3!}Gphl`W7@V=%|4ZZQQc*xpwXC?s;|J#h>)GFG)jZs
z-F%_LY2h>F+F$`xj|z-N^RHY{d~VOsT#pJ-uIb;>C`NdJYv{)PT@&9Z`+HanoCjzl
zhPUVO&k*eCozvasf4H8<j3BL)=Jo?>AmQGi?tvEoZ=VI`CjR@ml>W>kdbQ*;|ClpQ
z>H`pi317eRKL_!6uf?osjqSt!GM@&@@^{MeFEQaLf<+zqW0gtU0}z}t)Fl-3mDwMj
zIfIXT0%NpjS7VPs^%qj)%{MXT!fWO=T%F>A!LvOqR4m)}&SwheVHeJF-S%=y-7X`U
zI%u*UY`QBGV88k{e+N%c^1`i3tL`vx($=lsj^RHf%Oul4nW!Y*ff4&J3%62#53>YP
zCinXT)SlCV--{EiSVW*PU7x<mE%<d`f?1XVOuFg42ZbM6s3-S(B_-$);Q~|Vk3RJm
zKycmWlqQ*n_HlBrd*lmEqy$rPDAlD>dQgAm3gT^JvI~~I*GUVCdcBi)FF$XvOV>6i
zPIUP+xnDMU!*K{)PRpvK16pI{T=r&Z=G80bjXmSyIDe3h$%f_BSY11S@yv=Qm|Pa3
zP_dsBb|P<ht6JzC$xX!#U&KV8aWPJjhQo(P0&m?re6)U#>ueX6U97iPErAdRsV_l-
zx<9s!#FxH1#cyqyoe)$AC4GIv<0NZ-+V(zD>WOp->hAjAaZ(EHpHKMpAAcrZ&dgjj
z%S5ioF_NONn)zTE=U1ToXmGe8e~%S)JaG}TDY|fyvf*e7Z+7z#IF2M_yMo28t@f=F
zdd$JAov2t4*E!`iaU)+@JfUbKDddccnlFz{T?1gFx6hit_vViJ_l=I9t+~@h5fjyl
z3Y?l)k!!1doBTjAP_{r9sIZ;1&ZKcs2vF5`&1>~<t-QKMuNUd3hh<^rhiXu96{#*G
zCSz*Tqrsm<pDLr91j@kWJy4Zdbo&|qQ9N({UzlY4kD$#!kLtI-xExCG-}|db>;0C9
z?i*Q-zvLO%cD0=M9&{EDdY=LRHx$m5^j6yD`v&k;fC<Pd?))}L%{A|BMMV0QPaA*S
z@pY%*^HUWzDW}<x>94=C&HoMd<Z+(Ns8PcAih@&G$)bIWcZT0xB+$cb&7U|O+y&eM
zafr?};Dd#W`Lj#enhNm)t~)M)Ndi8k4Gr5@fCeR-*n1qXCgHxX_;401vo!>LNi|8x
ztAJnpC^bsn=7^emu_XeTV(k=yNV!#3gd1%In{O2edHNEJ&Sgyvdm^~`8*lKEqDHof
zJgiP<0Gs(e_e5pp@qVq5ehJOsmlgR87Wnqvptaosh`!<X4gObz6-c&(uN+8HsI8py
zqXBw={<mKgv4kc=X-9qin}?wWwxye0-k?E~dSHTzWMx^5N^bi!a<`KkZm=!Nx#SwD
zavi@J3hGJwW7NJxKe!G(ahM@+SM_&6g^!&fR@#84V+t^e%7#;yDjTNI0~LaiRX1Mv
zaJPs>0gQi{;D+l~7BsbAJ}EpktkkhF>0x}lKY_FHyRaQNd2T9<_F(S(F<1b}7W9RK
ztiJuJR(!F*#E>Uux62WbHGLA<u9EoEA*w0OWTXakv?9T()SV>`oSU{ET-+R4O05W*
zT-$sWbnT#)zqYdR`}9;KJak&Bt1^N!B@bf(%x)lOQ><}C1(~1*<=+mPj-RG#uBA3u
zfJ%U7G`XTgOxv+a+ZlJ<SsK-WLdJ_}GAo@k<0^EN7c<C%$R`8^3myMgwaXHEz$Ct8
z@;S#@=*tMmt6Ip1;u_57mBEP8wn-Efe;5n=`eA<{Z~R#rLL9CZ!A<rw%p!f5qq7YA
zj(PvhP=6ba>KIy86ipl$T`A#IeRhFtJPCcj;x&k0N*B#0@)O|JSX-ye^acy%D(>IU
zmS@+`Wo^culvcER1LKq0_~?Kb9MPz2NBVdM639Zb?D#8P_){r2a1gYDl^|ZVs(VwJ
zNhyuxBZD@5Zo_Dd3Q`{<nNVjKdX=o#GdbxGJGd#oQm1XBA$^&=Ea6nTTR6O$pN}zI
z+^ni3KVfec@TIOwkG5m3@|e`2115iXPxWNF@*-r~CK8^_IWNSgyU>8sNo*b&{f2Pz
z8uQ^ha;6r6vTI@!ktO^39ZzgDcK(gKu$!_h(L0Cz9C*F)G<|l;#4fDg$ea<T1PbJU
z61$^8Dy~bcO0xWH%JNd4q-c2rIU0+$r^!(C%IkZuc1jsbg%feOC+lS*3%Z*Rj&%lr
z0<R07S$?aqy%XHS)8oC_<Bc9DsU)|NIQ|037DZ4W?@xL}ao6Wpj$RAb5_>>z5Dk=+
z4l0?}>MFdcl&12*Fr`>99vk#}+}9RYC=2nS0UHN;+_51?-aFwT>n~eLPFnWZ*v-6E
z-*b(cE}UP?mjk3)$>{1X>q<e+WQl2?7e4NRTs?QIo`LSqm)gDM6mqjNrptWtR4dRG
zifAW|DgryCrGxm<fV+Lbg1q|r-FzO>!BX}6kt@4wZSO%n5(@Pp!8WGYR+-_U%cZuM
zM~TQD9DcK_O%qUIu|Pra+*JAyqZq~QPFBDN7I$%CQ^52jM%&yv=BzS%nbFGi8O@2)
zVbxnZyeXe%jzgq2^d*$sD;HVQO<}})1Z%>3rRsBT2R8@yc3{Ea58YorKM6($Rg_*f
zx>c1I{5$oBPH=g|>FrZZJ=K1E5X6st$(8-^M=ZNyc{{lzZTQn0TuGQIgeb>V!E}6p
zjKN2|VqL>1fcdVyHhqMYTS#QOK8^c0Y~f(=B9<C1(P8%FGZKs)!1~vmZ64H?^4+#n
zJ>$^SJYeS93O)){=MDb~qyeg;sdj@l(rUfBVkO*YuG2q=WmlT+8K6Jj*BrbO+s6(4
zaG3QbtVIh+Nm*+;{wNkC#gfiYW-{Y}l9ce-cldR@hgI^LhpF2AIwkhb#9%>At9c2E
zOOK4*qP)_qTb9JM>uo$H(cH67yeP(gAqY&${Okl^)fM_)z*6Tn(0B+_Lte$IH{wJ}
z0<!u~EJ0b8q7IjZ1<!)5kpoy|$q8&}Q@k5U%bNm(iCv}$!=qodUuB;6P_|dhF@P~z
zfRsY$9Yi*~T9Hjb5{;q{AAK=x)p+*pTzB#BVD)P~FD(LfRng-gO!o#)|3(iNrZuW`
zaS;6VF>EwI(e;gt!`<Q0PhapdYfE8gXnxY7^iKThJMX1K1-rRevhOd*9tu_|_2yjZ
z9>p_z63gyHaJ4v)gZCN4qqth}RNy9IPhtfe>3#Jh!&e%6Kj}W^{&<TOE|47z7P^gu
z4PtnDco|uhJ~Dl$z@6mppdKG^p!Q}i+#Lol-;aY+@G_jn*`^=KuM{Dvf*nol5#e>@
zES=2IuibOn=Kl9GM1sF>7|-Ao==NwC_d9<%+~A&CkkI2+M&&p<pL?F+PlUURGOosD
zkb102_E}zIA0pEq=5IM6eC}8$;bk7KRKq=D;k)EPe$H4r?>;Y6jr*rBwP^#xZij!1
zk6Mgu8~)O9wLuik{cvh&Y9nTOx;!*{3JChCI{k&v|6<=Cb^NmRZ!_v^`n3BrYLLeG
zjhMlnzgE0L3NlANdk`y+Ql6hqB`}TI$QBI4&Mi%u=mQJL*_oHT*>+o;fdU|&4$uBW
z*RIPal!jy6nG|sQ@=}i^Daw>Kz>3`IZ<cTP{(Sv@)*(->ip&C=<fu_91I*#8jkw>s
z*{mwm!5Yrslnt4+zk<}kp)1N#aQK=DzrlF@i={<>e=gyd&g~CS=9QLoAGrMzmSs^a
zo5u5k$B-%;wosT%pg$^=$84g$mtF2rd8!xvd#b7dt;7+Fv9$Eu?P-(&_1!Ala?(5|
z1@S8DCR$i4r1#O=NR^=p8(S5_PBxYDkMvo`(H6{B=c9~0d6l_mBiE=AmWBKJsaN91
zdP1IY*=zT@v8BIUIc7;H!lg~;ci@PoV;Nl(p~jw7i4T&sXYw>{c-H1g+Hmrcym{PM
zqEJtG_>!FtWwoTg^1K0RPaoK3*Q|#jy8)aHKwUluc#H=fU&8fEU>Cg`^+P9rSJH@c
z&tb9^4WmA_q#;)uBE9cPC0O>Xe76cpPOoSmEJ<I*z@-Iya$aRy2W!NE>sL6F@CTg1
zjK8QV{%b%^XQDjQYhP+_y<jbG=)mFXBNvBCdZJ?k7GJRn)1-+M-n{GnMkxmLt8g1*
zS=&In9&@;xkSc0wqZvpAT^W8*{LjS%R5JI$TkbWz6#iUfO4_&zm<AZqFLJ`x*|~ox
z1TmYgp-(7p2=(&X_lPDcfm)(BBp)}6S&W}Pl<}F}fO5i72EA{)uojsOT<<j3khipq
zirZpTB6}{jpLFvj2CIKTwg+Y*YR^;^=W}EFOp1qle&M6Lb|idtK^TWv$JqtxqIbmK
zRpeNKzTAg&K=3F>boBo3_qvgGQif8Vy$P!7HRo5yD}yIs>9F$&8u4%+o7UJoJq$oC
zoLvU$18JXT=q7??kMCJS2>Pe3RmAIBKwF@An~6PmDs{Lhby&dw`&QDey%Qzixz`Q`
ztLqHUK3OIUDqNJ+ews&5p-4FhL|vK#Ha+6HVnyT`*_861eS)2ri!Mvvgto>OJ;GG-
zh1ab-h)N&Nq#5lYw~tf!GHmOXCy0mLs|ut7A-~ff%mhNO^~}7*I)Av1@@HP*ML|Uh
zv6W>XV-@*%qH2mq3A^k8U#DfFTCILqEF{!nNSC+C`w{1$P~n5r_k~TsI0-1EcC{-4
zC_<SJ?z29u(pcMHJ>&v7YYU$P5SP|~?sGulall&D;A&9P+QI%0`pJpFBF>i@p01$z
zb9%4)u#fcA50gVWnYsY6*Qi%?QG3fc$0%Zkxj{-hd0Sv@B+vk=Swtwq^qSr9fp>-B
z5O3JNt8qv{@v0qgr{Iv`B1|Bab?hC-Yz^_Clr^~=BRuSdX5dDY>y5as!Ko<t7f$}^
za0}pxwZV(=5i-4YJDLJTDX8r(Ye4O^M+EUB35So$hR4rO1Y^S+KN!~Mj0)I@j~v}(
zY%#lmf{t}Xrt{nr=Ge~DD+h;(AYsQ`YYfN_$K;QXXA0P|-;|TSsHr6pqg24!QB$Id
zas<%o{do`MJQTiT5)2YJr)01#2^ZKJtEse$Y!3BwJv~4LY5qVqkmpt_y6X%2oJVrM
zw<-uZx|ss@(>oG`Z)=l@D$y@c4mZMnw=QjIJ*rCj1D4-u{~`yzdi>X7wTTUL{L~aH
z6_72k;y1xRbc3B~$#^^#CE#+pBlb&UlGp8M^&ERRd=AUGqOX9pCng}@T#Z@X_aA{I
zZUjteC(9{8MVEbZ-ZAw@7KZ+wD#7Cd5{L6^tisAu@xQ#)cnel%kG_}k30VR*&ad)z
zXEHKlvqRVP)L^g@PQGcsuOvhqSgj~~;gMaS*lx_I!3L65v+w+T><en~+b9yI#!9|c
zhYVokK|VU7S*aT3#_i`(bTWFOsjK#iIERO#U$v+wdOV2DuNbgX39g?LvB{f<fI)@S
z{#|MQQWBwC*@~bt+JzSZc951=%FMM5p_LuLpMu_`d$d-u%}>GZ{;LxDN=hEY6PE*8
zASaYwcYbfa#Af%6^NlmUpYw$>xk93s0Q$dQu36jckE9epvf`_w(#=En0tz=Wy3fn5
zvht7Be9Jr7&f>OD*uY_&K`B|TPrhMIP63*6W~NvY4%z0wb@Wi9=Idsl!Eb+B?fQCr
zR+GGac?~o$`^4Y*sa9u5uQAY;RvC~xt^>+Dao%O=lv+fJ;P8CLic58$lH`=YftsR&
zuSJ)|Z#K2zM(XArw%)2WHgIiv0tGX>o*18%AvyBTcal^dnZ~!bHH(;*YeZtL->JPX
z-z_gC^s-0$da2wPj@=I>XBiHDn@E#kgAKlBd=|S~cBf_F?+(O&P;>1Ey&gkCTj)=|
zsB#R(9d?GVc+FT<OUpB0wOF<|%;FWslksQ#vXEVAtcu4gkIUQ8PzY-5%MMQC_TjG?
z7O2Hm#VNfh*Vqb7#}1<IzFZG7T9k`;)6#}DG4+?_+r9q_W=})SIp@B_LjTgpvlj4o
zcrKWwbGPvB_dBPDXAplC5eN6vw2vZr#iLZ_lkdBGR?=5{CvPgul44v!c!%Sm#n^Iv
zH)@cH;pk?xpx@(<<1!D0pobkDsjO}QxY6E7e!;7UJKlT1q*M>vAS1oVAjW;WVyx*K
zvzZMG<{Om!TWz4;C2~KRPob9z1fzCNBsvILy5|Nw^-}|3f6&7n`rz%^f-bTYY~3q_
z@RLRyRXxJy7U=3k0NLl=MgLIPbK`Dw-!!@%J?kg$C3mQu^}bFg`#W}4<{Pm(u&3uD
zD_Idcx#4HJ=&^GfkzzFe1W+yX?#U=&tLZ6@g<g8F<>i*jf7A9-Lm&{51Pv0T96V3c
zu4i|c)l;TK6rX)QAlg~Ao$>!HXg^zUXeNGqd8X(kM>%(llYNeH!YHaf#>A+7D$*h7
zd7q$H<thV<Ixn*LrcM;jtxf%Z%4G2#%s~9lZohOVdrFo@#V+Lu7CUByRIm|PnU&4A
zHXVOpk2D=g5!ZXFAI(jZ7VwxWyI(0-3>}={FX;bE)=Ta~OIIw_Hc+a9<MbAHRb249
z!2M-y=k3nacnsQ`6^sn;Ha0zNMn`&)gLc8CA2q7iu^m`jdcfoc#<cAqJ|B>W#HLn_
zri7<${~k2E&8oQYdyoRf_wF+BY5m8R(BenpZudt9VxgyPp;1>^Xn{Iy<Pq{y#>MV$
z=SUUm0s_7F-_~bH4KvHNbH9|*cTH|c1Hh)yA#1Ss3uW`hu;i>-yU4DtUAE39;J~Yk
z4xMv<@g;mqDW8}njRexVF<9?3P<3$&J$!N@8GxrkWwmn2q#8$ZeM8IaMFCGzG>!hW
ziN3jUo{^L9gY2`qtWa1LUI8vA9T*d-a)W$`gNwWdC#(b)P)p$FXdgiqL<De}&{f&M
zX|zW)s4{b}LvP<!34V2Cxf*b`z<O8jrV<mAlbP8T`gh+5_*(t;N4eT!yYyBuC?cc9
z0H6j!u=Jm#s?Z32#O6H1>iq@oH5cvyQFrI9g2F&OF&2Kg`M=LJrWbf0`Cr>#ftcS4
zdw^<K)_ST%(MFDVPvw~%9c?3eybAFTJFeu=M=Y!AYK&2S9Qxc9i_hgi&zJ|gS7bJ7
z(>H3f5ibWGj#{8LI0HXq_}D*O33!Zbz7rss3{x+;pc04695rk7sbIH#SJlZ|ObPRl
z>{|#?=B2NSJ3r{D*|B6K;%mP7R}e(vr(dUcBNnA*J1H5w4vaq+ds%GgiK8jIlyjF{
z1A-Q`Hee6O4vC}C>mFf4G4%hv{*@N7NEi=l{=$ghoATx}{9&J*24mU`&=i+i4d(*x
zeT4Y0-|`@K%ej+Icph_e7PE1u&I6mht#qXbHOnn*<U|a!vM^nmNb+qTO$WV^Nq+e4
zN-a<HytqM6oELO`SHK#p5ZNH;BP)MjDJLn@ki$MOyMI@Z{@U`wy|r|h?6QaP$W%PW
zo8j?MYdoXYrGr?{FRBHGY?*)h21$*e`c!wMDEX$o>;XLq-f(a%P3{#%Eea<pXi*Na
ze2jIV6)G~o$k!fKa`DzRn`lzrTt}O&VMTLSH}Y|anm1zbu<SGzIHR+G%4)0Bsx3*a
z#w$4;lzqquvkFwdsmP>&6+=vME*yIhgG5M7Iivsqp?WgDC%0vPj30#ft91-VYwV35
z-c){<`FIUj0dsUtDGJogGvXhU^oc{i<kuL}M!zk-iak^_b7WS!twRQT`fV4S{fPFh
z$6suq5gk0d;vJIGd!P6WbD;-n>Emu&vqaW5EP_YE=#Fc1>>lN{Yn(BITGR-;D9?Ts
z2Tzyo2%tfvremZlln+V#eb8!;s5`OGHK|8(e(TmXxuQXwt6P3Qyl(O$yhOa?#P}~d
z{ImU?!IL@$F~7fmiSMTiApSQ%(hnB<P|`03oUE$G4g)B$v7)^8zBIc(nqtkZ1lS%k
z(+Qu=rc4w25+7XfNzQ4V%yP1hNxDKqhMg}1;xaFd;Zs*s-Uq=YZ>jMCcV{osJ5M?X
z=qD#hIPC*f*6knIQu<t6a(RRu?erU1H=@uHYHMy4W7%mVf%uqTD^ukF4P2H_uYLwv
zdjB=O?wG;*o=vSs`;kY?ZeQ0R(<*)~Fz`p8ACX{dc%?UVZ*8-mC6F3Mz)q!z!__0w
z2~qA{d+lxM5ohzm+E16bJHXBE*2W`iaPIkgM~WZ}_az!)7Inm`td&hKmoj1zT`VXl
zC()QuG0T{M3p5adLWC2ra<7Gd%=r;{Z5giYmwA&i2!8^pK^qk^VC?se#h=6m0LEzc
zibvB0>*^J@i>Dw!1rZiN;&b<iWRXw`a~H8!R(ZvXU<Z%+TZnoDDe7!k({(TjCE7!?
z+VtxIGfq1PHvwvOyDff^B2Y~R#ia2swr$zpkSX~Q9p1Y=fgVNcoTf)}KMQD1D*^LH
zU@YS;)0Zw@VUDvGxBlrs)rx_e^@^uMe-uc!T5YkH9ykBiNj=1fHQ;$=1DAxG6@)Ic
z_6GOhhyqBQa4iR!jZ!sCyvjovY~(lW`GewKw}t1%Kj`Kg^X50y$7*cty590FZ)&S3
z<rA?4Q!?hb1|R_oSB;ldq9B;5>2Qja^rOX4cxr8jD|_WMM}2UojoHE}pmKap@woQv
z13i7Uk_Q{XwaO;T0OQn6!^^5b4Us&JeLJ+VD^x<@g%7;Mb-z)p%`*UO`#_#!o*>Q{
zx-YiPF-_F)i%Lwqz5eB70-^MmkhQ8r_w`+icNGBKRl%hf8OR%nUi_G9BjjsIf=YV|
zbYK`Mk^fEmFQ37BQ=YEM4jwP1j@5-_m|hHyT<Pv!LTn22<9k6*VUM?(zar`ah<>l)
zf*h})C3O_>Dpe%%`}j~D<(H6tHOv2JIb{V*FL=4Sb1z~g*i=os&K&v6f{C8$tz;p*
z9<Yq8zj_4_Y^2`VHJuoI9Zh|_s6cl(aZ^F|beOd95%C2QZstu0YC`Lytp}eI{T{xJ
zkvS1}ga)2|h@(yOg+v1lde4f3!+kPE#b<^w4Wf{T0xIOewb{aFyLi4N9P*g8eToIf
zxaJyp>8cLTUU>|-`o5v@bA?Vcy&W=p65Xmrb#PU8^-8kM7e|PBHj(){+Hqhl#lDG(
zd?}et;azsaF9a3yLh`I^`jKxHGBL14`*&I$#z+cEqa7ESCTko8j71L}4GSD%3<kUU
zjon2ZXj88aKDjP2bj=R60QQlkP*L=~sQroSY!uRj9fNjP>UjwSI=3QOgSc`kd*cu}
zcvAXH6EZMsTSgyvR90&TkgN@DYVn4hz#mDg2QQsy4Ajs9XGzeuWd_QavN?N^t%u=U
z)E9<6+#z0G{$%s5u@@9|WjMXtWgJMYcVKe`@Q&|D*<?Ae`F7P*He!Z#1ee}m{MDR3
zUDj1u!NE*e2#F`>tq^K&PA+E&4XYLHT-yvbg_pTiO(Gb#VDy)pMEhoM<jbP;ex>2h
zQcDF1qlDRcX&hdi>dXTt5{yr6BzKa?UEN8lkrqRAHYz{XOzg$VT`jTTke9rl^>|!+
z)qCfzq>*VPDN?|&?eP|@>y$~AhV0u3d9zYd15a4L36lazxRzj6X3|*%93e}0WYE9}
zXN^4ipiOub_rU4l>fb@R*L37#x7}>{Kc5EM{5G+=GQcbwxY%_b=Q!V`KHT*sd3?Ra
z^3LHa!@ks4U$2(9HjtP1{?p|F{bj_LQXC*1>N|zZRVDD!kb1T-^O5KXYdfu)_6{5b
z!$4#QsqU@}zYYn1;v#~$YMw(TOF@Z~?{$D(^uGfli#4pg8Uha-e;!2wRoC|X3fvHv
zMqc$vquCkSvGJhQA@lbh*NYNOR5<U6<Ac>9=M~84{J2}bmmOAbY%lHc6pS66)=y7Z
zmh?o=MBGPiyM?eTkq+N}lLkGS%f+`cMxQh;$&L9~r>>}fPu`TDmDLN=Gg~Lk*z@yE
z*Pu!MR<{H6uTXOFTM`aR7tMeZ&Wxz1j}`2PDTtXShZ-F?ME;gQ5zYLChe++!IpNXP
zQvLv=cq7Ao=gX;oYDe3nEjm<SbOc;T*Ux==b=b=4;(3)><l^hk{`mfx{4;80Dyr0y
zeR?N%No&j#$!9kmuB*Gkx*XDuB;X_O9kx_3<9NQRu3)}6@q+A;1wueH@IS@I+iwyK
zB)fu{BoHMRQ*DW$o~&jD$O`|!qI$$lEw?L1nT!kdt~M(GcG&Mfjoy)ndFrkCnud-a
z*QJf@h(kcs%iG5`CnT}fL^eEUpZSh=vNUv0XM1iZ>t{Ge8t$uh!}qcvweFh%c53|Y
z)$;J+#SvfXPjaR<Nu~U}lF(kJp7ZAqA3r|fPvQwXrucCF*@PF+r_OoqC(en}+qkPt
zlTHUYVQp^Z%sPzL(4_<3;5M5M5%J37;6UmC=sd5U{1Exl+xKAn)QJQuIg~gQudM3)
zbH#VsJF6oqpIBo*`b9=$$lS$dBid53W`}w}+vU5G*e8f%Q3Lptlb2T0-JWsYMf3kR
zfd2HNzm-ArLP8kPNK~f*UND~9MA+Fb3PB_XCVt^%$ue<KKzIL7x7j)DbN}OWp!S0K
zUm8e;CRXP-|Kc4<mVxq#TDFX^rKpZ}@8vwGhx0Z-uEgHUqs)yu4-T=rms4#q4-7Sn
zzE?zvKxr6y!we>vyR}7sXkTgcft-Rv<2p8M?_x5HEU2mNC@P2WU`Rt=WOPL1qz<Dh
zl-6gekaT!gD_L0u)=pos-)jqSifMoQO5p<jd};J8Cj)i$N_4u-r|mM-9_ID{z=fP1
z6Znld{#r7ZRckz?1a)YoDOw}*SP1%1oVQVL9prS?!2%&G=(5``RwseKtHetNkmO&~
zT^dOtd>Iz(ij!sHC8_35yuCnB`rxmeJ7Vubr$fQl9A9cACc8@Gz1~_)U&Oh2^|89g
z_${vcuDIH`=`AdUNn3WY$lDHa{SyCRh`khxYH;2_oxP>y4Oj=spD{j;(+Jk_j>{|I
zdt5>>vh2FS8TXMsr1<nPsO1sxDzAGC4(e@?Q{wSAcbRVW68O_?`3)3sU|4nD5tKey
z5zRX$?3pa-VwEiBE$wzmx_64>`k#Wyx5M6!Y}0P9H46Fg3BQ)pV^)wB*ETc@rVNDt
zvGp1|>Pj2W#63x7(~7WB>1KLCeSY##+Ur9%+4;pz5+G8r?ut~vDTgq!Hz!UzM%aa}
zE`F5_a(y4hxFCQUuDl}QL~&AS)GUHn!uitPGe-}z_j7R2k|>t`dKh!j=++p~@JO}!
zbe3(FWv5*$pctze{PCPn5XH@J|IsizsQaY36*V{=r(#+(O&u**!Fhh3V=oHp0x8DB
zrox6+nE1OdTl=dT&Y&P{8P*zy5FQC*)Z?bUl_ZPdj=OquOT;Sq*A~6B#l(jw;2_I~
zq0iT2@xSmgO6cu)sBg3AZ=+(RxuK8>={Eu2a-}rHkmg$f!@)a#&ehSvl21JB^^wJd
zd_ynRW(o@X4F30B3q^;VhbN)pICEn)l<LcvUDb&63Z~BHRIp7<eGshjkua3R-NIP-
zx5BUbYy_XnX=4&t9t^$ErZ35c9nk#@Z*p<5=f;O`N4l@SV19%ZeLV;br`GOfR$7vV
zH(d_vCXPhT$-M0{h+@F#{x+P0(EOVabbo8fT<wFL2;v1Mhqe34e^(me7`O1;bH4Gt
zhA5&Tw{j62%Xl1+$H})9{-E$Ey|age$agdy-M=BMrd4g~n&6Gw1JvjQ#X6}UOYaJ3
zGDY<)<nS$H+pgz|Y^(lLTQJx=XK7QU-&2hK#MxQI&5SPDxIgwIJ=d#nVzqqj7*NQF
z{S--?fG_dt`5Q|*xchJVq1!u$QVOE^0&BbkzBMdv4Wdzdw(2CP>r>^ALoDC+p1k8E
zZ->*F;)3B_^(3*<h}D4wuDd|yyJ)z|vX$h)PseTk2c-J!qd6sOAzJLzpYhCWMoRQl
zykMr&W5ly*Qi^F^Nh{vXzCB))u>mQT*}<AlbiVeyoH#Hl6wS9D|3wACXGg(vNs=B(
z9K|$#qvr7&AqhF3;U~T?|0t7rWh1gx0y?P)Y6e@inG_~AUU^?#6aIS&6Nqi-NRv`k
zUniAZoBP`n4w}BhSHyhMW;vwE--F?^OjKB@FHs3`o=!#T!q#4rf>a5l#uFvnftT}}
z+~A_pJ@dCd<5NR-JnvfqY8yHz2s=`URWwE$K#GBOFKXUo`F7*Z9r^-AtSx1yW#>Ky
zXchOX{g9`s=naFuJ&OLTO9;t|-x`=41`LaQt<=<XoYO9QXZkAtdM0smBj9v5exBIX
z2C#$Xj!m>d=0TG>zBoh!ubtVg-Y<p9$xIYtf(+X-p;*0&=+bw^ZeAAQ<3`JB_kik5
z@g1u$Q#H#vtdK8B<wWh#1OlYXbC)J580jm0M#JJ28ScO1M@;=^`-GGid|M}upQ{5%
zAhJA~lXQ!6X6TR9!0ZlGXEqe^bu#sasYZ3ebBIImkV;LWIuk*vqFt~_Z5>8=$gK3r
z<rC{{_j4KOeajwe7QG02XHWu*J#9&JsitUD|6OU$2CPixmdBL(P(+-4eP^{BskTe<
z69>oNx3^|TESiN$n7T4RtHgj&Q?l0Un2Hp?ZOe3!enuSUf2SX0eMvjS+WnE(37o6L
zr_rHV%1Wf{csZoKz|Uuycdoe=mc(;QWSQK^Y;$+3#TAw;;a3X)I(pIeBoC=m2&4Wy
z=LpF*n@~@dn(w3xU3lLwZEp7W<+@Y$&#PB1fnLvU&TqnWL2V8ijPmc=?MhC_)nRrg
z2;=m7OzUvYNj=+b`j`ECH~MbQtG{U<3>f$d<cCv>vMLZ8D&Lm7{l7_rQ*pM+t0Qrh
zJ5=A!k_s;)vU}Kut3C{kDAwKaTH4G>-+L3&SXrm+9Y_A*w8;K?V;9Q{4l-mjnkX^T
znI60EmMS9ax%7PE<e?*BoG4nd9+g+Rr;S5L*iBN^2W^HT!eT9(CMl`;rvk%1U2<J5
zb#D!B3L6DWyoRMemV(L~geB6ZEm}=il>Mz$aOcKz3lF-h%U_1$JPLRhm8mre+0V9J
zBSyH!h8j{i^LJbwS(V^--T4hN2gXqm_B)*Ismk6Zbh7dcL_gadbHs8@sdR7hFv4#2
z$6`qwLw%d7srr`_sXyzGQTss6rQ$n2?^0{MY^vMg#A<1-Jj-iywRSc@?}g;@#i!@y
z0SC#0zR?P-gI@aLP#S6xR)wX;%8oRdWs`b^OMp+akel9Y;C2K;7oci6RO|ZgL`h`;
z(Cy^-ZqmWYhWGa}NmehK)7jdk6Z9<@V5X>4HXOxXFN}Gu&tv*Ae1368wxz$gtooOD
z{KvRc>~a8VPc=^IVG+SwyhrYKTxnB<8_2b@;{lMGYv;gm$L43F_d%EOq*WX8;3Fx@
z*14&8lI2evY1-@cpc|rtilFcY5H55|CZn!ii*PptUc;QDH|L8{{O}c+#DDYCg`6=T
zjhZ?>gDXZnD_#0g*H&lWrHWF?y*;+L<^@iZu226_*?N8W^jG-;YEXVwdgp>ydUHYg
z)(<nUd-mV%iIcP#s+6M2I!c+?mKRiBs+oSA_PF9wk1ta5y?|hqUZ<tirVqs(La)?Q
zb~z&db4V(0r1&&nWM}&>WqAduHxm<?{$B^3Ts=B_dUx0NN~f;K{fFXvcnzz!lb#v0
zO@Ef>Wy3oR;*^-yw%ThvYu5WN-JEzHgcs=&$fXWX#i9{iqcL3|09=)2si6u-a$Sy%
zFrqmIOcFOuBX*K#?>QuKHVAr>EUZ>yQk3};%9CRMD}sZXUBmwVDAm;*oF=XF4dKa#
zMmPmCeIraS8~()mZ@95ywTM?3dFi3Q%og@ysLmAaOW+iD^=;1nB8BF40;iN?0@vHd
zt=eXI;ruh(K@Vq*uQ+VVA7K)z;Qgbo#e-%>4DUSGRbr3M>&8WdABP?u3Hy@#>sYC3
zPJ-y35(<vskP0~w)s?53y|%|xu6mUsWQ^sVmQ`2gcNZ%iy-_)&9t-qRM`7GzW$+5#
zHJ^v1*gO7C)}$(!pL&nT)*!=?M<8Wh%ek^Dr5Qtzl^VPox`4g)sc^+^;`VV*{*RgM
zEYG&0;SyI%M|y?$>3PexCEZu?DMfo?RH|opGZaWLA)#%o8DD7BbF;ZKF0$*BBTtTz
zq)Jz=y@2&)K}25AH<_K7rXo&u=7U_nwGi|N`UUY}a%&ms?y$|5f{2qlt!ob#1}5sd
zTj^&Qsd$(q;uNBRpIsULHE=wsdodu-HJm#u=HuJ^u65uG0S4tv+2zNd>>F17urNk*
z-+{{K5}$0o#}yjBEjNUU>BUpj5G~^*a}8@M?i14gi+eF`%T7@t(a_4tj)O3RJiB7&
zr;6?#pUF9R2#}hHIIETXJ$ZMseqBjd(RiQIT_HYej>zwSs1DEArFR^}6++`1`su4Z
z%%@41@FtKZ@@*t2;q&x%l~KB!*O)%Kfy1Z%nWgAU7QI*s^UQ&sq$4lRhiygxiay7G
zJzyVWEM5GYOfVy-Tfl+&77M`en-1RF=1G=gzF+UKn?!M^fP@^&{>?&mjgzV>*76*b
z=x@!e;*>Y`xw?3NbYe#z<Fm9G7UlqzFJSz(XS17vn0OR)x<QGGTaisz2=2uSAUO2r
z9|EEydZK`>4XG8p{+~G6|L|p%rfDt=h&u%Wm{nZal){fAj$S$?HrO+!JlywjQ`P>w
z&0-~_N$n9}r0e{xyP#z5YXfcPcDNBL_VT*Ts?{HXnk4fdhJW+>%y@5c0f+4b8Z)Om
zQPLcpIqx~_y)((~&)kL{mXMkf3`m~b8vKr`Jf@OUriRdFU`QPI38~QO1#^mDAn}SY
z`eBP-V^yHUUPq}$ci1f<YIh}uD(Zf#*?g#<2z1tYBm4wc=-R&jX;VO6J{f}}gTq>C
z?ve}ld<#wiM6UV^gjSxpfCA%#SgKq<5SU~>5ME5TD+idUH!xK2PP@I7Bz0MtN5gE3
z+r>3TPR+*(!lb3G+|(DUyY>|QXxLl$0r9umtpgfZ``i=Vq9rSC=E7DFh(VI1W<K*j
zti|?|mQ$RdbHO0xb_~UnZ1SSWa&3by7JIHGU52WdGFIZr?ZW^PbI2;%--h^i+|JS-
zK)*m!G4a0`A)7x2bZ*gSS;fo%Ri}3+ApY`1Ig}yoO%)O%Pf@VCyM{Bz*gn0t!*^~4
z8n_KnGdF2=b4gqj3h#M2wk0TTy^LZ}%(d4Xd5@FEbB1&?C>xkdE}26ltKv#vTC;5g
z^XU+Nrm*&otAsNK5iHp?3P}akxu;FttIf7vpvn0KgJ}<@W@7-O+Px#>reSFTsku|H
z)n}wj1B21nx`g;8`|bfrWi;rC_RP2K#%<OH_s`fjPT^*5J3p_qNx+5oCvo_Q@t3)m
z$-8FBr)x1cmEeRWF%q)j3prd!*x*D#XnP>*@nD8M-c29tPNitOLHfeWeWX1Dw_sQV
zUN#|v8x<S0%SICTZXucr1w7*x1@bmu_r33?)*iasH5jHnKAs}s*WB})-PQe6$Is^9
z@}a;Fa4YShxn*-FKaZ3pp838S^!9T<i<(H0Phs^Q>hDfCR@DnWdYtdvoqysbS2G-c
z2l{Y}T<rMdr~~5M4dG&p*E`&2#8LTW*-ql4Q6!)=Deprs04*_sF$j<qv`H2?dXU1A
zl-g3ArVz7;#s4PA{Sp=h`2Qv^7F6adFk3&F_Uwk%6AWi?nGOxE@zH2!xA<97p8#h4
zxah>rd^t`rqDb#5d}!vEV)7p_TAM!g@w8J@+?*LEW;-!40{CCI%G|n<+QMn2xr=17
zyps*tg-Qev<3Koqq(s><E!r=QYShyU-QPWUHYGg3`{c>SOnQA3F_Uw?jwlMDPD9aK
zl=fOA=8Srhp|=HoBDDd#@}1{0Rw64u3@p)<lH><#b?VlT+<RHb4~{Z+_!SF+@6^eK
zdz!UGNi1H>#cGXi<nlvQItbn*QbM|y6j7rYROup`tR7YRdQOr#!@GvDLkfl1&5vn}
zH<!w==Yum%KCx@?tc|7*XDIr|#1~W-!(6*RH64$<tJ0*sw33BL^uy($8Z3-UTUC&7
z&?V~{)_km-{!j}}m=);&!y^AE%rV$8&HAg7OPdfgroGT~Dn;qDB7Kdq$pS8cPPwdi
zhfo_SqRdJ;eO_~4SCyyb$&o2+bWTx@kE%jga4G|{_oo-s9@aCH%y~x^+89P-OIulC
z1luC$Gm44L&7@C7Ef%B&-+s<Y@^*=k<MubiI1W$ZNXvE@s-5&&XP4~uvS9p8;lZ1V
zHGYwHL=Ha5v%|zX>cCYM_03yk-p)mOE`DrxO=9H|BZ1$5{9<-F&X7k{WZ%;Ri@WHl
zm|Bj2^+DKY07jiLig3RBR{xhvE@Koo^ip32gr&IP{*aLXKFjXHACfdmE7U_dD9)j1
zBWVdR_8+_^ZQxZF8`P<|QCAXsZVMdmJ}#n<7x#~zrt1oNIm<s3>wp2<_HK1sZTm#J
z$EOq&ZlsU?6(J`F75{la<|$G9D*1)dO3!-*`qbl9Yq5|_^$`L$aaa3F`lOcJ+MC~+
zGA_2CAyws90jTBJj%TgKx$)C?o3|lFOnLNs;wUBsH<@yB>?%CQmfxM(ok>myD~8uS
zakT&1lv!S~T@@T>VUxBjr({h*f7zO(@z5+}c(vRdb}JuxpLYLrqp*}u8tu9g?2mkI
zHTUdhmJG}WggKA3NH6S4leDIgq&0eD{c8^iX&ugP9A2H@D@dzg3y51jIs~2PlKL9(
zS%Vh+IsYN((sxs&W^ccYi_~RVo6!b;NmYmO3vW)E^|%GhP9Ix!78qLzbqxqgKjj^P
zlZ~ztQtL_{jT(m6wPL0)PHED5pQhnHEM7}Mr`g`O3+q6-O8>&VzWNu_Iri82zr^i5
zBD5NBkYraqs$CIZJrKBZSjnl<hs1k4_sB3kIg2}+<k$Va@0D}~mf*j9HUU6;P@MM*
z*;GWF&O^yv>O1es{;2KPif!XrNrT4E$`7cc`O$oO*&0qr!&w{RkQ{tIq!4y5nbhFy
z{=I6}W=N<=Z@gjcoM+5PmsJVG^V@kLa#2ruALSxhfHE<~3R_y~2s+`8T(1ueZG`);
zu+Z(D8JjXGHe7^hpp={%3S2{k7fZ_ZIH>^tHjY%<JROJp2=M>1%reZcB7!ITY`mOW
z%+>vIPzG9uzG}i^xA~+jYt+paa^^9g->iQ(sZ(=r^QHMTNUV?KM+&Wkmcvv&HVDGe
zE~Ur1g5-GiyDvOr;UWBMXtQ`0C3^-;w-v>(@lqrlld)8CN0o(N?nYC!9d%^C1b>3Y
zS^fTER---nPSy7tbP8U5y6TliKnP6Fy<O_aIS!sJs0%HL^#Js24Py297(udG&v;!V
zbM3!5@Ng(1@1WmJ;!jID;uGCXfD`zzZ6iw);6($^$^JiF?`IMPG_bVH{7D>CNME|Q
z^TaEURD(TXS8~tvb}Qucm&{sRFgIBN`0#!&-SfqzM=nlKf@KNqj`b~ORI5cxooXiI
z^fW4lYOZ17dGMxGK3R-LSiwB?#Q?RDU(&2{s%Lg#FgUAK<zB$dBh?b>1VK{r8K_FT
z1)0<Z5~<P4Z?rv0U98I&<7bXd1{=p~-_`5xx%aqxG<R+C#?5T=1^F=efxa{dHkA#{
zP!(kic2r^PQA~<yBOt+tm_sgG<B+8u)$%S@M!tX@|I!WD*U{LnyCEVYPa(%t*Qmn|
zn+sqU*~Wamf?1_a0+y1~hjZuK3_Oyx<jG*=kkc4Vo!!lB#%huXW@3cvTMX_&X&VHR
ztkbRY=Zy$18}ucx8c%NhqaAM9_v?*}r$)b|%b-(IJSyW5?%OZUz*gsX9qI$}-S&6+
zlMhZ#PO?AB);9EgdZsBl;by?$4tLFK;QFsU|8{pyB4mL(stfjeWVg69pqJf4tgR|_
zM_<7W-+=zsruuOv{T(}wd;PYJ;0pQqHAJ_(Y8G|xB;1ytzN)ccm`v{%&l-!){<o8-
zO$6Cx#_E^h)Mw843oPiX)_Be>oAZT8&hHzRuZK_C!Q2~p^F^{H58|LH3TDvD(X)B+
z_-S0nm!2)(_|Ij~X#N!6(*R?H9S+Z#EwJ8i^{qP`jm?Tk=L~!H`23v1KH+g>mz*?d
zzrMJgsd5hZWH9*l<d}@76g420WB)wm3miR+6xSg>n^6B$cA33z*RFi|l>+h4L=)>2
z`Q-<@B-Xi^T_sCk%s;H|*3kA_(~Az?vR%nihhqm~>&ts=OOF0iEElX+QHkW{sH<;n
zh#VC(GC+se?++MRs^)BBwTkaVBoZPQ%Y_Df);g?q?VpHD_gHf<DW|qB9$1z$2b2M3
zneGK?ZaBFSpWWm$#Lu6XU5}mDeH(efczPP#nBtKIZ!3b4rBYk}5qo*qCgI}5pQx(#
z;IX<Zhf@BbDvIyNISIv82|3b#lS>|PW>GP?%8ITWwfZ>+t&n=%ewa%g^z(y1lhzM%
zm|@_4NEOI*;_CA@l5L4pdZ)BmVAvp|knaGa=xwAz{6y`JsVX?yS4ud3FT~CWsEebm
z{?Qw-MqV%?rz4sUT{0y@c998G55|KZ#LO3^juL8X%ihR(!5%+S=`$EV<rMOn6o5XI
z{6rz}>M@H#{>hwiBQvahfZT7v>V-ZCSAuOmoP(JA2e^VHJ@a$+X@S2AhdQ{gQ8N~i
z5bDd{;WO#y<Zsdkv-`<*cJHtL$P=V^Fm<2F^2gT(XOUG*l7NfVc|?XnBycdb!TOVy
zH@iZ9@7MIgj?dXL!hDrAsSwhMSdqN#7XfeMgzByQprW~{bpL;$Ke|gcAZ&_G)n=;z
z60T&Ube7c=2Vr1&C%bo6wi$aE+mAAk3q%ucmTmjoH3k@)kT5E#ZNChMIE=(9ndE&m
zENzn(;h4fK@BG;DX$~|{n?`+$&lX0>Kj57R>x_?BG^A5qW{8d;r;1J>r}%}yA^sI6
zNQk?o9$yPdZGDU2yo6VOx}v-tT@slTM!BQod|)yqOiP+Lmj6aNMT5kS#Dld9TjJ6O
z$w%W2@{t*}q^hrpw5E*u(fZ~p4)?lbnimG>7V#_rtxTqNFE<WjC&N0GBJHeiurp)t
z>km&i;1KF217uRrCy--AN|C2)!@Yn5NEJm!m$SV-xR6i4*y`thUa;RKl^uC>dn0}Q
zsJ+WdU{vp!xA>U%V#{`T%@UJ0vpg76=Z?d(;a?4;rGbdnkAJq@RIOt?ZR5d_gD!eY
z;@a6j6JZq68pPCT>#jW-e@USo7A4(5%l6?5fbc)QO4{gtlZ@7m+4Pi%MZsVuFtsK%
z0(>NYBEW32oZ6tW@(i=!dle96-82Ke+P+Mj+ll<ys;$j1>t`kA(rfOONaB>C$Ny}Y
z(_Oy+ob628|9Y~fyYwD%@hgd;&@iSPRq_x%P>b^6<m3}MriYko5BN!wOSxHv=8b;S
z0a7w#TMbYX?2hrKkYUz<+-VS;D!edbMfpC8Nks%|sKTz~zeG@qDlXY|KyL><uM6Z>
znDwxJS%qZv<hkHKgNDyMnpab@!X$~1>MDoh8z7uRT#%~54#;vhIqeR)ZRu@ued1TS
z!Z~QYj8b}Y1d*;vhG{H1;@?R;JudE2vrZyfn|OD~yJIT9XPN(LFJBPm<W61>`9$*M
zps(AaNeL50DwZOz`!<uXN>=IM6j#pn`K-c+q0D^1(yx~>Ff}gr-$;$PvsdDbt0aZn
zq=`hcg?-YbC-OCArs-AisWV?n2wn;A0=<z)Q%piC?N^~`Cdoo5B-q9#?y5feL5lKO
zW5hHsS%{^}^uU`EQXyfC)LOybxix4LZAaB(w08d~jtr!|tgpbitR2yy62YzN!|Zpy
zNVGFo^1bT{b0HI=#?23ZB%aGgaMw5{$yynA$z_bhT|EnI2fRkYxFK(P>GWWvPHufE
zm%tCFBf6M@xs<Syo+1G+t-aS;y#0cW;O^7f<<xeJ7cYwbWmF{V*#W8{qM<Kh-jQ{x
zVEC|XF{AZuE2o2p=PKLeQpO(<X!2k6d9Y9qY7jKg56w>5Wod4nc1P_^`uR;3T4R``
zyrs9$qUcHq=t!a9B&lJFEA#61ae1^RoloZKI}s?Ykf`I+r9X=4tU^$4p1kfjP%h|*
zMJdPVXEzl{c<)UlC{$V<7PIa@i7!I!c@LzM#E+_bG-UPTm0veM7gAHst8`8M=Xs33
z4jI0AuS*n~tQ>39^dZhV`L0^g#&MubRRw!<>+~Q>U|juC%r}Jltf*&TgS$n&eX?wg
zBj)-kca=Iv!0glX?G4eijcWN^lh4Kbi|1TI#d=(M_t%tfa+`Q~X{9lY_sn3-A^K#O
zgbQet5;em=0^vzGag5%7glZe&r!qgcHPJ1J4I>{=3J6oR7DgCeH@WEX%rXC&vp-6z
zz(_*VhDu6*MeB?vdx^4L##Sqq7dyM4WjW>$&gGS%i=QPNJSrdZ4SSsPI#-8tk>d_{
zv)|C4H%4dF)haLn8l$;6)Y6ygsxt_O(zAg*$fH>2N>XcFL{jRr6a^HecieY&rPQXL
zZ~gb8?G|5~tuo$vmu+B`QogRyK{BXF$o|EZ3WQp~ZIYB9R-dYMygJE?)-y^=l}P^@
zQEI4(vH-TM-K<V<8*`h2_WAxm%V`9>?mO;>&t=(}>mg>+zjs~M*I2e>OvIzjJ}_K1
zMrM>>?-X8&a)#JXkY{LwS?EDh9$u2#?`X@Jl-DAPwv@dje}uIQhiyhJ{w0@=oO=wQ
z7$XNP>+NWx?_*qJTh*Bq{1sVe|KmX2@|z8jCUEY-4Z{+C=`&v@dfrp%@%(y}1S0aI
zJ2TvcsQK})XqU`>RIRh_c&9X9pw5Dr9?myoi94+wk-)h%9gf&51o5*|bfni8c2=?4
z@|PD7%u#5)cW@?WmNN_vx*r<$lN7?c?|E}~n5u@aj&Q~|Wz6iJua1NUuAX_x_E0nj
zRV*dbQZc~oFR+;F_3Qi%=xDEXd+QdwL>q3c#e2An1IfvIOe*7WQh@U!-IJ*>Kj~|p
z)>#aV%X3}wVk7mQ9c704HPTTA(i26RkfeV)nPf9U(*f7zpu;VPe+JE7#+sEUb@I<G
zi_8b{Cd07v*Wn)A73Zjl&F7vWVZI$$#<Mw<^(9AVP^j@zsUwt6{I~$paAYadr0qz%
z$;}g3nMd6;=653QB;c?&B(5q!>FVL>y!aY2%n}f74!8L2$K_y9Kh#7AoNB@A<PDdV
zo(s)%y0Xi{-p|~pp{sMQd)>OrZA)v;;nplahk#SjhSU*mI5&H!ZpegG@JBq&E*T0p
zmy_Rt%vr5BU6icfV;^{w?Ik8(uH(ge3v?QX`FvNg9Q;LA*q-=Xyu9@N|1kC5@l?NW
z{5UBZRtOo1jFgd#<CJV=D~B?}QOGzPGc!`wvB^3lvJ;MZY;ul~mB>6s$2gRcJ&y6a
zy+7aY@ArE=&L7lq&)4g|uj_d|ujdupLjElOjJ85%m7;|{Q-SK37DT&yo*d9}D`>5%
z5J239)f&D+NBzE;xvfXPaVHOe&p*|4J7<1BKM{8dvY`d($alp5W4H{DmpvdyI;E|o
zu5^q<8$oW4c~1V6?vZP<u9!TINTeC>BagzR+o6|Fy()Yiw95LKUsV-^$APOx7pJq#
zKNo9oKp|4%xe)!OC_u0J_21n|Tv=1@($(v$6ckh<{+|jfYAZHLwuh;iS-7nStZ-nR
z!*;N+ixrSkM&A-Z(9jR@IL-}Emk$mlH*274p}9q?H{KF8$VZc_1LZG$hgZf$tM)Cq
zF-PT-<#N?4J4is1as8NI)Xz&&z4c`FM(9|&AkRSrXFR-zU3nSV&NlL#pndrtSMUN$
zM<tdRWWDNXlpI(k)3ANNax?#OV?X_q<ngV*miUm9C1SOUHfgpHKN9vkIw3g>Tbq%1
zbnk?q))(8_wqmD4NY^(s;<D%;cdSvUIB~4;T|OqwdQJ{i`<InG{z;JW`^v@80R>(F
zwsJZ@^JGZ(&jBq|D33*2%q=W^G`qdyXGe(^U@up}Xdr5qEkus~A*A7zj}1P64FPx@
z9rP9q6wCkosg0OCBkP91iJC;{80Ylbq1N*~GQG<6=e?84y_0m+zR{pIoK6_lJJvCV
zXS8PWxH3_?p4-MSZCv(W727bU=6DvJb4^U#M#?0;!`Q$3Jh3|<lxAzLZJfF4Es<Y<
z%$lJPeor4gOFmBd_E7TIXuOXI^6F7Kn)gmB=1fMBYh4&OoBDc&f9kE0qHpHF5ed1U
zQ?|&&J!y4E_As)%3mEu<C0b4<LuEr`zXG0-Da)OOs=Kn5Pi@Ue3i+Mk(k?033zs1b
zNna7&9o3V^If;xsF$yO=PW?_!2cy-dW;>^@QljHni4{-64w*%`-q_y1ye|Zo441Ku
z7)ujNk_zeNLv)UQB59hiVTfm-_@sMaD57{T#zE(!1&S7b^Mgni3y3p4MIf0)!pDN)
z%-&T8=d!ZBJHBq7A!>MOiF+r)YP!oObZBfigu)}kdX?(NHWkbEz8ZXs2T*%nM0QfD
zyw|1AZWm~0m-1|2?=B{WT)&WYAuMjIa1mCk6?N&|ae(3PbE#PKr_BmQF<43w^V4@q
z8{|Hl%y9KjrDq)d!eimbYoZ@IHK2`v^meQ`_fe8puQdS2>dYB4{iaxr5Sz8WlhNDt
z1f-_@n$8!zgrpj0`u2v(O~~;)FGf^ajFH3C@b`{$({_DnSr&K}PnT8Rs!gBMqU+x(
z@Hr>gW;F-)JD8xbV&gl=1cV~ThJ8#d1iNeHM0_a8zath0izq-Y{TX!Q>@L3yQ5Cvb
z^CIfp`XaW4366SVyItJdi?1v|o{KWIr$Q83Nj_SV6ty#|BR9DHd4R5vY%s4Cd`VI;
znA2`#92}7-Rhr9TkA*jW5lQMauE6qItI`L?3Ihl|Y=D$6XbKR-JA2IB6Z*4fRN!Au
z19v=HrD~D4?Tij+%iKZZV=qj4%5v68K06?-_>H=;q#B8b&oz%#Dy^E{Cp_4?FT4F^
zai;{*O?%o8%NLq>(_X4J=GT}-(l?U8r6572K^A9?%3oI(nN1Ckn8)B0`JV>h4=-_?
z9+perY@+qoVAw@}^Exum6{}6M{<W0y&E4>Hs2bgcrGn%;>Ph_eW@5=Zw~vnY^{hk;
zM*}e)V;?xDwWC<?<?b9wkdG33ZXr@=e<Z~c;#rjo`g8HDCbksKoJ`LQ{ZWn>K)M;i
zzD%G@5_4R*xh;>s)O$tJr}@~s-ak7rbdSVNaoyFGQ97p|Sbl-V<pt}P@1d=Ud7O|(
zS;?82+#|{d{&#I16HsW0Akq|jdwY_DnWf#TTdCw78JQYp(;F((5lqy5mq=&I*CHQr
zx&fzCEY6xJn4Wk1>94HA;tf)m(_JL9q`KcTF}fgR5JtXtjM2}?(MrUd;{3}V#W>Sr
zF~`-LrVU3&inPdtgaRb+RRs}s>)TG9rqgRNV?ubor_B!@Icnf_z6Zhu{BH`!IAd~e
z;Ma8sxT`l8`fi8`Eqm@JH<BWbR*xm`J|xTm+LIX=Lf+NCLZK3djsti)ZW@?DPhwOH
z9MusImqaqJy=gTxbSkkkgM0wEAj!FUf=BkG5P)|MGRJwxN{hD<noLqUii@;P6O0kC
z=Ox^(4OvdZ2lKKy(V}VC)Vsp+E{6skeY`TU#68vtko=6h0`L{j=1d=#hB7vBvzyUu
zIZYPP=FPJj6%#9O@x4r{QCgYr|LUM#<p*|9^LDIF*nBP3eiShapfUIJJs((fdd|+X
zat7*YMbqIToxhI`i@CtVIEOiLIGf;Z74~9zy=6i4ZJDZ>@YeTqQ<p*z40&ts+9sx_
zZ|vAyhBougOE|5(3J0+;ow*+2Q^T8i+=jHMH-59R)G_!t5F@|M3Xx#=7$I>b$@FEt
z2vp|I(4%ASlp9UJoun7Eo)EA>$e<@89;h$7N;Ehuhrl!WJ-IJKcVk`I*<{4yMAhit
z(`gw!@U0kYP+9hXi?hUS`UuCY<2w&xw#OsWZ-Pgxa(_es;kqW?vE^OcLEXL=*4+4_
ze)2izMuz}@+d28&aJob$3p@WrcFsjpFSiaGNyxV1K)$?Rvnh&G?(4xv5PX<aUG{-@
z^gpPByFrBOYs<U~9ig(Yp~pY40<<6?vPqT(*+#y3qZZE_4Dtp7>bINE#=*+Lx!)Wp
z4+%$`9VE(cJy_F>q;uc@x>=T4`$|(gQ@r<sKnHal(G>1@y=G6Fz{S9#^0%bu`Sl5M
z_@u@%D?FuYfZ?^=d9K7~j!loh!|b0>$tr$!2S9yUOgL~BSK$9P)!=W+p!dmw!VZfH
zN?bbI7TKM~z=m&SC+sAfX5M|5MKTwb!q1Qo7t2}R1SO`QO$J>K8+iTKVdaUq(cn`r
z!)>dvfN*v(9joC57{2n;z?nxVF0*fM3u^5xuC<BL3*aNCNd1HnU@x%xR)?V{08uAe
z^hH^}`J%fhSIA9}25k4^`PY7t<k&iu{xVyqD~<d~W?u41*QVo_O74fHaiWxlEZal)
z&bpioi8+=K&}-AWbbIpo{%=QxQ05l2XD-P{(Gat=6nm6P0(5%g+rz7(D4XggN^4uA
z*OImL7^!yfn7O@iqS(213eB*78^kv;EstO3hQIGJ+h|<BRdSm;t2LFQZ~Pyrtw)DW
z!7a;<@@Bma!V<V^Uq&5dY;Bzr%OBS01R8}5oe(6UDrbA+K^7$!IjPA#!`HHFeSLGd
zK3B7NQT~eE`uroFOt*-BoKEvOe3Pe{Ay)Fw4jjT(AD6-^ISvl?C`${#-u3Dgvaf8^
zqxI5lL;^F-OE_jgBD(OTP)#?|IE_gydZ%{j?k!A{q{6|Ds8Y?_<k&C?c@w`)n2#So
z!JJMwSKn^eO!x;ouJ3}(f|tC{{(F*6sYoaljo{Zvtr2;?>;>Cgxpp?|$OAo5SA8=d
zcw?~H`)Iu|k8sX!)fZe>6tvdv*R%hzE+r9Wu0sWQJ=-ew@?L7JkM-z`S`JW8v>|qH
zjwxej;#sKuE^=}xsDM<@)AkGL&V=MvJE#rG>3+8!AAj0&5F_fEXQG!d;i!vNP#M2H
zVT<s$D{e{<5omf&r0y|qExc{Dx~HhgBhn<5g1st^DEjmFg|GExR)yvh?;0|4OeUNo
z6B{J0r1V(_g{~tY-Y9>!_N)(e?(6#)aGa3IvaRrRuBS>}mL`sh2M%Dzzbb>wZJ|@d
zkeL}6wSvbt(!Fab#1vKwGjLonLSE0GS$$lDrxm}j;u!-yp$+y&14}@9nfTa#Fna-`
ze{FOnK(#u(Yd;XE0foeHYM7t+ztg?-r0pJklm~s>pnDJd%HYdC^3>YiJ%waPM#-jD
zB6W`L7FU-?5QA_`#=TH;ZNpHl80Wr|+yzB0<fh`-#%e*ZQ_aak&GYo<W3fb=`u8sP
z$|jBq9EI)aJw10=gwd&*gzE70AxUWjH;Lc%)V^G%3f%tOroMjk8AlhsGD^6z6n{&;
zY>Rz_DYKWL4GF^)s06TGC1=1!npvSR^8ouVv$1=^ii#pxlKBPeadnxg=y)QE4{@H0
z`wxHc*;<2~?$HQ!<2X#&J;(f|H674KO64!!>AoYtnpoC~LS*tky>G5^6gq^oyVl;f
zFb8~D{cXwGPyM+P5_ys0MOaGz+XB0qTLby}aH+S2##-EO88cP>{J`~Y1xJ*qL~yW$
zahbp2_cWCT*1)Z}g!%&Hg{Ava{s*~ci+?u_Bp$Ls&QeN2r)$2s<$QUYSJaYNi7$J1
z?<}uG2+o#h^RYD-9Hnw_-!=c#qOWP#b!M$OfH(Q!{y4biI%ucdYkxtcUbL(`BmSYP
z9h<X9L4<3oSesR}r252OxFRjq)NLqn2RW!~aSFA9*rplbSZ()#mQsgor2@B>K9Y)^
z-N@uzyfog<V-)a?Drv7s$-_}x%#h#j=DuHn=Dc_^3!i;x5+8=n(`+MY72>MeJNuJZ
zKbwYra*h;4{A7d;VR5Gy^ucU*s&igQrg0{W9wB#lRr`vy0g_o?Dfd}6-pE?w!1!~E
zhJd5~e;71CZd_vPW4rZ+NppI-649&>ca|+=b&h5wI~v1&RBTmN|LJ2X-%;oO)a%nt
zS5b=&M_VnrX_3lSj0Co!mSN2*<f7V6iS|~a;8Uu$-8mC)R%=;Ilh8T0b}UXw55>Wx
zLIC%k*+B%D%260ncjJEG_WjLRx5!4EPEmUzZ2l|n!`SaUerp`?vsu&i?}FC8Ep(MP
znk<*%KZe9av)@3tGD(YN0gy?Dy*52T*jOc!;&_hBIv@MHRq;<wp8C_9FzNKd=vnKc
zx^&5hu@2@*vJ|eOIK=LQa{q+UZv1ib=m$8>K?FMeTvQCOUiBxlbtkJtc_S}FYCk4O
zfc7jSW;fX_7m*zJUb7478(0Y@Sr#teB5M=#yj*AVq&tkyM;jEY7de3HQY*^2cWR}&
z+&^n{-LzZ<uXD<B(U_wx9L(ag7GWv=)W04YhL+xX@W~l4EDFgDKmTl~6SOmmW%LDI
zOEg_m`5sz&q<-WLm^-C^Kj$}fzwnw<=6g)IzxwhKd<|UQ-TKON4Y2Ar71K24#60&W
zv&4vWd5<x7+aHN`K~&0qOJG6niwA8hwB4){+a(IJk^Ea~*aNn8dJ=IxCmes6<~T@<
z&9014ww>hE>o!0uz_@?PQD*J3FM8BLZEh&|H=<@DS%+u?M*f~pD2LvSQCiGjRTtoV
zjVF{6ex~{-gVar>Lv;<OHUj$dW*V?e9Byo3LS(IR=abk;TzsT&3%ADfhkjIIvyeLr
z+;C@B-`r6*)j5Lt_d(gq-Mx_H^pi@zk}*=ZUNrD_ROc$g(fS8GjGq~9<(^PFgbk8x
zOY3tNsDs||`#R$LdO3)W4vAv^0T4(CF4c#zq0D<}{~Dh5Q_64Kl9v5~Q5u}A@8&&;
zo}I%kVCC~<;xw|V-Gc`C?JJEsjfb#UKAInIGO@-JwXcv17mld68gBxpC*H!9${iys
z+BYf*?Z^(XoR)qz`s0r8ro2RPP3tMM=%WyE;ZjbqmB?yflT_TGfIYA*<^A{`)$~_o
zq6NyUWl_wKca(NXk0r!dN#*QJB%?S$ZDAU#BfialpgCfOZ1eA%YA^-nPbpiyCa#w*
zS1zxM^i!?xr&<(BZ;s+Vr2C~P@;RwNgu|eR>2?R6XvUg_d_L;8w*OoK?7c`H+eHS6
z7XR}JdW>X#AR5=^gYIX!-#+5a6c${)Eeuu8)Y`mH&FCQCI{dUF7k<=NeiPA4H}IjY
zKiR;lDMh5u^(wQi;iPdjFwflG@C$!;GOLhQCtMuoFLSuqYQG-;?EdxDLOaBFa~EAv
z0a5o3qj}e7IVYDOsoEprL>;=mH!f=Y-TU4GmuPqu&iEbnf{t83>D+g#^iQJEKRJo%
z$ftnk4dPv$%}?LNro^(>1>_g43QU*+P>%uE;-NanWg&(w+rK?FeDX9|s)fliGrvKs
zs`hRB5%7#bHdz(KdCalqjo>^bZeUm6M3+yfofa6}^zct7PN;B=o=ta6c=~67A40m1
zef({1BSHjgaSvsOY!4?*h-a;>zZQjd?J)o4*^y-AVU62F16`u5=1(#GI$&J>FM%%J
z9{qYYUAE#HnYN5yZpB06@@D{$RsL=bSYvy#sVdB1*Bn~HoCcfA!7dwQcdqYqxpK;0
z_5G-ej}3UaSo=Uog?Luw1fe@4dDN>*z-ij8UQsz|Vdv4Z3xp26GW5@P#OSI9hYtFy
zpVc)yk&R~o{XXlwHe6+90kY_UD$;3mo=U|0^`Fl})Rb)-uiw=Brzdvo5xMKn`)J02
zoE6J|&Zye6af5T#=(2&bN&EJXmxMdB6w=;S;V$^e+wdY5*~2mv{k(KP#201F4O6%k
z4HkWay};~Up;GuA*qguBWTDyz%U#y{b8m7bz^Ix<qD1K|APBr8A0&1(Ihgzynm-K^
zU#pm~%G#_KaPBWqcnru^{JEXsP}t{lim&*9jumo%B;S=~q3Qo|f$>I=ULo;pEp9xC
zY>e+Uh~f)vhrBFy2xoTZ&OfDea-#e<j!CfV2ze3epkNRFwfI&J=f+i=2%|55&}v49
zp-0E3R+T-k%548l|A*L8J?~|5F{{kPigk|M|A|Foi+9Q7elvJDC)4TDAI>qK0YEmu
zqTZ82ZK9imYvhFm98gs&d*l&uOWRvQsVsLq;C1nr(Y5f5&%Xh0`G+T=s4mmdSu8~B
z-r3-sYXn)}V6}3;Giwtsf3%-5SAeyf7&0U|iNdQVGAG_tPaLH<UVapIik76%Bm(e9
z-sHQrJ@UOD_ww@cZq637=}e#mpV0dPUh}t~gxLTtHk942wj2B+!cC|{Uib>@Utu;|
z#6KEg?)2OHVz50cjBd=|M~0K8)isyNQWA3LT&KW}Gsb;WGZz|wI)_uAb8IV_Cr8dt
zA?5CHk<TYbVYvMSBJ;ZP?4w_{EO&h}sg3Gf%1Y1aR1~yg{;hR<1G*W<shqLOgjjh#
zq1*!AtZ$aOaX>HtYz(7@huCkU+AWRiFVn9l8^I0+cG({Ross*pYV-7XIJa&e=IJko
zm%eW>6Da?XQ4f3_wKDAx);FR8f|bLwsXiB_I{x*g2*wDcKqEMR3cBV2yr5JuMSrdb
z1bK4ofEK3rWfV)m@B401%suA$Q_>LYgrsafm=z`@!ME6O`+oV+HH>fAq~<a;Jf-*g
zs$v0J-qv|<=P!sm*=%0KkR1E^R&Ts~4hW0K55kRWU}2ouYJG{>A+%R60<`P&cz;Un
zZgl38I5aaYRyk=xDy=hiXlm4<@Z-7{Fi)=_NbQlmBPjop(R>v0G7_jfq7}X$j6pg;
zaO*PpK86kT>#xgP`dBjb_wc}tFDK<dAaj*zvu#>P_>ZS1QW9c)PDMKo_O<|db^Myv
zBHE93eFDDnh%~7$t3E-wc=o2~l9&VPiWL5desNXVz9S|yVp0vzR!fB*J{c55Q0P*!
zi|MVe3inL?yFvw`y0xPfc$dOkdO=i5v%!3iMuattYk<up`EU+kLuSeocF#@>FY+E0
z<L^c4BB}gn%rw8553}4>bQI_?xy1R88*U*=9S4%J7u9ek1b_$nu71WX(`EX*y~elL
zY;s8SOv!02E7J4j|7R?s)P|*DL#5&9-&>cVTHvBx4wbU2&{{)LTARX(DKhbq(&_}p
zduNkUT%z!43N%)3UKnR)ki(^elUJiv?A&`t2gD6?>rV;ASnG>W;<C<Bw))-V7GP1P
zRcjeyB#@FH#p0+=fhhNB)#0B!;tzCVU6%*Gh;jx|l~wVhF(tqG-%_@J&vYYQcWg;U
z{jPRyFpBqjRJ%~GGj6;0py$9Zo_%<E<^!EkN+b>ClrrsK@8}@$j^mtj**0Nil-9??
zDc8<lc~*>-lr~uu(HND=B7e=zBF_qRTyQVG?%9xWDI&-@wxe16)ju!hudm28OiK|$
zyLAs(nSfrPC<tP3qQZDJ&05bG+51UCe0D;Bu$8641K(gRSSj0Pg1w;7`<oij1fY<M
z{O$d>Z;0YzdhT|Y(~*R+a*vb0>qPShP1xjHqjf+Mk+(4O`MIQE1ZxoJ@DXvm{^H-1
z07xwB765@$>FnL0+x8TAI-vBh!E$Z6qY8p``=bWWr=krPMdYQt(%^Lk?p3Ro*xi~{
zq}JMJMLXKV2m0_H|36wCruIkl;a+ydzDP-#S9|36_y;nt1n``n5lUj~*8m36xZ8B9
zoS}xxyt%+EV>0Aofx4PhvTx(Ol>vK(%3#tW^dR?d<^h~hGFpQ496@qAui`)K&vjG4
zX79n!$j?7sk<E1h<in%mNqq^XMBnmI!GdsoV$?iOlX$2R193qg6N>sh>?{|~4i?L7
zYn<cLuD>F#Y-m`@*DZ?O*4Y!De`>B4hlZcdg7(HjEoc3-mQwL+k7E9g6xfh+iN~cG
zYmt)!+{9l*AtRicDR}5ZbKYwhsT?(H%qcgx@CCqN2|Efao_dL*?;{;l*QjLtMeXUU
zCj&AQ_f|8LzB=zLK;ew{I%q*ZVjJ8yKtEg75lt88ep=*igie3y;$2AG@BfNuC9DHa
z>3XQD-cm6BJ{`*`yk_xsa@F?b-zi@F7-vg=+NTssLPsRsu7Y3(SxFdK%o8vAygLwV
z2>*O$<Ei}$+#wZ^rjEXoC!e{nTAFuHKIU`kjRoP&uh!3fj^0*V3xLF?@7G%iR~**!
z-giu_xCmdYc{6RYd;n*WY?^4K)N1jU@in&x5*Ws%jlVf7yzbL(IkU9g&;NKkgy!(q
zyNhUj)u_DEmZjT>v}+F`SFEEIR0-Pt$Jic^V_k0Xm@lc{XueD@{qX3S6}kdBOQU=B
zA0es}PmH=WJGpX4>uo+`eN8}U1ZPrU@AKsGN^H=2A%2ZHZgZ1(Y04VVrEcTtD<Hr;
z2O<+pw_KI+y##<WhbaIRxM-5Nx<7qCxA^Q(&W3R4>n@W&$#<qSaCBiAmH|AS0)=TT
zbhq$c?R*{$+XBJ_y6q$Iijb4wAU0HmRVvIhIlOjRwwYhxEE_`U%}0Ri4e}#Sy~R3J
z-DE6a>|nRn#Z?J&e#dX6w~e<@xD9dAz2~r_w_P|orMvC?e54l#VOPX&@-DD%&yu4}
z2y%+r&D)%MOd+2JvfHo71`4z^AvOq)G=Nr`W(v8l&;f8A!V}XC?_Ggt0S8Y999)Ds
zF>n$dIx#~8c8ss@K+|t*CD3ly<lK9%b)+kXXo<xo4!t%TW)%-SQ6ZjdYW{L7EEHUf
zKAb&CGsDh+)d2+M0MfGbdF!eg-R?etvq^%>OV?_p_qN(xgW>n_UFq{2JSCmT|D30D
z$B_Lge#F5?8Ym_&Kx<dw`p}8~?74djO&(^-4HaRWKR@JTb@hLUW#*mp(&V*iFx-|H
zgS#|*1)|14Q|?>)6=;hnCAv}UmC28?96*Ok&ih9|dxib3g_JVa+q-#sPWa2QQ#c2>
z7tgyz&2@3l2qQGvq|@?@2%{@<V$AJX>-fr?gL7KNv&MM3e*%uL=sM1=?-S2yMM58P
zKl`=v0tM*3X0+m!z-kZ$q*iIigPZ0KOtNOav%vh<#L*2?aQ7RDn9nH=G14A3-FptM
zDx?}cUT50VoJpc@R^QT$qdn}6Dg5ZIz_0aXV#s29<xt3HW77spyB@>$_p_U{Bb|@)
z%CeLcrGN&RWuevJqa~9B@W_3j4XuKt0QzE^57&uFLT)&hsJ#@|Rx1<mFQVCurmIBU
zi*bLjw0HP=F2<iXRSD*GlywMC^^oHdyWW0}Q<3s+^6$!4xDBE4y)l2!=*;BPUPW4|
z3vc7khX=2WbMHlMAju_2lE?Ah!Q%Rnv2h~DnxiB{`zdVJc)X>QGnCWRR7^APOSF=D
zkD-V77;%?Cvoo+KshLTc#3ADka-}3?e0cIK3c>*i9WYUCHOC%UKOu_f7Tg(h(7O|S
zF337LH;EF?=_{733Nt%Q7ZF~qt`qtC5xjAAPuv9xDph3$grY|!p2ZyO_<Qe2Hdl$~
z^Lh3dZby~lyCoz{&sYJC0>3jfSOLq55dj_4)tVfuAW5D-ySD**l)FcZ5$bP?HbYXG
z@jkw*gDLh`k}xvq$y$$(pIwD{<qmD~6K%BbDsvb|_i%4MA2suA>s=_?RrfX*R!B6P
z%L%LfSXKKWrD+>Yjhso6|9>}DCiG~9ReVTJ@x<Q&G2Z!Pj<)gL0{w<1;Hnr5VI!eJ
z3pNF74ye>ODw-(HV}^C;u8*!D!u@>=o%}9;ycxWtNb<5I5AzeZ8^Y6~0%D{Y)&&ND
z1QIW$8-X_xFdKnoE3&{W?PHM)QUiGGj^)nXG}}vMmGr1R4O;@DBtt^O@zTED5uPs9
zbPm8kY1OSws&SH__r#x}L5U={65PKJ(^*~6o!k*OcVxod$9`VXQ3ClXK*OBRPX5W+
z-ux~-c9C44QlDfdSsp;OyZQjtmZG$b^^o6PUuIk3W4*}1p)i>1&?4%QK$6!SFKih@
z@Z6r4sGnr$t_~=e9y315f!{Fzsx@l5v`<v(sQok0>1w)YXaDz6f-fy3k_?)@irNI^
z3+9i)MkG6Vr|gI}MbvV?kjkB+3qDD+tbEU>#NpHx+$6K@XdhM*k=e6<I?nwUoewHq
zcr(U&#Z%$BugMQAyj|4);g&pjd#j!d$vr$pO?l!(k27{CFGKWzymm2`5_Ud4B|GFD
z{b6lHx<Ph3{s7~h`i<?Hilo=_zgHJ|Tnqj_AwGOIHKe3%s3E^lgsq+(c7TapY2`b!
zP>vqru`lr<*R~Xj>menUj}e()5QD<53t_cDIE+YS+a-eucMV^GWPJ<CWsrFjkv3jE
z@o2W~1{lT%(Q|YGF=U?0$V~%b2N3azSDwo`HLfW-)#kJX?9CSbXemY?jk3(_!LFg#
z?T6zxp?`g1v8naQc;TZTbW)+%Dh9*%Lc7le`OYPOM%*GdQ9dc!FM1RErbFdlpSYg6
zALHbHf@kRgkvXoSx^8%zHsqRkUJIp!s;=e}m5_@;wW@u99{ck9rlS){s*88k=t%3P
zL&;xD<mcNjS5<3UY7FG(f6AIIjv%}qjlqW(hWT`-goyJt<o-sp?Wg-*W+lXVVD`>P
zpLzZC(saU>&wgV??~ZSP?#>8oq|QGW(-9^L^ef^dfoEiWF6g$a{)Kci5DoitEck0*
zGDH|o4aIZUH?POJnFkw4Q2BY~W4ka`dtocK7m&|BoR6bpB}_d(dqM2c??x?dGl4S;
zcjZ=+lk@kOI=#YwKhSVy@{Ky2+7)c}@VhDTH)L83{>$qYl1lm9srP_mqVBO+HcmHF
zi|XbeOZtno%hhOwUo93uFiz<CWgY|C2~6{?8G(Y_lA^SVd<Nv$d6?@%*;RWz@ak<Z
zg<XD`suE^`Ui%<1_kDwF%$oI=Yd6Sm8r0)H|K-4ytR)gd03j2qN*6B52oFyO#z6OI
z!0YAdezi!fRs{6no63bc>eXqUaL$aGpG-MR=;EIoYNC$U_(OztK{}t<qscQT{FO(g
zAJ33_H^@flSuwGNWx6TXBMuB(xRs}Rr`g=Qp$x<{zhQ<RFXFsfUwU>(4&%jp$^L4(
zg<#W`{7sl0P`-9N@0%;?<ZZ+en$C<m?uM_!kt5%zojZ=3LCV`eQ0TVO=;NVxVQ5I#
zv}HBT|KXpCoF=}R;s8_y+^;a<yUftnOq(B)C*L%`**DbNJZSeB&MDax#_Q<ju+aLe
z_JPT1J<F_`YvL*vSp6aI5WdaL#2k=+d*MIchn8j}3Vn0ZP7_tnDl=mdX3kjuAuP%(
z;&JQW3ySD6%EQdYMBkube8+!Fxp@mXFo5{hBjO4!SH&4i38_C%N2F7W`g906pLOOy
zavN4^+aY)RmA|nmLC1fT<Bw^Fd`?sFTGFkIpPX$<qkgHQUg48UXWMD|-s=n&(*+Fw
z`ht%NOFoK>`Pew%TnpyrfPXHw<A|XaWP$o!F3=moKAwv${5y%$@lm#QJ@sUU?{w}P
znG$?H2{{yP@@_Z2Mt)Av|8oJ!C^OT6zwUw%{6=)*dyEhz%Ol&4sF7|@X8iJ&>p>WD
zHOg-{V2An=>f~XMq^}CorSv@GG{!VB!(1R9DfKUXr<YKyF_bu7Lq~}zfg;+qldjd5
z%*t;!s)LtmI{B<jJd-S|3<D!jkTX(^WP|IE(y~C<&e4nO0fOih)T3&&8)stUto|ZS
z^5Kx(R&G%tU`Vi92z8{lg~s=-H&x;ny1Vu5P)<?EO}FyO(T?HWfL=P!q}UXBx`zI>
zKK$|Bo|msJSXxlx>l^L$5n+4k!DR!)_E0@SgHrF*%mxcktf&G`5+F2^ymY0nEARU`
zb78>Kn|O+Ub0m32?^=Dum=abn|8_g|;cKwzmZKw-BqYls=|)ym%cDLd4+{N8(9=Q!
zxDspOZ~Nt~1_fPi+EeV}ch1mw>8%gD0MDxmVpRdL#_Is?(p`M+EoKPvs&8~~)sFKg
z+~~-2lE1%gPufpnj4=s75t<H+n8RM_)i!~``=}!=%>8i2R?g<_;wYJxpZFX0cD~3q
zJl?O2XD$8Pa?~LiKZd^dOehk|Fa4na>5bc&>iR>#>BzYRv=`)q4z53?&%f?Tu++h9
z-j}NF$jt6*bU^%zsTEXtX6DFaE%;ibqe4dErso<UqBuk9Ee?349cCjqL>;lEUy{kB
z?1y8XWPkJ|y%$@pmu_tZq|eQ{lL9H3TriMRXYi6}BUjkhk>2OV;}FH!(!p~471Ot$
zk;XNvXGn^=6anLQxe1f$<AMXFxKh^N>+46hRb{Wzs)7Ikqj<skiQ7PlPaEDeALJEw
zRXgoalRMr$k00+408ok<+@k0%QZl`;Z(Eq0$T-XaG4fp&KC<db<09&rvwii_n*YJL
zuwk`2>Jdx;NF6TJU=VLRUTMt9A{j_#)FqL@b~@E4h=7tYe(k_sLao<A#IKNVOQ^LJ
z>(Ez7@#0R$pQqrUFfzglDI3k-4(i}{!!s!8^V9>nurSxa;>DDT^`Kff5OXZYJ55i6
zK-OhOKoLZt{}%Xv+NIp}*mgZJ>oKcz3#wp)Y&%>9SDD5Ig=@T~V8`=WK_<L2gF?O<
zA(78sN<z$V`wGN~AqyRk2>=eC<EF#?kyfq__tYCF&|gp^)8(xo?fLFR3{5!ao%b-P
zL0wFtb*Z?<k=y<f8NbR${QY@DlJ(GD2>`Ay2=QeRfUjHu(ZAMcu&Ki58lb5emQM3M
zsRAt0rXPl5TA&b^tlgtphP-El*q+RuX%5*NdPJCe-J~}^IBwl9j3^r(y$aEopD@_}
zbrxi4XS*((_d5^6Kc5yjhuoBgZ|obcY2HK(y(~mY%JRX*$Wmh@7;5@9A1PUFhVW<y
z>bt2d5td<%tT+pvXoJ&m1Grdh!eV%ddG9tKe28JK$A7%BrN`X;%x{+q2{MeXKU7<K
zv0(CBUccjc|G1pV&cEY=`w>4{K<R_RFnIeF>5?j?%d?UXfcMR{*<N1ieCbWh`E((z
zaN~5-@2t+WZ-NdH{u=h-*$*Y>^grnRFVA6*Ac%mc--j`G+oC4n;*<wpuKpntFbqtP
zvwgcB4VB*!e1^+a*jnYCCbM^K+b>QeU+}!ma~ci-fMHphuuY|~Rh#R{R1xQQdC*^}
zQR9wHeWUW(KB2DT>CUyIgKV`ZEuOf~cpbnd5#Xl=5sz<B1u5#&zAhh>E-_y^4p<$1
z6wb-Wp}O>8<%U$AJm%Ri^h@$rcn$OKKx57b&i^C|x8!G<N}ex6Qg68I5EmYnms%8f
z2atvgy-Yp;0W8<Ti$t3XAgCoOD2iB4uNh5N&P@4NuN9twbQp(s7p^`+asFV5)$P&0
zHSq{$y=poD7+)6Or`W;+_YB55a(TnppAqb={__AMJT!o!FZm|E#3yv`dH~mhp*8c3
zeUe7%bcKE1nQzqpY89P4n)$&K5jWdTgB+}xOjd_QIz)5NOb>J2H-aBV>U^H<k=Oy5
z!(~?Dwejd55)4tzfQMfOd@}1{Y9cip4+!1=TfP^Sub#9q5f?IuU}-bg(BCdePdC=W
zPi}?vE_^e5Q(32_KNHd2gtTx?$}U`0Sxvgd4XolL>5scFqA>L<0dz*o9dqoy?nsqk
z{Q>@m%Z47lV^hYe`24Vf76IPOg4D+Z%Qq)}+{LA>%XGM2Up2yvZVAVEuCgsWE-*U;
z3xdCO7Qvvdi?pQ^>4DM2OrEh@CWB+o{aDk(C&L6rZZ3HXm6wtM5YHb%#~>|Ehffe8
zJik59d=Z^O3^DBWX9rnC`Pj?#e;SGX9xpSK^QMF{{oA_~n{meJf}pmC<dwSBWHH26
zF`e<?a+L2!2I!iWz|-buw^&cC{A>yQ$$K;?bZmr~>&wt~9u8kog#2rHhhQzGk}}}=
z3%LZEGCh@0qx}^2+ty^XOm2F*Ih<>HzZD#`YddS$4Z1z8RQwW?^x1V8(OWiTBVrn7
zW&y8{j6*o-!Q#DLm4lG@rJ@Oe4j!fnlUY*ptA!pVXQX5f@gGF1aItAU6fhV4KZJ#u
zruWA`?s<&E=GHT8H8DH|-lDf^Fa9V7Rj~g`*a2iH3meY8i{Jpc1Lyy|5k4cNI%F5J
zbp@L6hai3q)jTa*owG;AeVhK(6BlfWl&sD^kfG%<+;$lY@N@Ir$vFrP|MB4i-|?(5
zS}#d&{9P2Q^!R@h)AY&&>2$Cmv)kF!&gT{Kv<R{Kr-z(0zbb*EI#XXw*8&_3)oUqe
z%(3YqtHMp_F>jM3qBjw0cLg$D%dQ($IA=2I^5ZyV^pV=!;lm?qJ~-ri-r59;(`8Jk
z^C2qbv6Tvl_1v_i*nL&f(yHC7r|C_r+PhG`i#lKbymX8%_H!qwsH9$i<t;wZSM4(b
z$Pn32v)6$1ro;$z$o^Nn`H`d=eFIU@LtutX_5)hchG(&6!9nQYe~<cCZt%H&qe)@R
zi*Ei{+j@=ox!@Hu@UE%<Tf<Efhpqj!+w(z_^v*O2nO(J-5t~=@cq_P|=eaI&+%Xu6
zZ31tI|NJdiIEo{Ah%{o9CwmfvcU~u5^wa*$V=W}?=E9H2)Am`!6#bcafg&|xhbkc3
z6JM-&K)~5RI8^e{A$g3^<?7jYx9zv&@u;bM%Eq<eU&ZHoTdOBJ)V(ch$P!~8QE6_!
zVVAgi#ORo*-TH`;8M*5c1_Z{+p!Bo4_D^Qt?&ZslD5q{5(!hAc-wFT45&I<rV#kH9
zh33dk2~4c8ejfe^jVBDJ6#WS($2b3?`Xk{&2ISe-IxRE+gi1~P-80tdvWz-oOTCw9
z&P2RKy(Lit)f0Br597G|6zpOnRIP6aoVcXg{8xWN^(9G|uJr9#70$9f(t1#bfJDqR
z8Bxfx#{>#|2m)!#->Kq?{hB{s_S}3t^N((rQTFvH!B=%oPES+eUZI=JtveoVuAD53
zzRT?WE<v(D;u}yR09k=?xGRy*Ru?=i+fc=YdnMiDvovmd<vV+n(f7R$Bh4j;^F?rU
zR`Fl{Jlz;<1T_wZ-3!kl+FZOZddm62ninrSV**0M(nmCm6JXY!8k3!HnNLOx1*iuo
z;AjotSSbrW51kPb0`33WPjyfz+u3VPgc|uCUeD+HA=LZ$q#WeG6ix9>yt(CB2-Hn#
zC`TlGKaWhi>`)UI8UaH9gz-56=4x8**aM(MF`HmsOlH%4PgYy|Co1}1)hID)x`6b0
z4yukU$&+o?kNw$iP#dLF#AU?U*-UrGQ^(>>1rx;3u#43}aaC~V)!t2tzA0>S{vBT`
z<R$`BgHn=ee7^h({-!<-o7<Dj9wq*e>eU&q*LYSY6&vINlQe(sP0J%ZBa~4_AdG`<
zHfF%aI$$Kxh~B>WD_wB~-46?$g0<9e&W2CxXdFT~kL_}Oa$aTkXsFWYzm1{waWqI9
zoWlB7jiPY>oYBQ<eLq5E^OWAjgXkD=MQaLpVPRB5q{l(9pN=}r*7xQl-k_Ns`ddfY
z|LqP_e|MtVvKYLgB}2?B`UqUYD`Y<qH~;+Um8qLbS$`G8>A#Gr1N5_x6F~$uUG>lI
zoQmH=()9_9)44@vs&uKE*UJzpYJLBaKI!ZF*OGAKZa*M`-AYGft;kF%eA0Vtq4=ZU
zwYL^yop0rx(@DTmx^oMhqaT@aL1I1vHXS?DrWahCF__|>;Ip{F;ZG{J?+b#MSc@@N
zJP;FxT{<`Hk<e+J4Y;!R*(i?vH8N^rs@dx|D$Xj8Q<QOuKxiUku*g0!guT^f75sJM
zHz&Nyt0ISCaDBAbV1f3Rmo8vbRKY=F!iSX1TD89aMa0Hb`rh38#Oe5KKJNwap|88R
zGE2V@YYnU$Ib%b2y4gRRo@a78w6K+;6LPJgWn6ax-eT9siivr^=L?5h@Ox58oKNE=
zQa>iN_*FpG7-xYOhWjWUGVNfa83!U^Dk!cRzE-ZN*P2Kw*DJDa7ilJ0hxzTL?$J1K
z{E$kb>ZUaErFTE1=-<eEA6&L?3-@AdYdg5<7{Wet`;w(m>|r=O<-#{~wSpR;i84OM
zGG8in$3_|5|F=2gz;WF^?Hyf9a~6^C9i3prP<op?tO06iYAMv7%1QC0LeQ#>YtB7D
z`~7^2D}@M6e$QPuH^xgftmIdqG+fA@3;tra;8stR%mZJlSvTjcWje&Aj+er6cy>wo
zm7J8;SIkm6r>ra#UCJlk`b-_AW!uThxW7GghiUqYwHYaSE7M8u{@1j0*e_R?wBRut
zg#EwjwSHCyW|;#wCq<Bpu}o)sngtnphNvsj!vwgcf^ga6O84HO%Jns`e!1!UftqUb
z<r19T!P}@h#Gm3lXDufhf44H69C+|WXgZu)JI3Aa%=Yv?3->Q&$DL!lJQ!$N_ruBj
z=N)FMwr}t$jy@3n5ap_XjD&#=F2#+9OSnlI{E!-`oWT}iI)Jk3&wfG~?2l<a(As;{
zj=MX*ADfniF)}UVqB!O@(!4fKOfe&HiD_6}UZ2F5QBzllnDn?`;5wz&FVq9RW@Bpx
z>~+C38s}oVX9(gr0qqyjquCD!JsufqY7=spA(%fdMb)uqx|O2lTU`}r-q22u{9v`I
z6M66TXws?z1kE)?&2BoHx&5}SJI!&S$pJ~%TSU0oM<S7^$5vl!<kxN%a1rlCYj7_z
z>iQM-(J1UEkQRbpe4S^138V2LIDSL%4QwupUw{5nj@*xFb|{4aDX7UyVyQ>xfy3q!
zpWJHQDP8j1m~!Nv4PsC72RTse@5T_2Ffff?Kk1Yg*I61vw_TF{I|kBFtprJl@{*83
zyf!DSpEz29Aodb+iiPgtCEDTMWn7HiDs+C@D;BHX?8IrH*G|9csUT)5vXEPVq{HT3
zn#?<mKnWE3ys1A5fKK&yHU+HGt)>%iUj_Otr7v2>(QFai%(omDK*R&~6%WF8&j~#P
zg>$2Ey&po;T`BT*y2h2G=CcGx<Y?DznUHPoRy<Rn`y;18KrK}rA~m(qndSNt{T_<d
z!J97fVrNJ+xwv(n+oob5)2}gT6#4`3tpRJTq%(ZdB{YmvE+%*B7o`)96{2$Fa`hI%
zbx}3MlS3l)J_B@!s!VREXHw9uGkE{8<Z$Q<Vn{Tl>@$mapSPoc*YmhoXS4-aICaHZ
zBlN_O{zgzn#NaIb^S*E`7=Q^x;pvUF`o(!Vqkvm4C2Wg42t!woP`!(VF9;^JEN!+l
zaNVQpH9I!CW-r1ZofOK!1xe-#jNfE5CrAl=E&^&SL9Cf7qwe9H>;tFU@l#q90Vc$E
zh9sd6XC+y5u`+D8ojzDRHqIri!Puagb<}BSO)J7Uoe?SdbSTyUuod>$_z(+!_?1(?
zD|D-XWozGfZ0%hT?wxK&%<C;II&d00&K{kIW3|GG0$b%QTAwC!V<`!tPevF0<u~)1
zME&ah-=61cIB3mi^sXA!!bjtE3bP+3z*+N`JpUO1WQ_^(qDMp*4H#;Ju2(0nrQMWZ
zxL)0y6iQV%ZgLS!Okm!s5_{o7brFJpf*kQX$>IE!h_uJZ*<b_=x7U-=n1yZqMq~(U
zX|3?QgW9Ak$B%<51izzxKZ_{y4ovI@ad`<_q#2UgbjU7`QT9{mnmjV0oLOB*ds?fH
zD)0p37qf2;vv$e`6N4#VqYmf1M^(pFbjxg^l@H#)1rz5R{$Cu*d{G9(R)KjvN6vd~
zD$B~+tf$)dh82|Q8Uq3uf7Qkh3lqBqhebei2w=SWD9)b{R#AlJDkuWmemCdAyn3Wu
zVD8+vjXPqj-EBb<D}|{4FuW`adH&d<Zy8Tc)M**I-QGvtwy&hDIm>wKopMO#lg=Mz
zL9@Pa<dJgk%8u~Vu8e2~rb71c2*9kTV%&?lx5CgEA@4p~CuXhg_out#VyP}B!Z27F
ze$=D$>|2MdzM+NqgccsuU=Cx+EE^!VOnL=9MuKdsIlwra1>TMhaD?X<?&p|^0~=se
z5Rgn>*dwXxY><0v!g@c=)W`G^RiCAU{V;d35jH{>bQS8DHHgf+**m^Jl`i)M1+(6B
zp2^c1{Si2|i}4~iY^AbFi@e%qMwJpusqU(GibRvgOs>t5`iOP|%&s*<`sxFEi5H2U
z);s>y?!`J>cHiI6TOG(C%NIiE12MV=SE#d1!<BOOa8Y`rpb!&}J7;b`@GW)}>b%<*
z9AqE~4?Zt&bZHG<pBxq(-b#dD<oNWS{!nw@<{wu$7;I!8RhijPF_fXj^@*hIwNGL@
zE#WEA2EQJhR$C3b5O|mEiyHGs1eK{IqjZ^|JNgcN_Cuhm-ztOIq3n@;?*#8X3d!IJ
z$U`ub&*4Xrx8aWG41Ynolh$JF(=b*`94=aPG}h+!v$Q}JP7-oc!Z&zZaa-us)TNK&
z@=DCEBMkCh3TXQso03#c{|lPI{a(#mDqm8oUO6yZ+F3l|OF~hBPuSSTV@WTud(P)}
zp`&Vsld$R<X0Z2qLyP|GKgfz}4qg~QK%3@wG`hBviK&fAl-_$mcP8H{NpPzqGjIBp
z&nF8JKt0mQrv9ftlqmGq>|MKEt*qtgr@&a{nxa_kd7nNyuBBO3L;o+JYVHEF6k_Z}
zU@k*l)KA-zPH0%#%FenzLMG-(O~9;0CliSO6bx(`bNzK-0|!kW6NDF_1Zz<Jiz>u&
zGp@4J&(O?n&^(`$*jpUkB52ks(2)tSB|!Ow|8KmdYEj2mvloPN<v!u*TAbqq&Zj?C
z`n=>z(u38jOP~@=2(*`_(*!(BtgSKsr`6N8)#Ff>NR=5?G?n4@^|65R6ulqr7dV|%
z*O>o18ToAM{fkdyXE6jhYq#djO#6QmVgeEAyxG9Hgy2TR;Qd5!idX{#r7Pp9<FqIn
zjmUo=&AxMiC(woL8Z4y~{i&*m=-Kewr}hd^A{|tKDAhPn&Pp~>npI3Z(5&8mS!C<D
z+I*rN-0Uu_HWPVS`b7bjQfGy4SVY(H^z^{u<d$H}6|i-yTG`kGvUNiFD(FVD=bZX)
zP{HCFKO*cDE}=Uc&MK*sTdzljSPDjrC_hBswg(ZX<dxqWEZw$_f0C{3|B1`HvdT)R
z(p|lQ2rIQ}Ps4}vy6B@gbXK{C6OWC>qA`B|TXC)#jN<fc6cdDkraza-olh~@;-qJ@
zeXZmLQ2vGg&!MrHV889!9)=bMv)3hEn5n%Rs^@mCJ{<bDW4xWxffFo6$5wBL9g=FH
z<m|P~t@Y2UK?%x3u_;9Az43PTAfTQM7~E2BnL^iTc*5pq1LukC-5r$Oc!{hg)ysfA
zk#YAmwMGb+Zy1&rhDtvT@34Y3mk9|=mk0c0;ORVjB(c4J^*dKUuOW@O(S&UKfBkm2
z&))#7{X*u}Kq>2J5;NqwP|#^Gst`x_PrAJcU;~7?TlQvof28W}1#zW(?_hGJ6yc%C
z+q&FQUi}27JVBuoa7sl{)8ETTW1m)dN{D6QvpqdnBRJpIx&IaW4+#XfmEcR7_>Fp4
z+&vzF`7=2iW8>`-Nio*?RrQJ3eNabAJ@V{;l}=9%1c05%EkM)8E{{o8apYxK%X&B(
zAeUM_eYoU_pJjerVJmNX2z^2GvneV2VHp!pOIi&)9s9V;;wM41Z`Ki<cOK3Fu(*?j
z7_vA12;DhwiljZ1thT;N-mSITmu=rbMuNX(-#5|}Q*=dA9q?x~Yv~Ks>ktC7x|VLZ
zx`GD^7~p;@pEYI_D;=9jq#g395V-&S!lq^m4lrgB9#GF3Z2pioNSuftO;i+2(f+V#
zK%{m*6-cB@H6buskbm&mzLJzSugnm)EX>en27jhZT=_m04<=Bt<EMQK5s21)N|AbF
zK=>TJi<)jpc1Vu^B5>{9oGqjDK{-oHzvZiMA(ivi;Ey?VFteM|3sigX8W}i=*4RN_
zkPQ+T{;MZ-Ziq;&I0Kj>o#}wmAoHy{$e2qJS%Di%6ZG3Rl0@*7@1z^a>tfs%QmW>u
z#J$pJ`A58%7CtUkL(JamN0fC@)<iL0yc))FzO3pzXWN~~6sc{D7X0TqJjX?j!wCYA
zZUl9lG~#;+m93t{>QJunPP0ANpNaVZUYldFSRQ`3oIX&DiQ>Nk(f-(;+*zBz#fNCw
zQ%%LLU)Dd-Qn+lc>{g!S7g+N8Yg9ViX^!3DM!tx&5Fp|ts3|85|GEPM8bm3DxZc<V
z`x2SESNz@X@`vVHL7`xiBIf5<aHB#^x%2!*SS#1gSpMy=vFt#){EnFM%P`JZ{h7!I
z;YprMXS%zDC0xsM`~oE;j5(orSJ&_Qu1so#J6B&g>gVZ}gri~l;haNG#XeE{=5Ckk
zznbbshi6RJmZhgNRe)b~!@)n_F(Q;n*ujP1-{*91xD4M$=zCl%Y=TG&A62KP!=b0G
zg7Kv2Z&Lc8IH|vAT$PQ6sKIpzT+CVoZ4X!NU%K!+A4-!FU?M{KM!LF~bgp3Qz<5_C
z5d?d>O_5^0x+4#gDx@oMI}8og4I$_$f<gcPzMY<Z^p^#4__Eh5s5RN31ITOkJVqv{
z%<7HlhQw;=DvEhy{?9OoH1fu}(MY$SHxY{sf}x7~hV}(mZ^F(Ld1Ij7cD4H$$0q9}
zp2($XflM&9?r+T`xSr9^P{=aUJ)D~f77X<%Pfw2zW=KnSbLB(qq4@LL)%5u*wFr+v
z<Uc%(0EB2<fy^i9e4=aN%t_u3D76$Qd{mLXhiL%oupT^Xq8t6HyGsqJLQ*f$7{V1V
z3nFKkrTHO9DtIr^Jse%jvB{XXQI(S(m_pLygmDW|4?jILGKJ#DzY9a>=i*m9eWk{e
zewL~CBq&`<mwEDeN!;*f1m|5(R={~mbkDBEIo?kD>2^j$yd!60(v{e;L8O^>f<gtQ
zgxCP+et{pubOFf>FuoEZH7H(Hg4Gx^%IEjw$`UeJ#r1USk6#QkZXSNBi>W5s3VVlh
zKg#5ynZEe^j5P<_ZC-;Ry8{82arc;7?Q=mDi3vR~9nG}*Q1jryyd40a1G^kqbwxqt
zIN%A9dh3Ce`%mSy6xS|eLTpooEQ^}f{Vuci%H-U;{OwKNB5_UL#ww<i{(l4Lyst7@
zPs=5BCVCsEV<~wrY#sH1^26T}WG(7|skXKDZc4)Np2|e`&kIWiBH{tc0k#_Ns;RoW
zg|li+0X_R=95||UbE@Cz+(5K62=De1_uloJ;OLeno)0U+4wKlrQ4HOv%<6_>X`$;c
zp95o+B4H>|wU-_A!3=%#UDzhfS;p3hNL`i@EA1u6(T(Eyzn@GN@7g}^TDuf%$-ATc
zQ{mgMmzZS&if7lYy`i7nth}L?wg0TW*Aw`}Q5m)C7dZS_({Pn26iKUgZ6l#cyXxta
z!J+3Z<M;V@8!!z+Snslip}mcn>MZG>iENg&;nN)=8wlYai7b$CC)&%hwGjZX9{4vs
z@;ct5DqP;lMgu38oTRG$yv4)~beQ|sZ0TS(_vbIc_R3T|ppt4VZq~m#+vhI4#w5L}
z-J7OcZs3&XE+XE$1ywjWL@XJh!8l*#_3umYL+~KQnl4+<l^mANh10Qk^4a)6L&gv-
z9EI_wOhQ|OKPu*hBqhW0>?QG_JS5$x{#_ii?2^9x!y)W-h}ON<1v|-H#xEsbd-pIh
zgOOEN6^3onE_CT2iGqgjLj@lg%xH@uz-8Ubq+3=yq1~6$8C8{PBLWFXie(FwE$&T^
zzZFuwCi;+|{iM~O!zQdVRe2@{xR?H}37241S1o~J#T+4L$2-Cr*FLT-nS{2<v-{gb
zcp;9+EBPVc@s~+f7?AzJO{8`ss&&YT+6a+`A?&4o77MxS!EJK-i_~Yggs*_Ra)xZ6
ziSB%*yZWzEWmFqn`p`@xXys`Sc-O(m`Mj&$I;YLM9RBB*Km~;IF9wTe1xQ^;Pa)<x
zRSN=A`%(g0xU-Are_s@V^!~3iPz0%Gg*IBxwTNGFTKVvgkjpnfU;y}p5TvlPm4*j2
z`hUMGWnBxM2kKc+uI{R=y};6}fI2?g0&Ewc9&B~#h-kjL55BzcZ}7hXadVBh&I)x9
z(u-?Tzjf8#vJ~-m9Tas*!|Mox`5I;<je3eeR<@v}?RS15;qcm5Hbpz~|N9ARddpBn
z921A#3J1plBN7HsJ52TIEK?ID5<h|&+%Md;u3b;?MR2SoMJ&DkezspN^YHN;m@R-l
zqpC7&;2q48BT!4H{HqT4SBxfJ*+e<zKOqESE*P6oA(vpSjIxMqo@T%vHj5}20RNw_
zH?fYHI|M&<Yz%5gj{f5w_B>1+@-)HIEt!r92!PSUb6Y^F|LH(_VvR%<R<@j+1qLBc
zPumX|Uz(U&5L71w#<mO($(kL^kxma@tzG3`Ki|<^aAM<yn(_IMN6&Zkn`|<3c&XDT
zht20_#9~$4QaC{lsFXnV(2Vt<kOISGX<H$z*#Kk|uH>gyb4krR=}7%QdwTqqUoTMk
zvf>k;F3)RTwr8q?ej#&-(wf9MNk2jE<tsW=6H(_^2n-WoC3(50+AgxL@8ZwG;!vf%
zM|mTh9%yd-vn3g<wD0M1+0*{k)8>~=n>7F4^rZ~V$If4K-~;*qsO0f!{tYr$A?)Oz
zFWD?3z3Q5d_(o5-=AdIA3-aYD#(%YEe=_D;Zuk>Xx9i0z{)pnfTSWm`bx}us=P$S=
zbv_7e(@QmzcXm5tgccS?*Xh{X{W{WnKQ_9~A>+={t%~b+NJ<@vl4^gte7537zO&h#
z5z<*eKb)Nq(f(|!i;n$Up59WAxaSW%?i^WhBZx`fY0V#o(}Bj<+HOTUOK<vPBD|V6
zvThcT9aUBL?UCBH#opNxnvW!J?<hKaE5Q0%+pdjfSAf2pedBq{)`ew7=gtEsIKJHq
z={uU25j=U<Bd_y7KbB55YP<4tK2x^yU6Ad!0?f0sogK@)dlw#YGfZ`TdPBo$hL!u$
zr|c1Zw`N+|A1J!wbJB9tpDmk@$*78(C#*WsmwK*iqs-RHmpw1HK3y?;=dIr{$7P$I
zu9yp99hy~a(z%1t(!3+4rdfXHJcDVA^K{(rKAEsM=G98h(}CueTMB_>@v{u0Lgyk6
zi<27*pFNxWbcHlf5TZ1qZ`Vedt3G;p3`}#aKU)5{(1syfYP_@_xC+-GT=l^Yh39Mz
zKnu=1U5%>DZziw>tEs(Y$*JoReTN#}Pg`6DROT~P+2HBMB%{>7Q6Ou6&IGPwm@?Hk
zRoS}}qJ8CKk4W}lL)X3oLZ4DBv(me^rC5HN+`5BtqjsjIdi$}WE52`LOq-#ckh@Yk
z+xza44$ZRLXBdI3BYm3Ez)Iibm1@{7HMbh?^MV~$r%js&QYZ_Qj)>+ud@IO&<E@~u
zM{GR2I&My0NgmAc$$bq^SI$+;<>dLhTWI4pk+!W%^VaCL8mjsKnEmDmF#o*CUR~gu
z@h1D6;D&8ieCOZL^)EZOH8EGSXJ2Jha-T!SygT<#huvw|#`X5H!8E_{c{=WI-yXen
zsd3#l79Ib)m78Qrw~L<+_Klvmt7wPXty|si?{5+_KTvv0>vsQBO`dq5`r|utkKdXk
ze>zxV+H!*l;&X++rysswHtW-ry*n6rI3iNblPkFne-de1uWabI(WW)A^3}0l%M6@8
zmCXHY6#b@!10-js*^^c>Pbd9s#JocrY`z}<bcOHuu4Oi<dlyLTXg0Om&iJPRXdA?e
zTc22T!r5zbkAEuZdaBuT!6sEb&q?dD_?=rEXN4n**Xj5_ESVcVZTYNqHjNYRM_MVq
zJ^D#xp8AGoF<;LH11DMXpRV1ysr^Xr{>bQg4)=FlpQA1ywfm{2jeo-0ottb*FMp4D
z_4~JXqQ|^6ar0#9Z?m+jeb!{37M2itf8$$((6r?R$L824|J!D=#uw-puJju}H{bm8
Y|M|Jt0~31YNHG9`r>mdKI;Vst0FV7=W&i*H

literal 0
HcmV?d00001

diff --git a/doc/images/pointInstancerSelectionHighlight.png b/doc/images/pointInstancerSelectionHighlight.png
new file mode 100644
index 0000000000000000000000000000000000000000..1097cf5668ed3363c0a3f9ce30ab5d2593fd926f
GIT binary patch
literal 36285
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
MvW>B|B_j3sf2y7{$p8QV

literal 0
HcmV?d00001

diff --git a/doc/images/prototypeSelectionHighlight.png b/doc/images/prototypeSelectionHighlight.png
new file mode 100644
index 0000000000000000000000000000000000000000..06c9baf5c53fbdbb71b23f31de5480a73b07a20e
GIT binary patch
literal 43988
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
OaMMuHR<2UCiuiwS4Z%qO

literal 0
HcmV?d00001

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index 994c3e0e05..c2fed1dcf3 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -294,12 +294,21 @@ WireframeSelectionHighlightSceneIndex o-- Selection : Read
 
 We currently support wireframe selection highlighting for point instancing of meshes
 for the three different point instancing selection modes :
+
 - Point Instancer
+
+![Point instancer selection highlight](images/pointInstancerSelectionHighlight.png)
+
 - Instance
+
+![Instance selection highlight](images/instanceSelectionHighlight.png)
+
 - Prototype
 
-Here is an overview of point instancing in Hydra, and how we implement wireframe 
-selection highlighting for it.
+![Prototype selection highlight](images/prototypeSelectionHighlight.png)
+
+Here is an overview of how point instancing works in Hydra, and how we implement 
+wireframe selection highlighting for it.
 
 ### Scene index structure
 

From 9af9823d841592ec46569de20da2b0436668dc43 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 01:27:50 -0400
Subject: [PATCH 085/112] Update implementation doc for point
 instancer/instance and add section on prototype highlight

---
 doc/selectionHighlightingArchitecture.md | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index c2fed1dcf3..ad6dda9ee9 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -392,12 +392,13 @@ as a whole or specific instances, as these require a more complicated workflow.
 selection, we cannot simply override instanced meshes to use the `refinedWireOnSurf`/`wireOnSurf`
 HdReprs, as that would lead to highlighting all instances of the prototype all the time. Instead, 
 we opt for the following approach : when an instancer is selected (entirely or only certain instances), 
-we will create a mirror of the instancing graph it is a part of. This mirror graph includes 
-everything from the most deeply buried prims to the topmost instancers; anything that this instancer 
-affects or is affected by, including itself. In practice, this means that each prototype and each 
-top-level instancer will have a corresponding mirror prim for selection highlighting, that will be 
-located alongside it as a sibling. This way, any parent transforms affecting the original prim will 
-also affect the selection highlight mirror prim.
+we will create a mirror of the instancing graph it is a part of, and make the mirror copies of the 
+instanced meshes draw with a wireframe representation. This mirror graph includes everything from 
+the most deeply buried prims to the topmost instancers; anything that this instancer affects or is 
+affected by, including itself. In practice, this means that each prototype and each instancer will 
+have a corresponding mirror prim for selection highlighting, that will be located alongside it as 
+a sibling. This way, any parent transforms affecting the original prim will also affect the selection 
+highlight mirror prim.
 
 For example, given the following scene structure : 
 ```
@@ -458,6 +459,11 @@ Of note are the following selection highlighting scenarios and their correspondi
 - Selecting a parent prim of a point instancer
   - (same as selecting a point instancer in its entirety)
 
+### Implementation for prototype selection
+
+We simply do as for a regular selection, and override the original prim's display style 
+to draw as a wireframe-on-surface representation.
+
 ### Current limitations
 
 - The wireframe colors for point instancer & instance selections might not always be correct (with 

From ecc377d23e216fc11b33d668aa754f91fff5821d Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 11:59:07 -0400
Subject: [PATCH 086/112] Change an axiom to a verify

---
 .../sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp   | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 7a17801e8d..cd9ecddf9a 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -107,7 +107,9 @@ VtBoolArray _GetSelectionHighlightMask(const HdInstancerTopologySchema& original
         auto protoInstances = instanceIndices.GetElement(iInstanceIndex)->GetTypedValue(0);
         nbInstances += protoInstances.size();
     }
-    TF_AXIOM(originalMask.empty() || originalMask.size() == nbInstances);
+    if (TF_VERIFY(originalMask.empty() || originalMask.size() == nbInstances, "Instancer mask has incorrect size.")) {
+        return originalMask;
+    }
     VtBoolArray selectionHighlightMask(nbInstances, false);
 
     for (size_t iSelection = 0; iSelection < selections.GetNumElements(); iSelection++) {

From 520a412c7c7a48f36373a09f40bb05a434e40ad0 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 12:02:11 -0400
Subject: [PATCH 087/112] Add back reserve call in selectionSceneIndex

---
 lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
index b7dbbdf18e..8248bc4405 100644
--- a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
@@ -229,6 +229,7 @@ void SelectionSceneIndex::ReplaceSelection(const Ufe::Selection& selection)
     _selection->Clear();
 
     PrimSelectionInfoVector sceneIndexSn;
+    sceneIndexSn.reserve(selection.size());
     for (const auto& snItem : selection) {
         // Call our input scene index to convert the application path to scene index paths and selection data sources.
         auto primSelections = ConvertUfePathToHydraSelections(snItem->path());

From 415c6516fc7bee45e7238159830c1c1c8b63f7f3 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 12:14:35 -0400
Subject: [PATCH 088/112] Minor doc corrections

---
 doc/selectionHighlightingArchitecture.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index ad6dda9ee9..f0c9425906 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -61,9 +61,9 @@ special way, e.g. object contour, modified object color, or object overlay.
 
 The former approach is handled by having a plugin provide a selection
 highlighting filtering scene index to the Flow Viewport Toolkit, and is the
-topic of this document at time of writing.  The
-latter is handled by having a plugin provide a selection highlighting 
-task to the Flow Viewport Toolkit, and is currently unimplemented.
+topic of this document at time of writing.  The latter is handled by having 
+a plugin provide a selection highlighting task to the Flow Viewport Toolkit, 
+and is currently unimplemented.
 
 ## Added Geometry Plugin Software Architecture Requirements
 
@@ -85,7 +85,7 @@ provide the following services:
 ### Selection Change
 
 This
-[selection change code](../lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp#L151-L170)
+[selection change code](../lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp#L152-L173)
 shows the use of the *Path Interface*, through the *ConvertUfePathToHydraSelections()* method,
 called on the input scene index.  The path interface allows the selection scene
 index to translate selected application paths to selected Hydra scene index
@@ -317,7 +317,7 @@ with an `instancerTopology` data source.
 
 ![instancerTopology data source](images/instancerTopology.png)
 
-This data source contains three inner data sources :
+This data source contains three relevant inner data sources :
 - The `prototypes` data source, of type `VtArray<SdfPath>`, lists the paths
 to each prototype this point instancer instances.
 - The `instanceIndices` data source, a vector data source where each element

From bff3dddf252042498353bf04d303ab9056c52407 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 12:31:30 -0400
Subject: [PATCH 089/112] Add verify for instance selection numeric path
 component

---
 lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
index 65e4d0978a..361d6dbf95 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
@@ -133,8 +133,9 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
         TF_AXIOM(appPath.nbSegments() == 2);
         const auto& secondSegment = appPath.getSegments()[1];
         for (const auto& pathComponent : secondSegment) {
-            // This should only occur on the last component, if we have an instance selection
             if (pathComponent.string().find_first_not_of(digits) == std::string::npos) {
+                // This should only occur on the last component, when we have an instance selection
+                TF_VERIFY(pathComponent == secondSegment.components().back());
                 continue;
             }
             primPath = primPath.AppendChild(TfToken(pathComponent.string()));

From efb4d767a5ebc7ad43c0a78aa87b6cf96fbe4ad1 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 12:36:00 -0400
Subject: [PATCH 090/112] Fix mask verification

---
 .../sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index cd9ecddf9a..9f1b434f2b 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -107,7 +107,7 @@ VtBoolArray _GetSelectionHighlightMask(const HdInstancerTopologySchema& original
         auto protoInstances = instanceIndices.GetElement(iInstanceIndex)->GetTypedValue(0);
         nbInstances += protoInstances.size();
     }
-    if (TF_VERIFY(originalMask.empty() || originalMask.size() == nbInstances, "Instancer mask has incorrect size.")) {
+    if (!TF_VERIFY(originalMask.empty() || originalMask.size() == nbInstances, "Instancer mask has incorrect size.")) {
         return originalMask;
     }
     VtBoolArray selectionHighlightMask(nbInstances, false);

From f2232c5c87937097c09d1f9284f8b8d3364427e4 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 12:41:56 -0400
Subject: [PATCH 091/112] Cleanup testMergingSceneIndex edits

---
 .../mayaToHydra/cpp/testMergingSceneIndex.cpp       | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
index 250e3c842e..d9ed57e473 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
@@ -111,12 +111,13 @@ TEST(FlowViewport, mergingSceneIndexAddRemove)
     auto mayaPath = Ufe::PathString::path("|aSphere");
     auto primSelections = mayaSi->ConvertUfePathToHydraSelections(mayaPath);
     ASSERT_EQ(primSelections.size(), 1u);
+    auto sceneIndexPath = primSelections.front().primPath;
 
     // With Maya scene index in the merging scene index, the sphere prim has
     // a valid scene index path.
-    auto spherePrim = sceneIndices.front()->GetPrim(primSelections.front().primPath);
+    auto spherePrim = sceneIndices.front()->GetPrim(sceneIndexPath);
     ASSERT_TRUE(spherePrim.dataSource);
-    spherePrim = mergingSi->GetPrim(primSelections.front().primPath);
+    spherePrim = mergingSi->GetPrim(sceneIndexPath);
     ASSERT_TRUE(spherePrim.dataSource);
 
     // Remove the Maya scene index from the Flow Viewport merging scene index.
@@ -126,9 +127,9 @@ TEST(FlowViewport, mergingSceneIndexAddRemove)
 
     // Without the Maya scene index in the merging scene index, the sphere prim
     // is no longer in the Hydra scene index scene.
-    spherePrim = sceneIndices.front()->GetPrim(primSelections.front().primPath);
+    spherePrim = sceneIndices.front()->GetPrim(sceneIndexPath);
     ASSERT_FALSE(spherePrim.dataSource);
-    spherePrim = mergingSi->GetPrim(primSelections.front().primPath);
+    spherePrim = mergingSi->GetPrim(sceneIndexPath);
     ASSERT_FALSE(spherePrim.dataSource);
 
     // Add the Maya scene index back to the Flow Viewport merging scene index,
@@ -136,8 +137,8 @@ TEST(FlowViewport, mergingSceneIndexAddRemove)
     // with the absolute root path as scene root, so duplicate that here.
     mergingSi->AddInputScene(mayaSi, SdfPath::AbsoluteRootPath());
     ASSERT_EQ(mergingSi->GetInputScenes().size(), 1u);
-    spherePrim = sceneIndices.front()->GetPrim(primSelections.front().primPath);
+    spherePrim = sceneIndices.front()->GetPrim(sceneIndexPath);
     ASSERT_TRUE(spherePrim.dataSource);
-    spherePrim = mergingSi->GetPrim(primSelections.front().primPath);
+    spherePrim = mergingSi->GetPrim(sceneIndexPath);
     ASSERT_TRUE(spherePrim.dataSource);
 }

From 256e8430cb9f341b3faad2f0c0d7b6489dd25b62 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 12:47:30 -0400
Subject: [PATCH 092/112] Add comment on fully selected when instance selecting

---
 lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
index 361d6dbf95..5677bb8ce5 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
@@ -150,6 +150,9 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
             instanceIndicesBuilder.SetInstancer(HdRetainedTypedSampledDataSource<SdfPath>::New(primPath));
             instanceIndicesBuilder.SetInstanceIndices(HdRetainedTypedSampledDataSource<VtArray<int>>::New({std::stoi(lastComponentString)}));
             HdSelectionSchema::Builder selectionBuilder;
+            // Instancer is expected to be marked "fully selected" even if only certain instances are selected,
+            // based on USD's _AddToSelection function in selectionSceneIndexObserver.cpp :
+            // https://github.com/PixarAnimationStudios/OpenUSD/blob/f7b8a021ce3d13f91a0211acf8a64a8b780524df/pxr/imaging/hdx/selectionSceneIndexObserver.cpp#L212-L251
             selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
             auto instanceIndicesDataSource = HdDataSourceBase::Cast(instanceIndicesBuilder.Build());
             selectionBuilder.SetNestedInstanceIndices(HdRetainedSmallVectorDataSource::New(1, &instanceIndicesDataSource));
@@ -161,8 +164,7 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
             selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
             selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
         }
-        Fvp::PrimSelectionInfo basePrimSelection {primPath, selectionDataSource};
-        Fvp::PrimSelectionInfoVector primSelections({basePrimSelection});
+        Fvp::PrimSelectionInfoVector primSelections({{primPath, selectionDataSource}});
 
         // Propagate selection to propagated prototypes
         auto ancestorsRange = primPath.GetAncestorsRange();

From efdaafafb1fddcb96cfd6561015899829878c0ad Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 12:55:13 -0400
Subject: [PATCH 093/112] Add more comments to test

---
 .../cpp/testPointInstancingWireframeHighlight.cpp   | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index 2abff92277..b8510055d5 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -169,10 +169,12 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
         auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(instancerPath);
         ASSERT_EQ(instancerHydraSelections.size(), 1u);
         auto instancerPrimPath = instancerHydraSelections.front().primPath;
-    
+
+        // Ensure selection is correct
         ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().size(), 1u);
         EXPECT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().front(), instancerPrimPath);
 
+        // Validate scene structure
         EXPECT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
         assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
     };
@@ -188,6 +190,7 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
         auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(instancerPath);
         ASSERT_EQ(instancerHydraSelections.size(), 1u);
     
+        // Validate scene structure
         EXPECT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
         assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerHydraSelections.front().primPath));
     };
@@ -195,7 +198,8 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
         // This is not an actual selection, we use it to get the Hydra path
         auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(instancerPath);
         ASSERT_EQ(instancerHydraSelections.size(), 1u);
-    
+
+        // Ensure there is no selection highlight mirror for the prim
         HdSceneIndexPrim selectionHighlightMirrorPrim = inspector.GetSceneIndex()->GetPrim(
             getSelectionHighlightMirrorPathFromOriginal(instancerHydraSelections.front().primPath));
         EXPECT_EQ(selectionHighlightMirrorPrim.primType, TfToken());
@@ -263,12 +267,15 @@ TEST(PointInstancingWireframeHighlight, instance)
         ASSERT_EQ(instanceHydraSelections.size(), 1u);
         auto instancerPrimPath = instanceHydraSelections.front().primPath;
 
+        // Ensure selection is correct
         ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().size(), 1u);
         EXPECT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().front(), instancerPrimPath);
 
+        // Validate scene structure
         EXPECT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
         assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
 
+        // Get the selection highlight instancer's mask
         HdSceneIndexPrim instancerHighlightPrim = inspector.GetSceneIndex()->GetPrim(getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
         HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(instancerHighlightPrim.dataSource);
         ASSERT_TRUE(instancerTopology.IsDefined());
@@ -276,6 +283,7 @@ TEST(PointInstancingWireframeHighlight, instance)
         auto mask = instancerTopology.GetMask()->GetTypedValue(0);
         EXPECT_FALSE(mask.empty());
 
+        // Ensure only the selected instance is shown
         size_t selectedInstanceIndex = std::stoul(instancePath.getSegments().back().components().back().string());
         for (size_t iMask = 0; iMask < mask.size(); iMask++) {
             EXPECT_EQ(mask[iMask], iMask == selectedInstanceIndex);
@@ -341,6 +349,7 @@ TEST(PointInstancingWireframeHighlight, prototype)
             }
         }
 
+        // Ensure the accumulated selected paths correspond to the intended/translated paths
         auto selectedPrimPaths = selectionObserver.GetSelection()->GetAllSelectedPrimPaths();
         ASSERT_EQ(selectedPrimPaths.size(), prototypeHydraSelections.size());
         for (const auto& prototypeHydraSelection : prototypeHydraSelections) {

From 1fcef2ed86c221c0e0f4470dd5875d12f7c39b7a Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 12:59:43 -0400
Subject: [PATCH 094/112] Minor adjustments to test

---
 .../cpp/testPointInstancingWireframeHighlight.cpp          | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index b8510055d5..9be9c3152c 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -81,6 +81,8 @@ void assertSelectionHighlightCorrectness(const HdSceneIndexBaseRefPtr& sceneInde
         const SdfPath& currPath = *it;
         HdSceneIndexPrim currPrim = sceneIndex->GetPrim(currPath);
 
+        // This check is similar in nature to the one in WireframeSelectionHighlightSceneIndex::_ForEachPrimInHierarchy
+        // to skip child prototypes
         VtArray<SdfPath> prototypeRoots = getPrototypeRoots(currPrim);
         bool isInSamePrototypeHierarchy = std::find_if(prototypeRoots.begin(), prototypeRoots.end(), [primPath](const auto& prototypeRoot) -> bool {
             return primPath.HasPrefix(prototypeRoot);
@@ -90,8 +92,9 @@ void assertSelectionHighlightCorrectness(const HdSceneIndexBaseRefPtr& sceneInde
             continue;
         }
 
-        HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(currPrim.dataSource);
-        if (instancerTopology.IsDefined()) {
+        if (currPrim.primType == HdPrimTypeTokens->instancer) {
+            HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(currPrim.dataSource);
+            ASSERT_TRUE(instancerTopology.IsDefined());
             ASSERT_NE(instancerTopology.GetPrototypes(), nullptr);
             auto prototypePaths = instancerTopology.GetPrototypes()->GetTypedValue(0);
             EXPECT_GE(prototypePaths.size(), 1u);

From 956177460b0e54f9c6e504d5169fc347ea30409d Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 13:03:39 -0400
Subject: [PATCH 095/112] Add another comment in test

---
 .../mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp    | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index 9be9c3152c..8d5d831503 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -100,6 +100,7 @@ void assertSelectionHighlightCorrectness(const HdSceneIndexBaseRefPtr& sceneInde
             EXPECT_GE(prototypePaths.size(), 1u);
             for (const auto& prototypePath : prototypePaths) {
                 auto prototypeName = prototypePath.GetElementString();
+                // Ensure prototype is a selection highlight mirror
                 ASSERT_GT(prototypeName.size(), selectionHighlightTag.size());
                 EXPECT_EQ(prototypeName.substr(prototypeName.size() - selectionHighlightTag.size()), selectionHighlightTag);
                 assertSelectionHighlightCorrectness(sceneIndex, prototypePath);

From aac8ac335086a79f0a270e6960a423c357c47c8d Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 13:08:48 -0400
Subject: [PATCH 096/112] Rename _IsInstancingRoot

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 27 +++++++++----------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 9f1b434f2b..3e03fb4754 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -199,29 +199,28 @@ VtArray<SdfPath> _GetPrototypeRoots(const HdSceneIndexPrim& prim)
     return instancedBy.GetPrototypeRoots()->GetTypedValue(0);
 }
 
-// This method is essentially "is not a prototype sub-prim".
-bool _IsInstancingRoot(const HdSceneIndexPrim& prim, const SdfPath& primPath)
+bool _IsPrototype(const HdSceneIndexPrim& prim)
+{
+    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
+    return instancedBy.IsDefined();
+}
+
+bool _IsPrototypeSubPrim(const HdSceneIndexPrim& prim, const SdfPath& primPath)
 {
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
     if (!instancedBy.IsDefined()) {
-        return true;
+        return false;
     }
     if (!instancedBy.GetPrototypeRoots()) {
-        return true;
+        return false;
     }
     auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
     for (const auto& protoRootPath : protoRootPaths) {
         if (protoRootPath == primPath) {
-            return true;
+            return false;
         }
     }
-    return false;
-}
-
-bool _IsPrototype(const HdSceneIndexPrim& prim)
-{
-    HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
-    return instancedBy.IsDefined();
+    return true;
 }
 
 // Similar to USD's _RerootingSceneIndexPathDataSource :
@@ -730,7 +729,7 @@ WireframeSelectionHighlightSceneIndex::_ForEachPrimInHierarchy(
         HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
 
         // Skip processing of prototypes nested under the hierarchy, as we consider prototype hierarchies to be separate.
-        if (_IsPrototype(currPrim) && _IsInstancingRoot(currPrim, currPath) && currPath != hierarchyRoot) {
+        if (_IsPrototype(currPrim) && !_IsPrototypeSubPrim(currPrim, currPath) && currPath != hierarchyRoot) {
             continue;
         }
 
@@ -766,7 +765,7 @@ WireframeSelectionHighlightSceneIndex::_CollectSelectionHighlightMirrors(const P
     // If this is a prototype sub-prim, redirect the call to the prototype root, so that the prototype root
     // becomes the actual selection highlight mirror. The instancing-related paths of the instancer will be
     // processed as part of the children traversal later down this method.
-    if (!_IsInstancingRoot(originalPrim, originalPrimPath)) {
+    if (_IsPrototypeSubPrim(originalPrim, originalPrimPath)) {
         HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(originalPrim.dataSource);
         auto protoRootPaths = instancedBy.GetPrototypeRoots()->GetTypedValue(0);
         for (const auto& protoRootPath : protoRootPaths) {

From 3ca1e386d117c5819f739a317c0422d29178d962 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 13:32:07 -0400
Subject: [PATCH 097/112] Rework prototype roots vs hierarchies

---
 ...pWireframeSelectionHighlightSceneIndex.cpp | 52 +++++++++----------
 .../testPointInstancingWireframeHighlight.cpp | 25 +++++----
 2 files changed, 36 insertions(+), 41 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 3e03fb4754..faf1715a5a 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -26,9 +26,10 @@
 #include <pxr/imaging/hd/legacyDisplayStyleSchema.h>
 #include <pxr/imaging/hd/overlayContainerDataSource.h>
 #include <pxr/imaging/hd/containerDataSourceEditor.h>
+#include <pxr/imaging/hd/sceneIndexPrimView.h>
 #include <pxr/imaging/hd/selectionSchema.h>
-#include <pxr/imaging/hd/tokens.h>
 #include <pxr/imaging/hd/selectionsSchema.h>
+#include <pxr/imaging/hd/tokens.h>
 
 #include <stack>
 
@@ -189,14 +190,14 @@ SdfPathVector _GetInstancingRelatedPaths(const HdSceneIndexPrim& prim)
     return instancingRelatedPaths;
 }
 
-VtArray<SdfPath> _GetPrototypeRoots(const HdSceneIndexPrim& prim)
+// We consider prototypes that have child prims to be different hierarchies,
+// separate from each other and from the "root" hierarchy.
+VtArray<SdfPath> _GetHierarchyRoots(const HdSceneIndexPrim& prim)
 {
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
-    if (!instancedBy.IsDefined() || !instancedBy.GetPrototypeRoots()) {
-        return {};
-    }
-
-    return instancedBy.GetPrototypeRoots()->GetTypedValue(0);
+    return instancedBy.IsDefined() && instancedBy.GetPrototypeRoots() 
+        ? instancedBy.GetPrototypeRoots()->GetTypedValue(0) 
+        : VtArray<SdfPath>({SdfPath::AbsoluteRootPath()});
 }
 
 bool _IsPrototype(const HdSceneIndexPrim& prim)
@@ -451,12 +452,8 @@ WireframeSelectionHighlightSceneIndex::GetPrim(const SdfPath &primPath) const
         // Note : in the USD data model, the original prims that get propagated as prototypes have their original prim types erased.
         // Only the resulting propagated prototypes keep the original prim type.
 
-        // We want to constrain the selected ancestor lookup to the propagated prototype only, if it is one.
-        auto roots = _GetPrototypeRoots(prim);
-        // If it is not a propagated prototype, consider the whole hierarchy.
-        if (roots.empty()) {
-            roots.push_back(SdfPath::AbsoluteRootPath());
-        }
+        // We want to constrain the selected ancestor lookup to only the hierarchies the prim is a part of.
+        auto roots = _GetHierarchyRoots(prim);
         for (const auto& root : roots) {
             if (_selection->HasFullySelectedAncestorInclusive(primPath, root)) {
                 prim.dataSource = _HighlightSelectedPrim(prim.dataSource, primPath, sRefinedWireOnSurfaceDisplayStyleDataSource);
@@ -721,22 +718,25 @@ WireframeSelectionHighlightSceneIndex::_ForEachPrimInHierarchy(
     const std::function<bool(const PXR_NS::SdfPath&, const PXR_NS::HdSceneIndexPrim&)>& operation
 )
 {
-    std::stack<SdfPath> pathsToTraverse({hierarchyRoot});
-    while (!pathsToTraverse.empty()) {
-        SdfPath currPath = pathsToTraverse.top();
-        pathsToTraverse.pop();
+    HdSceneIndexPrimView hierarchyView(GetInputSceneIndex(), hierarchyRoot);
+    for (auto itPrim = hierarchyView.begin(); itPrim != hierarchyView.end(); ++itPrim) {
+        const SdfPath& currPath = *itPrim;
 
         HdSceneIndexPrim currPrim = GetInputSceneIndex()->GetPrim(currPath);
 
-        // Skip processing of prototypes nested under the hierarchy, as we consider prototype hierarchies to be separate.
-        if (_IsPrototype(currPrim) && !_IsPrototypeSubPrim(currPrim, currPath) && currPath != hierarchyRoot) {
+        // If the current prim is not part of the same hierarchy we are traversing, skip it and its descendents.
+        VtArray<SdfPath> primRoots = _GetHierarchyRoots(currPrim);
+        bool sharesHierarchy = std::find_if(primRoots.begin(), primRoots.end(), [hierarchyRoot](const auto& primRoot) -> bool {
+            return hierarchyRoot.HasPrefix(primRoot);
+        }) != primRoots.end();
+        if (!sharesHierarchy) {
+            itPrim.SkipDescendants();
             continue;
         }
 
-        if (operation(currPath, currPrim)) {
-            for (const auto& childPath : GetInputSceneIndex()->GetChildPrimPaths(currPath)) {
-                pathsToTraverse.push(childPath);
-            }
+        if (!operation(currPath, currPrim)) {
+            itPrim.SkipDescendants();
+            continue;
         }
     }
 }
@@ -892,11 +892,7 @@ WireframeSelectionHighlightSceneIndex::_DeleteInstancerHighlight(const PXR_NS::S
 void
 WireframeSelectionHighlightSceneIndex::_CreateInstancerHighlightsForInstancer(const HdSceneIndexPrim& instancerPrim, const SdfPath& instancerPath)
 {
-    auto roots = _GetPrototypeRoots(instancerPrim);
-    // If there are no prototype roots, consider the whole hierarchy
-    if (roots.empty()) {
-        roots.push_back(SdfPath::AbsoluteRootPath());
-    }
+    auto roots = _GetHierarchyRoots(instancerPrim);
     for (const auto& root : roots) {
         // Ancestors include the instancer itself
         auto selectedAncestors = _selection->FindFullySelectedAncestorsInclusive(instancerPath, root);
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index 8d5d831503..0a5172b00c 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -63,7 +63,7 @@ TfToken getRefinedReprToken(const HdSceneIndexPrim& prim)
     return reprSelectors.empty() ? TfToken() : reprSelectors.front();
 }
 
-VtArray<SdfPath> getPrototypeRoots(const HdSceneIndexPrim& prim)
+VtArray<SdfPath> getHierarchyRoots(const HdSceneIndexPrim& prim)
 {
     HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
     return instancedBy.IsDefined() && instancedBy.GetPrototypeRoots() 
@@ -76,19 +76,18 @@ VtArray<SdfPath> getPrototypeRoots(const HdSceneIndexPrim& prim)
 // the proper display style.
 void assertSelectionHighlightCorrectness(const HdSceneIndexBaseRefPtr& sceneIndex, const SdfPath& primPath)
 {
-    HdSceneIndexPrimView view(sceneIndex, primPath);
-    for (auto it = view.begin(); it != view.end(); ++it) {
-        const SdfPath& currPath = *it;
+    HdSceneIndexPrimView primView(sceneIndex, primPath);
+    for (auto itPrim = primView.begin(); itPrim != primView.end(); ++itPrim) {
+        const SdfPath& currPath = *itPrim;
         HdSceneIndexPrim currPrim = sceneIndex->GetPrim(currPath);
 
-        // This check is similar in nature to the one in WireframeSelectionHighlightSceneIndex::_ForEachPrimInHierarchy
-        // to skip child prototypes
-        VtArray<SdfPath> prototypeRoots = getPrototypeRoots(currPrim);
-        bool isInSamePrototypeHierarchy = std::find_if(prototypeRoots.begin(), prototypeRoots.end(), [primPath](const auto& prototypeRoot) -> bool {
-            return primPath.HasPrefix(prototypeRoot);
-        }) != prototypeRoots.end();
-        if (!isInSamePrototypeHierarchy) {
-            it.SkipDescendants();
+        // Same check as in WireframeSelectionHighlightSceneIndex::_ForEachPrimInHierarchy
+        VtArray<SdfPath> currPrimRoots = getHierarchyRoots(currPrim);
+        bool sharesHierarchy = std::find_if(currPrimRoots.begin(), currPrimRoots.end(), [primPath](const auto& currPrimRoot) -> bool {
+            return primPath.HasPrefix(currPrimRoot);
+        }) != currPrimRoots.end();
+        if (!sharesHierarchy) {
+            itPrim.SkipDescendants();
             continue;
         }
 
@@ -105,7 +104,7 @@ void assertSelectionHighlightCorrectness(const HdSceneIndexBaseRefPtr& sceneInde
                 EXPECT_EQ(prototypeName.substr(prototypeName.size() - selectionHighlightTag.size()), selectionHighlightTag);
                 assertSelectionHighlightCorrectness(sceneIndex, prototypePath);
             }
-            it.SkipDescendants();
+            itPrim.SkipDescendants();
             continue;
         }
 

From 77c3fe5f79b0f5e9a96a376fef6a28bef5a84fdc Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 13:33:53 -0400
Subject: [PATCH 098/112] Whitespace fix

---
 .../mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp    | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index 0a5172b00c..37ea7ed5a3 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -1,4 +1,3 @@
-
 // Copyright 2024 Autodesk
 //
 // Licensed under the Apache License, Version 2.0 (the "License");

From 2444458e09eca9b438cc2a26e2b53873a220e2f0 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Wed, 5 Jun 2024 14:18:49 -0400
Subject: [PATCH 099/112] Update comments on PathInterface

---
 lib/flowViewport/sceneIndex/fvpPathInterface.h | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/flowViewport/sceneIndex/fvpPathInterface.h b/lib/flowViewport/sceneIndex/fvpPathInterface.h
index 10bfaab8b0..5c396d57e4 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterface.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterface.h
@@ -36,12 +36,15 @@ struct PrimSelectionInfo
     PXR_NS::HdDataSourceBaseHandle selectionDataSource;
 };
 
+// Using TfSmallVector to optimize for selections that map to a few prims,
+// which is likely going to be the bulk of use cases.
 using PrimSelectionInfoVector = PXR_NS::TfSmallVector<PrimSelectionInfo, 8>;
 
 /// \class PathInterface
 ///
 /// A pure interface class to allow for conversion between an application's
-/// path, expressed as a Ufe::Path, into an SdfPath valid for a scene index.
+/// path, expressed as a Ufe::Path, into SdfPaths valid for a scene index
+/// and selection data sources.
 /// To be used as a mix-in class for scene indices.
 ///
 class PathInterface

From fc4df132e781e3d2c8b2c14190755741de003caa Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 10 Jun 2024 18:11:11 -0400
Subject: [PATCH 100/112] Refactor pushHydraSelectionsToPathVector

---
 .../hydraExtensions/mhLeadObjectPathTracker.cpp  | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
index 430124b902..dab61e04a0 100644
--- a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
+++ b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
@@ -65,13 +65,15 @@ class GlobalSelectionChangedObs : public Ufe::Observer
             MayaHydra::MhLeadObjectPathTracker& _leadObjectPathTracker;
     };
 
-void pushHydraSelectionsToPathVector(const Fvp::PrimSelectionInfoVector& hydraSelections, SdfPathVector& outPathVector)
+SdfPathVector hydraSelectionsToSdfPathVector(const Fvp::PrimSelectionInfoVector& hydraSelections)
 {
+    SdfPathVector outVector;
     for (const auto& hydraSelection : hydraSelections) {
         if (!hydraSelection.primPath.IsEmpty()) {
-            outPathVector.push_back(hydraSelection.primPath);
+            outVector.emplace_back(hydraSelection.primPath);
         }
     }
+    return outVector;
 }
 
 }
@@ -92,8 +94,7 @@ MhLeadObjectPathTracker::MhLeadObjectPathTracker(const HdSceneIndexBaseRefPtr& s
         _leadObjectUfePath = leadObjectSceneItem->path();
         //_leadObjectPrimPaths can be empty with a valid _leadObjectUfePath when the lead object is in a data producer scene index not yet added to the merging scene index
         //This is fixed at some point by calling updatePrimPaths()
-        auto hydraSelections = _pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath);
-        pushHydraSelectionsToPathVector(hydraSelections, _leadObjectPrimPaths);
+        _leadObjectPrimPaths = hydraSelectionsToSdfPathVector(_pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath));
     }
 
    // Add ourself as an observer to the selection
@@ -129,9 +130,7 @@ void MhLeadObjectPathTracker::setLeadObjectUfePath(const Ufe::Path& newLeadObjec
     auto oldLeadObjectPrimPaths = _leadObjectPrimPaths;
 
     _leadObjectUfePath  = newLeadObjectUfePath;
-    auto hydraSelections = _pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath);
-    _leadObjectPrimPaths.clear();
-    pushHydraSelectionsToPathVector(hydraSelections, _leadObjectPrimPaths);
+    _leadObjectPrimPaths = hydraSelectionsToSdfPathVector(_pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath));
 
     // Dirty the previous lead object
     if(_dirtyLeadObjectSceneIndex){
@@ -143,8 +142,7 @@ void MhLeadObjectPathTracker::updatePrimPaths()
 { 
    // Update the lead object prim paths in case it was not valid yet
     if ( (_leadObjectUfePath.size() > 0) && _leadObjectPrimPaths.empty()) {
-        auto hydraSelections = _pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath);
-        pushHydraSelectionsToPathVector(hydraSelections, _leadObjectPrimPaths);
+        _leadObjectPrimPaths = hydraSelectionsToSdfPathVector(_pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath));
     }
 }
 

From 1a3abfaa3cbc9a9635c15b8294e8a868d5850be0 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 10 Jun 2024 18:19:38 -0400
Subject: [PATCH 101/112] Minor doc clarifications

---
 doc/selectionHighlightingArchitecture.md | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index f0c9425906..5c4d5b6bde 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -420,7 +420,7 @@ Root
 where `TopInstancer_SelectionHighlight` would instance `NestedInstancer_SelectionHighlight`, which would in turn instance `Prototype_SelectionHighlight`.
 
 Note that in the case where a prototype is not a single prim but a sub-hierarchy, we only need to 
-create a single *explicit* selection highlight mirror for the whole prototype sub-hierarchy; the 
+create a single *explicit* selection highlight mirror prim for the whole prototype sub-hierarchy; the 
 child prims of the selection highlight mirror will simply be pulled from the corresponding original 
 prim, and thus implicitly be selection highlight mirrors as well.
 
@@ -451,11 +451,13 @@ where `TopInstancer_SelectionHighlight` instances `Prototype_SelectionHighlight`
 
 Of note are the following selection highlighting scenarios and their corresponding behaviors :
 - Selecting a point instancer in its entirety
-  - If the instancer is a top-level instancer, all instances it draws WILL be highlighted
-  - If the instancer is a prototype, instances of itself drawn by other instancers will NOT be highlighted
+  - If the instancer is a top-level instancer, all instances it draws WILL be highlighted.
+  - If the instancer is a prototype, instances of itself drawn by other instancers will NOT be highlighted. 
+    This is an intentional workflow decision from the Hydra for Maya team.
 - Selecting specific instances of point instancer
-  - If the instancer is a top-level instancer, the selected instances it draws WILL be highlighted
-  - If the instancer is a prototype, the instances it would indirectly draw through instances of itself drawn by other instancers will NOT be highlighted
+  - If the instancer is a top-level instancer, the selected instances it draws WILL be highlighted.
+  - If the instancer is a prototype, the instances it would indirectly draw through instances of itself drawn by other instancers will NOT be highlighted. 
+    This is an intentional workflow decision from the Hydra for Maya team.
 - Selecting a parent prim of a point instancer
   - (same as selecting a point instancer in its entirety)
 

From 03ec9f43eedb1b7596ad63d4cf61958cdfc4bfbe Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Mon, 10 Jun 2024 18:22:27 -0400
Subject: [PATCH 102/112] Rename PrimSelectionInfo to PrimSelection

---
 .../sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h   | 2 +-
 lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp        | 4 ++--
 lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h          | 2 +-
 lib/flowViewport/sceneIndex/fvpPathInterface.h              | 6 +++---
 lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp      | 4 ++--
 lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h        | 2 +-
 lib/flowViewport/selection/fvpSelection.cpp                 | 4 ++--
 lib/flowViewport/selection/fvpSelection.h                   | 4 ++--
 lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp   | 2 +-
 .../hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp      | 6 +++---
 .../hydraExtensions/sceneIndex/mayaHydraSceneIndex.h        | 2 +-
 lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp   | 4 ++--
 12 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h b/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
index bc8e7e1125..83253ac2ae 100644
--- a/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
@@ -70,7 +70,7 @@ class BlockPrimRemovalPropagationSceneIndex : public PXR_NS::HdSingleInputFilter
 
     //from PathInterface
     FVP_API
-    PrimSelectionInfoVector ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override{
+    PrimSelections ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override{
         return _pathInterface->ConvertUfePathToHydraSelections(appPath);
     }
 
diff --git a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
index 55ff3f67a9..3a9fa4677e 100644
--- a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
@@ -34,7 +34,7 @@ MergingSceneIndex::MergingSceneIndex() : HdMergingSceneIndex()
         .Msg("MergingSceneIndex::MergingSceneIndex() called.\n");
 }
 
-PrimSelectionInfoVector MergingSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const
+PrimSelections MergingSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const
 {
     // FLOW_VIEWPORT_TODO  May be able to use a caching scheme for app path to
     // scene index path conversion using the run-time ID of the UFE path, as it
@@ -56,7 +56,7 @@ PrimSelectionInfoVector MergingSceneIndex::ConvertUfePathToHydraSelections(const
             }
         }
     }
-    return PrimSelectionInfoVector();
+    return PrimSelections();
 }
 
 }
diff --git a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
index d974a93c53..b83cfcefb4 100644
--- a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
@@ -41,7 +41,7 @@ class MergingSceneIndex
     static MergingSceneIndexRefPtr New();
 
     FVP_API
-    PrimSelectionInfoVector ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override;
+    PrimSelections ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override;
 
 private:
     MergingSceneIndex();
diff --git a/lib/flowViewport/sceneIndex/fvpPathInterface.h b/lib/flowViewport/sceneIndex/fvpPathInterface.h
index 5c396d57e4..025dcf1110 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterface.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterface.h
@@ -30,7 +30,7 @@ class Path;
 
 namespace FVP_NS_DEF {
 
-struct PrimSelectionInfo
+struct PrimSelection
 {
     PXR_NS::SdfPath primPath;
     PXR_NS::HdDataSourceBaseHandle selectionDataSource;
@@ -38,7 +38,7 @@ struct PrimSelectionInfo
 
 // Using TfSmallVector to optimize for selections that map to a few prims,
 // which is likely going to be the bulk of use cases.
-using PrimSelectionInfoVector = PXR_NS::TfSmallVector<PrimSelectionInfo, 8>;
+using PrimSelections = PXR_NS::TfSmallVector<PrimSelection, 8>;
 
 /// \class PathInterface
 ///
@@ -55,7 +55,7 @@ class PathInterface
     //! If no such path exists, an empty SdfPath should be returned.
     //! \return scene index path.
     FVP_API
-    virtual PrimSelectionInfoVector ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const = 0;
+    virtual PrimSelections ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const = 0;
 
 protected:
 
diff --git a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
index 8248bc4405..6429a0be20 100644
--- a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
@@ -228,7 +228,7 @@ void SelectionSceneIndex::ReplaceSelection(const Ufe::Selection& selection)
 
     _selection->Clear();
 
-    PrimSelectionInfoVector sceneIndexSn;
+    PrimSelections sceneIndexSn;
     sceneIndexSn.reserve(selection.size());
     for (const auto& snItem : selection) {
         // Call our input scene index to convert the application path to scene index paths and selection data sources.
@@ -260,7 +260,7 @@ bool SelectionSceneIndex::HasFullySelectedAncestorInclusive(const SdfPath& primP
     return _selection->HasFullySelectedAncestorInclusive(primPath);
 }
 
-PrimSelectionInfoVector SelectionSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const
+PrimSelections SelectionSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const
 {
     auto primSelections = _inputSceneIndexPathInterface->ConvertUfePathToHydraSelections(appPath);
 
diff --git a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
index fcd91e9cc0..d8e9aef605 100644
--- a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
@@ -117,7 +117,7 @@ class SelectionSceneIndex final
     //! and warns about empty return paths.
     //@{
     FVP_API
-    PrimSelectionInfoVector ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override;
+    PrimSelections ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override;
     //@}
 
     FVP_API
diff --git a/lib/flowViewport/selection/fvpSelection.cpp b/lib/flowViewport/selection/fvpSelection.cpp
index 312871c127..42b47fc669 100644
--- a/lib/flowViewport/selection/fvpSelection.cpp
+++ b/lib/flowViewport/selection/fvpSelection.cpp
@@ -53,7 +53,7 @@ Selection::_PrimSelectionState::GetVectorDataSource() const
 };
 
 bool
-Selection::Add(const PrimSelectionInfo& primSelection)
+Selection::Add(const PrimSelection& primSelection)
 {
     if (primSelection.primPath.IsEmpty()) {
         return false;
@@ -75,7 +75,7 @@ Selection::Clear()
     _pathToState.clear();
 }
 
-void Selection::Replace(const PrimSelectionInfoVector& primSelections)
+void Selection::Replace(const PrimSelections& primSelections)
 {
     Clear();
 
diff --git a/lib/flowViewport/selection/fvpSelection.h b/lib/flowViewport/selection/fvpSelection.h
index 55dcd1c700..55aa52c867 100644
--- a/lib/flowViewport/selection/fvpSelection.h
+++ b/lib/flowViewport/selection/fvpSelection.h
@@ -45,7 +45,7 @@ class Selection
 
     // Add primPath to selection and return true if the argument is not empty.
     FVP_API
-    bool Add(const PrimSelectionInfo& primSelection);
+    bool Add(const PrimSelection& primSelection);
 
     // Returns true if the removal was successful, false otherwise.
     FVP_API
@@ -54,7 +54,7 @@ class Selection
     // Replace the selection with the contents of the argument primPath vector.
     // Any empty primPath in the argument will be skipped.
     FVP_API
-    void Replace(const PrimSelectionInfoVector& primSelections);
+    void Replace(const PrimSelections& primSelections);
 
     // Remove all entries from the selection.
     FVP_API
diff --git a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
index dab61e04a0..c2664e1643 100644
--- a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
+++ b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
@@ -65,7 +65,7 @@ class GlobalSelectionChangedObs : public Ufe::Observer
             MayaHydra::MhLeadObjectPathTracker& _leadObjectPathTracker;
     };
 
-SdfPathVector hydraSelectionsToSdfPathVector(const Fvp::PrimSelectionInfoVector& hydraSelections)
+SdfPathVector hydraSelectionsToSdfPathVector(const Fvp::PrimSelections& hydraSelections)
 {
     SdfPathVector outVector;
     for (const auto& hydraSelection : hydraSelections) {
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
index 784cdaa8be..9c002a8e04 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
@@ -648,7 +648,7 @@ VtValue MayaHydraSceneIndex::CreateMayaDefaultMaterial()
     return VtValue(networkMap);
 }
 
-Fvp::PrimSelectionInfoVector MayaHydraSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const
+Fvp::PrimSelections MayaHydraSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const
 {
     TF_DEBUG(MAYAHYDRALIB_SCENE_INDEX)
         .Msg("MayaHydraSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& %s) called.\n", Ufe::PathString::string(appPath).c_str());
@@ -666,8 +666,8 @@ Fvp::PrimSelectionInfoVector MayaHydraSceneIndex::ConvertUfePathToHydraSelection
     HdSelectionSchema::Builder selectionBuilder;
     selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
     auto selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
-    Fvp::PrimSelectionInfo primSelection {primPath, selectionDataSource};
-    return Fvp::PrimSelectionInfoVector({primSelection});
+    Fvp::PrimSelection primSelection {primPath, selectionDataSource};
+    return Fvp::PrimSelections({primSelection});
 }
 
 SdfPath MayaHydraSceneIndex::SetCameraViewport(const MDagPath& camPath, const GfVec4d& viewport)
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h
index 157e71c215..1228337927 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h
@@ -202,7 +202,7 @@ class MAYAHYDRALIB_API MayaHydraSceneIndex : public HdRetainedSceneIndex, public
 
     void SetDefaultMaterial(bool useDefMaterial);
 
-    Fvp::PrimSelectionInfoVector ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override;
+    Fvp::PrimSelections ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override;
 
     // Common function to return templated sample types
     template <typename T, typename Getter>
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
index 5677bb8ce5..05d980a535 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
@@ -110,7 +110,7 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
             inputSceneIndex, sceneIndexPathPrefix, sceneIndexAppPath));
     }
 
-    Fvp::PrimSelectionInfoVector ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override
+    Fvp::PrimSelections ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override
     {
         // We only handle USD objects, so if the UFE path is not a USD object,
         // early out with failure.
@@ -164,7 +164,7 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
             selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
             selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
         }
-        Fvp::PrimSelectionInfoVector primSelections({{primPath, selectionDataSource}});
+        Fvp::PrimSelections primSelections({{primPath, selectionDataSource}});
 
         // Propagate selection to propagated prototypes
         auto ancestorsRange = primPath.GetAncestorsRange();

From 39009f76beebddadf477461ecc58c1631718eed8 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 11 Jun 2024 11:15:57 -0400
Subject: [PATCH 103/112] Rename isLeadPrim to isLeadObjectPrim

---
 lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp      | 2 +-
 lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.h        | 2 +-
 lib/mayaHydra/hydraExtensions/mhWireframeColorInterfaceImp.cpp | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
index c2664e1643..c370ec1eab 100644
--- a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
+++ b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
@@ -108,7 +108,7 @@ MhLeadObjectPathTracker::~MhLeadObjectPathTracker()
     _ufeSelectionObserver = nullptr;
 }
 
-bool MhLeadObjectPathTracker::isLeadPrim(const PXR_NS::SdfPath& primPath) const
+bool MhLeadObjectPathTracker::isLeadObjectPrim(const PXR_NS::SdfPath& primPath) const
 {
     //_leadObjectPrimPaths can be hierarchy paths, so we need to check if the primPath is a prefix
     //of a lead object prim path
diff --git a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.h b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.h
index d49c1a023d..b3db748634 100644
--- a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.h
+++ b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.h
@@ -47,7 +47,7 @@ class MhLeadObjectPathTracker
     ~MhLeadObjectPathTracker();
 
     MAYAHYDRALIB_API
-    bool isLeadPrim(const PXR_NS::SdfPath& primPath) const;
+    bool isLeadObjectPrim(const PXR_NS::SdfPath& primPath) const;
     
     MAYAHYDRALIB_API
     Ufe::Path getLeadObjectUfePath() const {return _leadObjectUfePath;}
diff --git a/lib/mayaHydra/hydraExtensions/mhWireframeColorInterfaceImp.cpp b/lib/mayaHydra/hydraExtensions/mhWireframeColorInterfaceImp.cpp
index 2526d2afe1..d2064af9f4 100644
--- a/lib/mayaHydra/hydraExtensions/mhWireframeColorInterfaceImp.cpp
+++ b/lib/mayaHydra/hydraExtensions/mhWireframeColorInterfaceImp.cpp
@@ -53,7 +53,7 @@ MhWireframeColorInterfaceImp::MhWireframeColorInterfaceImp(const std::shared_ptr
 MhWireframeColorInterfaceImp::SelectionState MhWireframeColorInterfaceImp::_getSelectionState(const PXR_NS::SdfPath& primPath)const
 {
     if (_selection->HasFullySelectedAncestorInclusive(primPath)){
-        return (_leadObjectPathTracker->isLeadPrim(primPath)) ? kLead : kActive;
+        return (_leadObjectPathTracker->isLeadObjectPrim(primPath)) ? kLead : kActive;
     }
     
     return kDormant;

From e04b7dc4b0946aaaecf225142f40008fe375aeb8 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 11 Jun 2024 11:19:19 -0400
Subject: [PATCH 104/112] Rename ConvertUfePathToHydraSelections to
 UfePathToPrimSelections

---
 doc/selectionHighlightingArchitecture.md             |  4 ++--
 .../fvpBlockPrimRemovalPropagationSceneIndex.h       |  4 ++--
 lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp |  4 ++--
 lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h   |  2 +-
 lib/flowViewport/sceneIndex/fvpPathInterface.h       |  2 +-
 .../sceneIndex/fvpPathInterfaceSceneIndex.h          |  2 +-
 .../sceneIndex/fvpSelectionSceneIndex.cpp            | 12 ++++++------
 lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h |  2 +-
 .../hydraExtensions/mhLeadObjectPathTracker.cpp      |  6 +++---
 .../sceneIndex/mayaHydraSceneIndex.cpp               |  4 ++--
 .../hydraExtensions/sceneIndex/mayaHydraSceneIndex.h |  2 +-
 .../hydraExtensions/sceneIndex/registration.cpp      |  2 +-
 .../mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp |  2 +-
 .../render/mayaToHydra/cpp/testMergingSceneIndex.cpp |  6 +++---
 .../render/mayaToHydra/cpp/testPathInterface.cpp     |  2 +-
 .../cpp/testPointInstancingWireframeHighlight.cpp    | 10 +++++-----
 .../mayaToHydra/cpp/testSelectionSceneIndex.cpp      |  6 +++---
 .../mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp   |  2 +-
 .../render/mayaToHydra/cpp/testUsdPicking.cpp        |  2 +-
 .../mayaToHydra/cpp/testUsdPointInstancePicking.cpp  |  2 +-
 .../testWireframeSelectionHighlightSceneIndex.cpp    | 10 +++++-----
 21 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index 5c4d5b6bde..fca9df0813 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -86,7 +86,7 @@ provide the following services:
 
 This
 [selection change code](../lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp#L152-L173)
-shows the use of the *Path Interface*, through the *ConvertUfePathToHydraSelections()* method,
+shows the use of the *Path Interface*, through the *UfePathToPrimSelections()* method,
 called on the input scene index.  The path interface allows the selection scene
 index to translate selected application paths to selected Hydra scene index
 paths.
@@ -234,7 +234,7 @@ class Selection{
 }
 
 class PathInterface{
-+ConvertUfePathToHydraSelections(Ufe::Path) SdfPath
++UfePathToPrimSelections(Ufe::Path) SdfPath
 }
 
 class SelectionSceneIndex
diff --git a/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h b/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
index 83253ac2ae..2ba8311f45 100644
--- a/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpBlockPrimRemovalPropagationSceneIndex.h
@@ -70,8 +70,8 @@ class BlockPrimRemovalPropagationSceneIndex : public PXR_NS::HdSingleInputFilter
 
     //from PathInterface
     FVP_API
-    PrimSelections ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override{
-        return _pathInterface->ConvertUfePathToHydraSelections(appPath);
+    PrimSelections UfePathToPrimSelections(const Ufe::Path& appPath) const override{
+        return _pathInterface->UfePathToPrimSelections(appPath);
     }
 
 protected:
diff --git a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
index 3a9fa4677e..912d51bc10 100644
--- a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.cpp
@@ -34,7 +34,7 @@ MergingSceneIndex::MergingSceneIndex() : HdMergingSceneIndex()
         .Msg("MergingSceneIndex::MergingSceneIndex() called.\n");
 }
 
-PrimSelections MergingSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const
+PrimSelections MergingSceneIndex::UfePathToPrimSelections(const Ufe::Path& appPath) const
 {
     // FLOW_VIEWPORT_TODO  May be able to use a caching scheme for app path to
     // scene index path conversion using the run-time ID of the UFE path, as it
@@ -50,7 +50,7 @@ PrimSelections MergingSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Pat
         // scene we know whether it supports the PathInterface or not.
         auto pathInterface = dynamic_cast<const PathInterface*>(&*inputScene);
         if (pathInterface) {
-            auto primSelections = pathInterface->ConvertUfePathToHydraSelections(appPath);
+            auto primSelections = pathInterface->UfePathToPrimSelections(appPath);
             if (!primSelections.empty()) {
                 return primSelections;
             }
diff --git a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
index b83cfcefb4..6945ca3d34 100644
--- a/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpMergingSceneIndex.h
@@ -41,7 +41,7 @@ class MergingSceneIndex
     static MergingSceneIndexRefPtr New();
 
     FVP_API
-    PrimSelections ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override;
+    PrimSelections UfePathToPrimSelections(const Ufe::Path& appPath) const override;
 
 private:
     MergingSceneIndex();
diff --git a/lib/flowViewport/sceneIndex/fvpPathInterface.h b/lib/flowViewport/sceneIndex/fvpPathInterface.h
index 025dcf1110..8a1ecd3dff 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterface.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterface.h
@@ -55,7 +55,7 @@ class PathInterface
     //! If no such path exists, an empty SdfPath should be returned.
     //! \return scene index path.
     FVP_API
-    virtual PrimSelections ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const = 0;
+    virtual PrimSelections UfePathToPrimSelections(const Ufe::Path& appPath) const = 0;
 
 protected:
 
diff --git a/lib/flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h b/lib/flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h
index 854aaa4b10..5765943d5c 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterfaceSceneIndex.h
@@ -27,7 +27,7 @@ namespace FVP_NS_DEF {
 ///
 /// A simple pass-through filtering scene index that adds support for the path
 /// interface.  Derived classes need only implement the 
-/// PathInterface::ConvertUfePathToHydraSelections() virtual.
+/// PathInterface::UfePathToPrimSelections() virtual.
 ///
 class PathInterfaceSceneIndexBase 
     : public PXR_NS::HdSingleInputFilteringSceneIndexBase
diff --git a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
index 6429a0be20..195246054a 100644
--- a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.cpp
@@ -156,7 +156,7 @@ SelectionSceneIndex::AddSelection(const Ufe::Path& appPath)
         .Msg("SelectionSceneIndex::AddSelection(const Ufe::Path& %s) called.\n", Ufe::PathString::string(appPath).c_str());
 
     // Call our input scene index to convert the application path to scene index paths and selection data sources.
-    auto primSelections = ConvertUfePathToHydraSelections(appPath);
+    auto primSelections = UfePathToPrimSelections(appPath);
 
     for (const auto& primSelection : primSelections) {
         TF_DEBUG(FVP_SELECTION_SCENE_INDEX)
@@ -178,7 +178,7 @@ void SelectionSceneIndex::RemoveSelection(const Ufe::Path& appPath)
         .Msg("SelectionSceneIndex::RemoveSelection(const Ufe::Path& %s) called.\n", Ufe::PathString::string(appPath).c_str());
 
     // Call our input scene index to convert the application path to scene index paths and selection data sources.
-    auto primSelections = ConvertUfePathToHydraSelections(appPath);
+    auto primSelections = UfePathToPrimSelections(appPath);
 
     HdSceneIndexObserver::DirtiedPrimEntries dirtiedPrims;
     for (const auto& primSelection : primSelections) {
@@ -232,7 +232,7 @@ void SelectionSceneIndex::ReplaceSelection(const Ufe::Selection& selection)
     sceneIndexSn.reserve(selection.size());
     for (const auto& snItem : selection) {
         // Call our input scene index to convert the application path to scene index paths and selection data sources.
-        auto primSelections = ConvertUfePathToHydraSelections(snItem->path());
+        auto primSelections = UfePathToPrimSelections(snItem->path());
 
         if (primSelections.empty()) {
             continue;
@@ -260,12 +260,12 @@ bool SelectionSceneIndex::HasFullySelectedAncestorInclusive(const SdfPath& primP
     return _selection->HasFullySelectedAncestorInclusive(primPath);
 }
 
-PrimSelections SelectionSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const
+PrimSelections SelectionSceneIndex::UfePathToPrimSelections(const Ufe::Path& appPath) const
 {
-    auto primSelections = _inputSceneIndexPathInterface->ConvertUfePathToHydraSelections(appPath);
+    auto primSelections = _inputSceneIndexPathInterface->UfePathToPrimSelections(appPath);
 
     if (primSelections.empty()) {
-        TF_WARN("SelectionSceneIndex::ConvertUfePathToHydraSelections(%s) returned no path, Hydra selection will be incorrect", Ufe::PathString::string(appPath).c_str());
+        TF_WARN("SelectionSceneIndex::UfePathToPrimSelections(%s) returned no path, Hydra selection will be incorrect", Ufe::PathString::string(appPath).c_str());
     }
 
     return primSelections;
diff --git a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
index d8e9aef605..be4ce573a8 100644
--- a/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpSelectionSceneIndex.h
@@ -117,7 +117,7 @@ class SelectionSceneIndex final
     //! and warns about empty return paths.
     //@{
     FVP_API
-    PrimSelections ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override;
+    PrimSelections UfePathToPrimSelections(const Ufe::Path& appPath) const override;
     //@}
 
     FVP_API
diff --git a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
index c370ec1eab..47cedd8696 100644
--- a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
+++ b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
@@ -94,7 +94,7 @@ MhLeadObjectPathTracker::MhLeadObjectPathTracker(const HdSceneIndexBaseRefPtr& s
         _leadObjectUfePath = leadObjectSceneItem->path();
         //_leadObjectPrimPaths can be empty with a valid _leadObjectUfePath when the lead object is in a data producer scene index not yet added to the merging scene index
         //This is fixed at some point by calling updatePrimPaths()
-        _leadObjectPrimPaths = hydraSelectionsToSdfPathVector(_pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath));
+        _leadObjectPrimPaths = hydraSelectionsToSdfPathVector(_pathInterface->UfePathToPrimSelections(_leadObjectUfePath));
     }
 
    // Add ourself as an observer to the selection
@@ -130,7 +130,7 @@ void MhLeadObjectPathTracker::setLeadObjectUfePath(const Ufe::Path& newLeadObjec
     auto oldLeadObjectPrimPaths = _leadObjectPrimPaths;
 
     _leadObjectUfePath  = newLeadObjectUfePath;
-    _leadObjectPrimPaths = hydraSelectionsToSdfPathVector(_pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath));
+    _leadObjectPrimPaths = hydraSelectionsToSdfPathVector(_pathInterface->UfePathToPrimSelections(_leadObjectUfePath));
 
     // Dirty the previous lead object
     if(_dirtyLeadObjectSceneIndex){
@@ -142,7 +142,7 @@ void MhLeadObjectPathTracker::updatePrimPaths()
 { 
    // Update the lead object prim paths in case it was not valid yet
     if ( (_leadObjectUfePath.size() > 0) && _leadObjectPrimPaths.empty()) {
-        _leadObjectPrimPaths = hydraSelectionsToSdfPathVector(_pathInterface->ConvertUfePathToHydraSelections(_leadObjectUfePath));
+        _leadObjectPrimPaths = hydraSelectionsToSdfPathVector(_pathInterface->UfePathToPrimSelections(_leadObjectUfePath));
     }
 }
 
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
index 9c002a8e04..11c8872060 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.cpp
@@ -648,10 +648,10 @@ VtValue MayaHydraSceneIndex::CreateMayaDefaultMaterial()
     return VtValue(networkMap);
 }
 
-Fvp::PrimSelections MayaHydraSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const
+Fvp::PrimSelections MayaHydraSceneIndex::UfePathToPrimSelections(const Ufe::Path& appPath) const
 {
     TF_DEBUG(MAYAHYDRALIB_SCENE_INDEX)
-        .Msg("MayaHydraSceneIndex::ConvertUfePathToHydraSelections(const Ufe::Path& %s) called.\n", Ufe::PathString::string(appPath).c_str());
+        .Msg("MayaHydraSceneIndex::UfePathToPrimSelections(const Ufe::Path& %s) called.\n", Ufe::PathString::string(appPath).c_str());
 
     // We only handle Maya objects, so if the UFE path is not a Maya object,
     // early out with failure.
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h
index 1228337927..01a71e20e7 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/mayaHydraSceneIndex.h
@@ -202,7 +202,7 @@ class MAYAHYDRALIB_API MayaHydraSceneIndex : public HdRetainedSceneIndex, public
 
     void SetDefaultMaterial(bool useDefMaterial);
 
-    Fvp::PrimSelections ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override;
+    Fvp::PrimSelections UfePathToPrimSelections(const Ufe::Path& appPath) const override;
 
     // Common function to return templated sample types
     template <typename T, typename Getter>
diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
index 05d980a535..3e9ed77cae 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
@@ -110,7 +110,7 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
             inputSceneIndex, sceneIndexPathPrefix, sceneIndexAppPath));
     }
 
-    Fvp::PrimSelections ConvertUfePathToHydraSelections(const Ufe::Path& appPath) const override
+    Fvp::PrimSelections UfePathToPrimSelections(const Ufe::Path& appPath) const override
     {
         // We only handle USD objects, so if the UFE path is not a USD object,
         // early out with failure.
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
index 93c4a90f8b..00f3e0ae88 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
@@ -39,7 +39,7 @@ TEST(TestHydraPrim, fromAppPath)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto primSelections = snSi->ConvertUfePathToHydraSelections(appPath);
+    const auto primSelections = snSi->UfePathToPrimSelections(appPath);
     ASSERT_EQ(primSelections.size(), 1u);
     const auto sceneIndexPath = primSelections.front().primPath;
     ASSERT_FALSE(sceneIndexPath.IsEmpty());
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
index d9ed57e473..cc68b42ccf 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
@@ -69,7 +69,7 @@ TEST(FlowViewport, mergingSceneIndex)
 
     // The Maya data producer scene index supports the path interface.  Ask it
     // to translate the application path into a scene index path.
-    auto primSelections = mayaSi->ConvertUfePathToHydraSelections(mayaPath);
+    auto primSelections = mayaSi->UfePathToPrimSelections(mayaPath);
     ASSERT_EQ(primSelections.size(), 1u);
     auto sceneIndexPath = primSelections.front().primPath;
 
@@ -88,7 +88,7 @@ TEST(FlowViewport, mergingSceneIndex)
 
     // Flow Viewport merging scene index must give the same scene index path
     // answer as the Maya data producer scene index.
-    auto mergingSiSelections = mergingSi->ConvertUfePathToHydraSelections(mayaPath);
+    auto mergingSiSelections = mergingSi->UfePathToPrimSelections(mayaPath);
     ASSERT_EQ(mergingSiSelections.size(), 1u);
     ASSERT_EQ(mergingSiSelections.front().primPath, sceneIndexPath);
 }
@@ -109,7 +109,7 @@ TEST(FlowViewport, mergingSceneIndexAddRemove)
         producers.begin(), producers.end(), isMayaProducerSceneIndex);
     auto mayaSi = TfDynamic_cast<PXR_NS::MayaHydraSceneIndexRefPtr>(*found);
     auto mayaPath = Ufe::PathString::path("|aSphere");
-    auto primSelections = mayaSi->ConvertUfePathToHydraSelections(mayaPath);
+    auto primSelections = mayaSi->UfePathToPrimSelections(mayaPath);
     ASSERT_EQ(primSelections.size(), 1u);
     auto sceneIndexPath = primSelections.front().primPath;
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
index c66082f82c..12cbace1d2 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
@@ -38,7 +38,7 @@ SdfPath getArgSceneIndexPath(const Fvp::SelectionSceneIndexRefPtr& snSi)
     const auto mayaPath = Ufe::PathString::path(argv[0]);
 
     // Translate the application path into a scene index path.
-    auto primSelections = snSi->ConvertUfePathToHydraSelections(mayaPath);
+    auto primSelections = snSi->UfePathToPrimSelections(mayaPath);
     EXPECT_GE(primSelections.size(), 1u);
     return primSelections.empty() ? SdfPath() : primSelections.front().primPath;
 }
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index 37ea7ed5a3..870253fa24 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -168,7 +168,7 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     auto testInstancerDirectHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
         ufeSelection->replaceWith(instancerItem);
 
-        auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(instancerPath);
+        auto instancerHydraSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancerPath);
         ASSERT_EQ(instancerHydraSelections.size(), 1u);
         auto instancerPrimPath = instancerHydraSelections.front().primPath;
 
@@ -189,7 +189,7 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     // Select point instancer ancestors
     auto testInstancerIndirectHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
         // This is not an actual selection, we use it to get the Hydra path
-        auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(instancerPath);
+        auto instancerHydraSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancerPath);
         ASSERT_EQ(instancerHydraSelections.size(), 1u);
     
         // Validate scene structure
@@ -198,7 +198,7 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     };
     auto testInstancerNoHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
         // This is not an actual selection, we use it to get the Hydra path
-        auto instancerHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(instancerPath);
+        auto instancerHydraSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancerPath);
         ASSERT_EQ(instancerHydraSelections.size(), 1u);
 
         // Ensure there is no selection highlight mirror for the prim
@@ -265,7 +265,7 @@ TEST(PointInstancingWireframeHighlight, instance)
     auto testInstanceHighlightFn = [&](const Ufe::SceneItem::Ptr& instanceItem, const Ufe::Path& instancePath) -> void {
         ufeSelection->replaceWith(instanceItem);
 
-        auto instanceHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(instancePath);
+        auto instanceHydraSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancePath);
         ASSERT_EQ(instanceHydraSelections.size(), 1u);
         auto instancerPrimPath = instanceHydraSelections.front().primPath;
 
@@ -335,7 +335,7 @@ TEST(PointInstancingWireframeHighlight, prototype)
     auto testPrototypeHighlightFn = [&](const Ufe::SceneItem::Ptr& prototypeItem, const Ufe::Path& prototypePath) -> void {
         ufeSelection->replaceWith(prototypeItem);
 
-        auto prototypeHydraSelections = fvpMergingSceneIndex->ConvertUfePathToHydraSelections(prototypePath);
+        auto prototypeHydraSelections = fvpMergingSceneIndex->UfePathToPrimSelections(prototypePath);
         // Original prim + 4 propagated prototypes
         EXPECT_EQ(prototypeHydraSelections.size(), 1u + 4u);
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
index 7790c2cd36..867caf9531 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
@@ -61,7 +61,7 @@ TEST(FlowViewport, selectionSceneIndex)
 
     // The sphere prim in the Hydra scene index scene has no selection data
     // source.  First, translate the application path into a scene index path.
-    const auto primSelections = selectionSi->ConvertUfePathToHydraSelections(mayaPath);
+    const auto primSelections = selectionSi->UfePathToPrimSelections(mayaPath);
     ASSERT_EQ(primSelections.size(), 1u);
     const auto sceneIndexPath = primSelections.front().primPath;
     ASSERT_EQ(sceneIndexPath.GetName(), mayaPath.back().string());
@@ -106,7 +106,7 @@ TEST(FlowViewport, selectionSceneIndex)
     // The shape under the sphere transform is not selected, but it has a
     // selected ancestor.
     auto mayaShapePath = Ufe::PathString::path("|aSphere|aSphereShape");
-    const auto shapePrimSelections = selectionSi->ConvertUfePathToHydraSelections(mayaShapePath);
+    const auto shapePrimSelections = selectionSi->UfePathToPrimSelections(mayaShapePath);
     ASSERT_EQ(shapePrimSelections.size(), 1u);
     const auto sceneIndexShapePath = shapePrimSelections.front().primPath;
 
@@ -157,7 +157,7 @@ TEST(FlowViewport, selectionSceneIndexDirty)
     MSelectionList sphereSn;
     sphereSn.add("|aSphere");
     const auto mayaPath = Ufe::PathString::path("|aSphere");
-    const auto primSelections = selectionSi->ConvertUfePathToHydraSelections(mayaPath);
+    const auto primSelections = selectionSi->UfePathToPrimSelections(mayaPath);
     ASSERT_EQ(primSelections.size(), 1u);
     const auto sceneIndexPath = primSelections.front().primPath;
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
index d47463cadf..ce3c348677 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
@@ -27,7 +27,7 @@ TEST(TestUsdAnim, timeVaryingTransform)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto primSelections = snSi->ConvertUfePathToHydraSelections(cubePath);
+    const auto primSelections = snSi->UfePathToPrimSelections(cubePath);
     ASSERT_EQ(primSelections.size(), 1u);
     const auto cubeSiPath = primSelections.front().primPath;
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
index 0673bf925a..ccc44640dc 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
@@ -53,7 +53,7 @@ TEST(TestUsdPicking, pick)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto primSelections = snSi->ConvertUfePathToHydraSelections(selected);
+    const auto primSelections = snSi->UfePathToPrimSelections(selected);
     ASSERT_EQ(primSelections.size(), 1u);
     const auto sceneIndexPath = primSelections.front().primPath;
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
index 4fbe5da726..bf7aaa7dd4 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
@@ -51,7 +51,7 @@ TEST(TestUsdPointInstancePicking, pickPointInstance)
     const auto selectionSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(selectionSi);
 
-    const auto primSelections = selectionSi->ConvertUfePathToHydraSelections(marker);
+    const auto primSelections = selectionSi->UfePathToPrimSelections(marker);
     ASSERT_EQ(primSelections.size(), 1u);
     const auto sceneIndexPath = primSelections.front().primPath;
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
index 2c185358d9..47ccee43a6 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
@@ -161,10 +161,10 @@ TEST(FlowViewport, wireframeSelectionHighlightSceneIndexDirty)
     sn->append(sphereItem);
 
     // Find the sphere in the Hydra scene index scene.
-    auto sphereSelections = mergingSi->ConvertUfePathToHydraSelections(spherePath);
+    auto sphereSelections = mergingSi->UfePathToPrimSelections(spherePath);
     ASSERT_EQ(sphereSelections.size(), 1u);
     auto sphereSiPath = sphereSelections.front().primPath;
-    auto cubeSelections = mergingSi->ConvertUfePathToHydraSelections(scParentPath + "cube");
+    auto cubeSelections = mergingSi->UfePathToPrimSelections(scParentPath + "cube");
     ASSERT_EQ(cubeSelections.size(), 1u);
     auto cubeSiPath = cubeSelections.front().primPath;
 
@@ -195,13 +195,13 @@ TEST(FlowViewport, wireframeSelectionHighlightSceneIndexDirty)
 
     sn->replaceWith(newSn);
 
-    auto ccSelections = mergingSi->ConvertUfePathToHydraSelections(ccParentPath);
+    auto ccSelections = mergingSi->UfePathToPrimSelections(ccParentPath);
     ASSERT_EQ(ccSelections.size(), 1u);
     auto ccSiPath = ccSelections.front().primPath;
-    auto coneSelections = mergingSi->ConvertUfePathToHydraSelections(ccParentPath + "cone");
+    auto coneSelections = mergingSi->UfePathToPrimSelections(ccParentPath + "cone");
     ASSERT_EQ(coneSelections.size(), 1u);
     auto coneSiPath = coneSelections.front().primPath;
-    auto cylinderSelections = mergingSi->ConvertUfePathToHydraSelections(ccParentPath + "cylinder");
+    auto cylinderSelections = mergingSi->UfePathToPrimSelections(ccParentPath + "cylinder");
     ASSERT_EQ(cylinderSelections.size(), 1u);
     auto cylinderSiPath = cylinderSelections.front().primPath;
 

From 0b8988fba85bfb4aa8bee12c8269d04579fd446a Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 11 Jun 2024 11:24:44 -0400
Subject: [PATCH 105/112] Reformat comment

---
 .../fvpWireframeSelectionHighlightSceneIndex.cpp           | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index faf1715a5a..50b38c687b 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -573,9 +573,10 @@ WireframeSelectionHighlightSceneIndex::_PrimsDirtied(
         if (entry.dirtyLocators.Intersects(HdInstancerTopologySchema::GetDefaultLocator())
             && _selectionHighlightMirrorsByInstancer.find(entry.primPath) != _selectionHighlightMirrorsByInstancer.end()) {
             // An instancer with a selection highlight was changed; rebuild its selection highlight.
-            // We do not need to check for instancedBy dirtying : if an instancedBy data source is dirtied,
-            // then either a new instancer was added, which will be handled in _PrimsAdded, either an
-            // existing instancer's instancerTopology data source was dirtied., which is handled here.
+            // We do not need to check for instancedBy dirtying. If an instancedBy data source is dirtied,
+            // then either :
+            // 1) A new instancer was added : this is handled in _PrimsAdded.
+            // 2) An existing instancer's instancerTopology data source was dirtied : this is handled here.
             instancerHighlightsToRebuild.push_back(entry.primPath);
         }
         

From 4826d359ec791afc8de62286d13d7d5e32bfc933 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 11 Jun 2024 14:09:48 -0400
Subject: [PATCH 106/112] Add back SceneIndexPath method

---
 .../sceneIndex/fvpPathInterface.cpp           | 22 +++++++++++++++++++
 .../sceneIndex/fvpPathInterface.h             | 22 ++++++++++++++++---
 2 files changed, 41 insertions(+), 3 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpPathInterface.cpp b/lib/flowViewport/sceneIndex/fvpPathInterface.cpp
index 28445061d3..b5ff075cd9 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterface.cpp
+++ b/lib/flowViewport/sceneIndex/fvpPathInterface.cpp
@@ -15,8 +15,30 @@
 
 #include "flowViewport/sceneIndex/fvpPathInterface.h"
 
+#include <pxr/base/tf/diagnosticLite.h>
+
+#include <stdexcept>
+
+PXR_NAMESPACE_USING_DIRECTIVE
+
 namespace FVP_NS_DEF {
 
 PathInterface::~PathInterface() {}
 
+SdfPath PathInterface::SceneIndexPath(const Ufe::Path& appPath) const
+{
+    auto primSelections = UfePathToPrimSelections(appPath);
+    if (!TF_VERIFY(primSelections.size() <= 1u)) {
+        throw PrimPathsCountOutOfRangeException(0, 1, primSelections.size());
+    }
+    return primSelections.empty() ? SdfPath() : primSelections.front().primPath;
+}
+
+PrimPathsCountOutOfRangeException::PrimPathsCountOutOfRangeException(size_t min, size_t max, size_t actual)
+    : std::out_of_range("Prim paths count out of range, expected [" 
+        + std::to_string(min) + "," + std::to_string(max) 
+        + "] but got " + std::to_string(actual))
+{
+}
+
 }
diff --git a/lib/flowViewport/sceneIndex/fvpPathInterface.h b/lib/flowViewport/sceneIndex/fvpPathInterface.h
index 8a1ecd3dff..4f1743399f 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterface.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterface.h
@@ -24,6 +24,8 @@
 #include <pxr/imaging/hd/dataSource.h>
 #include <pxr/usd/sdf/path.h>
 
+#include <stdexcept>
+
 UFE_NS_DEF {
 class Path;
 }
@@ -51,12 +53,20 @@ class PathInterface
 {
 public:
 
-    //! Return the prim path corresponding to the argument application path.
-    //! If no such path exists, an empty SdfPath should be returned.
-    //! \return scene index path.
+    //! Return the prim path(s) corresponding to the argument application path,
+    //! as well as their associated selection data source(s).
+    //! If no such selected path exists, an empty container should be returned.
+    //! \return Selected prim paths and their associated selection data sources.
     FVP_API
     virtual PrimSelections UfePathToPrimSelections(const Ufe::Path& appPath) const = 0;
 
+    //! Return the prim path corresponding to the argument application path,
+    //! for when an application path maps to at most a single prim path.
+    //! If no such path exists, an empty SdfPath should be returned.
+    //! \return Scene index path.
+    FVP_API
+    PXR_NS::SdfPath SceneIndexPath(const Ufe::Path& appPath) const;
+
 protected:
 
     FVP_API
@@ -66,6 +76,12 @@ class PathInterface
     virtual ~PathInterface();
 };
 
+class PrimPathsCountOutOfRangeException : public std::out_of_range
+{
+public:
+    PrimPathsCountOutOfRangeException(size_t min, size_t max, size_t actual);
+};
+
 }
 
 #endif

From c8343d9e54ea8a7821cf129d60bcbbde6b67ccdc Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 11 Jun 2024 14:51:03 -0400
Subject: [PATCH 107/112] Revert unrelated tests changes

---
 .../render/mayaToHydra/cpp/testHydraPrim.cpp  |  5 ++---
 .../mayaToHydra/cpp/testMergingSceneIndex.cpp | 12 +++--------
 .../mayaToHydra/cpp/testPathInterface.cpp     |  4 +---
 .../cpp/testSelectionSceneIndex.cpp           | 12 +++--------
 .../render/mayaToHydra/cpp/testUsdAnim.cpp    |  4 +---
 .../render/mayaToHydra/cpp/testUsdPicking.cpp |  4 +---
 .../cpp/testUsdPointInstancePicking.cpp       |  4 +---
 ...tWireframeSelectionHighlightSceneIndex.cpp | 20 +++++--------------
 8 files changed, 17 insertions(+), 48 deletions(-)

diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
index 00f3e0ae88..99ce31aa27 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testHydraPrim.cpp
@@ -39,8 +39,7 @@ TEST(TestHydraPrim, fromAppPath)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto primSelections = snSi->UfePathToPrimSelections(appPath);
-    ASSERT_EQ(primSelections.size(), 1u);
-    const auto sceneIndexPath = primSelections.front().primPath;
+    const auto sceneIndexPath = snSi->SceneIndexPath(appPath);
+
     ASSERT_FALSE(sceneIndexPath.IsEmpty());
 }
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
index cc68b42ccf..1278463104 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testMergingSceneIndex.cpp
@@ -69,9 +69,7 @@ TEST(FlowViewport, mergingSceneIndex)
 
     // The Maya data producer scene index supports the path interface.  Ask it
     // to translate the application path into a scene index path.
-    auto primSelections = mayaSi->UfePathToPrimSelections(mayaPath);
-    ASSERT_EQ(primSelections.size(), 1u);
-    auto sceneIndexPath = primSelections.front().primPath;
+    auto sceneIndexPath = mayaSi->SceneIndexPath(mayaPath);
 
     // Regardless of prefix, the scene index path tail component will match the
     // Maya node name
@@ -88,9 +86,7 @@ TEST(FlowViewport, mergingSceneIndex)
 
     // Flow Viewport merging scene index must give the same scene index path
     // answer as the Maya data producer scene index.
-    auto mergingSiSelections = mergingSi->UfePathToPrimSelections(mayaPath);
-    ASSERT_EQ(mergingSiSelections.size(), 1u);
-    ASSERT_EQ(mergingSiSelections.front().primPath, sceneIndexPath);
+    ASSERT_EQ(mergingSi->SceneIndexPath(mayaPath), sceneIndexPath);
 }
 
 TEST(FlowViewport, mergingSceneIndexAddRemove)
@@ -109,9 +105,7 @@ TEST(FlowViewport, mergingSceneIndexAddRemove)
         producers.begin(), producers.end(), isMayaProducerSceneIndex);
     auto mayaSi = TfDynamic_cast<PXR_NS::MayaHydraSceneIndexRefPtr>(*found);
     auto mayaPath = Ufe::PathString::path("|aSphere");
-    auto primSelections = mayaSi->UfePathToPrimSelections(mayaPath);
-    ASSERT_EQ(primSelections.size(), 1u);
-    auto sceneIndexPath = primSelections.front().primPath;
+    auto sceneIndexPath = mayaSi->SceneIndexPath(mayaPath);
 
     // With Maya scene index in the merging scene index, the sphere prim has
     // a valid scene index path.
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
index 12cbace1d2..cfefc90600 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPathInterface.cpp
@@ -38,9 +38,7 @@ SdfPath getArgSceneIndexPath(const Fvp::SelectionSceneIndexRefPtr& snSi)
     const auto mayaPath = Ufe::PathString::path(argv[0]);
 
     // Translate the application path into a scene index path.
-    auto primSelections = snSi->UfePathToPrimSelections(mayaPath);
-    EXPECT_GE(primSelections.size(), 1u);
-    return primSelections.empty() ? SdfPath() : primSelections.front().primPath;
+    return snSi->SceneIndexPath(mayaPath);
 }
 
 Fvp::SelectionSceneIndexRefPtr getSelectionSceneIndex()
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
index 867caf9531..e3836d232b 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testSelectionSceneIndex.cpp
@@ -61,9 +61,7 @@ TEST(FlowViewport, selectionSceneIndex)
 
     // The sphere prim in the Hydra scene index scene has no selection data
     // source.  First, translate the application path into a scene index path.
-    const auto primSelections = selectionSi->UfePathToPrimSelections(mayaPath);
-    ASSERT_EQ(primSelections.size(), 1u);
-    const auto sceneIndexPath = primSelections.front().primPath;
+    const auto sceneIndexPath = selectionSi->SceneIndexPath(mayaPath);
     ASSERT_EQ(sceneIndexPath.GetName(), mayaPath.back().string());
 
     // Next, check that there is no selections data source on the prim.
@@ -106,9 +104,7 @@ TEST(FlowViewport, selectionSceneIndex)
     // The shape under the sphere transform is not selected, but it has a
     // selected ancestor.
     auto mayaShapePath = Ufe::PathString::path("|aSphere|aSphereShape");
-    const auto shapePrimSelections = selectionSi->UfePathToPrimSelections(mayaShapePath);
-    ASSERT_EQ(shapePrimSelections.size(), 1u);
-    const auto sceneIndexShapePath = shapePrimSelections.front().primPath;
+    const auto sceneIndexShapePath = selectionSi->SceneIndexPath(mayaShapePath);
 
     auto sphereShapePrim = sceneIndices.front()->GetPrim(sceneIndexShapePath);
     ASSERT_TRUE(sphereShapePrim.dataSource);
@@ -157,9 +153,7 @@ TEST(FlowViewport, selectionSceneIndexDirty)
     MSelectionList sphereSn;
     sphereSn.add("|aSphere");
     const auto mayaPath = Ufe::PathString::path("|aSphere");
-    const auto primSelections = selectionSi->UfePathToPrimSelections(mayaPath);
-    ASSERT_EQ(primSelections.size(), 1u);
-    const auto sceneIndexPath = primSelections.front().primPath;
+    const auto sceneIndexPath = selectionSi->SceneIndexPath(mayaPath);
 
     MGlobal::setActiveSelectionList(sphereSn);
     hdSn = ssio.GetSelection();
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
index ce3c348677..c1fcda3164 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdAnim.cpp
@@ -27,9 +27,7 @@ TEST(TestUsdAnim, timeVaryingTransform)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto primSelections = snSi->UfePathToPrimSelections(cubePath);
-    ASSERT_EQ(primSelections.size(), 1u);
-    const auto cubeSiPath = primSelections.front().primPath;
+    const auto cubeSiPath = snSi->SceneIndexPath(cubePath);
 
     ASSERT_FALSE(cubeSiPath.IsEmpty());
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
index ccc44640dc..95b5afe00e 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPicking.cpp
@@ -53,9 +53,7 @@ TEST(TestUsdPicking, pick)
     const auto snSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(snSi);
 
-    const auto primSelections = snSi->UfePathToPrimSelections(selected);
-    ASSERT_EQ(primSelections.size(), 1u);
-    const auto sceneIndexPath = primSelections.front().primPath;
+    const auto sceneIndexPath = snSi->SceneIndexPath(selected);
 
     ASSERT_FALSE(sceneIndexPath.IsEmpty());
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
index bf7aaa7dd4..a153d20476 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testUsdPointInstancePicking.cpp
@@ -51,9 +51,7 @@ TEST(TestUsdPointInstancePicking, pickPointInstance)
     const auto selectionSi = findSelectionSceneIndexInTree(siRoot);
     ASSERT_TRUE(selectionSi);
 
-    const auto primSelections = selectionSi->UfePathToPrimSelections(marker);
-    ASSERT_EQ(primSelections.size(), 1u);
-    const auto sceneIndexPath = primSelections.front().primPath;
+    const auto sceneIndexPath = selectionSi->SceneIndexPath(marker);
 
     ASSERT_FALSE(sceneIndexPath.IsEmpty());
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
index 47ccee43a6..f29f4a98d8 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testWireframeSelectionHighlightSceneIndex.cpp
@@ -161,12 +161,8 @@ TEST(FlowViewport, wireframeSelectionHighlightSceneIndexDirty)
     sn->append(sphereItem);
 
     // Find the sphere in the Hydra scene index scene.
-    auto sphereSelections = mergingSi->UfePathToPrimSelections(spherePath);
-    ASSERT_EQ(sphereSelections.size(), 1u);
-    auto sphereSiPath = sphereSelections.front().primPath;
-    auto cubeSelections = mergingSi->UfePathToPrimSelections(scParentPath + "cube");
-    ASSERT_EQ(cubeSelections.size(), 1u);
-    auto cubeSiPath = cubeSelections.front().primPath;
+    auto sphereSiPath = mergingSi->SceneIndexPath(spherePath);
+    auto cubeSiPath = mergingSi->SceneIndexPath(scParentPath + "cube");
 
     // Sphere is selected.
     hdSn = ssio.GetSelection();
@@ -195,15 +191,9 @@ TEST(FlowViewport, wireframeSelectionHighlightSceneIndexDirty)
 
     sn->replaceWith(newSn);
 
-    auto ccSelections = mergingSi->UfePathToPrimSelections(ccParentPath);
-    ASSERT_EQ(ccSelections.size(), 1u);
-    auto ccSiPath = ccSelections.front().primPath;
-    auto coneSelections = mergingSi->UfePathToPrimSelections(ccParentPath + "cone");
-    ASSERT_EQ(coneSelections.size(), 1u);
-    auto coneSiPath = coneSelections.front().primPath;
-    auto cylinderSelections = mergingSi->UfePathToPrimSelections(ccParentPath + "cylinder");
-    ASSERT_EQ(cylinderSelections.size(), 1u);
-    auto cylinderSiPath = cylinderSelections.front().primPath;
+    auto ccSiPath = mergingSi->SceneIndexPath(ccParentPath);
+    auto coneSiPath = mergingSi->SceneIndexPath(ccParentPath + "cone");
+    auto cylinderSiPath = mergingSi->SceneIndexPath(ccParentPath + "cylinder");
 
     // Cone and cylinder parent is selected.
     // Cone is not selected.

From 0cd2a5d9dc2ebf97fb0ef8e3d1cabbe39a98799a Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 11 Jun 2024 15:09:27 -0400
Subject: [PATCH 108/112] Rename hydra selections to prim selections

---
 .../mhLeadObjectPathTracker.cpp               | 14 ++++----
 .../testPointInstancingWireframeHighlight.cpp | 36 +++++++++----------
 2 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
index 47cedd8696..ad482d22d7 100644
--- a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
+++ b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
@@ -65,12 +65,12 @@ class GlobalSelectionChangedObs : public Ufe::Observer
             MayaHydra::MhLeadObjectPathTracker& _leadObjectPathTracker;
     };
 
-SdfPathVector hydraSelectionsToSdfPathVector(const Fvp::PrimSelections& hydraSelections)
+SdfPathVector primsSelectionsToSdfPathVector(const Fvp::PrimSelections& primSelections)
 {
     SdfPathVector outVector;
-    for (const auto& hydraSelection : hydraSelections) {
-        if (!hydraSelection.primPath.IsEmpty()) {
-            outVector.emplace_back(hydraSelection.primPath);
+    for (const auto& primSelection : primSelections) {
+        if (!primSelection.primPath.IsEmpty()) {
+            outVector.emplace_back(primSelection.primPath);
         }
     }
     return outVector;
@@ -94,7 +94,7 @@ MhLeadObjectPathTracker::MhLeadObjectPathTracker(const HdSceneIndexBaseRefPtr& s
         _leadObjectUfePath = leadObjectSceneItem->path();
         //_leadObjectPrimPaths can be empty with a valid _leadObjectUfePath when the lead object is in a data producer scene index not yet added to the merging scene index
         //This is fixed at some point by calling updatePrimPaths()
-        _leadObjectPrimPaths = hydraSelectionsToSdfPathVector(_pathInterface->UfePathToPrimSelections(_leadObjectUfePath));
+        _leadObjectPrimPaths = primsSelectionsToSdfPathVector(_pathInterface->UfePathToPrimSelections(_leadObjectUfePath));
     }
 
    // Add ourself as an observer to the selection
@@ -130,7 +130,7 @@ void MhLeadObjectPathTracker::setLeadObjectUfePath(const Ufe::Path& newLeadObjec
     auto oldLeadObjectPrimPaths = _leadObjectPrimPaths;
 
     _leadObjectUfePath  = newLeadObjectUfePath;
-    _leadObjectPrimPaths = hydraSelectionsToSdfPathVector(_pathInterface->UfePathToPrimSelections(_leadObjectUfePath));
+    _leadObjectPrimPaths = primsSelectionsToSdfPathVector(_pathInterface->UfePathToPrimSelections(_leadObjectUfePath));
 
     // Dirty the previous lead object
     if(_dirtyLeadObjectSceneIndex){
@@ -142,7 +142,7 @@ void MhLeadObjectPathTracker::updatePrimPaths()
 { 
    // Update the lead object prim paths in case it was not valid yet
     if ( (_leadObjectUfePath.size() > 0) && _leadObjectPrimPaths.empty()) {
-        _leadObjectPrimPaths = hydraSelectionsToSdfPathVector(_pathInterface->UfePathToPrimSelections(_leadObjectUfePath));
+        _leadObjectPrimPaths = primsSelectionsToSdfPathVector(_pathInterface->UfePathToPrimSelections(_leadObjectUfePath));
     }
 }
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index 870253fa24..1234bcf8b3 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -168,9 +168,9 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     auto testInstancerDirectHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
         ufeSelection->replaceWith(instancerItem);
 
-        auto instancerHydraSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancerPath);
-        ASSERT_EQ(instancerHydraSelections.size(), 1u);
-        auto instancerPrimPath = instancerHydraSelections.front().primPath;
+        auto instancerPrimSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancerPath);
+        ASSERT_EQ(instancerPrimSelections.size(), 1u);
+        auto instancerPrimPath = instancerPrimSelections.front().primPath;
 
         // Ensure selection is correct
         ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().size(), 1u);
@@ -189,21 +189,21 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     // Select point instancer ancestors
     auto testInstancerIndirectHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
         // This is not an actual selection, we use it to get the Hydra path
-        auto instancerHydraSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancerPath);
-        ASSERT_EQ(instancerHydraSelections.size(), 1u);
+        auto instancerPrimSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancerPath);
+        ASSERT_EQ(instancerPrimSelections.size(), 1u);
     
         // Validate scene structure
         EXPECT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
-        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerHydraSelections.front().primPath));
+        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimSelections.front().primPath));
     };
     auto testInstancerNoHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
         // This is not an actual selection, we use it to get the Hydra path
-        auto instancerHydraSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancerPath);
-        ASSERT_EQ(instancerHydraSelections.size(), 1u);
+        auto instancerPrimSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancerPath);
+        ASSERT_EQ(instancerPrimSelections.size(), 1u);
 
         // Ensure there is no selection highlight mirror for the prim
         HdSceneIndexPrim selectionHighlightMirrorPrim = inspector.GetSceneIndex()->GetPrim(
-            getSelectionHighlightMirrorPathFromOriginal(instancerHydraSelections.front().primPath));
+            getSelectionHighlightMirrorPathFromOriginal(instancerPrimSelections.front().primPath));
         EXPECT_EQ(selectionHighlightMirrorPrim.primType, TfToken());
     };
 
@@ -265,9 +265,9 @@ TEST(PointInstancingWireframeHighlight, instance)
     auto testInstanceHighlightFn = [&](const Ufe::SceneItem::Ptr& instanceItem, const Ufe::Path& instancePath) -> void {
         ufeSelection->replaceWith(instanceItem);
 
-        auto instanceHydraSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancePath);
-        ASSERT_EQ(instanceHydraSelections.size(), 1u);
-        auto instancerPrimPath = instanceHydraSelections.front().primPath;
+        auto instancePrimSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancePath);
+        ASSERT_EQ(instancePrimSelections.size(), 1u);
+        auto instancerPrimPath = instancePrimSelections.front().primPath;
 
         // Ensure selection is correct
         ASSERT_EQ(selectionObserver.GetSelection()->GetAllSelectedPrimPaths().size(), 1u);
@@ -335,13 +335,13 @@ TEST(PointInstancingWireframeHighlight, prototype)
     auto testPrototypeHighlightFn = [&](const Ufe::SceneItem::Ptr& prototypeItem, const Ufe::Path& prototypePath) -> void {
         ufeSelection->replaceWith(prototypeItem);
 
-        auto prototypeHydraSelections = fvpMergingSceneIndex->UfePathToPrimSelections(prototypePath);
+        auto prototypePrimSelections = fvpMergingSceneIndex->UfePathToPrimSelections(prototypePath);
         // Original prim + 4 propagated prototypes
-        EXPECT_EQ(prototypeHydraSelections.size(), 1u + 4u);
+        EXPECT_EQ(prototypePrimSelections.size(), 1u + 4u);
 
         // Ensure meshes use the correct display style
         EXPECT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
-        for (const auto& prototypeSelection : prototypeHydraSelections) {
+        for (const auto& prototypeSelection : prototypePrimSelections) {
             HdSceneIndexPrimView view(inspector.GetSceneIndex(), prototypeSelection.primPath);
             for (auto it = view.begin(); it != view.end(); ++it) {
                 HdSceneIndexPrim prim = inspector.GetSceneIndex()->GetPrim(*it);
@@ -353,9 +353,9 @@ TEST(PointInstancingWireframeHighlight, prototype)
 
         // Ensure the accumulated selected paths correspond to the intended/translated paths
         auto selectedPrimPaths = selectionObserver.GetSelection()->GetAllSelectedPrimPaths();
-        ASSERT_EQ(selectedPrimPaths.size(), prototypeHydraSelections.size());
-        for (const auto& prototypeHydraSelection : prototypeHydraSelections) {
-            auto foundSelectedPrimPath = std::find(selectedPrimPaths.begin(), selectedPrimPaths.end(), prototypeHydraSelection.primPath);
+        ASSERT_EQ(selectedPrimPaths.size(), prototypePrimSelections.size());
+        for (const auto& prototypePrimSelection : prototypePrimSelections) {
+            auto foundSelectedPrimPath = std::find(selectedPrimPaths.begin(), selectedPrimPaths.end(), prototypePrimSelection.primPath);
             EXPECT_NE(foundSelectedPrimPath, selectedPrimPaths.end());
         }
     };

From 707744a9a8f6469f79408fe3aa1e7e421ded3801 Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 11 Jun 2024 15:28:10 -0400
Subject: [PATCH 109/112] Add SceneIndexPaths method for multi prim paths

---
 .../sceneIndex/fvpPathInterface.cpp             | 12 ++++++++++++
 lib/flowViewport/sceneIndex/fvpPathInterface.h  |  6 ++++++
 .../hydraExtensions/mhLeadObjectPathTracker.cpp | 17 +++--------------
 .../testPointInstancingWireframeHighlight.cpp   | 14 ++++++--------
 4 files changed, 27 insertions(+), 22 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpPathInterface.cpp b/lib/flowViewport/sceneIndex/fvpPathInterface.cpp
index b5ff075cd9..eaf4df7926 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterface.cpp
+++ b/lib/flowViewport/sceneIndex/fvpPathInterface.cpp
@@ -34,6 +34,18 @@ SdfPath PathInterface::SceneIndexPath(const Ufe::Path& appPath) const
     return primSelections.empty() ? SdfPath() : primSelections.front().primPath;
 }
 
+SdfPathVector PathInterface::SceneIndexPaths(const Ufe::Path& appPath) const
+{
+    auto primSelections = UfePathToPrimSelections(appPath);
+
+    SdfPathVector outVector;
+    outVector.reserve(primSelections.size());
+    for (const auto& primSelection : primSelections) {
+        outVector.emplace_back(primSelection.primPath);
+    }
+    return outVector;
+}
+
 PrimPathsCountOutOfRangeException::PrimPathsCountOutOfRangeException(size_t min, size_t max, size_t actual)
     : std::out_of_range("Prim paths count out of range, expected [" 
         + std::to_string(min) + "," + std::to_string(max) 
diff --git a/lib/flowViewport/sceneIndex/fvpPathInterface.h b/lib/flowViewport/sceneIndex/fvpPathInterface.h
index 4f1743399f..1a4615eba1 100644
--- a/lib/flowViewport/sceneIndex/fvpPathInterface.h
+++ b/lib/flowViewport/sceneIndex/fvpPathInterface.h
@@ -67,6 +67,12 @@ class PathInterface
     FVP_API
     PXR_NS::SdfPath SceneIndexPath(const Ufe::Path& appPath) const;
 
+    //! Return the prim paths corresponding to the argument application path.
+    //! If no such paths exist, an empty SdfPathVector should be returned.
+    //! \return Scene index paths.
+    FVP_API
+    PXR_NS::SdfPathVector SceneIndexPaths(const Ufe::Path& appPath) const;
+
 protected:
 
     FVP_API
diff --git a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
index ad482d22d7..352bdf0142 100644
--- a/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
+++ b/lib/mayaHydra/hydraExtensions/mhLeadObjectPathTracker.cpp
@@ -65,17 +65,6 @@ class GlobalSelectionChangedObs : public Ufe::Observer
             MayaHydra::MhLeadObjectPathTracker& _leadObjectPathTracker;
     };
 
-SdfPathVector primsSelectionsToSdfPathVector(const Fvp::PrimSelections& primSelections)
-{
-    SdfPathVector outVector;
-    for (const auto& primSelection : primSelections) {
-        if (!primSelection.primPath.IsEmpty()) {
-            outVector.emplace_back(primSelection.primPath);
-        }
-    }
-    return outVector;
-}
-
 }
 namespace MAYAHYDRA_NS_DEF {
 
@@ -94,7 +83,7 @@ MhLeadObjectPathTracker::MhLeadObjectPathTracker(const HdSceneIndexBaseRefPtr& s
         _leadObjectUfePath = leadObjectSceneItem->path();
         //_leadObjectPrimPaths can be empty with a valid _leadObjectUfePath when the lead object is in a data producer scene index not yet added to the merging scene index
         //This is fixed at some point by calling updatePrimPaths()
-        _leadObjectPrimPaths = primsSelectionsToSdfPathVector(_pathInterface->UfePathToPrimSelections(_leadObjectUfePath));
+        _leadObjectPrimPaths = _pathInterface->SceneIndexPaths(_leadObjectUfePath);
     }
 
    // Add ourself as an observer to the selection
@@ -130,7 +119,7 @@ void MhLeadObjectPathTracker::setLeadObjectUfePath(const Ufe::Path& newLeadObjec
     auto oldLeadObjectPrimPaths = _leadObjectPrimPaths;
 
     _leadObjectUfePath  = newLeadObjectUfePath;
-    _leadObjectPrimPaths = primsSelectionsToSdfPathVector(_pathInterface->UfePathToPrimSelections(_leadObjectUfePath));
+    _leadObjectPrimPaths = _pathInterface->SceneIndexPaths(_leadObjectUfePath);
 
     // Dirty the previous lead object
     if(_dirtyLeadObjectSceneIndex){
@@ -142,7 +131,7 @@ void MhLeadObjectPathTracker::updatePrimPaths()
 { 
    // Update the lead object prim paths in case it was not valid yet
     if ( (_leadObjectUfePath.size() > 0) && _leadObjectPrimPaths.empty()) {
-        _leadObjectPrimPaths = primsSelectionsToSdfPathVector(_pathInterface->UfePathToPrimSelections(_leadObjectUfePath));
+        _leadObjectPrimPaths = _pathInterface->SceneIndexPaths(_leadObjectUfePath);
     }
 }
 
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index 1234bcf8b3..b400cc8cd5 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -188,22 +188,20 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     
     // Select point instancer ancestors
     auto testInstancerIndirectHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
-        // This is not an actual selection, we use it to get the Hydra path
-        auto instancerPrimSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancerPath);
-        ASSERT_EQ(instancerPrimSelections.size(), 1u);
+        auto instancerPrimPaths = fvpMergingSceneIndex->SceneIndexPaths(instancerPath);
+        ASSERT_EQ(instancerPrimPaths.size(), 1u);
     
         // Validate scene structure
         EXPECT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
-        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimSelections.front().primPath));
+        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimPaths.front()));
     };
     auto testInstancerNoHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
-        // This is not an actual selection, we use it to get the Hydra path
-        auto instancerPrimSelections = fvpMergingSceneIndex->UfePathToPrimSelections(instancerPath);
-        ASSERT_EQ(instancerPrimSelections.size(), 1u);
+        auto instancerPrimPaths = fvpMergingSceneIndex->SceneIndexPaths(instancerPath);
+        ASSERT_EQ(instancerPrimPaths.size(), 1u);
 
         // Ensure there is no selection highlight mirror for the prim
         HdSceneIndexPrim selectionHighlightMirrorPrim = inspector.GetSceneIndex()->GetPrim(
-            getSelectionHighlightMirrorPathFromOriginal(instancerPrimSelections.front().primPath));
+            getSelectionHighlightMirrorPathFromOriginal(instancerPrimPaths.front()));
         EXPECT_EQ(selectionHighlightMirrorPrim.primType, TfToken());
     };
 

From cc8f7fad166a89bd17c47ba18760390553d4556d Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 11 Jun 2024 15:42:04 -0400
Subject: [PATCH 110/112] Extract out code blocks into anonymous namespace
 funcs

---
 .../sceneIndex/registration.cpp               | 55 +++++++++++--------
 1 file changed, 31 insertions(+), 24 deletions(-)

diff --git a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
index 3e9ed77cae..02232e3581 100644
--- a/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
+++ b/lib/mayaHydra/hydraExtensions/sceneIndex/registration.cpp
@@ -89,6 +89,28 @@ class SceneObserver : public Observer
     }
 };
 
+HdDataSourceBaseHandle createInstanceSelectionDataSource(const SdfPath& instancerPrimPath, int instanceIndex)
+{
+    HdInstanceIndicesSchema::Builder instanceIndicesBuilder;
+    instanceIndicesBuilder.SetInstancer(HdRetainedTypedSampledDataSource<SdfPath>::New(instancerPrimPath));
+    instanceIndicesBuilder.SetInstanceIndices(HdRetainedTypedSampledDataSource<VtArray<int>>::New({instanceIndex}));
+    HdSelectionSchema::Builder selectionBuilder;
+    // Instancer is expected to be marked "fully selected" even if only certain instances are selected,
+    // based on USD's _AddToSelection function in selectionSceneIndexObserver.cpp :
+    // https://github.com/PixarAnimationStudios/OpenUSD/blob/f7b8a021ce3d13f91a0211acf8a64a8b780524df/pxr/imaging/hdx/selectionSceneIndexObserver.cpp#L212-L251
+    selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
+    auto instanceIndicesDataSource = HdDataSourceBase::Cast(instanceIndicesBuilder.Build());
+    selectionBuilder.SetNestedInstanceIndices(HdRetainedSmallVectorDataSource::New(1, &instanceIndicesDataSource));
+    return HdDataSourceBase::Cast(selectionBuilder.Build());
+}
+
+HdDataSourceBaseHandle createFullPrimSelectionDataSource()
+{
+    HdSelectionSchema::Builder selectionBuilder;
+    selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
+    return HdDataSourceBase::Cast(selectionBuilder.Build());
+}
+
 /// \class PathInterfaceSceneIndex
 ///
 /// Implement the path interface for plugin scene indices.
@@ -131,39 +153,24 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
         //    then we are dealing with an instance selection.
         SdfPath primPath = _sceneIndexPathPrefix;
         TF_AXIOM(appPath.nbSegments() == 2);
+
+        bool lastComponentIsNumeric = false;
         const auto& secondSegment = appPath.getSegments()[1];
         for (const auto& pathComponent : secondSegment) {
             if (pathComponent.string().find_first_not_of(digits) == std::string::npos) {
                 // This should only occur on the last component, when we have an instance selection
-                TF_VERIFY(pathComponent == secondSegment.components().back());
+                if (TF_VERIFY(pathComponent == secondSegment.components().back())) {
+                    lastComponentIsNumeric = true;
+                }
                 continue;
             }
             primPath = primPath.AppendChild(TfToken(pathComponent.string()));
         }
 
         const auto lastComponentString = secondSegment.components().back().string();
-        bool lastComponentIsNumeric = lastComponentString.find_first_not_of(digits) == std::string::npos;
-        HdDataSourceBaseHandle selectionDataSource;
-        if (lastComponentIsNumeric) {
-            // Instance selection
-            HdInstanceIndicesSchema::Builder instanceIndicesBuilder;
-            instanceIndicesBuilder.SetInstancer(HdRetainedTypedSampledDataSource<SdfPath>::New(primPath));
-            instanceIndicesBuilder.SetInstanceIndices(HdRetainedTypedSampledDataSource<VtArray<int>>::New({std::stoi(lastComponentString)}));
-            HdSelectionSchema::Builder selectionBuilder;
-            // Instancer is expected to be marked "fully selected" even if only certain instances are selected,
-            // based on USD's _AddToSelection function in selectionSceneIndexObserver.cpp :
-            // https://github.com/PixarAnimationStudios/OpenUSD/blob/f7b8a021ce3d13f91a0211acf8a64a8b780524df/pxr/imaging/hdx/selectionSceneIndexObserver.cpp#L212-L251
-            selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
-            auto instanceIndicesDataSource = HdDataSourceBase::Cast(instanceIndicesBuilder.Build());
-            selectionBuilder.SetNestedInstanceIndices(HdRetainedSmallVectorDataSource::New(1, &instanceIndicesDataSource));
-            selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
-        }
-        else {
-            // Full prim selection
-            HdSelectionSchema::Builder selectionBuilder;
-            selectionBuilder.SetFullySelected(HdRetainedTypedSampledDataSource<bool>::New(true));
-            selectionDataSource = HdDataSourceBase::Cast(selectionBuilder.Build());
-        }
+        HdDataSourceBaseHandle selectionDataSource = lastComponentIsNumeric 
+            ? createInstanceSelectionDataSource(primPath, std::stoi(lastComponentString))
+            : createFullPrimSelectionDataSource();
         Fvp::PrimSelections primSelections({{primPath, selectionDataSource}});
 
         // Propagate selection to propagated prototypes
@@ -262,7 +269,7 @@ class PathInterfaceSceneIndex : public Fvp::PathInterfaceSceneIndexBase
 };
 
 constexpr char kMayaUsdProxyShapeNode[] = { "mayaUsdProxyShape" };
-}
+} // namespace
 
 PXR_NAMESPACE_OPEN_SCOPE
 // Bring the MayaHydra namespace into scope.

From 1c4293a9ed2a61acb4d0b28a3a6ddfe8d5012d5b Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 11 Jun 2024 16:21:16 -0400
Subject: [PATCH 111/112] Expose selection highlight mirror tag in wireframe
 scene index public API

---
 ...pWireframeSelectionHighlightSceneIndex.cpp |  6 ++
 ...fvpWireframeSelectionHighlightSceneIndex.h |  4 ++
 .../testPointInstancingWireframeHighlight.cpp | 63 +++++++++++++------
 3 files changed, 55 insertions(+), 18 deletions(-)

diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
index 50b38c687b..f87a0fcf1f 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.cpp
@@ -699,6 +699,12 @@ bool WireframeSelectionHighlightSceneIndex::_IsExcluded(
     return false;
 }
 
+std::string
+WireframeSelectionHighlightSceneIndex::GetSelectionHighlightMirrorTag() const
+{
+    return selectionHighlightMirrorTag;
+}
+
 SdfPath
 WireframeSelectionHighlightSceneIndex::GetSelectionHighlightPath(const SdfPath& path) const
 {
diff --git a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
index 4094cde39d..5e90ace22f 100644
--- a/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
+++ b/lib/flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h
@@ -72,6 +72,10 @@ class WireframeSelectionHighlightSceneIndex
     FVP_API
     void addExcludedSceneRoot(const PXR_NS::SdfPath& sceneRoot);
 
+    // Returns the selection highlight tag used in selection highlight mirror prim names.
+    FVP_API
+    std::string GetSelectionHighlightMirrorTag() const;
+
     // Returns the corresponding selection highlight mirror path, if one exists.
     // Otherwise, returns the given path as-is.
     FVP_API
diff --git a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
index b400cc8cd5..1b74a32d1a 100644
--- a/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
+++ b/test/lib/mayaUsd/render/mayaToHydra/cpp/testPointInstancingWireframeHighlight.cpp
@@ -17,6 +17,7 @@
 #include <mayaHydraLib/mayaHydra.h>
 
 #include <flowViewport/sceneIndex/fvpMergingSceneIndex.h>
+#include <flowViewport/sceneIndex/fvpWireframeSelectionHighlightSceneIndex.h>
 
 #include <pxr/imaging/hd/instancedBySchema.h>
 #include <pxr/imaging/hd/instancerTopologySchema.h>
@@ -42,13 +43,11 @@ using namespace MayaHydra;
 
 namespace {
 
-const std::string selectionHighlightTag = "_SelectionHighlight";
-
 const std::string stagePathSegment = "|NestedAndComposedPointInstancers|NestedAndComposedPointInstancersShape";
 
-SdfPath getSelectionHighlightMirrorPathFromOriginal(const SdfPath& originalPath)
+SdfPath getSelectionHighlightMirrorPathFromOriginal(const SdfPath& originalPath, const std::string& selectionHighlightMirrorTag)
 {
-    return originalPath.ReplaceName(TfToken(originalPath.GetName() + selectionHighlightTag));
+    return originalPath.ReplaceName(TfToken(originalPath.GetName() + selectionHighlightMirrorTag));
 }
 
 TfToken getRefinedReprToken(const HdSceneIndexPrim& prim)
@@ -73,7 +72,7 @@ VtArray<SdfPath> getHierarchyRoots(const HdSceneIndexPrim& prim)
 // This method takes in a path to a prim in a selection highlight hierarchy and ensures that 
 // the selection highlight graph is structured properly, and that the leaf mesh prims have
 // the proper display style.
-void assertSelectionHighlightCorrectness(const HdSceneIndexBaseRefPtr& sceneIndex, const SdfPath& primPath)
+void assertSelectionHighlightCorrectness(const HdSceneIndexBaseRefPtr& sceneIndex, const SdfPath& primPath, const std::string& selectionHighlightMirrorTag)
 {
     HdSceneIndexPrimView primView(sceneIndex, primPath);
     for (auto itPrim = primView.begin(); itPrim != primView.end(); ++itPrim) {
@@ -99,9 +98,9 @@ void assertSelectionHighlightCorrectness(const HdSceneIndexBaseRefPtr& sceneInde
             for (const auto& prototypePath : prototypePaths) {
                 auto prototypeName = prototypePath.GetElementString();
                 // Ensure prototype is a selection highlight mirror
-                ASSERT_GT(prototypeName.size(), selectionHighlightTag.size());
-                EXPECT_EQ(prototypeName.substr(prototypeName.size() - selectionHighlightTag.size()), selectionHighlightTag);
-                assertSelectionHighlightCorrectness(sceneIndex, prototypePath);
+                ASSERT_GT(prototypeName.size(), selectionHighlightMirrorTag.size());
+                EXPECT_EQ(prototypeName.substr(prototypeName.size() - selectionHighlightMirrorTag.size()), selectionHighlightMirrorTag);
+                assertSelectionHighlightCorrectness(sceneIndex, prototypePath, selectionHighlightMirrorTag);
             }
             itPrim.SkipDescendants();
             continue;
@@ -113,9 +112,9 @@ void assertSelectionHighlightCorrectness(const HdSceneIndexBaseRefPtr& sceneInde
     }
 }
 
-bool findSelectionHighlightMirrorsPredicate(const HdSceneIndexBasePtr& sceneIndex, const SdfPath& primPath)
+bool isSelectionHighlightMirror(const SdfPath& primPath, const std::string& selectionHighlightMirrorTag)
 {
-    return primPath.GetElementString().find(selectionHighlightTag) != std::string::npos;
+    return primPath.GetElementString().find(selectionHighlightMirrorTag) != std::string::npos;
 }
 
 bool findMeshPrimsPredicate(const HdSceneIndexBasePtr& sceneIndex, const SdfPath& primPath)
@@ -135,6 +134,12 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     auto fvpMergingSceneIndex = TfDynamic_cast<Fvp::MergingSceneIndexRefPtr>(
         findSceneIndexInTree(terminalSceneIndices.front(), isFvpMergingSceneIndexPredicate));
 
+    auto isFvpWireframeSelectionHighlightSceneIndex = SceneIndexDisplayNamePred(
+        "Flow Viewport Wireframe Selection Highlight Scene Index");
+    auto fvpWireframeSelectionHighlightSceneIndex = TfDynamic_cast<Fvp::WireframeSelectionHighlightSceneIndexRefPtr>(
+        findSceneIndexInTree(terminalSceneIndices.front(), isFvpWireframeSelectionHighlightSceneIndex));
+    std::string selectionHighlightMirrorTag = fvpWireframeSelectionHighlightSceneIndex->GetSelectionHighlightMirrorTag();
+
     auto ufeSelection = Ufe::GlobalSelection::get();
 
     HdxSelectionSceneIndexObserver selectionObserver;
@@ -154,7 +159,9 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     // Initial state : ensure nothing is highlighted
     ufeSelection->clear();
 
-    auto selectionHighlightMirrors = inspector.FindPrims(findSelectionHighlightMirrorsPredicate);
+    auto selectionHighlightMirrors = inspector.FindPrims([selectionHighlightMirrorTag](const HdSceneIndexBasePtr& sceneIndex, const SdfPath& primPath) -> bool {
+        return isSelectionHighlightMirror(primPath, selectionHighlightMirrorTag);
+    });
     EXPECT_TRUE(selectionHighlightMirrors.empty()); // No selection highlight mirrors
 
     auto meshPrims = inspector.FindPrims(findMeshPrimsPredicate);
@@ -178,7 +185,8 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
 
         // Validate scene structure
         EXPECT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
-        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
+        auto selectionHighlightPath = getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath, selectionHighlightMirrorTag);
+        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), selectionHighlightPath, selectionHighlightMirrorTag);
     };
     
     testInstancerDirectHighlightFn(topInstancerItem, topInstancerPath);
@@ -193,7 +201,8 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
     
         // Validate scene structure
         EXPECT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
-        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimPaths.front()));
+        auto selectionHighlightPath = getSelectionHighlightMirrorPathFromOriginal(instancerPrimPaths.front(), selectionHighlightMirrorTag);
+        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), selectionHighlightPath, selectionHighlightMirrorTag);
     };
     auto testInstancerNoHighlightFn = [&](const Ufe::SceneItem::Ptr& instancerItem, const Ufe::Path& instancerPath) -> void {
         auto instancerPrimPaths = fvpMergingSceneIndex->SceneIndexPaths(instancerPath);
@@ -201,7 +210,7 @@ TEST(PointInstancingWireframeHighlight, pointInstancer)
 
         // Ensure there is no selection highlight mirror for the prim
         HdSceneIndexPrim selectionHighlightMirrorPrim = inspector.GetSceneIndex()->GetPrim(
-            getSelectionHighlightMirrorPathFromOriginal(instancerPrimPaths.front()));
+            getSelectionHighlightMirrorPathFromOriginal(instancerPrimPaths.front(), selectionHighlightMirrorTag));
         EXPECT_EQ(selectionHighlightMirrorPrim.primType, TfToken());
     };
 
@@ -234,6 +243,12 @@ TEST(PointInstancingWireframeHighlight, instance)
     auto fvpMergingSceneIndex = TfDynamic_cast<Fvp::MergingSceneIndexRefPtr>(
         findSceneIndexInTree(terminalSceneIndices.front(), isFvpMergingSceneIndexPredicate));
 
+    auto isFvpWireframeSelectionHighlightSceneIndex = SceneIndexDisplayNamePred(
+        "Flow Viewport Wireframe Selection Highlight Scene Index");
+    auto fvpWireframeSelectionHighlightSceneIndex = TfDynamic_cast<Fvp::WireframeSelectionHighlightSceneIndexRefPtr>(
+        findSceneIndexInTree(terminalSceneIndices.front(), isFvpWireframeSelectionHighlightSceneIndex));
+    std::string selectionHighlightMirrorTag = fvpWireframeSelectionHighlightSceneIndex->GetSelectionHighlightMirrorTag();
+
     auto ufeSelection = Ufe::GlobalSelection::get();
 
     HdxSelectionSceneIndexObserver selectionObserver;
@@ -249,7 +264,9 @@ TEST(PointInstancingWireframeHighlight, instance)
     // Initial state : ensure nothing is highlighted
     ufeSelection->clear();
 
-    auto selectionHighlightMirrors = inspector.FindPrims(findSelectionHighlightMirrorsPredicate);
+    auto selectionHighlightMirrors = inspector.FindPrims([selectionHighlightMirrorTag](const HdSceneIndexBasePtr& sceneIndex, const SdfPath& primPath) -> bool {
+        return isSelectionHighlightMirror(primPath, selectionHighlightMirrorTag);
+    });
     EXPECT_TRUE(selectionHighlightMirrors.empty()); // No selection highlight mirrors
 
     auto meshPrims = inspector.FindPrims(findMeshPrimsPredicate);
@@ -273,10 +290,12 @@ TEST(PointInstancingWireframeHighlight, instance)
 
         // Validate scene structure
         EXPECT_FALSE(inspector.FindPrims(findMeshPrimsPredicate).empty());
-        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
+        auto selectionHighlightPath = getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath, selectionHighlightMirrorTag);
+        assertSelectionHighlightCorrectness(inspector.GetSceneIndex(), selectionHighlightPath, selectionHighlightMirrorTag);
 
         // Get the selection highlight instancer's mask
-        HdSceneIndexPrim instancerHighlightPrim = inspector.GetSceneIndex()->GetPrim(getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath));
+        HdSceneIndexPrim instancerHighlightPrim = inspector.GetSceneIndex()->GetPrim(
+            getSelectionHighlightMirrorPathFromOriginal(instancerPrimPath, selectionHighlightMirrorTag));
         HdInstancerTopologySchema instancerTopology = HdInstancerTopologySchema::GetFromParent(instancerHighlightPrim.dataSource);
         ASSERT_TRUE(instancerTopology.IsDefined());
         ASSERT_NE(instancerTopology.GetMask(), nullptr);
@@ -304,6 +323,12 @@ TEST(PointInstancingWireframeHighlight, prototype)
     auto fvpMergingSceneIndex = TfDynamic_cast<Fvp::MergingSceneIndexRefPtr>(
         findSceneIndexInTree(terminalSceneIndices.front(), isFvpMergingSceneIndexPredicate));
 
+    auto isFvpWireframeSelectionHighlightSceneIndex = SceneIndexDisplayNamePred(
+        "Flow Viewport Wireframe Selection Highlight Scene Index");
+    auto fvpWireframeSelectionHighlightSceneIndex = TfDynamic_cast<Fvp::WireframeSelectionHighlightSceneIndexRefPtr>(
+        findSceneIndexInTree(terminalSceneIndices.front(), isFvpWireframeSelectionHighlightSceneIndex));
+    std::string selectionHighlightMirrorTag = fvpWireframeSelectionHighlightSceneIndex->GetSelectionHighlightMirrorTag();
+
     auto ufeSelection = Ufe::GlobalSelection::get();
 
     HdxSelectionSceneIndexObserver selectionObserver;
@@ -319,7 +344,9 @@ TEST(PointInstancingWireframeHighlight, prototype)
     // Initial state : ensure nothing is highlighted
     ufeSelection->clear();
 
-    auto selectionHighlightMirrors = inspector.FindPrims(findSelectionHighlightMirrorsPredicate);
+    auto selectionHighlightMirrors = inspector.FindPrims([selectionHighlightMirrorTag](const HdSceneIndexBasePtr& sceneIndex, const SdfPath& primPath) -> bool {
+        return isSelectionHighlightMirror(primPath, selectionHighlightMirrorTag);
+    });
     EXPECT_TRUE(selectionHighlightMirrors.empty()); // No selection highlight mirrors
 
     auto meshPrims = inspector.FindPrims(findMeshPrimsPredicate);

From 916035901289f8ccf924098801c47ae4d5f18b1b Mon Sep 17 00:00:00 2001
From: debloip <philippe.de.blois@autodesk.com>
Date: Tue, 11 Jun 2024 16:57:38 -0400
Subject: [PATCH 112/112] Add mermaid graph to visualize instancer
 relationships

---
 doc/selectionHighlightingArchitecture.md | 30 +++++++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/doc/selectionHighlightingArchitecture.md b/doc/selectionHighlightingArchitecture.md
index fca9df0813..0e6796bbdb 100644
--- a/doc/selectionHighlightingArchitecture.md
+++ b/doc/selectionHighlightingArchitecture.md
@@ -383,7 +383,35 @@ This nesting and composition of instancers is what leads to most of the complexi
 instancing selection highlighting. We can view such nesting and composition of instancers as 
 graphs, with the vertices being the instancer prims, and the edges being the paths contained 
 in the `instancerTopology/prototypes`, `instancedBy/paths` and `instancedBy/prototypeRoots` 
-data sources.
+data sources, as well as parent-child relationships.
+
+For example, given the following scene structure :
+```
+Root
+|__TopInstancer
+|  |__NestedInstancer
+|  |  |__LeafInstancer
+|  |     |__PrototypePrim
+|  |        |__PrototypeSubPrim
+|__AnotherPrototypePrim
+   |__ChildInstancer
+```
+
+```mermaid
+graph LR
+    TopInstancer -->|instancerTopology/prototypes| NestedInstancer
+    NestedInstancer -->|instancerTopology/prototypes| LeafInstancer
+    LeafInstancer -->|instancedBy/paths| NestedInstancer
+    NestedInstancer -->|instancedBy/paths| TopInstancer
+    LeafInstancer -->|instancerTopology/prototypes| PrototypePrim
+    PrototypePrim -->|instancedBy/paths| LeafInstancer
+    PrototypeSubPrim -->|instancedBy/prototypeRoots| PrototypePrim
+
+    TopInstancer -->|instancerTopology/prototypes| AnotherPrototypePrim
+    AnotherPrototypePrim -->|parent-child relationship| ChildInstancer
+    ChildInstancer -->|instancedBy/prototypeRoots| AnotherPrototypePrim
+    ChildInstancer -->|instancedBy/paths| TopInstancer
+```
 
 ### Implementation for point instancer and instance selection