From 6122155880fd829bae5dad42050c14a4d593f6e8 Mon Sep 17 00:00:00 2001 From: samcake Date: Wed, 5 Apr 2017 13:10:31 -0700 Subject: [PATCH 1/5] Renaming the PendingCHanges class to Transaction --- interface/src/Application.cpp | 30 +++++--- interface/src/avatar/Avatar.cpp | 40 +++++----- interface/src/avatar/Avatar.h | 6 +- interface/src/avatar/AvatarManager.cpp | 30 ++++---- interface/src/avatar/CauterizedModel.cpp | 6 +- interface/src/ui/overlays/Base3DOverlay.cpp | 12 +-- interface/src/ui/overlays/ModelOverlay.cpp | 20 ++--- interface/src/ui/overlays/ModelOverlay.h | 4 +- interface/src/ui/overlays/Overlay.cpp | 8 +- interface/src/ui/overlays/Overlay.h | 4 +- interface/src/ui/overlays/Overlays.cpp | 14 ++-- .../src/EntityTreeRenderer.cpp | 18 ++--- .../src/RenderableEntityItem.h | 18 ++--- .../src/RenderableLightEntityItem.cpp | 18 ++--- .../src/RenderableLightEntityItem.h | 6 +- .../src/RenderableModelEntityItem.cpp | 32 ++++---- .../src/RenderableModelEntityItem.h | 4 +- .../RenderableParticleEffectEntityItem.cpp | 26 +++---- .../src/RenderableParticleEffectEntityItem.h | 4 +- .../src/RenderablePolyVoxEntityItem.cpp | 14 ++-- .../src/RenderablePolyVoxEntityItem.h | 4 +- .../src/RenderableZoneEntityItem.cpp | 30 ++++---- .../src/RenderableZoneEntityItem.h | 4 +- libraries/entities/src/EntityItem.h | 6 +- .../physics/src/PhysicalEntitySimulation.cpp | 14 ++-- .../physics/src/PhysicalEntitySimulation.h | 2 +- libraries/render-utils/src/AnimDebugDraw.cpp | 18 ++--- libraries/render-utils/src/Model.cpp | 76 +++++++++---------- libraries/render-utils/src/Model.h | 10 +-- libraries/render/src/render/Scene.cpp | 50 ++++++------ libraries/render/src/render/Scene.h | 24 +++--- .../src/SceneScriptingInterface.h | 3 +- libraries/shared/src/SettingManager.cpp | 12 +-- libraries/shared/src/SettingManager.h | 2 +- libraries/shared/src/Trace.cpp | 2 +- plugins/openvr/src/ViveControllerManager.cpp | 6 +- plugins/openvr/src/ViveControllerManager.h | 2 +- tests/render-perf/src/main.cpp | 18 ++--- 38 files changed, 305 insertions(+), 292 deletions(-) diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index e19eea0a2e..9c41a78805 100644 --- a/interface/src/Application.cpp +++ b/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(); auto backgroundRenderPayload = make_shared(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(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::_item, + transaction.updateItem(WorldBoxRenderData::_item, [](WorldBoxRenderData& payload) { payload._val++; }); @@ -5089,10 +5089,10 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se } { - PerformanceTimer perfTimer("SceneProcessPendingChanges"); - _main3DScene->enqueuePendingChanges(pendingChanges); + PerformanceTimer perfTimer("SceneProcessTransaction"); + _main3DScene->enqueueTransaction(transaction); - _main3DScene->processPendingChangesQueue(); + _main3DScene->processTransactionQueue(); } // For now every frame pass the renderContext @@ -5786,10 +5786,22 @@ void Application::toggleRunningScriptsWidget() const { } void Application::showScriptLogs() { + auto tabletScriptingInterface = DependencyManager::get(); + auto tablet = dynamic_cast(tabletScriptingInterface->getTablet("com.highfidelity.interface.tablet.system")); auto scriptEngines = DependencyManager::get(); QUrl defaultScriptsLoc = defaultScriptsLocation(); defaultScriptsLoc.setPath(defaultScriptsLoc.path() + "developer/debugging/debugWindow.js"); - scriptEngines->loadScript(defaultScriptsLoc.toString()); + + if (tablet->getToolbarMode()) { + scriptEngines->loadScript(defaultScriptsLoc.toString()); + } else { + QQuickItem* tabletRoot = tablet->getTabletRoot(); + if (!tabletRoot && !isHMDMode()) { + scriptEngines->loadScript(defaultScriptsLoc.toString()); + } else { + tablet->pushOntoStack("../../hifi/dialogs/TabletDebugWindow.qml"); + } + } } void Application::showAssetServerWidget(QString filePath) { diff --git a/interface/src/avatar/Avatar.cpp b/interface/src/avatar/Avatar.cpp index ade98c63d8..b6ec45b308 100644 --- a/interface/src/avatar/Avatar.cpp +++ b/interface/src/avatar/Avatar.cpp @@ -476,34 +476,34 @@ static TextRenderer3D* textRenderer(TextRendererType type) { return displayNameRenderer; } -bool Avatar::addToScene(AvatarSharedPointer self, std::shared_ptr scene, render::PendingChanges& pendingChanges) { +bool Avatar::addToScene(AvatarSharedPointer self, std::shared_ptr scene, render::Transaction& transaction) { auto avatarPayload = new render::Payload(self); auto avatarPayloadPointer = Avatar::PayloadPointer(avatarPayload); _renderItemID = scene->allocateID(); - pendingChanges.resetItem(_renderItemID, avatarPayloadPointer); - _skeletonModel->addToScene(scene, pendingChanges); + transaction.resetItem(_renderItemID, avatarPayloadPointer); + _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 scene, render::PendingChanges& pendingChanges) { - pendingChanges.removeItem(_renderItemID); +void Avatar::removeFromScene(AvatarSharedPointer self, std::shared_ptr scene, render::Transaction& transaction) { + 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>(_renderItemID, [](render::Payload& p) {}); + transaction.updateItem>(_renderItemID, [](render::Payload& 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->addToScene(scene, pendingChanges); + _skeletonModel->removeFromScene(scene, transaction); + _skeletonModel->addToScene(scene, transaction); } for (auto attachmentModel : _attachmentModels) { if (attachmentModel->isRenderable() && attachmentModel->needsFixupInScene()) { - attachmentModel->removeFromScene(scene, pendingChanges); - attachmentModel->addToScene(scene, pendingChanges); + attachmentModel->removeFromScene(scene, transaction); + 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 Avatar::getSkeleton() { void Avatar::addToScene(AvatarSharedPointer myHandle) { render::ScenePointer scene = qApp->getMain3DScene(); if (scene) { - render::PendingChanges pendingChanges; + render::Transaction transaction; auto nodelist = DependencyManager::get(); if (DependencyManager::get()->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"; } diff --git a/interface/src/avatar/Avatar.h b/interface/src/avatar/Avatar.h index ba7e1c617e..7fadf96e11 100644 --- a/interface/src/avatar/Avatar.h +++ b/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 scene, - render::PendingChanges& pendingChanges); + render::Transaction& transaction); void removeFromScene(AvatarSharedPointer self, std::shared_ptr scene, - render::PendingChanges& pendingChanges); + render::Transaction& transaction); - void updateRenderItem(render::PendingChanges& pendingChanges); + void updateRenderItem(render::Transaction& transaction); virtual void postUpdate(float deltaTime); diff --git a/interface/src/avatar/AvatarManager.cpp b/interface/src/avatar/AvatarManager.cpp index 6152148887..48914908c6 100644 --- a/interface/src/avatar/AvatarManager.cpp +++ b/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()->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(*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(avatarData); render::ScenePointer scene = qApp->getMain3DScene(); - render::PendingChanges pendingChanges; - avatar->addToScene(avatar, scene, pendingChanges); - scene->enqueuePendingChanges(pendingChanges); + render::Transaction transaction; + avatar->addToScene(avatar, scene, transaction); + scene->enqueueTransaction(transaction); } } else { for (auto avatarData : _avatarHash) { auto avatar = std::static_pointer_cast(avatarData); render::ScenePointer scene = qApp->getMain3DScene(); - render::PendingChanges pendingChanges; - avatar->removeFromScene(avatar, scene, pendingChanges); - scene->enqueuePendingChanges(pendingChanges); + render::Transaction transaction; + avatar->removeFromScene(avatar, scene, transaction); + scene->enqueueTransaction(transaction); } } } diff --git a/interface/src/avatar/CauterizedModel.cpp b/interface/src/avatar/CauterizedModel.cpp index f479ed9a35..c7d25d3151 100644 --- a/interface/src/avatar/CauterizedModel.cpp +++ b/interface/src/avatar/CauterizedModel.cpp @@ -205,10 +205,10 @@ void CauterizedModel::updateRenderItems() { uint32_t deleteGeometryCounter = self->getGeometryCounter(); - render::PendingChanges pendingChanges; + render::Transaction transaction; QList keys = self->getRenderItems().keys(); foreach (auto itemID, keys) { - pendingChanges.updateItem(itemID, [modelTransform, deleteGeometryCounter](CauterizedMeshPartPayload& data) { + transaction.updateItem(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(); diff --git a/interface/src/ui/overlays/Base3DOverlay.cpp b/interface/src/ui/overlays/Base3DOverlay.cpp index 70b1fa4b71..d7057c6faa 100644 --- a/interface/src/ui/overlays/Base3DOverlay.cpp +++ b/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; - pendingChanges.updateItem(itemID); - scene->enqueuePendingChanges(pendingChanges); + render::Transaction transaction; + transaction.updateItem(itemID); + 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; - pendingChanges.updateItem(itemID); - scene->enqueuePendingChanges(pendingChanges); + render::Transaction transaction; + transaction.updateItem(itemID); + scene->enqueueTransaction(transaction); } } diff --git a/interface/src/ui/overlays/ModelOverlay.cpp b/interface/src/ui/overlays/ModelOverlay.cpp index a0f7c4e824..98ca7110ae 100644 --- a/interface/src/ui/overlays/ModelOverlay.cpp +++ b/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 scene, render::PendingChanges& pendingChanges) { - Volume3DOverlay::addToScene(overlay, scene, pendingChanges); - _model->addToScene(scene, pendingChanges); +bool ModelOverlay::addToScene(Overlay::Pointer overlay, std::shared_ptr scene, render::Transaction& transaction) { + Volume3DOverlay::addToScene(overlay, scene, transaction); + _model->addToScene(scene, transaction); return true; } -void ModelOverlay::removeFromScene(Overlay::Pointer overlay, std::shared_ptr scene, render::PendingChanges& pendingChanges) { - Volume3DOverlay::removeFromScene(overlay, scene, pendingChanges); - _model->removeFromScene(scene, pendingChanges); +void ModelOverlay::removeFromScene(Overlay::Pointer overlay, std::shared_ptr scene, render::Transaction& transaction) { + Volume3DOverlay::removeFromScene(overlay, scene, transaction); + _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->addToScene(scene, pendingChanges); + _model->removeFromScene(scene, transaction); + _model->addToScene(scene, transaction); } _model->setVisibleInScene(_visible, scene); _model->setLayeredInFront(getDrawInFront(), scene); - scene->enqueuePendingChanges(pendingChanges); + scene->enqueueTransaction(transaction); } void ModelOverlay::setProperties(const QVariantMap& properties) { diff --git a/interface/src/ui/overlays/ModelOverlay.h b/interface/src/ui/overlays/ModelOverlay.h index d5f709c2db..245688156f 100644 --- a/interface/src/ui/overlays/ModelOverlay.h +++ b/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 scene, render::PendingChanges& pendingChanges) override; - virtual void removeFromScene(Overlay::Pointer overlay, std::shared_ptr scene, render::PendingChanges& pendingChanges) override; + virtual bool addToScene(Overlay::Pointer overlay, std::shared_ptr scene, render::Transaction& transaction) override; + virtual void removeFromScene(Overlay::Pointer overlay, std::shared_ptr scene, render::Transaction& transaction) override; void locationChanged(bool tellPhysics) override; diff --git a/interface/src/ui/overlays/Overlay.cpp b/interface/src/ui/overlays/Overlay.cpp index 764422019e..e3004bd9c6 100644 --- a/interface/src/ui/overlays/Overlay.cpp +++ b/interface/src/ui/overlays/Overlay.cpp @@ -196,14 +196,14 @@ float Overlay::updatePulse() { return _pulse; } -bool Overlay::addToScene(Overlay::Pointer overlay, std::shared_ptr scene, render::PendingChanges& pendingChanges) { +bool Overlay::addToScene(Overlay::Pointer overlay, std::shared_ptr scene, render::Transaction& transaction) { _renderItemID = scene->allocateID(); - pendingChanges.resetItem(_renderItemID, std::make_shared(overlay)); + transaction.resetItem(_renderItemID, std::make_shared(overlay)); return true; } -void Overlay::removeFromScene(Overlay::Pointer overlay, std::shared_ptr scene, render::PendingChanges& pendingChanges) { - pendingChanges.removeItem(_renderItemID); +void Overlay::removeFromScene(Overlay::Pointer overlay, std::shared_ptr scene, render::Transaction& transaction) { + transaction.removeItem(_renderItemID); render::Item::clearID(_renderItemID); } diff --git a/interface/src/ui/overlays/Overlay.h b/interface/src/ui/overlays/Overlay.h index 9ad4f0ba70..9849c71a1f 100644 --- a/interface/src/ui/overlays/Overlay.h +++ b/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 scene, render::PendingChanges& pendingChanges); - virtual void removeFromScene(Overlay::Pointer overlay, std::shared_ptr scene, render::PendingChanges& pendingChanges); + virtual bool addToScene(Overlay::Pointer overlay, std::shared_ptr scene, render::Transaction& transaction); + virtual void removeFromScene(Overlay::Pointer overlay, std::shared_ptr scene, render::Transaction& transaction); virtual const render::ShapeKey getShapeKey() { return render::ShapeKey::Builder::ownPipeline(); } diff --git a/interface/src/ui/overlays/Overlays.cpp b/interface/src/ui/overlays/Overlays.cpp index 712342087d..61a283b88c 100644 --- a/interface/src/ui/overlays/Overlays.cpp +++ b/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) { - scene->enqueuePendingChanges(pendingChanges); + if (transaction._removedItems.size() > 0) { + scene->enqueueTransaction(transaction); } } } @@ -197,9 +197,9 @@ OverlayID Overlays::addOverlay(Overlay::Pointer overlay) { _overlaysWorld[thisID] = overlay; render::ScenePointer scene = qApp->getMain3DScene(); - render::PendingChanges pendingChanges; - overlay->addToScene(overlay, scene, pendingChanges); - scene->enqueuePendingChanges(pendingChanges); + render::Transaction transaction; + overlay->addToScene(overlay, scene, transaction); + scene->enqueueTransaction(transaction); } else { _overlaysHUD[thisID] = overlay; } diff --git a/libraries/entities-renderer/src/EntityTreeRenderer.cpp b/libraries/entities-renderer/src/EntityTreeRenderer.cpp index 4843afd5b1..fd5e07918e 100644 --- a/libraries/entities-renderer/src/EntityTreeRenderer.cpp +++ b/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); - scene->enqueuePendingChanges(pendingChanges); + entity->removeFromScene(entity, scene, transaction); + 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"; } diff --git a/libraries/entities-renderer/src/RenderableEntityItem.h b/libraries/entities-renderer/src/RenderableEntityItem.h index 98271ddbbb..2f053924ab 100644 --- a/libraries/entities-renderer/src/RenderableEntityItem.h +++ b/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 scene, render::PendingChanges& pendingChanges) { + bool addToScene(EntityItemPointer self, std::shared_ptr scene, render::Transaction& transaction) { _myItem = scene->allocateID(); auto renderData = std::make_shared(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 scene, render::PendingChanges& pendingChanges) { - pendingChanges.removeItem(_myItem); + void removeFromScene(EntityItemPointer self, std::shared_ptr scene, render::Transaction& transaction) { + 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(_myItem, [](RenderableEntityItemProxy& data) { + transaction.updateItem(_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 scene, render::PendingChanges& pendingChanges) override { return _renderHelper.addToScene(self, scene, pendingChanges); } \ - virtual void removeFromScene(EntityItemPointer self, std::shared_ptr scene, render::PendingChanges& pendingChanges) override { _renderHelper.removeFromScene(self, scene, pendingChanges); } \ + virtual bool addToScene(EntityItemPointer self, std::shared_ptr scene, render::Transaction& transaction) override { return _renderHelper.addToScene(self, scene, transaction); } \ + virtual void removeFromScene(EntityItemPointer self, std::shared_ptr 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() { \ diff --git a/libraries/entities-renderer/src/RenderableLightEntityItem.cpp b/libraries/entities-renderer/src/RenderableLightEntityItem.cpp index a7fcbf53ae..0b8592e678 100644 --- a/libraries/entities-renderer/src/RenderableLightEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableLightEntityItem.cpp @@ -27,7 +27,7 @@ RenderableLightEntityItem::RenderableLightEntityItem(const EntityItemID& entityI { } -bool RenderableLightEntityItem::addToScene(EntityItemPointer self, std::shared_ptr scene, render::PendingChanges& pendingChanges) { +bool RenderableLightEntityItem::addToScene(EntityItemPointer self, std::shared_ptr scene, render::Transaction& transaction) { _myItem = scene->allocateID(); auto renderItem = std::make_shared(); @@ -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 scene, render::PendingChanges& pendingChanges) { - pendingChanges.removeItem(_myItem); +void RenderableLightEntityItem::removeFromScene(EntityItemPointer self, std::shared_ptr scene, render::Transaction& transaction) { + 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(_myItem, [&](LightPayload& data) { + transaction.updateItem(_myItem, [&](LightPayload& data) { updateRenderItemFromEntity(data); }); } diff --git a/libraries/entities-renderer/src/RenderableLightEntityItem.h b/libraries/entities-renderer/src/RenderableLightEntityItem.h index 36ba0d6311..42a5dbc91a 100644 --- a/libraries/entities-renderer/src/RenderableLightEntityItem.h +++ b/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 scene, render::PendingChanges& pendingChanges) override; + virtual bool addToScene(EntityItemPointer self, std::shared_ptr scene, render::Transaction& transaction) override; virtual void somethingChangedNotification() override; - virtual void removeFromScene(EntityItemPointer self, std::shared_ptr scene, render::PendingChanges& pendingChanges) override; + virtual void removeFromScene(EntityItemPointer self, std::shared_ptr scene, render::Transaction& transaction) override; virtual void locationChanged(bool tellPhysics = true) override; diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp index 487a3e1e56..0cd5b718af 100644 --- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp @@ -228,20 +228,20 @@ namespace render { } bool RenderableModelEntityItem::addToScene(EntityItemPointer self, std::shared_ptr scene, - render::PendingChanges& pendingChanges) { + render::Transaction& transaction) { _myMetaItem = scene->allocateID(); auto renderData = std::make_shared(self); auto renderPayload = std::make_shared(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 scene, - render::PendingChanges& pendingChanges) { - pendingChanges.removeItem(_myMetaItem); + render::Transaction& transaction) { + 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(QSharedPointergetMain3DScene(); - render::PendingChanges pendingChanges; - _model->removeFromScene(scene, pendingChanges); - scene->enqueuePendingChanges(pendingChanges); + render::Transaction transaction; + _model->removeFromScene(scene, transaction); + 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); - scene->enqueuePendingChanges(pendingChanges); + transaction.updateItem(myMetaItem); + scene->enqueueTransaction(transaction); }); } } diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.h b/libraries/entities-renderer/src/RenderableModelEntityItem.h index 057ca36e13..c770e85089 100644 --- a/libraries/entities-renderer/src/RenderableModelEntityItem.h +++ b/libraries/entities-renderer/src/RenderableModelEntityItem.h @@ -40,8 +40,8 @@ public: void doInitialModelSimulation(); - virtual bool addToScene(EntityItemPointer self, std::shared_ptr scene, render::PendingChanges& pendingChanges) override; - virtual void removeFromScene(EntityItemPointer self, std::shared_ptr scene, render::PendingChanges& pendingChanges) override; + virtual bool addToScene(EntityItemPointer self, std::shared_ptr scene, render::Transaction& transaction) override; + virtual void removeFromScene(EntityItemPointer self, std::shared_ptr scene, render::Transaction& transaction) override; void updateModelBounds(); diff --git a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp b/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp index 86c3f5ff35..fdf9ba888f 100644 --- a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp +++ b/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(); @@ -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) { - pendingChanges.removeItem(_renderItemId); + render::Transaction& transaction) { + transaction.removeItem(_renderItemId); _scene = nullptr; render::Item::clearID(_renderItemId); }; @@ -206,12 +206,12 @@ void RenderableParticleEffectEntityItem::updateRenderItem() { return; } if (!getVisible()) { - render::PendingChanges pendingChanges; - pendingChanges.updateItem(_renderItemId, [](ParticlePayloadData& payload) { + render::Transaction transaction; + transaction.updateItem(_renderItemId, [](ParticlePayloadData& payload) { payload.setVisibleFlag(false); }); - _scene->enqueuePendingChanges(pendingChanges); + _scene->enqueueTransaction(transaction); return; } @@ -253,8 +253,8 @@ void RenderableParticleEffectEntityItem::updateRenderItem() { } - render::PendingChanges pendingChanges; - pendingChanges.updateItem(_renderItemId, [=](ParticlePayloadData& payload) { + render::Transaction transaction; + transaction.updateItem(_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; - pendingChanges.updateItem(_renderItemId, [](ParticlePayloadData& payload) { + render::Transaction transaction; + transaction.updateItem(_renderItemId, [](ParticlePayloadData& payload) { }); - _scene->enqueuePendingChanges(pendingChanges); + _scene->enqueueTransaction(transaction); } \ No newline at end of file diff --git a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h b/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h index a36c3640d6..9b31c92b07 100644 --- a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h +++ b/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 void removeFromScene(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::Transaction& transaction) override; protected: virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); notifyBoundChanged(); } diff --git a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp index 419f32f897..b8093d85d0 100644 --- a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp @@ -817,7 +817,7 @@ void RenderablePolyVoxEntityItem::render(RenderArgs* args) { bool RenderablePolyVoxEntityItem::addToScene(EntityItemPointer self, std::shared_ptr scene, - render::PendingChanges& pendingChanges) { + render::Transaction& transaction) { _myItem = scene->allocateID(); auto renderItem = std::make_shared(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 scene, - render::PendingChanges& pendingChanges) { - pendingChanges.removeItem(_myItem); + render::Transaction& transaction) { + 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; - pendingChanges.updateItem(_myItem, [](PolyVoxPayload& payload) {}); + render::Transaction transaction; + transaction.updateItem(_myItem, [](PolyVoxPayload& payload) {}); - scene->enqueuePendingChanges(pendingChanges); + scene->enqueueTransaction(transaction); } bool RenderablePolyVoxEntityItem::getMeshes(MeshProxyList& result) { diff --git a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h index cdfe2e38fe..ecb1817e94 100644 --- a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h +++ b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h @@ -107,10 +107,10 @@ public: virtual bool addToScene(EntityItemPointer self, std::shared_ptr scene, - render::PendingChanges& pendingChanges) override; + render::Transaction& transaction) override; virtual void removeFromScene(EntityItemPointer self, std::shared_ptr scene, - render::PendingChanges& pendingChanges) override; + render::Transaction& transaction) override; virtual void setXNNeighborID(const EntityItemID& xNNeighborID) override; virtual void setYNNeighborID(const EntityItemID& yNNeighborID) override; diff --git a/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp b/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp index 0215ce4d07..c9a45465c2 100644 --- a/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp +++ b/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; - _model->removeFromScene(scene, pendingChanges); + render::Transaction transaction; + _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; - _model->removeFromScene(scene, pendingChanges); - scene->enqueuePendingChanges(pendingChanges); + render::Transaction transaction; + _model->removeFromScene(scene, transaction); + scene->enqueueTransaction(transaction); } } @@ -218,7 +218,7 @@ namespace render { } bool RenderableZoneEntityItem::addToScene(EntityItemPointer self, std::shared_ptr scene, - render::PendingChanges& pendingChanges) { + render::Transaction& transaction) { _myMetaItem = scene->allocateID(); auto renderData = std::make_shared(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 scene, - render::PendingChanges& pendingChanges) { - pendingChanges.removeItem(_myMetaItem); + render::Transaction& transaction) { + 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(_myMetaItem, [](RenderableZoneEntityItemMeta& data) { + transaction.updateItem(_myMetaItem, [](RenderableZoneEntityItemMeta& data) { }); - scene->enqueuePendingChanges(pendingChanges); + scene->enqueueTransaction(transaction); } else { qCWarning(entitiesrenderer) << "RenderableZoneEntityItem::notifyBoundChanged(), Unexpected null scene, possibly during application shutdown"; } diff --git a/libraries/entities-renderer/src/RenderableZoneEntityItem.h b/libraries/entities-renderer/src/RenderableZoneEntityItem.h index 58aa951e64..bbb7ed0c01 100644 --- a/libraries/entities-renderer/src/RenderableZoneEntityItem.h +++ b/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 scene, render::PendingChanges& pendingChanges) override; - virtual void removeFromScene(EntityItemPointer self, std::shared_ptr scene, render::PendingChanges& pendingChanges) override; + virtual bool addToScene(EntityItemPointer self, std::shared_ptr scene, render::Transaction& transaction) override; + virtual void removeFromScene(EntityItemPointer self, std::shared_ptr scene, render::Transaction& transaction) override; private: virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); notifyBoundChanged(); } diff --git a/libraries/entities/src/EntityItem.h b/libraries/entities/src/EntityItem.h index b973d916e6..74d2daccbf 100644 --- a/libraries/entities/src/EntityItem.h +++ b/libraries/entities/src/EntityItem.h @@ -53,7 +53,7 @@ using EntityTreeElementExtraEncodeDataPointer = std::shared_ptr 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 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(); diff --git a/libraries/physics/src/PhysicalEntitySimulation.cpp b/libraries/physics/src/PhysicalEntitySimulation.cpp index 6f5b474810..72b0ef5623 100644 --- a/libraries/physics/src/PhysicalEntitySimulation.cpp +++ b/libraries/physics/src/PhysicalEntitySimulation.cpp @@ -96,7 +96,7 @@ void PhysicalEntitySimulation::changeEntityInternal(EntityItemPointer entity) { if (motionState) { if (!entity->shouldBePhysical()) { // the entity should be removed from the physical simulation - _pendingChanges.remove(motionState); + _transaction.remove(motionState); _physicalObjects.remove(motionState); _outgoingChanges.remove(motionState); _entitiesToRemoveFromPhysics.insert(entity); @@ -104,7 +104,7 @@ void PhysicalEntitySimulation::changeEntityInternal(EntityItemPointer entity) { _simpleKinematicEntities.insert(entity); } } else { - _pendingChanges.insert(motionState); + _transaction.insert(motionState); } } else if (entity->shouldBePhysical()) { // The intent is for this object to be in the PhysicsEngine, but it has no MotionState yet. @@ -148,7 +148,7 @@ void PhysicalEntitySimulation::clearEntitiesInternal() { _entitiesToRemoveFromPhysics.clear(); _entitiesToRelease.clear(); _entitiesToAddToPhysics.clear(); - _pendingChanges.clear(); + _transaction.clear(); _outgoingChanges.clear(); } @@ -170,7 +170,7 @@ void PhysicalEntitySimulation::getObjectsToRemoveFromPhysics(VectorOfMotionState EntityMotionState* motionState = static_cast(entity->getPhysicsInfo()); if (motionState) { - _pendingChanges.remove(motionState); + _transaction.remove(motionState); _outgoingChanges.remove(motionState); _physicalObjects.remove(motionState); result.push_back(motionState); @@ -246,18 +246,18 @@ void PhysicalEntitySimulation::getObjectsToAddToPhysics(VectorOfMotionStates& re void PhysicalEntitySimulation::setObjectsToChange(const VectorOfMotionStates& objectsToChange) { QMutexLocker lock(&_mutex); for (auto object : objectsToChange) { - _pendingChanges.insert(static_cast(object)); + _transaction.insert(static_cast(object)); } } void PhysicalEntitySimulation::getObjectsToChange(VectorOfMotionStates& result) { result.clear(); QMutexLocker lock(&_mutex); - for (auto stateItr : _pendingChanges) { + for (auto stateItr : _transaction) { EntityMotionState* motionState = &(*stateItr); result.push_back(motionState); } - _pendingChanges.clear(); + _transaction.clear(); } void PhysicalEntitySimulation::handleDeactivatedMotionStates(const VectorOfMotionStates& motionStates) { diff --git a/libraries/physics/src/PhysicalEntitySimulation.h b/libraries/physics/src/PhysicalEntitySimulation.h index 5f6185add3..c12f9316fc 100644 --- a/libraries/physics/src/PhysicalEntitySimulation.h +++ b/libraries/physics/src/PhysicalEntitySimulation.h @@ -67,7 +67,7 @@ private: SetOfEntities _entitiesToRelease; SetOfEntities _entitiesToAddToPhysics; - SetOfEntityMotionStates _pendingChanges; // EntityMotionStates already in PhysicsEngine that need their physics changed + SetOfEntityMotionStates _transaction; // EntityMotionStates already in PhysicsEngine that need their physics changed SetOfEntityMotionStates _outgoingChanges; // EntityMotionStates for which we may need to send updates to entity-server SetOfMotionStates _physicalObjects; // MotionStates of entities in PhysicsEngine diff --git a/libraries/render-utils/src/AnimDebugDraw.cpp b/libraries/render-utils/src/AnimDebugDraw.cpp index 6066385847..162745e76f 100644 --- a/libraries/render-utils/src/AnimDebugDraw.cpp +++ b/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; - pendingChanges.resetItem(_itemID, _animDebugDrawPayload); - scene->enqueuePendingChanges(pendingChanges); + render::Transaction transaction; + transaction.resetItem(_itemID, _animDebugDrawPayload); + 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; - pendingChanges.removeItem(_itemID); - scene->enqueuePendingChanges(pendingChanges); + render::Transaction transaction; + transaction.removeItem(_itemID); + scene->enqueueTransaction(transaction); } } @@ -317,8 +317,8 @@ void AnimDebugDraw::update() { return; } - render::PendingChanges pendingChanges; - pendingChanges.updateItem(_itemID, [&](AnimDebugDrawData& data) { + render::Transaction transaction; + transaction.updateItem(_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(i, (uint16_t)i);; } }); - scene->enqueuePendingChanges(pendingChanges); + scene->enqueueTransaction(transaction); } diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp index 3448c9e8da..c274d69af6 100644 --- a/libraries/render-utils/src/Model.cpp +++ b/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(itemID, [deleteGeometryCounter](ModelMeshPartPayload& data) { + transaction.updateItem(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()) { - pendingChanges.updateItem(itemID, [modelTransform, collisionMeshOffset](MeshPartPayload& data) { + foreach(auto itemID, self->_collisionRenderItemsMap.keys()) { + transaction.updateItem(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 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()) { - pendingChanges.resetItem(item, _collisionRenderItemsMap[item]); + foreach(auto item, _collisionRenderItemsMap.keys()) { + transaction.resetItem(item, _collisionRenderItemsMap[item]); } - scene->enqueuePendingChanges(pendingChanges); + scene->enqueueTransaction(transaction); } } @@ -554,19 +554,19 @@ void Model::setLayeredInFront(bool layered, std::shared_ptr 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()) { - pendingChanges.resetItem(item, _collisionRenderItemsMap[item]); + foreach(auto item, _collisionRenderItemsMap.keys()) { + transaction.resetItem(item, _collisionRenderItemsMap[item]); } - scene->enqueuePendingChanges(pendingChanges); + scene->enqueueTransaction(transaction); } } bool Model::addToScene(std::shared_ptr 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 scene, foreach (auto renderItem, _collisionRenderItems) { auto item = scene->allocateID(); auto renderPayload = std::make_shared(renderItem); - if (_collisionRenderItems.empty() && statusGetters.size()) { + if (_collisionRenderItems.empty() && statusGetters.size()) { renderPayload->addStatusGetters(statusGetters); } - pendingChanges.resetItem(item, renderPayload); - _collisionRenderItemsMap.insert(item, renderPayload); + transaction.resetItem(item, renderPayload); + _collisionRenderItemsMap.insert(item, renderPayload); } somethingAdded = !_collisionRenderItems.empty(); } @@ -595,10 +595,10 @@ bool Model::addToScene(std::shared_ptr scene, foreach(auto renderItem, _modelMeshRenderItems) { auto item = scene->allocateID(); auto renderPayload = std::make_shared(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 scene, return somethingAdded; } -void Model::removeFromScene(std::shared_ptr scene, render::PendingChanges& pendingChanges) { +void Model::removeFromScene(std::shared_ptr 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()) { - pendingChanges.removeItem(item); + foreach(auto item, _collisionRenderItemsMap.keys()) { + 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); - scene->enqueuePendingChanges(pendingChanges); + removeFromScene(scene, transaction); + 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(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; - if (addedPendingChanges) { - scene->enqueuePendingChanges(pendingChanges); - // NOTE: updateRender items enqueues identical pendingChanges (using a lambda) + _addedToScene = addedTransaction; + if (addedTransaction) { + scene->enqueueTransaction(transaction); + // 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. diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h index bb283cce1f..e852358bc4 100644 --- a/libraries/render-utils/src/Model.h +++ b/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 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 scene, - render::PendingChanges& pendingChanges, + render::Transaction& transaction, render::Item::Status::Getters& statusGetters); - void removeFromScene(std::shared_ptr scene, render::PendingChanges& pendingChanges); + void removeFromScene(std::shared_ptr scene, render::Transaction& transaction); bool isRenderable() const; bool isVisible() const { return _isVisible; } diff --git a/libraries/render/src/render/Scene.cpp b/libraries/render/src/render/Scene.cpp index 076879ae25..45685a9407 100644 --- a/libraries/render/src/render/Scene.cpp +++ b/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) { - _resetItems.insert(_resetItems.end(), changes._resetItems.begin(), changes._resetItems.end()); - _resetPayloads.insert(_resetPayloads.end(), changes._resetPayloads.begin(), changes._resetPayloads.end()); - _removedItems.insert(_removedItems.end(), changes._removedItems.begin(), changes._removedItems.end()); - _updatedItems.insert(_updatedItems.end(), changes._updatedItems.begin(), changes._updatedItems.end()); - _updateFunctors.insert(_updateFunctors.end(), changes._updateFunctors.begin(), changes._updateFunctors.end()); +void Transaction::merge(const Transaction& change) { + _resetItems.insert(_resetItems.end(), change._resetItems.begin(), change._resetItems.end()); + _resetPayloads.insert(_resetPayloads.end(), change._resetPayloads.begin(), change._resetPayloads.end()); + _removedItems.insert(_removedItems.end(), change._removedItems.begin(), change._removedItems.end()); + _updatedItems.insert(_updatedItems.end(), change._updatedItems.begin(), change._updatedItems.end()); + _updateFunctors.insert(_updateFunctors.end(), change._updateFunctors.begin(), change._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) { - _changeQueueMutex.lock(); - _changeQueue.push(pendingChanges); - _changeQueueMutex.unlock(); +void Scene::enqueueTransaction(const Transaction& transaction) { + _transactionQueueMutex.lock(); + _transactionQueue.push(transaction); + _transactionQueueMutex.unlock(); } -void consolidateChangeQueue(PendingChangesQueue& queue, PendingChanges& singleBatch) { +void consolidateTransaction(TransactionQueue& queue, Transaction& singleBatch) { while (!queue.empty()) { - const auto& pendingChanges = queue.front(); - singleBatch.merge(pendingChanges); + const auto& transaction = queue.front(); + singleBatch.merge(transaction); queue.pop(); }; } -void Scene::processPendingChangesQueue() { +void Scene::processTransactionQueue() { PROFILE_RANGE(render, __FUNCTION__); - PendingChanges consolidatedPendingChanges; + Transaction consolidatedTransaction; { - std::unique_lock lock(_changeQueueMutex); - consolidateChangeQueue(_changeQueue, consolidatedPendingChanges); + std::unique_lock lock(_transactionQueueMutex); + 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); diff --git a/libraries/render/src/render/Scene.h b/libraries/render/src/render/Scene.h index f2f8403dc9..d277f50650 100644 --- a/libraries/render/src/render/Scene.h +++ b/libraries/render/src/render/Scene.h @@ -19,10 +19,10 @@ namespace render { class Engine; -class PendingChanges { +class Transaction { public: - PendingChanges() {} - ~PendingChanges() {} + Transaction() {} + ~Transaction() {} void resetItem(ItemID id, const PayloadPointer& payload); void removeItem(ItemID id); @@ -34,7 +34,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& change); ItemIDs _resetItems; Payloads _resetPayloads; @@ -44,12 +44,12 @@ public: protected: }; -typedef std::queue PendingChangesQueue; +typedef std::queue TransactionQueue; // Scene is a container for Items -// Items are introduced, modified or erased in the scene through PendingChanges -// Once per Frame, the PendingChanges are all flushed +// Items are introduced, modified or erased in the scene through Transaction +// 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 { @@ -67,10 +67,10 @@ public: size_t getNumItems() const { return _numAllocatedItems.load(); } // Enqueue change batch to the scene - void enqueuePendingChanges(const PendingChanges& pendingChanges); + void enqueueTransaction(const Transaction& transaction); - // Process the penging changes equeued - void processPendingChangesQueue(); + // Process the pending transactions equeued + void processTransactionQueue(); // This next call are NOT threadsafe, you have to call them from the correct thread to avoid any potential issues @@ -91,8 +91,8 @@ protected: // Thread safe elements that can be accessed from anywhere std::atomic _IDAllocator{ 1 }; // first valid itemID will be One std::atomic _numAllocatedItems{ 1 }; // num of allocated items, matching the _items.size() - std::mutex _changeQueueMutex; - PendingChangesQueue _changeQueue; + std::mutex _transactionQueueMutex; + TransactionQueue _transactionQueue; // The actual database // database of items is protected for editing by a mutex diff --git a/libraries/script-engine/src/SceneScriptingInterface.h b/libraries/script-engine/src/SceneScriptingInterface.h index e8ea2e0217..7bc22eb3e6 100644 --- a/libraries/script-engine/src/SceneScriptingInterface.h +++ b/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) diff --git a/libraries/shared/src/SettingManager.cpp b/libraries/shared/src/SettingManager.cpp index 6c246d4cea..6acd758ad7 100644 --- a/libraries/shared/src/SettingManager.cpp +++ b/libraries/shared/src/SettingManager.cpp @@ -53,8 +53,8 @@ namespace Setting { const auto& key = handle->getKey(); withWriteLock([&] { QVariant loadedValue; - if (_pendingChanges.contains(key) && _pendingChanges[key] != UNSET_VALUE) { - loadedValue = _pendingChanges[key]; + if (_transaction.contains(key) && _transaction[key] != UNSET_VALUE) { + loadedValue = _transaction[key]; } else { loadedValue = value(key); } @@ -73,7 +73,7 @@ namespace Setting { } withWriteLock([&] { - _pendingChanges[key] = handleValue; + _transaction[key] = handleValue; }); } @@ -98,8 +98,8 @@ namespace Setting { void Manager::saveAll() { bool forceSync = false; withWriteLock([&] { - for (auto key : _pendingChanges.keys()) { - auto newValue = _pendingChanges[key]; + for (auto key : _transaction.keys()) { + auto newValue = _transaction[key]; auto savedValue = value(key, UNSET_VALUE); if (newValue == savedValue) { continue; @@ -112,7 +112,7 @@ namespace Setting { setValue(key, newValue); } } - _pendingChanges.clear(); + _transaction.clear(); }); if (forceSync) { diff --git a/libraries/shared/src/SettingManager.h b/libraries/shared/src/SettingManager.h index ffdd4ba42a..507e11edaa 100644 --- a/libraries/shared/src/SettingManager.h +++ b/libraries/shared/src/SettingManager.h @@ -47,7 +47,7 @@ namespace Setting { QHash _handles; QPointer _saveTimer = nullptr; const QVariant UNSET_VALUE { QUuid::createUuid() }; - QHash _pendingChanges; + QHash _transaction; friend class Interface; friend void cleanupPrivateInstance(); diff --git a/libraries/shared/src/Trace.cpp b/libraries/shared/src/Trace.cpp index 1e3d490a9c..d7feb65ff3 100644 --- a/libraries/shared/src/Trace.cpp +++ b/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; diff --git a/plugins/openvr/src/ViveControllerManager.cpp b/plugins/openvr/src/ViveControllerManager.cpp index 2e930c0fdc..d6e816346a 100644 --- a/plugins/openvr/src/ViveControllerManager.cpp +++ b/plugins/openvr/src/ViveControllerManager.cpp @@ -145,7 +145,7 @@ void ViveControllerManager::deactivate() { _registeredWithInputMapper = false; } -void ViveControllerManager::updateRendering(RenderArgs* args, render::ScenePointer scene, render::PendingChanges pendingChanges) { +void ViveControllerManager::updateRendering(RenderArgs* args, render::ScenePointer scene, render::Transaction transaction) { PerformanceTimer perfTimer("ViveControllerManager::updateRendering"); /* @@ -154,9 +154,9 @@ void ViveControllerManager::updateRendering(RenderArgs* args, render::ScenePoint //auto controllerPayloadPointer = ViveControllerManager::PayloadPointer(controllerPayload); //if (_leftHandRenderID == 0) { // _leftHandRenderID = scene->allocateID(); - // pendingChanges.resetItem(_leftHandRenderID, controllerPayloadPointer); + // transaction.resetItem(_leftHandRenderID, controllerPayloadPointer); //} - //pendingChanges.updateItem(_leftHandRenderID, ); + //transaction.updateItem(_leftHandRenderID, ); controller::Pose leftHand = _inputDevice->_poseStateMap[controller::StandardPoseChannel::LEFT_HAND]; diff --git a/plugins/openvr/src/ViveControllerManager.h b/plugins/openvr/src/ViveControllerManager.h index 3fb166c842..9b34f987ab 100644 --- a/plugins/openvr/src/ViveControllerManager.h +++ b/plugins/openvr/src/ViveControllerManager.h @@ -43,7 +43,7 @@ public: void pluginFocusOutEvent() override { _inputDevice->focusOutEvent(); } void pluginUpdate(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) override; - void updateRendering(RenderArgs* args, render::ScenePointer scene, render::PendingChanges pendingChanges); + void updateRendering(RenderArgs* args, render::ScenePointer scene, render::Transaction transaction); void setRenderControllers(bool renderControllers) { _renderControllers = renderControllers; } diff --git a/tests/render-perf/src/main.cpp b/tests/render-perf/src/main.cpp index 522fe79b10..b76776b1ab 100644 --- a/tests/render-perf/src/main.cpp +++ b/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(); auto backgroundRenderPayload = std::make_shared(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"); - _main3DScene->enqueuePendingChanges(pendingChanges); + PerformanceTimer perfTimer("SceneProcessTransaction"); + _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()->setGlobalLight(_sunSkyStage.getSunLight()); { - PerformanceTimer perfTimer("SceneProcessPendingChanges"); - _main3DScene->enqueuePendingChanges(pendingChanges); - _main3DScene->processPendingChangesQueue(); + PerformanceTimer perfTimer("SceneProcessTransaction"); + _main3DScene->enqueueTransaction(transaction); + _main3DScene->processTransactionQueue(); } // For now every frame pass the renderContext From 5629cf425ec5bb0b464ad8b3fed9908a1aecdad8 Mon Sep 17 00:00:00 2001 From: samcake Date: Wed, 5 Apr 2017 13:49:07 -0700 Subject: [PATCH 2/5] Cleaning up the files updated --- libraries/physics/src/PhysicalEntitySimulation.cpp | 14 +++++++------- libraries/physics/src/PhysicalEntitySimulation.h | 2 +- libraries/render/src/render/Scene.cpp | 12 ++++++------ libraries/render/src/render/Scene.h | 2 +- libraries/shared/src/SettingManager.cpp | 12 ++++++------ libraries/shared/src/SettingManager.h | 2 +- 6 files changed, 22 insertions(+), 22 deletions(-) diff --git a/libraries/physics/src/PhysicalEntitySimulation.cpp b/libraries/physics/src/PhysicalEntitySimulation.cpp index 72b0ef5623..6f5b474810 100644 --- a/libraries/physics/src/PhysicalEntitySimulation.cpp +++ b/libraries/physics/src/PhysicalEntitySimulation.cpp @@ -96,7 +96,7 @@ void PhysicalEntitySimulation::changeEntityInternal(EntityItemPointer entity) { if (motionState) { if (!entity->shouldBePhysical()) { // the entity should be removed from the physical simulation - _transaction.remove(motionState); + _pendingChanges.remove(motionState); _physicalObjects.remove(motionState); _outgoingChanges.remove(motionState); _entitiesToRemoveFromPhysics.insert(entity); @@ -104,7 +104,7 @@ void PhysicalEntitySimulation::changeEntityInternal(EntityItemPointer entity) { _simpleKinematicEntities.insert(entity); } } else { - _transaction.insert(motionState); + _pendingChanges.insert(motionState); } } else if (entity->shouldBePhysical()) { // The intent is for this object to be in the PhysicsEngine, but it has no MotionState yet. @@ -148,7 +148,7 @@ void PhysicalEntitySimulation::clearEntitiesInternal() { _entitiesToRemoveFromPhysics.clear(); _entitiesToRelease.clear(); _entitiesToAddToPhysics.clear(); - _transaction.clear(); + _pendingChanges.clear(); _outgoingChanges.clear(); } @@ -170,7 +170,7 @@ void PhysicalEntitySimulation::getObjectsToRemoveFromPhysics(VectorOfMotionState EntityMotionState* motionState = static_cast(entity->getPhysicsInfo()); if (motionState) { - _transaction.remove(motionState); + _pendingChanges.remove(motionState); _outgoingChanges.remove(motionState); _physicalObjects.remove(motionState); result.push_back(motionState); @@ -246,18 +246,18 @@ void PhysicalEntitySimulation::getObjectsToAddToPhysics(VectorOfMotionStates& re void PhysicalEntitySimulation::setObjectsToChange(const VectorOfMotionStates& objectsToChange) { QMutexLocker lock(&_mutex); for (auto object : objectsToChange) { - _transaction.insert(static_cast(object)); + _pendingChanges.insert(static_cast(object)); } } void PhysicalEntitySimulation::getObjectsToChange(VectorOfMotionStates& result) { result.clear(); QMutexLocker lock(&_mutex); - for (auto stateItr : _transaction) { + for (auto stateItr : _pendingChanges) { EntityMotionState* motionState = &(*stateItr); result.push_back(motionState); } - _transaction.clear(); + _pendingChanges.clear(); } void PhysicalEntitySimulation::handleDeactivatedMotionStates(const VectorOfMotionStates& motionStates) { diff --git a/libraries/physics/src/PhysicalEntitySimulation.h b/libraries/physics/src/PhysicalEntitySimulation.h index c12f9316fc..5f6185add3 100644 --- a/libraries/physics/src/PhysicalEntitySimulation.h +++ b/libraries/physics/src/PhysicalEntitySimulation.h @@ -67,7 +67,7 @@ private: SetOfEntities _entitiesToRelease; SetOfEntities _entitiesToAddToPhysics; - SetOfEntityMotionStates _transaction; // EntityMotionStates already in PhysicsEngine that need their physics changed + SetOfEntityMotionStates _pendingChanges; // EntityMotionStates already in PhysicsEngine that need their physics changed SetOfEntityMotionStates _outgoingChanges; // EntityMotionStates for which we may need to send updates to entity-server SetOfMotionStates _physicalObjects; // MotionStates of entities in PhysicsEngine diff --git a/libraries/render/src/render/Scene.cpp b/libraries/render/src/render/Scene.cpp index 45685a9407..537d8c1337 100644 --- a/libraries/render/src/render/Scene.cpp +++ b/libraries/render/src/render/Scene.cpp @@ -35,12 +35,12 @@ void Transaction::updateItem(ItemID id, const UpdateFunctorPointer& functor) { _updateFunctors.push_back(functor); } -void Transaction::merge(const Transaction& change) { - _resetItems.insert(_resetItems.end(), change._resetItems.begin(), change._resetItems.end()); - _resetPayloads.insert(_resetPayloads.end(), change._resetPayloads.begin(), change._resetPayloads.end()); - _removedItems.insert(_removedItems.end(), change._removedItems.begin(), change._removedItems.end()); - _updatedItems.insert(_updatedItems.end(), change._updatedItems.begin(), change._updatedItems.end()); - _updateFunctors.insert(_updateFunctors.end(), change._updateFunctors.begin(), change._updateFunctors.end()); +void Transaction::merge(const Transaction& transaction) { + _resetItems.insert(_resetItems.end(), transaction._resetItems.begin(), transaction._resetItems.end()); + _resetPayloads.insert(_resetPayloads.end(), transaction._resetPayloads.begin(), transaction._resetPayloads.end()); + _removedItems.insert(_removedItems.end(), transaction._removedItems.begin(), transaction._removedItems.end()); + _updatedItems.insert(_updatedItems.end(), transaction._updatedItems.begin(), transaction._updatedItems.end()); + _updateFunctors.insert(_updateFunctors.end(), transaction._updateFunctors.begin(), transaction._updateFunctors.end()); } Scene::Scene(glm::vec3 origin, float size) : diff --git a/libraries/render/src/render/Scene.h b/libraries/render/src/render/Scene.h index d277f50650..dcbd87b74a 100644 --- a/libraries/render/src/render/Scene.h +++ b/libraries/render/src/render/Scene.h @@ -34,7 +34,7 @@ public: void updateItem(ItemID id, const UpdateFunctorPointer& functor); void updateItem(ItemID id) { updateItem(id, nullptr); } - void merge(const Transaction& change); + void merge(const Transaction& transaction); ItemIDs _resetItems; Payloads _resetPayloads; diff --git a/libraries/shared/src/SettingManager.cpp b/libraries/shared/src/SettingManager.cpp index 6acd758ad7..6c246d4cea 100644 --- a/libraries/shared/src/SettingManager.cpp +++ b/libraries/shared/src/SettingManager.cpp @@ -53,8 +53,8 @@ namespace Setting { const auto& key = handle->getKey(); withWriteLock([&] { QVariant loadedValue; - if (_transaction.contains(key) && _transaction[key] != UNSET_VALUE) { - loadedValue = _transaction[key]; + if (_pendingChanges.contains(key) && _pendingChanges[key] != UNSET_VALUE) { + loadedValue = _pendingChanges[key]; } else { loadedValue = value(key); } @@ -73,7 +73,7 @@ namespace Setting { } withWriteLock([&] { - _transaction[key] = handleValue; + _pendingChanges[key] = handleValue; }); } @@ -98,8 +98,8 @@ namespace Setting { void Manager::saveAll() { bool forceSync = false; withWriteLock([&] { - for (auto key : _transaction.keys()) { - auto newValue = _transaction[key]; + for (auto key : _pendingChanges.keys()) { + auto newValue = _pendingChanges[key]; auto savedValue = value(key, UNSET_VALUE); if (newValue == savedValue) { continue; @@ -112,7 +112,7 @@ namespace Setting { setValue(key, newValue); } } - _transaction.clear(); + _pendingChanges.clear(); }); if (forceSync) { diff --git a/libraries/shared/src/SettingManager.h b/libraries/shared/src/SettingManager.h index 507e11edaa..ffdd4ba42a 100644 --- a/libraries/shared/src/SettingManager.h +++ b/libraries/shared/src/SettingManager.h @@ -47,7 +47,7 @@ namespace Setting { QHash _handles; QPointer _saveTimer = nullptr; const QVariant UNSET_VALUE { QUuid::createUuid() }; - QHash _transaction; + QHash _pendingChanges; friend class Interface; friend void cleanupPrivateInstance(); From 1a9005ed8bc439fa93f037896175d1e345dcc6d7 Mon Sep 17 00:00:00 2001 From: samcake Date: Wed, 5 Apr 2017 13:57:40 -0700 Subject: [PATCH 3/5] Avoid unexpected changes --- interface/src/Application.cpp | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-) diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index 9c41a78805..342d325f58 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -5786,22 +5786,10 @@ void Application::toggleRunningScriptsWidget() const { } void Application::showScriptLogs() { - auto tabletScriptingInterface = DependencyManager::get(); - auto tablet = dynamic_cast(tabletScriptingInterface->getTablet("com.highfidelity.interface.tablet.system")); auto scriptEngines = DependencyManager::get(); QUrl defaultScriptsLoc = defaultScriptsLocation(); defaultScriptsLoc.setPath(defaultScriptsLoc.path() + "developer/debugging/debugWindow.js"); - - if (tablet->getToolbarMode()) { - scriptEngines->loadScript(defaultScriptsLoc.toString()); - } else { - QQuickItem* tabletRoot = tablet->getTabletRoot(); - if (!tabletRoot && !isHMDMode()) { - scriptEngines->loadScript(defaultScriptsLoc.toString()); - } else { - tablet->pushOntoStack("../../hifi/dialogs/TabletDebugWindow.qml"); - } - } + scriptEngines->loadScript(defaultScriptsLoc.toString()); } void Application::showAssetServerWidget(QString filePath) { From 026e7bc249d04fe12c5918f5ab5ec398564fb3f7 Mon Sep 17 00:00:00 2001 From: samcake Date: Wed, 5 Apr 2017 14:17:26 -0700 Subject: [PATCH 4/5] Add a description of the Transaction class --- libraries/render/src/render/Scene.h | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/libraries/render/src/render/Scene.h b/libraries/render/src/render/Scene.h index dcbd87b74a..cca72bb3c6 100644 --- a/libraries/render/src/render/Scene.h +++ b/libraries/render/src/render/Scene.h @@ -19,6 +19,15 @@ namespace render { class Engine; +// 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: Transaction() {} From 8267db6ce5220422cc7d2e47568593eeb6c8005a Mon Sep 17 00:00:00 2001 From: samcake Date: Wed, 5 Apr 2017 14:19:00 -0700 Subject: [PATCH 5/5] Add a description of the Transaction class --- libraries/render/src/render/Scene.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libraries/render/src/render/Scene.h b/libraries/render/src/render/Scene.h index cca72bb3c6..09a725205d 100644 --- a/libraries/render/src/render/Scene.h +++ b/libraries/render/src/render/Scene.h @@ -75,10 +75,10 @@ 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 enqueueTransaction(const Transaction& transaction); - // Process the pending transactions equeued + // Process the pending transactions queued void processTransactionQueue(); // This next call are NOT threadsafe, you have to call them from the correct thread to avoid any potential issues