Delete domain entities only

interface/src/Application.cpp

@@ -6755,7 +6755,7 @@ void Application::updateWindowTitle() const {
     DependencyManager::get< MessagesClient >()->sendLocalMessage("Toolbar-DomainChanged", "");
 }
 
-void Application::clearDomainOctreeDetails() {
+void Application::clearDomainOctreeDetails(bool clearAll) {
     // before we delete all entities get MyAvatar's AvatarEntityData ready
     getMyAvatar()->prepareAvatarEntityDataForReload();
 
@@ -6774,7 +6774,8 @@ void Application::clearDomainOctreeDetails() {
     });
 
     // reset the model renderer
-    getEntities()->clear();
+    qDebug() << "-----> clearAll: " << clearAll;
+    clearAll ? getEntities()->clear() : getEntities()->clearDomainEntities();
 
     auto skyStage = DependencyManager::get<SceneScriptingInterface>()->getSkyStage();
 
@@ -6812,7 +6813,7 @@ void Application::goToErrorDomainURL(QUrl errorDomainURL) {
 void Application::resettingDomain() {
     _notifiedPacketVersionMismatchThisDomain = false;
 
-    clearDomainOctreeDetails();
+    clearDomainOctreeDetails(false);
 }
 
 void Application::nodeAdded(SharedNodePointer node) const {
@@ -6898,7 +6899,7 @@ void Application::nodeKilled(SharedNodePointer node) {
         QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "audioMixerKilled");
     } else if (node->getType() == NodeType::EntityServer) {
         // we lost an entity server, clear all of the domain octree details
-        clearDomainOctreeDetails();
+        clearDomainOctreeDetails(false);
     } else if (node->getType() == NodeType::AssetServer) {
         // asset server going away - check if we have the asset browser showing
 

interface/src/Application.h

@@ -469,7 +469,7 @@ private slots:
     void onDesktopRootItemCreated(QQuickItem* qmlContext);
     void onDesktopRootContextCreated(QQmlContext* qmlContext);
     void showDesktop();
-    void clearDomainOctreeDetails();
+    void clearDomainOctreeDetails(bool clearAll = true);
     void onAboutToQuit();
     void onPresent(quint32 frameCount);
 

libraries/entities-renderer/src/EntityTreeRenderer.cpp

@@ -197,9 +197,8 @@ void EntityTreeRenderer::resetEntitiesScriptEngine() {
     });
 }
 
-void EntityTreeRenderer::clear() {
-    leaveAllEntities();
-
+void EntityTreeRenderer::stopEntityScripts() {
+     leaveAllEntities();
     // unload and stop the engine
     if (_entitiesScriptEngine) {
         // do this here (instead of in deleter) to avoid marshalling unload signals back to this thread
@@ -211,6 +210,42 @@ void EntityTreeRenderer::clear() {
     if (_wantScripts && !_shuttingDown) {
         resetEntitiesScriptEngine();
     }
+}
+
+void EntityTreeRenderer::clearDomainEntities() {
+    stopEntityScripts();
+
+    std::unordered_map<EntityItemID, EntityRendererPointer> savedEntities;
+    // remove all entities from the scene
+    _space->clear();
+    auto scene = _viewState->getMain3DScene();
+    if (scene) {
+        render::Transaction transaction;
+        for (const auto& entry :  _entitiesInScene) {
+            const auto& renderer = entry.second;
+            const EntityItemPointer& entityItem = renderer->getEntity();
+            if (entityItem->isDomainEntity()) {
+                renderer->removeFromScene(scene, transaction);
+            } else {
+                savedEntities[entry.first] = entry.second;
+            }
+        }
+        scene->enqueueTransaction(transaction);
+    } else {
+        qCWarning(entitiesrenderer) << "EntitityTreeRenderer::clear(), Unexpected null scene, possibly during application shutdown";
+    }
+    _entitiesInScene.clear();
+    _renderablesToUpdate = savedEntities;
+    _entitiesInScene = savedEntities;
+
+    // reset the zone to the default (while we load the next scene)
+    _layeredZones.clear();
+
+    OctreeProcessor::clearDomainEntities();
+}
+
+void EntityTreeRenderer::clear() {
+    stopEntityScripts();
 
     // remove all entities from the scene
     _space->clear();

libraries/entities-renderer/src/EntityTreeRenderer.h

@@ -86,6 +86,7 @@ public:
     virtual void init() override;
 
     /// clears the tree
+    virtual void clearDomainEntities() override;
     virtual void clear() override;
 
     /// reloads the entity scripts, calling unload and preload
@@ -161,6 +162,7 @@ private:
     bool findBestZoneAndMaybeContainingEntities(QVector<EntityItemID>* entitiesContainingAvatar = nullptr);
 
     bool applyLayeredZones();
+    void stopEntityScripts();
 
     void checkAndCallPreload(const EntityItemID& entityID, bool reload = false, bool unloadFirst = false);
 

libraries/entities/src/EntityTree.cpp

@@ -70,6 +70,39 @@ OctreeElementPointer EntityTree::createNewElement(unsigned char* octalCode) {
     return std::static_pointer_cast<OctreeElement>(newElement);
 }
 
+void EntityTree::eraseDomainEntities() {
+    emit clearingEntities();
+
+    if (_simulation) {
+        _simulation->clearEntities();
+    }
+    _staleProxies.clear();
+    QHash<EntityItemID, EntityItemPointer> localMap;
+    localMap.swap(_entityMap);
+    QHash<EntityItemID, EntityItemPointer> savedEntities;
+    this->withWriteLock([&] {
+        foreach(EntityItemPointer entity, localMap) {
+            EntityTreeElementPointer element = entity->getElement();
+            if (element) {
+                element->cleanupDomainEntities();
+            }
+
+            if (!entity->isDomainEntity()) {
+                savedEntities[entity->getEntityItemID()] = entity;
+            }
+        }
+    });
+    localMap.clear();
+    _entityMap = savedEntities;
+
+    resetClientEditStats();
+    clearDeletedEntities();
+
+    {
+        QWriteLocker locker(&_needsParentFixupLock);
+        _needsParentFixup.clear();
+    }
+}
 void EntityTree::eraseAllOctreeElements(bool createNewRoot) {
     emit clearingEntities();
 

libraries/entities/src/EntityTree.h

@@ -74,6 +74,8 @@ public:
         return std::static_pointer_cast<EntityTreeElement>(_rootElement);
     }
 
+
+    virtual void eraseDomainEntities() override;
     virtual void eraseAllOctreeElements(bool createNewRoot = true) override;
 
     virtual void readBitstreamToTree(const unsigned char* bitstream,

libraries/entities/src/EntityTreeElement.cpp

@@ -683,6 +683,23 @@ EntityItemPointer EntityTreeElement::getEntityWithEntityItemID(const EntityItemI
     return foundEntity;
 }
 
+void EntityTreeElement::cleanupDomainEntities() {
+    withWriteLock([&] {
+        EntityItems savedEntities;
+        foreach(EntityItemPointer entity, _entityItems) {
+            if (entity->isDomainEntity()) {
+                entity->preDelete();
+                entity->_element = NULL;
+            } else {
+                savedEntities.push_back(entity);
+            }
+        }
+
+        _entityItems = savedEntities;
+    });
+    bumpChangedContent();
+}
+
 void EntityTreeElement::cleanupEntities() {
     withWriteLock([&] {
         foreach(EntityItemPointer entity, _entityItems) {

libraries/entities/src/EntityTreeElement.h

@@ -189,6 +189,7 @@ public:
     EntityItemPointer getEntityWithEntityItemID(const EntityItemID& id) const;
     void getEntitiesInside(const AACube& box, QVector<EntityItemPointer>& foundEntities);
 
+    void cleanupDomainEntities();
     void cleanupEntities(); /// called by EntityTree on cleanup this will free all entities
     bool removeEntityItem(EntityItemPointer entity, bool deletion = false);
 

libraries/octree/src/Octree.h

@@ -149,6 +149,7 @@ public:
 
     OctreeElementPointer getRoot() { return _rootElement; }
 
+    virtual void eraseDomainEntities() { _isDirty = true; };
     virtual void eraseAllOctreeElements(bool createNewRoot = true);
 
     virtual void readBitstreamToTree(const unsigned char* bitstream,  uint64_t bufferSizeBytes, ReadBitstreamToTreeParams& args);

libraries/octree/src/OctreeProcessor.cpp

@@ -197,6 +197,14 @@ void OctreeProcessor::processDatagram(ReceivedMessage& message, SharedNodePointe
     }
 }
 
+
+void OctreeProcessor::clearDomainEntities() {
+    if (_tree) {
+        _tree->withWriteLock([&] {
+            _tree->eraseDomainEntities();
+        });
+    }
+}
 void OctreeProcessor::clear() {
     if (_tree) {
         _tree->withWriteLock([&] {

libraries/octree/src/OctreeProcessor.h

@@ -43,6 +43,7 @@ public:
     virtual void init();
 
     /// clears the tree
+    virtual void clearDomainEntities();
     virtual void clear();
 
     float getAverageElementsPerPacket() const { return _elementsPerPacket.getAverage(); }