I finally understand - initial progress

interface/src/scripting/SelectionScriptingInterface.cpp

@@ -12,40 +12,61 @@
 #include "SelectionScriptingInterface.h"
 #include "Application.h"
 
+GameplayObjects::GameplayObjects() {
+}
+
+bool GameplayObjects::addToGameplayObjects(const QUuid& avatarID) {
+    _avatarIDs.push_back(avatarID);
+    return true;
+}
+bool GameplayObjects::removeFromGameplayObjects(const QUuid& avatarID) {
+    _avatarIDs.erase(std::remove(_avatarIDs.begin(), _avatarIDs.end(), avatarID), _avatarIDs.end());
+    return true;
+}
+
+bool GameplayObjects::addToGameplayObjects(const EntityItemID& entityID) {
+    _entityIDs.push_back(entityID);
+    return true;
+}
+bool GameplayObjects::removeFromGameplayObjects(const EntityItemID& entityID) {
+    _entityIDs.erase(std::remove(_entityIDs.begin(), _entityIDs.end(), entityID), _entityIDs.end());
+    return true;
+}
+
+bool GameplayObjects::addToGameplayObjects(const OverlayID& overlayID) {
+    _overlayIDs.push_back(overlayID);
+    return true;
+}
+bool GameplayObjects::removeFromGameplayObjects(const OverlayID& overlayID) {
+    _overlayIDs.erase(std::remove(_overlayIDs.begin(), _overlayIDs.end(), overlayID), _overlayIDs.end());
+    return true;
+}
+
 SelectionScriptingInterface::SelectionScriptingInterface(AbstractViewStateInterface* viewState) {
     _viewState = viewState;
 }
 
+//
+// START HANDLING AVATARS
+//
+bool SelectionScriptingInterface::addToSelectedItemsList(const render::Selection::Name& listName, const QUuid& avatarSessionID) {
+    return addToGameplayObjects(listName, avatarSessionID);
+}
+bool SelectionScriptingInterface::removeFromSelectedItemsList(const render::Selection::Name& listName, const QUuid& avatarSessionID) {
+    return addToGameplayObjects(listName, avatarSessionID);
+}
+//
+// END HANDLING AVATARS
+//
+
 //
 // START HANDLING ENTITIES
 //
-render::ItemID getItemIDFromEntityID(const EntityItemID& entityID) {
-    auto entityTree = qApp->getEntities()->getTree();
-    entityTree->withReadLock([&] {
-        auto entityItem = entityTree->findEntityByEntityItemID(entityID);
-        if (entityItem != NULL) {
-            auto renderableInterface = entityItem->getRenderableInterface();
-            if (renderableInterface != NULL) {
-                return renderableInterface->getMetaRenderItemID();
-            }
-        }
-        return render::Item::INVALID_ITEM_ID;
-    });
-    return render::Item::INVALID_ITEM_ID;
-}
 bool SelectionScriptingInterface::addToSelectedItemsList(const render::Selection::Name& listName, const EntityItemID& entityID) {
-    render::ItemID itemID = getItemIDFromEntityID(entityID);
+    return addToGameplayObjects(listName, entityID);
-    if (itemID != render::Item::INVALID_ITEM_ID) {
-        return addToSelectedItemsList(listName, itemID);
-    }
-    return false;
 }
 bool SelectionScriptingInterface::removeFromSelectedItemsList(const render::Selection::Name& listName, const EntityItemID& entityID) {
-    render::ItemID itemID = getItemIDFromEntityID(entityID);
+    return addToGameplayObjects(listName, entityID);
-    if (itemID != render::Item::INVALID_ITEM_ID) {
-        return removeFromSelectedItemsList(listName, itemID);
-    }
-    return false;
 }
 //
 // END HANDLING ENTITIES
@@ -54,30 +75,11 @@ bool SelectionScriptingInterface::removeFromSelectedItemsList(const render::Sele
 //
 // START HANDLING OVERLAYS
 //
-render::ItemID getItemIDFromOverlayID(const OverlayID& overlayID) {
-    auto& overlays = qApp->getOverlays();
-    auto overlay = overlays.getOverlay(overlayID);
-    if (overlay != NULL) {
-        auto itemID = overlay->getRenderItemID();
-        if (itemID != render::Item::INVALID_ITEM_ID) {
-            return overlay->getRenderItemID();
-        }
-    }
-    return render::Item::INVALID_ITEM_ID;
-}
 bool SelectionScriptingInterface::addToSelectedItemsList(const render::Selection::Name& listName, const OverlayID& overlayID) {
-    render::ItemID itemID = getItemIDFromOverlayID(overlayID);
+    return addToGameplayObjects(listName, overlayID);
-    if (itemID != render::Item::INVALID_ITEM_ID) {
-        return addToSelectedItemsList(listName, itemID);
-    }
-    return false;
 }
 bool SelectionScriptingInterface::removeFromSelectedItemsList(const render::Selection::Name& listName, const OverlayID& overlayID) {
-    render::ItemID itemID = getItemIDFromOverlayID(overlayID);
+    return addToGameplayObjects(listName, overlayID);
-    if (itemID != render::Item::INVALID_ITEM_ID) {
-        return removeFromSelectedItemsList(listName, itemID);
-    }
-    return false;
 }
 //
 // END HANDLING OVERLAYS
@@ -86,31 +88,25 @@ bool SelectionScriptingInterface::removeFromSelectedItemsList(const render::Sele
 //
 // START HANDLING GENERIC ITEMS
 //
-bool SelectionScriptingInterface::addToSelectedItemsList(const render::Selection::Name& listName, render::ItemID idToAdd) {
+template <class T> bool SelectionScriptingInterface::addToGameplayObjects(const render::Selection::Name& listName, T idToAdd) {
     if (_selectedItemsListMap.contains(listName)) {
         auto currentList = _selectedItemsListMap.take(listName);
-        currentList.push_back(idToAdd); // TODO: Ensure thread safety
+        currentList.addToGameplayObjects(idToAdd);
         _selectedItemsListMap.insert(listName, currentList);
         updateRendererSelectedList(listName);
         return true;
     } else {
-        _selectedItemsListMap.insert(listName, render::ItemIDs());
+        _selectedItemsListMap.insert(listName, GameplayObjects());
         return addToSelectedItemsList(listName, idToAdd);
     }
 }
-bool SelectionScriptingInterface::removeFromSelectedItemsList(const render::Selection::Name& listName, render::ItemID idToRemove) {
+template <class T> bool SelectionScriptingInterface::removeFromGameplayObjects(const render::Selection::Name& listName, T idToRemove) {
-    auto hashItr = _selectedItemsListMap.find(listName);
+    if (_selectedItemsListMap.contains(listName)) {
-    if (hashItr != _selectedItemsListMap.end()) {
         auto currentList = _selectedItemsListMap.take(listName);
-        auto listItr = std::find(currentList.begin(), currentList.end(), idToRemove); // TODO: Ensure thread safety
+        currentList.removeFromGameplayObjects(idToRemove);
-        if (listItr == currentList.end()) {
+        _selectedItemsListMap.insert(listName, currentList);
-            return false;
+        updateRendererSelectedList(listName);
-        } else {
+        return true;
-            currentList.erase(listItr);
-            _selectedItemsListMap.insert(listName, currentList);
-            updateRendererSelectedList(listName);
-            return true;
-        }
     } else {
         return false;
     }
@@ -133,12 +129,53 @@ void SelectionScriptingInterface::updateRendererSelectedList(const render::Selec
         render::Transaction transaction;
 
         if (_selectedItemsListMap.contains(listName)) {
-            render::Selection selection(listName, _selectedItemsListMap.value(listName));
+            render::ItemIDs finalList;
+            render::ItemID currentID;
+            auto entityTree = qApp->getEntities()->getTree();
+            auto& overlays = qApp->getOverlays();
+            auto currentList = _selectedItemsListMap.value(listName);
+
+            for (QUuid& currentAvatarID : currentList.getAvatarIDs()) {
+                auto avatar = std::static_pointer_cast<Avatar>(DependencyManager::get<AvatarManager>()->getAvatarBySessionID(currentAvatarID));
+                if (avatar) {
+                    currentID = avatar->getRenderItemID();
+                    if (currentID != render::Item::INVALID_ITEM_ID) {
+                        finalList.push_back(currentID);
+                    }
+                }
+            }
+
+            for (EntityItemID& currentEntityID : currentList.getEntityIDs()) {
+                entityTree->withReadLock([&] {
+                    auto entityItem = entityTree->findEntityByEntityItemID(currentEntityID);
+                    if (entityItem != NULL) {
+                        auto renderableInterface = entityItem->getRenderableInterface();
+                        if (renderableInterface != NULL) {
+                            currentID = renderableInterface->getMetaRenderItemID();
+                            if (currentID != render::Item::INVALID_ITEM_ID) {
+                                finalList.push_back(currentID);
+                            }
+                        }
+                    }
+                });
+            }
+
+            for (OverlayID& currentOverlayID : currentList.getOverlayIDs()) {
+                auto overlay = overlays.getOverlay(currentOverlayID);
+                if (overlay != NULL) {
+                    currentID = overlay->getRenderItemID();
+                    if (currentID != render::Item::INVALID_ITEM_ID) {
+                        finalList.push_back(currentID);
+                    }
+                }
+            }
+
+            render::Selection selection(listName, finalList);
             transaction.resetSelection(selection);
 
             scene->enqueueTransaction(transaction);
         } else {
-            qWarning() << "List of ItemIDs doesn't exist in _selectedItemsListMap";
+            qWarning() << "List of GameplayObjects doesn't exist in _selectedItemsListMap";
         }
     } else {
         qWarning() << "SelectionScriptingInterface::updateRendererSelectedList(), Unexpected null scene, possibly during application shutdown";

interface/src/scripting/SelectionScriptingInterface.h

@@ -20,6 +20,29 @@
 
 #include "RenderableEntityItem.h"
 #include "ui/overlays/Overlay.h"
+#include <avatar/AvatarManager.h>
+
+class GameplayObjects {
+public:
+    GameplayObjects();
+
+    std::vector<QUuid> getAvatarIDs() { return _avatarIDs; }
+    bool addToGameplayObjects(const QUuid& avatarID);
+    bool removeFromGameplayObjects(const QUuid& avatarID);
+
+    std::vector<EntityItemID> getEntityIDs() { return _entityIDs; }
+    bool addToGameplayObjects(const EntityItemID& entityID);
+    bool removeFromGameplayObjects(const EntityItemID& entityID);
+
+    std::vector<OverlayID> getOverlayIDs() { return _overlayIDs; }
+    bool addToGameplayObjects(const OverlayID& overlayID);
+    bool removeFromGameplayObjects(const OverlayID& overlayID);
+
+private:
+    std::vector<QUuid> _avatarIDs;
+    std::vector<EntityItemID> _entityIDs;
+    std::vector<OverlayID> _overlayIDs;
+};
 
 class SelectionScriptingInterface : public QObject, public Dependency {
     Q_OBJECT
@@ -29,6 +52,9 @@ public:
 
     Q_INVOKABLE bool removeListFromMap(const render::Selection::Name& listName);
 
+    Q_INVOKABLE bool addToSelectedItemsList(const render::Selection::Name& listName, const QUuid& avatarSessionID);
+    Q_INVOKABLE bool removeFromSelectedItemsList(const render::Selection::Name& listName, const QUuid& avatarSessionID);
+
     Q_INVOKABLE bool addToSelectedItemsList(const render::Selection::Name& listName, const EntityItemID& entityID);
     Q_INVOKABLE bool removeFromSelectedItemsList(const render::Selection::Name& listName, const EntityItemID& entityID);
     
@@ -37,10 +63,10 @@ public:
 
 private:
     AbstractViewStateInterface* _viewState;
-    QMap<render::Selection::Name, render::ItemIDs> _selectedItemsListMap;
+    QMap<render::Selection::Name, GameplayObjects> _selectedItemsListMap;
 
-    bool addToSelectedItemsList(const render::Selection::Name& listName, render::ItemID idToAdd);
+    template <class T> bool addToGameplayObjects(const render::Selection::Name& listName, T idToAdd);
-    bool removeFromSelectedItemsList(const render::Selection::Name& listName, render::ItemID idToRemove);
+    template <class T> bool removeFromGameplayObjects(const render::Selection::Name& listName, T idToRemove);
 
     void updateRendererSelectedList(const render::Selection::Name& listName);
 };

libraries/avatars-renderer/src/avatars-renderer/Avatar.h

@@ -240,6 +240,7 @@ public:
     void addToScene(AvatarSharedPointer self, const render::ScenePointer& scene);
     void ensureInScene(AvatarSharedPointer self, const render::ScenePointer& scene);
     bool isInScene() const { return render::Item::isValidID(_renderItemID); }
+    render::ItemID getRenderItemID() { return _renderItemID; }
     bool isMoving() const { return _moving; }
 
     void setPhysicsCallback(AvatarPhysicsCallback cb);