adding entity to a faded list

interface/src/avatar/MyAvatar.cpp

@@ -939,8 +939,6 @@ void MyAvatar::simulate(float deltaTime, bool inView) {
     }
 
     handleChangedAvatarEntityData();
-
-    updateFadingStatus();
 }
 
 // As far as I know no HMD system supports a play area of a kilometer in radius.

interface/src/avatar/OtherAvatar.cpp

@@ -356,7 +356,6 @@ void OtherAvatar::simulate(float deltaTime, bool inView) {
         PROFILE_RANGE(simulation, "grabs");
         applyGrabChanges();
     }
-    updateFadingStatus();
 }
 
 void OtherAvatar::handleChangedAvatarEntityData() {

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

@@ -682,18 +682,6 @@ void Avatar::fade(render::Transaction& transaction, render::Transition::Type typ
     _isFading = true;
 }
 
-void Avatar::updateFadingStatus() {
-    if (_isFading) {
-        render::Transaction transaction;
-        transaction.queryTransitionOnItem(_renderItemID, [this](render::ItemID id, const render::Transition* transition) {
-            if (!transition || transition->isFinished) {
-                _isFading = false;
-            }
-        });
-        AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction);
-    }
-}
-
 void Avatar::removeFromScene(AvatarSharedPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
     transaction.removeItem(_renderItemID);
     render::Item::clearID(_renderItemID);

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

@@ -464,7 +464,6 @@ public:
     void fadeOut(render::ScenePointer scene, KillAvatarReason reason);
     bool isFading() const { return _isFading; }
     void setIsFading(bool isFading) { _isFading = isFading; }
-    void updateFadingStatus();
 
     // JSDoc is in AvatarData.h.
     Q_INVOKABLE virtual float getEyeHeight() const override;

libraries/entities-renderer/src/EntityTreeRenderer.cpp

@@ -1057,6 +1057,17 @@ void EntityTreeRenderer::checkAndCallPreload(const EntityItemID& entityID, bool
     }
 }
 
+void EntityTreeRenderable::fadeOutRenderable(const EntityRendererPointer& renderable) {
+    render::Transaction transaction;
+    auto scene = qApp->getMain3DScene();
+
+    transaction.transitionFinishedOperator(renderable->getRenderItemID(), [renderable]() {
+        renderable->setIsFading(false);
+    });
+
+    scene->enqueueTransaction(transaction);
+}
+
 void EntityTreeRenderer::playEntityCollisionSound(const EntityItemPointer& entity, const Collision& collision) {
     assert((bool)entity);
     auto renderable = renderableForEntity(entity);

libraries/entities-renderer/src/EntityTreeRenderer.h

@@ -93,6 +93,9 @@ public:
     /// reloads the entity scripts, calling unload and preload
     void reloadEntityScripts();
 
+    void fadeOutRenderable(const EntityRenderablePointer& renderable);
+    void removeFadedRenderables();
+
     // event handles which may generate entity related events
     QUuid mousePressEvent(QMouseEvent* event);
     void mouseReleaseEvent(QMouseEvent* event);
@@ -255,6 +258,7 @@ private:
     std::unordered_map<EntityItemID, EntityRendererPointer> _renderablesToUpdate;
     std::unordered_map<EntityItemID, EntityRendererPointer> _entitiesInScene;
     std::unordered_map<EntityItemID, EntityItemWeakPointer> _entitiesToAdd;
+    std::vector<EntityRendererPointer> _entityRendersToFadeOut;
     // For Scene.shouldRenderEntities
     QList<EntityItemID> _entityIDsLastInScene;
 

libraries/entities-renderer/src/RenderableEntityItem.h

@@ -44,6 +44,9 @@ public:
     const EntityItemPointer& getEntity() const { return _entity; }
     const ItemID& getRenderItemID() const { return _renderItemID; }
 
+    bool getIsFading() { return _isFading; }
+    void setIsFading(bool isFading) { _isFading = isFading; }
+
     const SharedSoundPointer& getCollisionSound() { return _collisionSound; }
     void setCollisionSound(const SharedSoundPointer& sound) { _collisionSound = sound; }
 

libraries/render/src/render/Scene.cpp

@@ -271,10 +271,6 @@ void Scene::processTransactionFrame(const Transaction& transaction) {
         // Update the numItemsAtomic counter AFTER the reset changes went through
         _numAllocatedItems.exchange(maxID);
 
-        // reset transition finished operator
-
-        resetTransitionFinishedOperator(transaction._transitionFinishedOperators);
-
         // updates
         updateItems(transaction._updatedItems);
 
@@ -285,6 +281,7 @@ void Scene::processTransactionFrame(const Transaction& transaction) {
         transitionItems(transaction._addedTransitions);
         reApplyTransitions(transaction._reAppliedTransitions);
         queryTransitionItems(transaction._queriedTransitions);
+        resetTransitionFinishedOperator(transaction._transitionFinishedOperators);
 
         // Update the numItemsAtomic counter AFTER the pending changes went through
         _numAllocatedItems.exchange(maxID);
@@ -408,7 +405,7 @@ void Scene::transitionItems(const Transaction::TransitionAdds& transactions) {
             // Only remove if:
             // transitioning to something other than none or we're transitioning to none from ELEMENT_LEAVE_DOMAIN or USER_LEAVE_DOMAIN
             const auto& oldTransitionType = transitionStage->getTransition(transitionId).eventType;
-            if (transitionType == Transition::NONE && oldTransitionType != Transition::NONE) {
+            if (transitionType != oldTransitionType) {
                 resetItemTransition(itemId);
             }
         }
@@ -454,14 +451,19 @@ void Scene::queryTransitionItems(const Transaction::TransitionQueries& transacti
     }
 }
 
-void Scene::resetTransitionFinishedOperator(const Transaction::TransitionFinishedOperators& transactions) {
+void Scene::resetTransitionFinishedOperator(const Transaction::TransitionFinishedOperators& operators) {
-    for (auto& finishedOperator : transactions) {
+    for (auto& finishedOperator : operators) {
         auto itemId = std::get<0>(finishedOperator);
         const auto& item = _items[itemId];
         auto func = std::get<1>(finishedOperator);
 
         if (item.exist() && func != nullptr) {
-            _transitionFinishedOperatorMap[itemId] = func;
+            TransitionStage::Index transitionId = item.getTransitionId();
+            if (!TransitionStage::isIndexInvalid(transitionId)) {
+                _transitionFinishedOperatorMap[transitionId].emplace_back(func);
+            } else {
+                fucn();
+            }
         }
     }
 }
@@ -552,20 +554,20 @@ void Scene::setItemTransition(ItemID itemId, Index transitionId) {
 
 void Scene::resetItemTransition(ItemID itemId) {
     auto& item = _items[itemId];
-    if (!render::TransitionStage::isIndexInvalid(item.getTransitionId())) {
+    TransitionStage::Index transitionId = item.getTransitionId();
+    if (!render::TransitionStage::isIndexInvalid(transitionId)) {
         auto transitionStage = getStage<TransitionStage>(TransitionStage::getName());
-        auto transitionItemId = transitionStage->getTransition(item.getTransitionId()).itemId;
 
-        if (transitionItemId == itemId) {
+        auto finishedOperators = _transitionFinishedOperatorMap[transitionId];
-            auto transitionFinishedOperator = _transitionFinishedOperatorMap[transitionItemId];
 
-            if (transitionFinishedOperator) {
+        for (auto finishedOperator : finishedOperators) {
-                transitionFinishedOperator();
+            if (finishedOperator) {
-                _transitionFinishedOperatorMap[transitionItemId] = nullptr;
+                finishedOperator();
             }
-            transitionStage->removeTransition(item.getTransitionId());
-            setItemTransition(itemId, render::TransitionStage::INVALID_INDEX);
         }
+        _transitionFinishedOperatorMap.erase(transitionId);
+        transitionStage->removeTransition(transitionId);
+        setItemTransition(itemId, render::TransitionStage::INVALID_INDEX);
     }
 }
 

libraries/render/src/render/Scene.h

@@ -230,8 +230,7 @@ protected:
     mutable std::mutex _selectionsMutex; // mutable so it can be used in the thread safe getSelection const method
     SelectionMap _selections;
 
-    mutable std::mutex _transitionFinishedOperatorMapMutex;
+    std::unordered_map<TransitionStage::Index, std::vector<Transaction::TransitionFinishedFunc>> _transitionFinishedOperatorMap;
-    std::unordered_map<ItemID, Transaction::TransitionFinishedFunc> _transitionFinishedOperatorMap;
 
     void resetSelections(const Transaction::SelectionResets& transactions);
   // More actions coming to selections soon: