Merge pull request #10135 from samcake/ambient

Rename render::PendingChanges to render::Transaction

interface/src/Application.cpp

@@ -5036,7 +5036,7 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
     // TODO fix shadows and make them use the GPU library
 
     // The pending changes collecting the changes here
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
 
     // FIXME: Move this out of here!, Background / skybox should be driven by the enityt content just like the other entities
     // Background rendering decision
@@ -5044,7 +5044,7 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
         auto backgroundRenderData = make_shared<BackgroundRenderData>();
         auto backgroundRenderPayload = make_shared<BackgroundRenderData::Payload>(backgroundRenderData);
         BackgroundRenderData::_item = _main3DScene->allocateID();
-        pendingChanges.resetItem(BackgroundRenderData::_item, backgroundRenderPayload);
+        transaction.resetItem(BackgroundRenderData::_item, backgroundRenderPayload);
     }
 
     // Assuming nothing get's rendered through that
@@ -5062,7 +5062,7 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
                     static_cast<int>(RenderArgs::RENDER_DEBUG_HULLS));
             }
             renderArgs->_debugFlags = renderDebugFlags;
-            //ViveControllerManager::getInstance().updateRendering(renderArgs, _main3DScene, pendingChanges);
+            //ViveControllerManager::getInstance().updateRendering(renderArgs, _main3DScene, transaction);
         }
     }
 
@@ -5074,9 +5074,9 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
 
         WorldBoxRenderData::_item = _main3DScene->allocateID();
 
-        pendingChanges.resetItem(WorldBoxRenderData::_item, worldBoxRenderPayload);
+        transaction.resetItem(WorldBoxRenderData::_item, worldBoxRenderPayload);
     } else {
-        pendingChanges.updateItem<WorldBoxRenderData>(WorldBoxRenderData::_item,
+        transaction.updateItem<WorldBoxRenderData>(WorldBoxRenderData::_item,
             [](WorldBoxRenderData& payload) {
             payload._val++;
         });
@@ -5089,10 +5089,10 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
     }
 
     {
-        PerformanceTimer perfTimer("SceneProcessPendingChanges");
+        PerformanceTimer perfTimer("SceneProcessTransaction");
-        _main3DScene->enqueuePendingChanges(pendingChanges);
+        _main3DScene->enqueueTransaction(transaction);
 
-        _main3DScene->processPendingChangesQueue();
+        _main3DScene->processTransactionQueue();
     }
 
     // For now every frame pass the renderContext

interface/src/avatar/Avatar.cpp

@@ -476,34 +476,34 @@ static TextRenderer3D* textRenderer(TextRendererType type) {
     return displayNameRenderer;
 }
 
-bool Avatar::addToScene(AvatarSharedPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
+bool Avatar::addToScene(AvatarSharedPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) {
     auto avatarPayload = new render::Payload<AvatarData>(self);
     auto avatarPayloadPointer = Avatar::PayloadPointer(avatarPayload);
     _renderItemID = scene->allocateID();
-    pendingChanges.resetItem(_renderItemID, avatarPayloadPointer);
+    transaction.resetItem(_renderItemID, avatarPayloadPointer);
-    _skeletonModel->addToScene(scene, pendingChanges);
+    _skeletonModel->addToScene(scene, transaction);
 
     for (auto& attachmentModel : _attachmentModels) {
-        attachmentModel->addToScene(scene, pendingChanges);
+        attachmentModel->addToScene(scene, transaction);
     }
 
     _inScene = true;
     return true;
 }
 
-void Avatar::removeFromScene(AvatarSharedPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
+void Avatar::removeFromScene(AvatarSharedPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) {
-    pendingChanges.removeItem(_renderItemID);
+    transaction.removeItem(_renderItemID);
     render::Item::clearID(_renderItemID);
-    _skeletonModel->removeFromScene(scene, pendingChanges);
+    _skeletonModel->removeFromScene(scene, transaction);
     for (auto& attachmentModel : _attachmentModels) {
-        attachmentModel->removeFromScene(scene, pendingChanges);
+        attachmentModel->removeFromScene(scene, transaction);
     }
     _inScene = false;
 }
 
-void Avatar::updateRenderItem(render::PendingChanges& pendingChanges) {
+void Avatar::updateRenderItem(render::Transaction& transaction) {
     if (render::Item::isValidID(_renderItemID)) {
-        pendingChanges.updateItem<render::Payload<AvatarData>>(_renderItemID, [](render::Payload<AvatarData>& p) {});
+        transaction.updateItem<render::Payload<AvatarData>>(_renderItemID, [](render::Payload<AvatarData>& p) {});
     }
 }
 
@@ -680,24 +680,24 @@ void Avatar::fixupModelsInScene() {
     // check to see if when we added our models to the scene they were ready, if they were not ready, then
     // fix them up in the scene
     render::ScenePointer scene = qApp->getMain3DScene();
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
     if (_skeletonModel->isRenderable() && _skeletonModel->needsFixupInScene()) {
-        _skeletonModel->removeFromScene(scene, pendingChanges);
+        _skeletonModel->removeFromScene(scene, transaction);
-        _skeletonModel->addToScene(scene, pendingChanges);
+        _skeletonModel->addToScene(scene, transaction);
     }
     for (auto attachmentModel : _attachmentModels) {
         if (attachmentModel->isRenderable() && attachmentModel->needsFixupInScene()) {
-            attachmentModel->removeFromScene(scene, pendingChanges);
+            attachmentModel->removeFromScene(scene, transaction);
-            attachmentModel->addToScene(scene, pendingChanges);
+            attachmentModel->addToScene(scene, transaction);
         }
     }
 
     for (auto attachmentModelToRemove : _attachmentsToRemove) {
-        attachmentModelToRemove->removeFromScene(scene, pendingChanges);
+        attachmentModelToRemove->removeFromScene(scene, transaction);
     }
     _attachmentsToDelete.insert(_attachmentsToDelete.end(), _attachmentsToRemove.begin(), _attachmentsToRemove.end());
     _attachmentsToRemove.clear();
-    scene->enqueuePendingChanges(pendingChanges);
+    scene->enqueueTransaction(transaction);
 }
 
 bool Avatar::shouldRenderHead(const RenderArgs* renderArgs) const {
@@ -1422,14 +1422,14 @@ QList<QVariant> Avatar::getSkeleton() {
 void Avatar::addToScene(AvatarSharedPointer myHandle) {
     render::ScenePointer scene = qApp->getMain3DScene();
     if (scene) {
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
         auto nodelist = DependencyManager::get<NodeList>();
         if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderAvatars()
             && !nodelist->isIgnoringNode(getSessionUUID())
             && !nodelist->isRadiusIgnoringNode(getSessionUUID())) {
-            addToScene(myHandle, scene, pendingChanges);
+            addToScene(myHandle, scene, transaction);
         }
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
     } else {
         qCWarning(interfaceapp) << "AvatarManager::addAvatar() : Unexpected null scene, possibly during application shutdown";
     }

interface/src/avatar/Avatar.h

@@ -82,12 +82,12 @@ public:
     virtual void render(RenderArgs* renderArgs, const glm::vec3& cameraPosition);
 
     bool addToScene(AvatarSharedPointer self, std::shared_ptr<render::Scene> scene,
-                            render::PendingChanges& pendingChanges);
+                            render::Transaction& transaction);
 
     void removeFromScene(AvatarSharedPointer self, std::shared_ptr<render::Scene> scene,
-                                render::PendingChanges& pendingChanges);
+                                render::Transaction& transaction);
 
-    void updateRenderItem(render::PendingChanges& pendingChanges);
+    void updateRenderItem(render::Transaction& transaction);
 
     virtual void postUpdate(float deltaTime);
 

interface/src/avatar/AvatarManager.cpp

@@ -104,11 +104,11 @@ void AvatarManager::init() {
             this, &AvatarManager::updateAvatarRenderStatus, Qt::QueuedConnection);
 
     render::ScenePointer scene = qApp->getMain3DScene();
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
     if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderAvatars()) {
-        _myAvatar->addToScene(_myAvatar, scene, pendingChanges);
+        _myAvatar->addToScene(_myAvatar, scene, transaction);
     }
-    scene->enqueuePendingChanges(pendingChanges);
+    scene->enqueueTransaction(transaction);
 }
 
 void AvatarManager::updateMyAvatar(float deltaTime) {
@@ -192,7 +192,7 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
             return false;
         });
 
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
     uint64_t startTime = usecTimestampNow();
     const uint64_t UPDATE_BUDGET = 2000; // usec
     uint64_t updateExpiry = startTime + UPDATE_BUDGET;
@@ -228,7 +228,7 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
                 numAvatarsUpdated++;
             }
             avatar->simulate(deltaTime, inView);
-            avatar->updateRenderItem(pendingChanges);
+            avatar->updateRenderItem(transaction);
             avatar->setLastRenderUpdateTime(startTime);
         } else {
             // we've spent our full time budget --> bail on the rest of the avatar updates
@@ -262,7 +262,7 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
     _avatarSimulationTime = (float)(usecTimestampNow() - startTime) / (float)USECS_PER_MSEC;
     _numAvatarsUpdated = numAvatarsUpdated;
     _numAvatarsNotUpdated = numAVatarsNotUpdated;
-    qApp->getMain3DScene()->enqueuePendingChanges(pendingChanges);
+    qApp->getMain3DScene()->enqueueTransaction(transaction);
 
     simulateAvatarFades(deltaTime);
 }
@@ -283,13 +283,13 @@ void AvatarManager::simulateAvatarFades(float deltaTime) {
     const float MIN_FADE_SCALE = MIN_AVATAR_SCALE;
 
     render::ScenePointer scene = qApp->getMain3DScene();
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
     while (fadingIterator != _avatarFades.end()) {
         auto avatar = std::static_pointer_cast<Avatar>(*fadingIterator);
         avatar->setTargetScale(avatar->getUniformScale() * SHRINK_RATE);
         avatar->animateScaleChanges(deltaTime);
         if (avatar->getTargetScale() <= MIN_FADE_SCALE) {
-            avatar->removeFromScene(*fadingIterator, scene, pendingChanges);
+            avatar->removeFromScene(*fadingIterator, scene, transaction);
             // only remove from _avatarFades if we're sure its motionState has been removed from PhysicsEngine
             if (_motionStatesToRemoveFromPhysics.empty()) {
                 fadingIterator = _avatarFades.erase(fadingIterator);
@@ -302,7 +302,7 @@ void AvatarManager::simulateAvatarFades(float deltaTime) {
             ++fadingIterator;
         }
     }
-    scene->enqueuePendingChanges(pendingChanges);
+    scene->enqueueTransaction(transaction);
 }
 
 AvatarSharedPointer AvatarManager::newSharedAvatar() {
@@ -479,17 +479,17 @@ void AvatarManager::updateAvatarRenderStatus(bool shouldRenderAvatars) {
         for (auto avatarData : _avatarHash) {
             auto avatar = std::static_pointer_cast<Avatar>(avatarData);
             render::ScenePointer scene = qApp->getMain3DScene();
-            render::PendingChanges pendingChanges;
+            render::Transaction transaction;
-            avatar->addToScene(avatar, scene, pendingChanges);
+            avatar->addToScene(avatar, scene, transaction);
-            scene->enqueuePendingChanges(pendingChanges);
+            scene->enqueueTransaction(transaction);
         }
     } else {
         for (auto avatarData : _avatarHash) {
             auto avatar = std::static_pointer_cast<Avatar>(avatarData);
             render::ScenePointer scene = qApp->getMain3DScene();
-            render::PendingChanges pendingChanges;
+            render::Transaction transaction;
-            avatar->removeFromScene(avatar, scene, pendingChanges);
+            avatar->removeFromScene(avatar, scene, transaction);
-            scene->enqueuePendingChanges(pendingChanges);
+            scene->enqueueTransaction(transaction);
         }
     }
 }

interface/src/avatar/CauterizedModel.cpp

@@ -205,10 +205,10 @@ void CauterizedModel::updateRenderItems() {
 
             uint32_t deleteGeometryCounter = self->getGeometryCounter();
 
-            render::PendingChanges pendingChanges;
+            render::Transaction transaction;
             QList<render::ItemID> keys = self->getRenderItems().keys();
             foreach (auto itemID, keys) {
-                pendingChanges.updateItem<CauterizedMeshPartPayload>(itemID, [modelTransform, deleteGeometryCounter](CauterizedMeshPartPayload& data) {
+                transaction.updateItem<CauterizedMeshPartPayload>(itemID, [modelTransform, deleteGeometryCounter](CauterizedMeshPartPayload& data) {
                     if (data._model && data._model->isLoaded()) {
                         // Ensure the model geometry was not reset between frames
                         if (deleteGeometryCounter == data._model->getGeometryCounter()) {
@@ -233,7 +233,7 @@ void CauterizedModel::updateRenderItems() {
                 });
             }
 
-            scene->enqueuePendingChanges(pendingChanges);
+            scene->enqueueTransaction(transaction);
         });
     } else {
         Model::updateRenderItems();

interface/src/ui/overlays/Base3DOverlay.cpp

@@ -199,9 +199,9 @@ void Base3DOverlay::setProperties(const QVariantMap& originalProperties) {
         auto itemID = getRenderItemID();
         if (render::Item::isValidID(itemID)) {
             render::ScenePointer scene = qApp->getMain3DScene();
-            render::PendingChanges pendingChanges;
+            render::Transaction transaction;
-            pendingChanges.updateItem(itemID);
+            transaction.updateItem(itemID);
-            scene->enqueuePendingChanges(pendingChanges);
+            scene->enqueueTransaction(transaction);
         }
     }
 }
@@ -264,9 +264,9 @@ void Base3DOverlay::locationChanged(bool tellPhysics) {
     auto itemID = getRenderItemID();
     if (render::Item::isValidID(itemID)) {
         render::ScenePointer scene = qApp->getMain3DScene();
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
-        pendingChanges.updateItem(itemID);
+        transaction.updateItem(itemID);
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
     }
 }
 

interface/src/ui/overlays/ModelOverlay.cpp

@@ -58,15 +58,15 @@ void ModelOverlay::update(float deltatime) {
     _isLoaded = _model->isActive();
 }
 
-bool ModelOverlay::addToScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
+bool ModelOverlay::addToScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) {
-    Volume3DOverlay::addToScene(overlay, scene, pendingChanges);
+    Volume3DOverlay::addToScene(overlay, scene, transaction);
-    _model->addToScene(scene, pendingChanges);
+    _model->addToScene(scene, transaction);
     return true;
 }
 
-void ModelOverlay::removeFromScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
+void ModelOverlay::removeFromScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) {
-    Volume3DOverlay::removeFromScene(overlay, scene, pendingChanges);
+    Volume3DOverlay::removeFromScene(overlay, scene, transaction);
-    _model->removeFromScene(scene, pendingChanges);
+    _model->removeFromScene(scene, transaction);
 }
 
 void ModelOverlay::render(RenderArgs* args) {
@@ -74,16 +74,16 @@ void ModelOverlay::render(RenderArgs* args) {
     // check to see if when we added our model to the scene they were ready, if they were not ready, then
     // fix them up in the scene
     render::ScenePointer scene = qApp->getMain3DScene();
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
     if (_model->needsFixupInScene()) {
-        _model->removeFromScene(scene, pendingChanges);
+        _model->removeFromScene(scene, transaction);
-        _model->addToScene(scene, pendingChanges);
+        _model->addToScene(scene, transaction);
     }
 
     _model->setVisibleInScene(_visible, scene);
     _model->setLayeredInFront(getDrawInFront(), scene);
 
-    scene->enqueuePendingChanges(pendingChanges);
+    scene->enqueueTransaction(transaction);
 }
 
 void ModelOverlay::setProperties(const QVariantMap& properties) {

interface/src/ui/overlays/ModelOverlay.h

@@ -36,8 +36,8 @@ public:
 
     virtual ModelOverlay* createClone() const override;
 
-    virtual bool addToScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) override;
+    virtual bool addToScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override;
-    virtual void removeFromScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) override;
+    virtual void removeFromScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override;
 
     void locationChanged(bool tellPhysics) override;
 

interface/src/ui/overlays/Overlay.cpp

@@ -196,14 +196,14 @@ float Overlay::updatePulse() {
     return _pulse;
 }
 
-bool Overlay::addToScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
+bool Overlay::addToScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) {
     _renderItemID = scene->allocateID();
-    pendingChanges.resetItem(_renderItemID, std::make_shared<Overlay::Payload>(overlay));
+    transaction.resetItem(_renderItemID, std::make_shared<Overlay::Payload>(overlay));
     return true;
 }
 
-void Overlay::removeFromScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
+void Overlay::removeFromScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) {
-    pendingChanges.removeItem(_renderItemID);
+    transaction.removeItem(_renderItemID);
     render::Item::clearID(_renderItemID);
 }
 

interface/src/ui/overlays/Overlay.h

@@ -48,8 +48,8 @@ public:
     virtual AABox getBounds() const = 0;
     virtual bool supportsGetProperty() const { return true; }
 
-    virtual bool addToScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges);
+    virtual bool addToScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction);
-    virtual void removeFromScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges);
+    virtual void removeFromScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction);
 
     virtual const render::ShapeKey getShapeKey() { return render::ShapeKey::Builder::ownPipeline(); }
 

interface/src/ui/overlays/Overlays.cpp

@@ -78,7 +78,7 @@ void Overlays::update(float deltatime) {
 void Overlays::cleanupOverlaysToDelete() {
     if (!_overlaysToDelete.isEmpty()) {
         render::ScenePointer scene = qApp->getMain3DScene();
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
 
         {
             QWriteLocker lock(&_deleteLock);
@@ -88,13 +88,13 @@ void Overlays::cleanupOverlaysToDelete() {
 
                 auto itemID = overlay->getRenderItemID();
                 if (render::Item::isValidID(itemID)) {
-                    overlay->removeFromScene(overlay, scene, pendingChanges);
+                    overlay->removeFromScene(overlay, scene, transaction);
                 }
             } while (!_overlaysToDelete.isEmpty());
         }
 
-        if (pendingChanges._removedItems.size() > 0) {
+        if (transaction._removedItems.size() > 0) {
-            scene->enqueuePendingChanges(pendingChanges);
+            scene->enqueueTransaction(transaction);
         }
     }
 }
@@ -197,9 +197,9 @@ OverlayID Overlays::addOverlay(Overlay::Pointer overlay) {
         _overlaysWorld[thisID] = overlay;
 
         render::ScenePointer scene = qApp->getMain3DScene();
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
-        overlay->addToScene(overlay, scene, pendingChanges);
+        overlay->addToScene(overlay, scene, transaction);
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
     } else {
         _overlaysHUD[thisID] = overlay;
     }

libraries/entities-renderer/src/EntityTreeRenderer.cpp

@@ -127,11 +127,11 @@ void EntityTreeRenderer::clear() {
     // remove all entities from the scene
     auto scene = _viewState->getMain3DScene();
     if (scene) {
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
         foreach(auto entity, _entitiesInScene) {
-            entity->removeFromScene(entity, scene, pendingChanges);
+            entity->removeFromScene(entity, scene, transaction);
         }
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
     } else {
         qCWarning(entitiesrenderer) << "EntitityTreeRenderer::clear(), Unexpected null scene, possibly during application shutdown";
     }
@@ -951,11 +951,11 @@ void EntityTreeRenderer::deletingEntity(const EntityItemID& entityID) {
     // here's where we remove the entity payload from the scene
     if (_entitiesInScene.contains(entityID)) {
         auto entity = _entitiesInScene.take(entityID);
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
         auto scene = _viewState->getMain3DScene();
         if (scene) {
-            entity->removeFromScene(entity, scene, pendingChanges);
+            entity->removeFromScene(entity, scene, transaction);
-            scene->enqueuePendingChanges(pendingChanges);
+            scene->enqueueTransaction(transaction);
         } else {
             qCWarning(entitiesrenderer) << "EntityTreeRenderer::deletingEntity(), Unexpected null scene, possibly during application shutdown";
         }
@@ -973,13 +973,13 @@ void EntityTreeRenderer::addingEntity(const EntityItemID& entityID) {
 
 void EntityTreeRenderer::addEntityToScene(EntityItemPointer entity) {
     // here's where we add the entity payload to the scene
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
     auto scene = _viewState->getMain3DScene();
     if (scene) {
-        if (entity->addToScene(entity, scene, pendingChanges)) {
+        if (entity->addToScene(entity, scene, transaction)) {
             _entitiesInScene.insert(entity->getEntityItemID(), entity);
         }
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
     } else {
         qCWarning(entitiesrenderer) << "EntityTreeRenderer::addEntityToScene(), Unexpected null scene, possibly during application shutdown";
     }

libraries/entities-renderer/src/RenderableEntityItem.h

@@ -54,7 +54,7 @@ namespace render {
 // Mixin class for implementing basic single item rendering
 class SimpleRenderableEntityItem {
 public:
-    bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
+    bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) {
         _myItem = scene->allocateID();
 
         auto renderData = std::make_shared<RenderableEntityItemProxy>(self, _myItem);
@@ -64,13 +64,13 @@ public:
         makeEntityItemStatusGetters(self, statusGetters);
         renderPayload->addStatusGetters(statusGetters);
 
-        pendingChanges.resetItem(_myItem, renderPayload);
+        transaction.resetItem(_myItem, renderPayload);
 
         return true;
     }
 
-    void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
+    void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) {
-        pendingChanges.removeItem(_myItem);
+        transaction.removeItem(_myItem);
         render::Item::clearID(_myItem);
     }
 
@@ -79,14 +79,14 @@ public:
             return;
         }
 
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
         render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
 
         if (scene) {
-            pendingChanges.updateItem<RenderableEntityItemProxy>(_myItem, [](RenderableEntityItemProxy& data) {
+            transaction.updateItem<RenderableEntityItemProxy>(_myItem, [](RenderableEntityItemProxy& data) {
             });
 
-            scene->enqueuePendingChanges(pendingChanges);
+            scene->enqueueTransaction(transaction);
         } else {
             qCWarning(entitiesrenderer) << "SimpleRenderableEntityItem::notifyChanged(), Unexpected null scene, possibly during application shutdown";
         }
@@ -99,8 +99,8 @@ private:
 
 #define SIMPLE_RENDERABLE() \
 public: \
-    virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) override { return _renderHelper.addToScene(self, scene, pendingChanges); } \
+    virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override { return _renderHelper.addToScene(self, scene, transaction); } \
-    virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) override { _renderHelper.removeFromScene(self, scene, pendingChanges); } \
+    virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override { _renderHelper.removeFromScene(self, scene, transaction); } \
     virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); _renderHelper.notifyChanged(); } \
     virtual void dimensionsChanged() override { EntityItem::dimensionsChanged(); _renderHelper.notifyChanged(); } \
     void checkFading() { \

libraries/entities-renderer/src/RenderableLightEntityItem.cpp

@@ -27,7 +27,7 @@ RenderableLightEntityItem::RenderableLightEntityItem(const EntityItemID& entityI
 {
 }
 
-bool RenderableLightEntityItem::addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
+bool RenderableLightEntityItem::addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) {
     _myItem = scene->allocateID();
 
     auto renderItem = std::make_shared<LightPayload>();
@@ -39,7 +39,7 @@ bool RenderableLightEntityItem::addToScene(EntityItemPointer self, std::shared_p
     makeEntityItemStatusGetters(self, statusGetters);
     renderPayload->addStatusGetters(statusGetters);
 
-    pendingChanges.resetItem(_myItem, renderPayload);
+    transaction.resetItem(_myItem, renderPayload);
 
     return true;
 }
@@ -51,8 +51,8 @@ void RenderableLightEntityItem::somethingChangedNotification() {
     LightEntityItem::somethingChangedNotification();
 }
 
-void RenderableLightEntityItem::removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
+void RenderableLightEntityItem::removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) {
-    pendingChanges.removeItem(_myItem);
+    transaction.removeItem(_myItem);
     render::Item::clearID(_myItem);
 }
 
@@ -81,12 +81,12 @@ void RenderableLightEntityItem::notifyChanged() {
         return;
     }
 
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
     render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
 
-    updateLightFromEntity(pendingChanges);
+    updateLightFromEntity(transaction);
 
-    scene->enqueuePendingChanges(pendingChanges);
+    scene->enqueueTransaction(transaction);
 }
 
 bool RenderableLightEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
@@ -103,13 +103,13 @@ bool RenderableLightEntityItem::findDetailedRayIntersection(const glm::vec3& ori
 }
 
 
-void RenderableLightEntityItem::updateLightFromEntity(render::PendingChanges& pendingChanges) {
+void RenderableLightEntityItem::updateLightFromEntity(render::Transaction& transaction) {
     if (!render::Item::isValidID(_myItem)) {
         return;
     }
 
 
-    pendingChanges.updateItem<LightPayload>(_myItem, [&](LightPayload& data) {
+    transaction.updateItem<LightPayload>(_myItem, [&](LightPayload& data) {
         updateRenderItemFromEntity(data);
     });
 }

libraries/entities-renderer/src/RenderableLightEntityItem.h

@@ -28,12 +28,12 @@ public:
                          BoxFace& face, glm::vec3& surfaceNormal,
                          void** intersectedObject, bool precisionPicking) const override;
 
-    void updateLightFromEntity(render::PendingChanges& pendingChanges);
+    void updateLightFromEntity(render::Transaction& transaction);
 
-    virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) override;
+    virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override;
 
     virtual void somethingChangedNotification() override;
-    virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) override;
+    virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override;
 
     virtual void locationChanged(bool tellPhysics = true) override;
 

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -228,20 +228,20 @@ namespace render {
 }
 
 bool RenderableModelEntityItem::addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, 
-                                            render::PendingChanges& pendingChanges) {
+                                            render::Transaction& transaction) {
     _myMetaItem = scene->allocateID();
 
     auto renderData = std::make_shared<RenderableModelEntityItemMeta>(self);
     auto renderPayload = std::make_shared<RenderableModelEntityItemMeta::Payload>(renderData);
 
-    pendingChanges.resetItem(_myMetaItem, renderPayload);
+    transaction.resetItem(_myMetaItem, renderPayload);
 
     if (_model) {
         render::Item::Status::Getters statusGetters;
         makeEntityItemStatusGetters(getThisPointer(), statusGetters);
 
         // note: we don't mind if the model fails to add, we'll retry (in render()) until it succeeds
-        _model->addToScene(scene, pendingChanges, statusGetters);
+        _model->addToScene(scene, transaction, statusGetters);
     }
 
     // we've successfully added _myMetaItem so we always return true
@@ -249,11 +249,11 @@ bool RenderableModelEntityItem::addToScene(EntityItemPointer self, std::shared_p
 }
 
 void RenderableModelEntityItem::removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene,
-                                                render::PendingChanges& pendingChanges) {
+                                                render::Transaction& transaction) {
-    pendingChanges.removeItem(_myMetaItem);
+    transaction.removeItem(_myMetaItem);
     render::Item::clearID(_myMetaItem);
     if (_model) {
-        _model->removeFromScene(scene, pendingChanges);
+        _model->removeFromScene(scene, transaction);
     }
 }
 
@@ -467,15 +467,15 @@ void RenderableModelEntityItem::render(RenderArgs* args) {
         }
 
         if (_model->needsFixupInScene()) {
-            render::PendingChanges pendingChanges;
+            render::Transaction transaction;
 
-            _model->removeFromScene(scene, pendingChanges);
+            _model->removeFromScene(scene, transaction);
 
             render::Item::Status::Getters statusGetters;
             makeEntityItemStatusGetters(getThisPointer(), statusGetters);
-            _model->addToScene(scene, pendingChanges, statusGetters);
+            _model->addToScene(scene, transaction, statusGetters);
 
-            scene->enqueuePendingChanges(pendingChanges);
+            scene->enqueueTransaction(transaction);
         }
 
         auto& currentURL = getParsedModelURL();
@@ -525,9 +525,9 @@ ModelPointer RenderableModelEntityItem::getModel(QSharedPointer<EntityTreeRender
     } else if (_model) {
         // remove from scene
         render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
-        _model->removeFromScene(scene, pendingChanges);
+        _model->removeFromScene(scene, transaction);
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
 
         // release interest
         _myRenderer->releaseModel(_model);
@@ -1226,10 +1226,10 @@ void RenderableModelEntityItem::locationChanged(bool tellPhysics) {
             }
 
             render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
-            render::PendingChanges pendingChanges;
+            render::Transaction transaction;
 
-            pendingChanges.updateItem(myMetaItem);
+            transaction.updateItem(myMetaItem);
-            scene->enqueuePendingChanges(pendingChanges);
+            scene->enqueueTransaction(transaction);
         });
     }
 }

libraries/entities-renderer/src/RenderableModelEntityItem.h

@@ -40,8 +40,8 @@ public:
 
     void doInitialModelSimulation();
 
-    virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) override;
+    virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override;
-    virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) override;
+    virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override;
 
 
     void updateModelBounds();

libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp

@@ -162,7 +162,7 @@ RenderableParticleEffectEntityItem::RenderableParticleEffectEntityItem(const Ent
 
 bool RenderableParticleEffectEntityItem::addToScene(EntityItemPointer self,
                                                     render::ScenePointer scene,
-                                                    render::PendingChanges& pendingChanges) {
+                                                    render::Transaction& transaction) {
     _scene = scene;
     _renderItemId = _scene->allocateID();
     auto particlePayloadData = std::make_shared<ParticlePayloadData>();
@@ -171,14 +171,14 @@ bool RenderableParticleEffectEntityItem::addToScene(EntityItemPointer self,
     render::Item::Status::Getters statusGetters;
     makeEntityItemStatusGetters(getThisPointer(), statusGetters);
     renderPayload->addStatusGetters(statusGetters);
-    pendingChanges.resetItem(_renderItemId, renderPayload);
+    transaction.resetItem(_renderItemId, renderPayload);
     return true;
 }
 
 void RenderableParticleEffectEntityItem::removeFromScene(EntityItemPointer self,
                                                          render::ScenePointer scene,
-                                                         render::PendingChanges& pendingChanges) {
+                                                         render::Transaction& transaction) {
-    pendingChanges.removeItem(_renderItemId);
+    transaction.removeItem(_renderItemId);
     _scene = nullptr;
     render::Item::clearID(_renderItemId);
 };
@@ -206,12 +206,12 @@ void RenderableParticleEffectEntityItem::updateRenderItem() {
         return;
     }
     if (!getVisible()) {
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
-        pendingChanges.updateItem<ParticlePayloadData>(_renderItemId, [](ParticlePayloadData& payload) {
+        transaction.updateItem<ParticlePayloadData>(_renderItemId, [](ParticlePayloadData& payload) {
             payload.setVisibleFlag(false);
         });
         
-        _scene->enqueuePendingChanges(pendingChanges);
+        _scene->enqueueTransaction(transaction);
         return;
     }
     
@@ -253,8 +253,8 @@ void RenderableParticleEffectEntityItem::updateRenderItem() {
     }
 
 
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
-    pendingChanges.updateItem<ParticlePayloadData>(_renderItemId, [=](ParticlePayloadData& payload) {
+    transaction.updateItem<ParticlePayloadData>(_renderItemId, [=](ParticlePayloadData& payload) {
         payload.setVisibleFlag(true);
         
         // Update particle uniforms
@@ -282,7 +282,7 @@ void RenderableParticleEffectEntityItem::updateRenderItem() {
         }
     });
 
-    _scene->enqueuePendingChanges(pendingChanges);
+    _scene->enqueueTransaction(transaction);
 }
 
 void RenderableParticleEffectEntityItem::createPipelines() {
@@ -318,9 +318,9 @@ void RenderableParticleEffectEntityItem::notifyBoundChanged() {
     if (!render::Item::isValidID(_renderItemId)) {
         return;
     }
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
-    pendingChanges.updateItem<ParticlePayloadData>(_renderItemId, [](ParticlePayloadData& payload) {
+    transaction.updateItem<ParticlePayloadData>(_renderItemId, [](ParticlePayloadData& payload) {
     });
 
-    _scene->enqueuePendingChanges(pendingChanges);
+    _scene->enqueueTransaction(transaction);
 }

libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h

@@ -25,8 +25,8 @@ public:
 
     void updateRenderItem();
 
-    virtual bool addToScene(EntityItemPointer self, render::ScenePointer scene, render::PendingChanges& pendingChanges) override;
+    virtual bool addToScene(EntityItemPointer self, render::ScenePointer scene, render::Transaction& transaction) override;
-    virtual void removeFromScene(EntityItemPointer self, render::ScenePointer scene, render::PendingChanges& pendingChanges) override;
+    virtual void removeFromScene(EntityItemPointer self, render::ScenePointer scene, render::Transaction& transaction) override;
 
 protected:
     virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); notifyBoundChanged(); }

libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp

@@ -817,7 +817,7 @@ void RenderablePolyVoxEntityItem::render(RenderArgs* args) {
 
 bool RenderablePolyVoxEntityItem::addToScene(EntityItemPointer self,
                                              std::shared_ptr<render::Scene> scene,
-                                             render::PendingChanges& pendingChanges) {
+                                             render::Transaction& transaction) {
     _myItem = scene->allocateID();
 
     auto renderItem = std::make_shared<PolyVoxPayload>(getThisPointer());
@@ -828,15 +828,15 @@ bool RenderablePolyVoxEntityItem::addToScene(EntityItemPointer self,
     makeEntityItemStatusGetters(getThisPointer(), statusGetters);
     renderPayload->addStatusGetters(statusGetters);
 
-    pendingChanges.resetItem(_myItem, renderPayload);
+    transaction.resetItem(_myItem, renderPayload);
 
     return true;
 }
 
 void RenderablePolyVoxEntityItem::removeFromScene(EntityItemPointer self,
                                                   std::shared_ptr<render::Scene> scene,
-                                                  render::PendingChanges& pendingChanges) {
+                                                  render::Transaction& transaction) {
-    pendingChanges.removeItem(_myItem);
+    transaction.removeItem(_myItem);
     render::Item::clearID(_myItem);
 }
 
@@ -1615,10 +1615,10 @@ void RenderablePolyVoxEntityItem::locationChanged(bool tellPhysics) {
         return;
     }
     render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
-    pendingChanges.updateItem<PolyVoxPayload>(_myItem, [](PolyVoxPayload& payload) {});
+    transaction.updateItem<PolyVoxPayload>(_myItem, [](PolyVoxPayload& payload) {});
 
-    scene->enqueuePendingChanges(pendingChanges);
+    scene->enqueueTransaction(transaction);
 }
 
 bool RenderablePolyVoxEntityItem::getMeshes(MeshProxyList& result) {

libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h

@@ -107,10 +107,10 @@ public:
 
     virtual bool addToScene(EntityItemPointer self,
                             std::shared_ptr<render::Scene> scene,
-                            render::PendingChanges& pendingChanges) override;
+                            render::Transaction& transaction) override;
     virtual void removeFromScene(EntityItemPointer self,
                                  std::shared_ptr<render::Scene> scene,
-                                 render::PendingChanges& pendingChanges) override;
+                                 render::Transaction& transaction) override;
 
     virtual void setXNNeighborID(const EntityItemID& xNNeighborID) override;
     virtual void setYNNeighborID(const EntityItemID& yNNeighborID) override;

libraries/entities-renderer/src/RenderableZoneEntityItem.cpp

@@ -118,13 +118,13 @@ void RenderableZoneEntityItem::render(RenderArgs* args) {
                     // check to see if when we added our models to the scene they were ready, if they were not ready, then
                     // fix them up in the scene
                     render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
-                    render::PendingChanges pendingChanges;
+                    render::Transaction transaction;
-                    _model->removeFromScene(scene, pendingChanges);
+                    _model->removeFromScene(scene, transaction);
                     render::Item::Status::Getters statusGetters;
                     makeEntityItemStatusGetters(getThisPointer(), statusGetters);
-                    _model->addToScene(scene, pendingChanges);
+                    _model->addToScene(scene, transaction);
                     
-                    scene->enqueuePendingChanges(pendingChanges);
+                    scene->enqueueTransaction(transaction);
                     
                     _model->setVisibleInScene(getVisible(), scene);
                 }
@@ -164,9 +164,9 @@ void RenderableZoneEntityItem::render(RenderArgs* args) {
         _model && !_model->needsFixupInScene()) {
         // If the model is in the scene but doesn't need to be, remove it.
         render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
-        _model->removeFromScene(scene, pendingChanges);
+        _model->removeFromScene(scene, transaction);
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
     }
 }
 
@@ -218,7 +218,7 @@ namespace render {
 }
 
 bool RenderableZoneEntityItem::addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene,
-                                           render::PendingChanges& pendingChanges) {
+                                           render::Transaction& transaction) {
     _myMetaItem = scene->allocateID();
     
     auto renderData = std::make_shared<RenderableZoneEntityItemMeta>(self);
@@ -228,16 +228,16 @@ bool RenderableZoneEntityItem::addToScene(EntityItemPointer self, std::shared_pt
     makeEntityItemStatusGetters(getThisPointer(), statusGetters);
     renderPayload->addStatusGetters(statusGetters);
 
-    pendingChanges.resetItem(_myMetaItem, renderPayload);
+    transaction.resetItem(_myMetaItem, renderPayload);
     return true;
 }
 
 void RenderableZoneEntityItem::removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene,
-                                                render::PendingChanges& pendingChanges) {
+                                                render::Transaction& transaction) {
-    pendingChanges.removeItem(_myMetaItem);
+    transaction.removeItem(_myMetaItem);
     render::Item::clearID(_myMetaItem);
     if (_model) {
-        _model->removeFromScene(scene, pendingChanges);
+        _model->removeFromScene(scene, transaction);
     }
 }
 
@@ -246,13 +246,13 @@ void RenderableZoneEntityItem::notifyBoundChanged() {
     if (!render::Item::isValidID(_myMetaItem)) {
         return;
     }
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
     render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
     if (scene) {
-        pendingChanges.updateItem<RenderableZoneEntityItemMeta>(_myMetaItem, [](RenderableZoneEntityItemMeta& data) {
+        transaction.updateItem<RenderableZoneEntityItemMeta>(_myMetaItem, [](RenderableZoneEntityItemMeta& data) {
         });
 
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
     } else {
         qCWarning(entitiesrenderer) << "RenderableZoneEntityItem::notifyBoundChanged(), Unexpected null scene, possibly during application shutdown";
     }

libraries/entities-renderer/src/RenderableZoneEntityItem.h

@@ -38,8 +38,8 @@ public:
     virtual void render(RenderArgs* args) override;
     virtual bool contains(const glm::vec3& point) const override;
     
-    virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) override;
+    virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override;
-    virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) override;
+    virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override;
     
 private:
     virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); notifyBoundChanged(); }

libraries/entities/src/EntityItem.h

@@ -53,7 +53,7 @@ using EntityTreeElementExtraEncodeDataPointer = std::shared_ptr<EntityTreeElemen
 
 namespace render {
     class Scene;
-    class PendingChanges;
+    class Transaction;
 }
 
 #define DONT_ALLOW_INSTANTIATION virtual void pureVirtualFunctionPlaceHolder() = 0;
@@ -153,9 +153,9 @@ public:
                                                 { somethingChanged = false; return 0; }
 
     virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene,
-                            render::PendingChanges& pendingChanges) { return false; } // by default entity items don't add to scene
+                            render::Transaction& transaction) { return false; } // by default entity items don't add to scene
     virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene,
-                                render::PendingChanges& pendingChanges) { } // by default entity items don't add to scene
+                                render::Transaction& transaction) { } // by default entity items don't add to scene
     virtual void render(RenderArgs* args) { } // by default entity items don't know how to render
 
     static int expectedBytes();

libraries/render-utils/src/AnimDebugDraw.cpp

@@ -114,9 +114,9 @@ AnimDebugDraw::AnimDebugDraw() :
     render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
     if (scene) {
         _itemID = scene->allocateID();
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
-        pendingChanges.resetItem(_itemID, _animDebugDrawPayload);
+        transaction.resetItem(_itemID, _animDebugDrawPayload);
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
     }
 
     // HACK: add red, green and blue axis at (1,1,1)
@@ -142,9 +142,9 @@ void AnimDebugDraw::shutdown() {
     // remove renderItem from main 3d scene.
     render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
     if (scene && _itemID) {
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
-        pendingChanges.removeItem(_itemID);
+        transaction.removeItem(_itemID);
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
     }
 }
 
@@ -317,8 +317,8 @@ void AnimDebugDraw::update() {
         return;
     }
 
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
-    pendingChanges.updateItem<AnimDebugDrawData>(_itemID, [&](AnimDebugDrawData& data) {
+    transaction.updateItem<AnimDebugDrawData>(_itemID, [&](AnimDebugDrawData& data) {
 
         const size_t VERTICES_PER_BONE = (6 + (NUM_CIRCLE_SLICES * 2) * 3);
         const size_t VERTICES_PER_LINK = 8 * 2;
@@ -422,5 +422,5 @@ void AnimDebugDraw::update() {
             data._indexBuffer->setSubData<uint16_t>(i, (uint16_t)i);;
         }
     });
-    scene->enqueuePendingChanges(pendingChanges);
+    scene->enqueueTransaction(transaction);
 }

libraries/render-utils/src/Model.cpp

@@ -235,9 +235,9 @@ void Model::updateRenderItems() {
 
         uint32_t deleteGeometryCounter = self->_deleteGeometryCounter;
 
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
         foreach (auto itemID, self->_modelMeshRenderItemsMap.keys()) {
-            pendingChanges.updateItem<ModelMeshPartPayload>(itemID, [deleteGeometryCounter](ModelMeshPartPayload& data) {
+            transaction.updateItem<ModelMeshPartPayload>(itemID, [deleteGeometryCounter](ModelMeshPartPayload& data) {
                 if (data._model && data._model->isLoaded()) {
                     // Ensure the model geometry was not reset between frames
                     if (deleteGeometryCounter == data._model->_deleteGeometryCounter) {
@@ -259,14 +259,14 @@ void Model::updateRenderItems() {
         Transform collisionMeshOffset;
         collisionMeshOffset.setIdentity();
         Transform modelTransform = self->getTransform();
-		foreach(auto itemID, self->_collisionRenderItemsMap.keys()) {
+        foreach(auto itemID, self->_collisionRenderItemsMap.keys()) {
-            pendingChanges.updateItem<MeshPartPayload>(itemID, [modelTransform, collisionMeshOffset](MeshPartPayload& data) {
+            transaction.updateItem<MeshPartPayload>(itemID, [modelTransform, collisionMeshOffset](MeshPartPayload& data) {
                 // update the model transform for this render item.
                 data.updateTransform(modelTransform, collisionMeshOffset);
             });
         }
 
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
     });
 }
 
@@ -538,14 +538,14 @@ void Model::setVisibleInScene(bool newValue, std::shared_ptr<render::Scene> scen
     if (_isVisible != newValue) {
         _isVisible = newValue;
 
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
         foreach (auto item, _modelMeshRenderItemsMap.keys()) {
-            pendingChanges.resetItem(item, _modelMeshRenderItemsMap[item]);
+            transaction.resetItem(item, _modelMeshRenderItemsMap[item]);
         }
-		foreach(auto item, _collisionRenderItemsMap.keys()) {
+        foreach(auto item, _collisionRenderItemsMap.keys()) {
-			pendingChanges.resetItem(item, _collisionRenderItemsMap[item]);
+            transaction.resetItem(item, _collisionRenderItemsMap[item]);
         }
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
     }
 }
 
@@ -554,19 +554,19 @@ void Model::setLayeredInFront(bool layered, std::shared_ptr<render::Scene> scene
     if (_isLayeredInFront != layered) {
         _isLayeredInFront = layered;
 
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
         foreach(auto item, _modelMeshRenderItemsMap.keys()) {
-            pendingChanges.resetItem(item, _modelMeshRenderItemsMap[item]);
+            transaction.resetItem(item, _modelMeshRenderItemsMap[item]);
         }
-		foreach(auto item, _collisionRenderItemsMap.keys()) {
+        foreach(auto item, _collisionRenderItemsMap.keys()) {
-			pendingChanges.resetItem(item, _collisionRenderItemsMap[item]);
+            transaction.resetItem(item, _collisionRenderItemsMap[item]);
         }
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
     }
 }
 
 bool Model::addToScene(std::shared_ptr<render::Scene> scene,
-                       render::PendingChanges& pendingChanges,
+                       render::Transaction& transaction,
                        render::Item::Status::Getters& statusGetters) {
     bool readyToRender = _collisionGeometry || isLoaded();
     if (!_addedToScene && readyToRender) {
@@ -579,11 +579,11 @@ bool Model::addToScene(std::shared_ptr<render::Scene> scene,
             foreach (auto renderItem, _collisionRenderItems) {
                 auto item = scene->allocateID();
                 auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderItem);
-				if (_collisionRenderItems.empty() && statusGetters.size()) {
+                if (_collisionRenderItems.empty() && statusGetters.size()) {
                     renderPayload->addStatusGetters(statusGetters);
                 }
-                pendingChanges.resetItem(item, renderPayload);
+                transaction.resetItem(item, renderPayload);
-				_collisionRenderItemsMap.insert(item, renderPayload);
+                _collisionRenderItemsMap.insert(item, renderPayload);
             }
             somethingAdded = !_collisionRenderItems.empty();
         }
@@ -595,10 +595,10 @@ bool Model::addToScene(std::shared_ptr<render::Scene> scene,
             foreach(auto renderItem, _modelMeshRenderItems) {
                 auto item = scene->allocateID();
                 auto renderPayload = std::make_shared<ModelMeshPartPayload::Payload>(renderItem);
-				if (_modelMeshRenderItemsMap.empty() && statusGetters.size()) {
+                if (_modelMeshRenderItemsMap.empty() && statusGetters.size()) {
                     renderPayload->addStatusGetters(statusGetters);
                 }
-                pendingChanges.resetItem(item, renderPayload);
+                transaction.resetItem(item, renderPayload);
 
                 hasTransparent = hasTransparent || renderItem.get()->getShapeKey().isTranslucent();
                 verticesCount += renderItem.get()->getVerticesCount();
@@ -622,16 +622,16 @@ bool Model::addToScene(std::shared_ptr<render::Scene> scene,
     return somethingAdded;
 }
 
-void Model::removeFromScene(std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
+void Model::removeFromScene(std::shared_ptr<render::Scene> scene, render::Transaction& transaction) {
     foreach (auto item, _modelMeshRenderItemsMap.keys()) {
-        pendingChanges.removeItem(item);
+        transaction.removeItem(item);
     }
     _modelMeshRenderItemIDs.clear();
     _modelMeshRenderItemsMap.clear();
     _modelMeshRenderItems.clear();
 
-	foreach(auto item, _collisionRenderItemsMap.keys()) {
+    foreach(auto item, _collisionRenderItemsMap.keys()) {
-        pendingChanges.removeItem(item);
+        transaction.removeItem(item);
     }
     _collisionRenderItems.clear();
     _collisionRenderItems.clear();
@@ -794,11 +794,11 @@ void Model::setURL(const QUrl& url) {
     _url = url;
 
     {
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
         render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
         if (scene) {
-            removeFromScene(scene, pendingChanges);
+            removeFromScene(scene, transaction);
-            scene->enqueuePendingChanges(pendingChanges);
+            scene->enqueueTransaction(transaction);
         } else {
             qCWarning(renderutils) << "Model::setURL(), Unexpected null scene, possibly during application shutdown";
         }
@@ -1279,17 +1279,17 @@ bool Model::initWhenReady(render::ScenePointer scene) {
 
     createRenderItemSet();
 
-    render::PendingChanges pendingChanges;
+    render::Transaction transaction;
 
-    bool addedPendingChanges = false;
+    bool addedTransaction = false;
     if (_collisionGeometry) {
         foreach (auto renderItem, _collisionRenderItems) {
             auto item = scene->allocateID();
             auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderItem);
             _collisionRenderItemsMap.insert(item, renderPayload);
-            pendingChanges.resetItem(item, renderPayload);
+            transaction.resetItem(item, renderPayload);
         }
-        addedPendingChanges = !_collisionRenderItems.empty();
+        addedTransaction = !_collisionRenderItems.empty();
     } else {
         bool hasTransparent = false;
         size_t verticesCount = 0;
@@ -1300,17 +1300,17 @@ bool Model::initWhenReady(render::ScenePointer scene) {
             hasTransparent = hasTransparent || renderItem.get()->getShapeKey().isTranslucent();
             verticesCount += renderItem.get()->getVerticesCount();
             _modelMeshRenderItemsMap.insert(item, renderPayload);
-            pendingChanges.resetItem(item, renderPayload);
+            transaction.resetItem(item, renderPayload);
         }
-        addedPendingChanges = !_modelMeshRenderItemsMap.empty();
+        addedTransaction = !_modelMeshRenderItemsMap.empty();
         _renderInfoVertexCount = verticesCount;
         _renderInfoDrawCalls = _modelMeshRenderItemsMap.count();
         _renderInfoHasTransparent = hasTransparent;
     }
-    _addedToScene = addedPendingChanges;
+    _addedToScene = addedTransaction;
-    if (addedPendingChanges) {
+    if (addedTransaction) {
-        scene->enqueuePendingChanges(pendingChanges);
+        scene->enqueueTransaction(transaction);
-        // NOTE: updateRender items enqueues identical pendingChanges (using a lambda)
+        // NOTE: updateRender items enqueues identical transaction (using a lambda)
         // so it looks like we're doing double work here, but I don't want to remove the call
         // for fear there is some side effect we'll miss. -- Andrew 2016.07.21
         // TODO: figure out if we really need this call to updateRenderItems() or not.

libraries/render-utils/src/Model.h

@@ -42,7 +42,7 @@ class ViewFrustum;
 
 namespace render {
     class Scene;
-    class PendingChanges;
+    class Transaction;
     typedef unsigned int ItemID;
 }
 class MeshPartPayload;
@@ -88,14 +88,14 @@ public:
     bool needsReload() const { return _needsReload; }
     bool initWhenReady(render::ScenePointer scene);
     bool addToScene(std::shared_ptr<render::Scene> scene,
-                    render::PendingChanges& pendingChanges) {
+                    render::Transaction& transaction) {
         auto getters = render::Item::Status::Getters(0);
-        return addToScene(scene, pendingChanges, getters);
+        return addToScene(scene, transaction, getters);
     }
     bool addToScene(std::shared_ptr<render::Scene> scene,
-                    render::PendingChanges& pendingChanges,
+                    render::Transaction& transaction,
                     render::Item::Status::Getters& statusGetters);
-    void removeFromScene(std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges);
+    void removeFromScene(std::shared_ptr<render::Scene> scene, render::Transaction& transaction);
     bool isRenderable() const;
 
     bool isVisible() const { return _isVisible; }

libraries/render/src/render/Scene.cpp

@@ -16,31 +16,31 @@
 
 using namespace render;
 
-void PendingChanges::resetItem(ItemID id, const PayloadPointer& payload) {
+void Transaction::resetItem(ItemID id, const PayloadPointer& payload) {
     if (payload) {
         _resetItems.push_back(id);
         _resetPayloads.push_back(payload);
     } else {
-        qCDebug(renderlogging) << "WARNING: PendingChanges::resetItem with a null payload!";
+        qCDebug(renderlogging) << "WARNING: Transaction::resetItem with a null payload!";
         removeItem(id);
     }
 }
 
-void PendingChanges::removeItem(ItemID id) {
+void Transaction::removeItem(ItemID id) {
     _removedItems.push_back(id);
 }
 
-void PendingChanges::updateItem(ItemID id, const UpdateFunctorPointer& functor) {
+void Transaction::updateItem(ItemID id, const UpdateFunctorPointer& functor) {
     _updatedItems.push_back(id);
     _updateFunctors.push_back(functor);
 }
 
-void PendingChanges::merge(const PendingChanges& changes) {
+void Transaction::merge(const Transaction& transaction) {
-    _resetItems.insert(_resetItems.end(), changes._resetItems.begin(), changes._resetItems.end());
+    _resetItems.insert(_resetItems.end(), transaction._resetItems.begin(), transaction._resetItems.end());
-    _resetPayloads.insert(_resetPayloads.end(), changes._resetPayloads.begin(), changes._resetPayloads.end());
+    _resetPayloads.insert(_resetPayloads.end(), transaction._resetPayloads.begin(), transaction._resetPayloads.end());
-    _removedItems.insert(_removedItems.end(), changes._removedItems.begin(), changes._removedItems.end());
+    _removedItems.insert(_removedItems.end(), transaction._removedItems.begin(), transaction._removedItems.end());
-    _updatedItems.insert(_updatedItems.end(), changes._updatedItems.begin(), changes._updatedItems.end());
+    _updatedItems.insert(_updatedItems.end(), transaction._updatedItems.begin(), transaction._updatedItems.end());
-    _updateFunctors.insert(_updateFunctors.end(), changes._updateFunctors.begin(), changes._updateFunctors.end());
+    _updateFunctors.insert(_updateFunctors.end(), transaction._updateFunctors.begin(), transaction._updateFunctors.end());
 }
 
 Scene::Scene(glm::vec3 origin, float size) :
@@ -63,27 +63,27 @@ bool Scene::isAllocatedID(const ItemID& id) const {
 }
 
 /// Enqueue change batch to the scene
-void Scene::enqueuePendingChanges(const PendingChanges& pendingChanges) {
+void Scene::enqueueTransaction(const Transaction& transaction) {
-    _changeQueueMutex.lock();
+    _transactionQueueMutex.lock();
-    _changeQueue.push(pendingChanges);
+    _transactionQueue.push(transaction);
-    _changeQueueMutex.unlock();
+    _transactionQueueMutex.unlock();
 }
 
-void consolidateChangeQueue(PendingChangesQueue& queue, PendingChanges& singleBatch) {
+void consolidateTransaction(TransactionQueue& queue, Transaction& singleBatch) {
     while (!queue.empty()) {
-        const auto& pendingChanges = queue.front();
+        const auto& transaction = queue.front();
-        singleBatch.merge(pendingChanges);
+        singleBatch.merge(transaction);
         queue.pop();
     };
 }
  
-void Scene::processPendingChangesQueue() {
+void Scene::processTransactionQueue() {
     PROFILE_RANGE(render, __FUNCTION__);
-    PendingChanges consolidatedPendingChanges;
+    Transaction consolidatedTransaction;
 
     {
-        std::unique_lock<std::mutex> lock(_changeQueueMutex);
+        std::unique_lock<std::mutex> lock(_transactionQueueMutex);
-        consolidateChangeQueue(_changeQueue, consolidatedPendingChanges);
+        consolidateTransaction(_transactionQueue, consolidatedTransaction);
     }
     
     {
@@ -95,19 +95,19 @@ void Scene::processPendingChangesQueue() {
             _items.resize(maxID + 100); // allocate the maxId and more
         }
         // Now we know for sure that we have enough items in the array to
-        // capture anything coming from the pendingChanges
+        // capture anything coming from the transaction
 
         // resets and potential NEW items
-        resetItems(consolidatedPendingChanges._resetItems, consolidatedPendingChanges._resetPayloads);
+        resetItems(consolidatedTransaction._resetItems, consolidatedTransaction._resetPayloads);
 
         // Update the numItemsAtomic counter AFTER the reset changes went through
         _numAllocatedItems.exchange(maxID);
 
         // updates
-        updateItems(consolidatedPendingChanges._updatedItems, consolidatedPendingChanges._updateFunctors);
+        updateItems(consolidatedTransaction._updatedItems, consolidatedTransaction._updateFunctors);
 
         // removes
-        removeItems(consolidatedPendingChanges._removedItems);
+        removeItems(consolidatedTransaction._removedItems);
 
         // Update the numItemsAtomic counter AFTER the pending changes went through
         _numAllocatedItems.exchange(maxID);

libraries/render/src/render/Scene.h

@@ -19,10 +19,19 @@ namespace render {
 
 class Engine;
 
-class PendingChanges {
+// Transaction is the mechanism to make any change to the scene.
+// Whenever a new item need to be reset,
+// or when an item changes its position or its size
+// or when an item's payload has to be be updated with new states (coming from outside the scene knowledge)
+// or when an item is destroyed
+// These changes must be expressed through the corresponding command from the Transaction
+// THe Transaction is then queued on the Scene so all the pending transactions can be consolidated and processed at the time
+// of updating the scene before it s rendered.
+// 
+class Transaction {
 public:
-    PendingChanges() {}
+    Transaction() {}
-    ~PendingChanges() {}
+    ~Transaction() {}
 
     void resetItem(ItemID id, const PayloadPointer& payload);
     void removeItem(ItemID id);
@@ -34,7 +43,7 @@ public:
     void updateItem(ItemID id, const UpdateFunctorPointer& functor);
     void updateItem(ItemID id) { updateItem(id, nullptr); }
 
-    void merge(const PendingChanges& changes);
+    void merge(const Transaction& transaction);
 
     ItemIDs _resetItems; 
     Payloads _resetPayloads;
@@ -44,12 +53,12 @@ public:
 
 protected:
 };
-typedef std::queue<PendingChanges> PendingChangesQueue;
+typedef std::queue<Transaction> TransactionQueue;
 
 
 // Scene is a container for Items
-// Items are introduced, modified or erased in the scene through PendingChanges
+// Items are introduced, modified or erased in the scene through Transaction
-// Once per Frame, the PendingChanges are all flushed
+// Once per Frame, the Transaction are all flushed
 // During the flush the standard buckets are updated
 // Items are notified accordingly on any update message happening
 class Scene {
@@ -66,11 +75,11 @@ public:
     // THis is the total number of allocated items, this a threadsafe call
     size_t getNumItems() const { return _numAllocatedItems.load(); }
 
-    // Enqueue change batch to the scene
+    // Enqueue transaction to the scene
-    void enqueuePendingChanges(const PendingChanges& pendingChanges);
+    void enqueueTransaction(const Transaction& transaction);
 
-    // Process the penging changes equeued
+    // Process the pending transactions queued
-    void processPendingChangesQueue();
+    void processTransactionQueue();
 
     // This next call are  NOT threadsafe, you have to call them from the correct thread to avoid any potential issues
 
@@ -91,8 +100,8 @@ protected:
     // Thread safe elements that can be accessed from anywhere
     std::atomic<unsigned int> _IDAllocator{ 1 }; // first valid itemID will be One
     std::atomic<unsigned int> _numAllocatedItems{ 1 }; // num of allocated items, matching the _items.size()
-    std::mutex _changeQueueMutex;
+    std::mutex _transactionQueueMutex;
-    PendingChangesQueue _changeQueue;
+    TransactionQueue _transactionQueue;
 
     // The actual database
     // database of items is protected for editing by a mutex

libraries/script-engine/src/SceneScriptingInterface.h

@@ -133,7 +133,8 @@ namespace SceneScripting {
 class SceneScriptingInterface : public QObject, public Dependency {
     Q_OBJECT
     SINGLETON_DEPENDENCY
-    
+     
+
 public:
     Q_PROPERTY(bool shouldRenderAvatars READ shouldRenderAvatars WRITE setShouldRenderAvatars)
     Q_PROPERTY(bool shouldRenderEntities READ shouldRenderEntities WRITE setShouldRenderEntities)

libraries/shared/src/Trace.cpp

@@ -179,7 +179,7 @@ void Tracer::serialize(const QString& originalPath) {
     {
 
         // "traceEvents":[
-        // {"args":{"nv_payload":0},"cat":"hifi.render","name":"render::Scene::processPendingChangesQueue","ph":"B","pid":14796,"tid":21636,"ts":68795933487}
+        // {"args":{"nv_payload":0},"cat":"hifi.render","name":"render::Scene::processTransactionQueue","ph":"B","pid":14796,"tid":21636,"ts":68795933487}
 
         QJsonArray traceEvents;
 

tests/render-perf/src/main.cpp

@@ -880,7 +880,7 @@ private:
         getEntities()->update();
 
         // The pending changes collecting the changes here
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
 
         // FIXME: Move this out of here!, Background / skybox should be driven by the enityt content just like the other entities
         // Background rendering decision
@@ -888,7 +888,7 @@ private:
             auto backgroundRenderData = std::make_shared<BackgroundRenderData>();
             auto backgroundRenderPayload = std::make_shared<BackgroundRenderData::Payload>(backgroundRenderData);
             BackgroundRenderData::_item = _main3DScene->allocateID();
-            pendingChanges.resetItem(BackgroundRenderData::_item, backgroundRenderPayload);
+            transaction.resetItem(BackgroundRenderData::_item, backgroundRenderPayload);
         }
         // Setup the current Zone Entity lighting
         {
@@ -897,10 +897,10 @@ private:
         }
 
         {
-            PerformanceTimer perfTimer("SceneProcessPendingChanges");
+            PerformanceTimer perfTimer("SceneProcessTransaction");
-            _main3DScene->enqueuePendingChanges(pendingChanges);
+            _main3DScene->enqueueTransaction(transaction);
 
-            _main3DScene->processPendingChangesQueue();
+            _main3DScene->processTransactionQueue();
         }
 
     }
@@ -914,13 +914,13 @@ private:
         PROFILE_RANGE(render, __FUNCTION__);
         PerformanceTimer perfTimer("draw");
         // The pending changes collecting the changes here
-        render::PendingChanges pendingChanges;
+        render::Transaction transaction;
         // Setup the current Zone Entity lighting
         DependencyManager::get<DeferredLightingEffect>()->setGlobalLight(_sunSkyStage.getSunLight());
         {
-            PerformanceTimer perfTimer("SceneProcessPendingChanges");
+            PerformanceTimer perfTimer("SceneProcessTransaction");
-            _main3DScene->enqueuePendingChanges(pendingChanges);
+            _main3DScene->enqueueTransaction(transaction);
-            _main3DScene->processPendingChangesQueue();
+            _main3DScene->processTransactionQueue();
         }
 
         // For now every frame pass the renderContext