From 51669e1ac304ff3b01b7a31cc0ad0f653227499f Mon Sep 17 00:00:00 2001 From: Brad Hefta-Gaub Date: Fri, 11 Oct 2019 11:06:10 -0700 Subject: [PATCH] Revert "DEV-1811: apply deletion rules to linked entities" --- interface/src/InterfaceParentFinder.cpp | 4 + interface/src/avatar/AvatarManager.cpp | 20 +- interface/src/avatar/MyAvatar.cpp | 61 ++- interface/src/avatar/OtherAvatar.cpp | 8 +- interface/src/ui/AvatarCertifyBanner.cpp | 11 +- .../src/avatars-renderer/Avatar.cpp | 12 +- libraries/avatars/src/AvatarData.cpp | 5 +- libraries/avatars/src/AvatarData.h | 2 +- .../src/EntityTreeRenderer.cpp | 14 +- .../src/EntityTreeRenderer.h | 1 - .../src/RenderableEntityItem.cpp | 5 +- .../entities/src/DeleteEntityOperator.cpp | 9 - libraries/entities/src/DeleteEntityOperator.h | 1 - libraries/entities/src/EntityEditFilters.cpp | 2 +- libraries/entities/src/EntityEditFilters.h | 2 +- .../entities/src/EntityEditPacketSender.cpp | 8 +- libraries/entities/src/EntityItem.cpp | 44 +-- libraries/entities/src/EntityItem.h | 7 +- .../entities/src/EntityItemProperties.cpp | 2 +- .../entities/src/EntityScriptingInterface.cpp | 87 ++--- libraries/entities/src/EntitySimulation.cpp | 96 ++--- libraries/entities/src/EntitySimulation.h | 46 ++- libraries/entities/src/EntityTree.cpp | 354 ++++++++---------- libraries/entities/src/EntityTree.h | 19 +- libraries/entities/src/EntityTreeElement.cpp | 2 +- .../entities/src/SimpleEntitySimulation.cpp | 17 +- .../entities/src/SimpleEntitySimulation.h | 10 +- libraries/physics/src/EntityMotionState.cpp | 24 +- libraries/physics/src/EntityMotionState.h | 2 +- .../physics/src/PhysicalEntitySimulation.cpp | 111 ++---- .../physics/src/PhysicalEntitySimulation.h | 24 +- libraries/shared/src/PhysicsHelpers.cpp | 6 +- libraries/shared/src/SpatialParentFinder.h | 2 +- tests/octree/src/ModelTests.cpp | 7 +- 34 files changed, 455 insertions(+), 570 deletions(-) diff --git a/interface/src/InterfaceParentFinder.cpp b/interface/src/InterfaceParentFinder.cpp index 0f1c8876a9..33328f54cc 100644 --- a/interface/src/InterfaceParentFinder.cpp +++ b/interface/src/InterfaceParentFinder.cpp @@ -45,6 +45,10 @@ SpatiallyNestableWeakPointer InterfaceParentFinder::find(QUuid parentID, bool& s success = true; return parent; } + if (parentID == AVATAR_SELF_ID) { + success = true; + return avatarManager->getMyAvatar(); + } success = false; return parent; diff --git a/interface/src/avatar/AvatarManager.cpp b/interface/src/avatar/AvatarManager.cpp index 32e725388c..553033f394 100755 --- a/interface/src/avatar/AvatarManager.cpp +++ b/interface/src/avatar/AvatarManager.cpp @@ -543,8 +543,26 @@ void AvatarManager::removeDeadAvatarEntities(const SetOfEntities& deadEntities) for (auto entity : deadEntities) { QUuid entityOwnerID = entity->getOwningAvatarID(); AvatarSharedPointer avatar = getAvatarBySessionID(entityOwnerID); + const bool REQUIRES_REMOVAL_FROM_TREE = false; if (avatar) { - avatar->clearAvatarEntity(entity->getID()); + avatar->clearAvatarEntity(entity->getID(), REQUIRES_REMOVAL_FROM_TREE); + } + if (entityTree && entity->isMyAvatarEntity()) { + entityTree->withWriteLock([&] { + // We only need to delete the direct children (rather than the descendants) because + // when the child is deleted, it will take care of its own children. If the child + // is also an avatar-entity, we'll end up back here. If it's not, the entity-server + // will take care of it in the usual way. + entity->forEachChild([&](SpatiallyNestablePointer child) { + EntityItemPointer childEntity = std::dynamic_pointer_cast(child); + if (childEntity) { + entityTree->deleteEntity(childEntity->getID(), true, true); + if (avatar) { + avatar->clearAvatarEntity(childEntity->getID(), REQUIRES_REMOVAL_FROM_TREE); + } + } + }); + }); } } } diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp index 386e15b041..6c9b62cfcf 100644 --- a/interface/src/avatar/MyAvatar.cpp +++ b/interface/src/avatar/MyAvatar.cpp @@ -1577,8 +1577,7 @@ void MyAvatar::storeAvatarEntityDataPayload(const QUuid& entityID, const QByteAr } void MyAvatar::clearAvatarEntity(const QUuid& entityID, bool requiresRemovalFromTree) { - // NOTE: the requiresRemovalFromTree argument is unused - AvatarData::clearAvatarEntity(entityID); + AvatarData::clearAvatarEntity(entityID, requiresRemovalFromTree); _avatarEntitiesLock.withWriteLock([&] { _cachedAvatarEntityBlobsToDelete.push_back(entityID); }); @@ -1586,12 +1585,7 @@ void MyAvatar::clearAvatarEntity(const QUuid& entityID, bool requiresRemovalFrom void MyAvatar::sanitizeAvatarEntityProperties(EntityItemProperties& properties) const { properties.setEntityHostType(entity::HostType::AVATAR); - - // Note: we store AVATAR_SELF_ID in EntityItem::_owningAvatarID and we usually - // store the actual sessionUUID in EntityItemProperties::_owningAvatarID (for JS - // consumption, for example). However at this context we are preparing properties - // for outgoing packet, in which case we use AVATAR_SELF_ID. - properties.setOwningAvatarID(AVATAR_SELF_ID); + properties.setOwningAvatarID(getID()); // there's no entity-server to tell us we're the simulation owner, so always set the // simulationOwner to the owningAvatarID and a high priority. @@ -1648,16 +1642,13 @@ void MyAvatar::handleChangedAvatarEntityData() { // move the lists to minimize lock time std::vector cachedBlobsToDelete; std::vector cachedBlobsToUpdate; - QSet idsToDelete; + std::vector entitiesToDelete; std::vector entitiesToAdd; std::vector entitiesToUpdate; _avatarEntitiesLock.withWriteLock([&] { cachedBlobsToDelete = std::move(_cachedAvatarEntityBlobsToDelete); cachedBlobsToUpdate = std::move(_cachedAvatarEntityBlobsToAddOrUpdate); - foreach (auto id, _entitiesToDelete) { - idsToDelete.insert(id); - } - _entitiesToDelete.clear(); + entitiesToDelete = std::move(_entitiesToDelete); entitiesToAdd = std::move(_entitiesToAdd); entitiesToUpdate = std::move(_entitiesToUpdate); }); @@ -1675,7 +1666,7 @@ void MyAvatar::handleChangedAvatarEntityData() { }; // remove delete-add and delete-update overlap - for (const auto& id : idsToDelete) { + for (const auto& id : entitiesToDelete) { removeAllInstancesHelper(id, cachedBlobsToUpdate); removeAllInstancesHelper(id, entitiesToAdd); removeAllInstancesHelper(id, entitiesToUpdate); @@ -1689,9 +1680,11 @@ void MyAvatar::handleChangedAvatarEntityData() { } // DELETE real entities - entityTree->withWriteLock([&] { - entityTree->deleteEntitiesByID(idsToDelete); - }); + for (const auto& id : entitiesToDelete) { + entityTree->withWriteLock([&] { + entityTree->deleteEntity(id); + }); + } // ADD real entities EntityEditPacketSender* packetSender = qApp->getEntityEditPacketSender(); @@ -1804,7 +1797,7 @@ void MyAvatar::handleChangedAvatarEntityData() { // we have a client traits handler // flag removed entities as deleted so that changes are sent next frame _avatarEntitiesLock.withWriteLock([&] { - for (const auto& id : idsToDelete) { + for (const auto& id : entitiesToDelete) { if (_packedAvatarEntityData.find(id) != _packedAvatarEntityData.end()) { _clientTraitsHandler->markInstancedTraitDeleted(AvatarTraits::AvatarEntity, id); } @@ -2533,11 +2526,18 @@ bool isWearableEntity(const EntityItemPointer& entity) { void MyAvatar::removeWornAvatarEntity(const EntityItemID& entityID) { auto treeRenderer = DependencyManager::get(); EntityTreePointer entityTree = treeRenderer ? treeRenderer->getTree() : nullptr; + if (entityTree) { auto entity = entityTree->findEntityByID(entityID); if (entity && isWearableEntity(entity)) { - treeRenderer->deleteEntity(entityID); - clearAvatarEntity(entityID); + entityTree->withWriteLock([&entityID, &entityTree] { + // remove this entity first from the entity tree + entityTree->deleteEntity(entityID, true, true); + }); + + // remove the avatar entity from our internal list + // (but indicate it doesn't need to be pulled from the tree) + clearAvatarEntity(entityID, false); } } } @@ -2547,16 +2547,8 @@ void MyAvatar::clearWornAvatarEntities() { _avatarEntitiesLock.withReadLock([&] { avatarEntityIDs = _packedAvatarEntityData.keys(); }); - auto treeRenderer = DependencyManager::get(); - EntityTreePointer entityTree = treeRenderer ? treeRenderer->getTree() : nullptr; - if (entityTree) { - for (auto entityID : avatarEntityIDs) { - auto entity = entityTree->findEntityByID(entityID); - if (entity && isWearableEntity(entity)) { - treeRenderer->deleteEntity(entityID); - clearAvatarEntity(entityID); - } - } + for (auto entityID : avatarEntityIDs) { + removeWornAvatarEntity(entityID); } } @@ -4009,10 +4001,6 @@ float MyAvatar::getGravity() { void MyAvatar::setSessionUUID(const QUuid& sessionUUID) { QUuid oldSessionID = getSessionUUID(); Avatar::setSessionUUID(sessionUUID); - bool sendPackets = !DependencyManager::get()->getSessionUUID().isNull(); - if (!sendPackets) { - return; - } QUuid newSessionID = getSessionUUID(); if (newSessionID != oldSessionID) { auto treeRenderer = DependencyManager::get(); @@ -4022,6 +4010,7 @@ void MyAvatar::setSessionUUID(const QUuid& sessionUUID) { _avatarEntitiesLock.withReadLock([&] { avatarEntityIDs = _packedAvatarEntityData.keys(); }); + bool sendPackets = !DependencyManager::get()->getSessionUUID().isNull(); EntityEditPacketSender* packetSender = qApp->getEntityEditPacketSender(); entityTree->withWriteLock([&] { for (const auto& entityID : avatarEntityIDs) { @@ -4029,9 +4018,11 @@ void MyAvatar::setSessionUUID(const QUuid& sessionUUID) { if (!entity) { continue; } + // update OwningAvatarID so entity can be identified as "ours" later + entity->setOwningAvatarID(newSessionID); // NOTE: each attached AvatarEntity already have the correct updated parentID // via magic in SpatiallyNestable, hence we check against newSessionID - if (entity->getParentID() == newSessionID) { + if (sendPackets && entity->getParentID() == newSessionID) { // but when we have a real session and the AvatarEntity is parented to MyAvatar // we need to update the "packedAvatarEntityData" sent to the avatar-mixer // because it contains a stale parentID somewhere deep inside diff --git a/interface/src/avatar/OtherAvatar.cpp b/interface/src/avatar/OtherAvatar.cpp index 5a9d20bd81..5673c2443f 100755 --- a/interface/src/avatar/OtherAvatar.cpp +++ b/interface/src/avatar/OtherAvatar.cpp @@ -558,17 +558,11 @@ void OtherAvatar::handleChangedAvatarEntityData() { _avatarEntitiesLock.withReadLock([&] { packedAvatarEntityData = _packedAvatarEntityData; }); - QSet idsToDelete; foreach (auto entityID, recentlyRemovedAvatarEntities) { if (!packedAvatarEntityData.contains(entityID)) { - idsToDelete.insert(entityID); + entityTree->deleteEntity(entityID, true, true); } } - if (!idsToDelete.empty()) { - bool force = true; - bool ignoreWarnings = true; - entityTree->deleteEntitiesByID(idsToDelete, force, ignoreWarnings); - } // TODO: move this outside of tree lock // remove stale data hashes diff --git a/interface/src/ui/AvatarCertifyBanner.cpp b/interface/src/ui/AvatarCertifyBanner.cpp index 3fe2ed2027..5101188885 100644 --- a/interface/src/ui/AvatarCertifyBanner.cpp +++ b/interface/src/ui/AvatarCertifyBanner.cpp @@ -62,7 +62,16 @@ void AvatarCertifyBanner::show(const QUuid& avatarID) { void AvatarCertifyBanner::clear() { if (_active) { - DependencyManager::get()->deleteEntity(_bannerID); + auto entityTreeRenderer = DependencyManager::get(); + EntityTreePointer entityTree = entityTreeRenderer->getTree(); + if (!entityTree) { + return; + } + + entityTree->withWriteLock([&] { + entityTree->deleteEntity(_bannerID); + }); + _active = false; } } diff --git a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp index 54b9334540..7a2ea5321f 100644 --- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp +++ b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp @@ -357,13 +357,11 @@ void Avatar::removeAvatarEntitiesFromTree() { _avatarEntitiesLock.withReadLock([&] { avatarEntityIDs = _packedAvatarEntityData.keys(); }); - QSet ids; - foreach (auto id, avatarEntityIDs) { - ids.insert(id); - } - bool force = true; - bool ignoreWarnings = true; - entityTree->deleteEntitiesByID(ids, force, ignoreWarnings); // locks tree + entityTree->withWriteLock([&] { + for (const auto& entityID : avatarEntityIDs) { + entityTree->deleteEntity(entityID, true, true); + } + }); } } diff --git a/libraries/avatars/src/AvatarData.cpp b/libraries/avatars/src/AvatarData.cpp index 25a9543b18..710bfb8d2a 100755 --- a/libraries/avatars/src/AvatarData.cpp +++ b/libraries/avatars/src/AvatarData.cpp @@ -2985,12 +2985,15 @@ void AvatarData::updateAvatarEntity(const QUuid& entityID, const QByteArray& ent } void AvatarData::clearAvatarEntity(const QUuid& entityID, bool requiresRemovalFromTree) { - // NOTE: requiresRemovalFromTree is unused + bool removedEntity = false; + _avatarEntitiesLock.withWriteLock([this, &removedEntity, &entityID] { removedEntity = _packedAvatarEntityData.remove(entityID); }); + insertRemovedEntityID(entityID); + if (removedEntity && _clientTraitsHandler) { // we have a client traits handler, so we need to mark this removed instance trait as deleted // so that changes are sent next frame diff --git a/libraries/avatars/src/AvatarData.h b/libraries/avatars/src/AvatarData.h index abb21bd926..df0783ef4b 100755 --- a/libraries/avatars/src/AvatarData.h +++ b/libraries/avatars/src/AvatarData.h @@ -1158,7 +1158,7 @@ public: /**jsdoc * @function Avatar.clearAvatarEntity * @param {Uuid} entityID - The entity ID. - * @param {boolean} [requiresRemovalFromTree=true] - unused + * @param {boolean} [requiresRemovalFromTree=true] - Requires removal from tree. * @deprecated This function is deprecated and will be removed. */ Q_INVOKABLE virtual void clearAvatarEntity(const QUuid& entityID, bool requiresRemovalFromTree = true); diff --git a/libraries/entities-renderer/src/EntityTreeRenderer.cpp b/libraries/entities-renderer/src/EntityTreeRenderer.cpp index fa18783b98..ab3f4c5243 100644 --- a/libraries/entities-renderer/src/EntityTreeRenderer.cpp +++ b/libraries/entities-renderer/src/EntityTreeRenderer.cpp @@ -226,7 +226,7 @@ void EntityTreeRenderer::stopDomainAndNonOwnedEntities() { EntityItemPointer entityItem = getTree()->findEntityByEntityItemID(entityID); if (entityItem && !entityItem->getScript().isEmpty()) { - if (!(entityItem->isLocalEntity() || entityItem->isMyAvatarEntity())) { + if (!(entityItem->isLocalEntity() || (entityItem->isAvatarEntity() && entityItem->getOwningAvatarID() == getTree()->getMyAvatarSessionUUID()))) { if (_currentEntitiesInside.contains(entityID)) { _entitiesScriptEngine->callEntityScriptMethod(entityID, "leaveEntity"); } @@ -240,6 +240,7 @@ void EntityTreeRenderer::stopDomainAndNonOwnedEntities() { void EntityTreeRenderer::clearDomainAndNonOwnedEntities() { stopDomainAndNonOwnedEntities(); + auto sessionUUID = getTree()->getMyAvatarSessionUUID(); std::unordered_map savedEntities; std::unordered_set savedRenderables; // remove all entities from the scene @@ -248,7 +249,7 @@ void EntityTreeRenderer::clearDomainAndNonOwnedEntities() { for (const auto& entry : _entitiesInScene) { const auto& renderer = entry.second; const EntityItemPointer& entityItem = renderer->getEntity(); - if (!(entityItem->isLocalEntity() || entityItem->isMyAvatarEntity())) { + if (!(entityItem->isLocalEntity() || (entityItem->isAvatarEntity() && entityItem->getOwningAvatarID() == sessionUUID))) { fadeOutRenderable(renderer); } else { savedEntities[entry.first] = entry.second; @@ -260,7 +261,6 @@ void EntityTreeRenderer::clearDomainAndNonOwnedEntities() { _renderablesToUpdate = savedRenderables; _entitiesInScene = savedEntities; - auto sessionUUID = getTree()->getMyAvatarSessionUUID(); if (_layeredZones.clearDomainAndNonOwnedZones(sessionUUID)) { applyLayeredZones(); } @@ -683,7 +683,7 @@ void EntityTreeRenderer::leaveDomainAndNonOwnedEntities() { QSet currentEntitiesInsideToSave; foreach (const EntityItemID& entityID, _currentEntitiesInside) { EntityItemPointer entityItem = getTree()->findEntityByEntityItemID(entityID); - if (!(entityItem->isLocalEntity() || entityItem->isMyAvatarEntity())) { + if (!(entityItem->isLocalEntity() || (entityItem->isAvatarEntity() && entityItem->getOwningAvatarID() == getTree()->getMyAvatarSessionUUID()))) { emit leaveEntity(entityID); if (_entitiesScriptEngine) { _entitiesScriptEngine->callEntityScriptMethod(entityID, "leaveEntity"); @@ -1221,7 +1221,7 @@ bool EntityTreeRenderer::LayeredZones::clearDomainAndNonOwnedZones(const QUuid& auto it = begin(); while (it != end()) { auto zone = it->zone.lock(); - if (!zone || !(zone->isLocalEntity() || zone->isMyAvatarEntity())) { + if (!zone || !(zone->isLocalEntity() || (zone->isAvatarEntity() && zone->getOwningAvatarID() == sessionUUID))) { zonesChanged = true; it = erase(it); } else { @@ -1362,10 +1362,6 @@ EntityItemPointer EntityTreeRenderer::getEntity(const EntityItemID& id) { return result; } -void EntityTreeRenderer::deleteEntity(const EntityItemID& id) const { - DependencyManager::get()->deleteEntity(id); -} - void EntityTreeRenderer::onEntityChanged(const EntityItemID& id) { _changedEntitiesGuard.withWriteLock([&] { _changedEntities.insert(id); diff --git a/libraries/entities-renderer/src/EntityTreeRenderer.h b/libraries/entities-renderer/src/EntityTreeRenderer.h index 6a5152b219..6dbaedc123 100644 --- a/libraries/entities-renderer/src/EntityTreeRenderer.h +++ b/libraries/entities-renderer/src/EntityTreeRenderer.h @@ -118,7 +118,6 @@ public: void setProxyWindow(const EntityItemID& id, QWindow* proxyWindow); void setCollisionSound(const EntityItemID& id, const SharedSoundPointer& sound); EntityItemPointer getEntity(const EntityItemID& id); - void deleteEntity(const EntityItemID& id) const; void onEntityChanged(const EntityItemID& id); // Access the workload Space diff --git a/libraries/entities-renderer/src/RenderableEntityItem.cpp b/libraries/entities-renderer/src/RenderableEntityItem.cpp index 0e5dab6524..fb3d2f1bf5 100644 --- a/libraries/entities-renderer/src/RenderableEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableEntityItem.cpp @@ -43,7 +43,6 @@ const Transform& EntityRenderer::getModelTransform() const { void EntityRenderer::makeStatusGetters(const EntityItemPointer& entity, Item::Status::Getters& statusGetters) { auto nodeList = DependencyManager::get(); - // DANGER: nodeList->getSessionUUID() will return null id when not connected to domain. const QUuid& myNodeID = nodeList->getSessionUUID(); statusGetters.push_back([entity]() -> render::Item::Status::Value { @@ -104,9 +103,9 @@ void EntityRenderer::makeStatusGetters(const EntityItemPointer& entity, Item::St (unsigned char)render::Item::Status::Icon::HAS_ACTIONS); }); - statusGetters.push_back([entity] () -> render::Item::Status::Value { + statusGetters.push_back([entity, myNodeID] () -> render::Item::Status::Value { if (entity->isAvatarEntity()) { - if (entity->isMyAvatarEntity()) { + if (entity->getOwningAvatarID() == myNodeID) { return render::Item::Status::Value(1.0f, render::Item::Status::Value::GREEN, (unsigned char)render::Item::Status::Icon::ENTITY_HOST_TYPE); } else { diff --git a/libraries/entities/src/DeleteEntityOperator.cpp b/libraries/entities/src/DeleteEntityOperator.cpp index a4ecb532e5..1dca171ae3 100644 --- a/libraries/entities/src/DeleteEntityOperator.cpp +++ b/libraries/entities/src/DeleteEntityOperator.cpp @@ -53,15 +53,6 @@ void DeleteEntityOperator::addEntityIDToDeleteList(const EntityItemID& searchEnt } } -void DeleteEntityOperator::addEntityToDeleteList(const EntityItemPointer& entity) { - assert(entity && entity->getElement()); - EntityToDeleteDetails details; - details.entity = entity; - details.containingElement = entity->getElement(); - details.cube = details.containingElement->getAACube(); - _entitiesToDelete << details; - _lookingCount++; -} // does this entity tree element contain the old entity bool DeleteEntityOperator::subTreeContainsSomeEntitiesToDelete(const OctreeElementPointer& element) { diff --git a/libraries/entities/src/DeleteEntityOperator.h b/libraries/entities/src/DeleteEntityOperator.h index 1449e2caad..3b3ee2a868 100644 --- a/libraries/entities/src/DeleteEntityOperator.h +++ b/libraries/entities/src/DeleteEntityOperator.h @@ -42,7 +42,6 @@ public: ~DeleteEntityOperator(); void addEntityIDToDeleteList(const EntityItemID& searchEntityID); - void addEntityToDeleteList(const EntityItemPointer& entity); virtual bool preRecursion(const OctreeElementPointer& element) override; virtual bool postRecursion(const OctreeElementPointer& element) override; diff --git a/libraries/entities/src/EntityEditFilters.cpp b/libraries/entities/src/EntityEditFilters.cpp index 16dace0fc8..a222ca8216 100644 --- a/libraries/entities/src/EntityEditFilters.cpp +++ b/libraries/entities/src/EntityEditFilters.cpp @@ -43,7 +43,7 @@ QList EntityEditFilters::getZonesByPosition(glm::vec3& position) { } bool EntityEditFilters::filter(glm::vec3& position, EntityItemProperties& propertiesIn, EntityItemProperties& propertiesOut, - bool& wasChanged, EntityTree::FilterType filterType, EntityItemID& itemID, const EntityItemPointer& existingEntity) { + bool& wasChanged, EntityTree::FilterType filterType, EntityItemID& itemID, EntityItemPointer& existingEntity) { // get the ids of all the zones (plus the global entity edit filter) that the position // lies within diff --git a/libraries/entities/src/EntityEditFilters.h b/libraries/entities/src/EntityEditFilters.h index 69fd920998..cb99c97762 100644 --- a/libraries/entities/src/EntityEditFilters.h +++ b/libraries/entities/src/EntityEditFilters.h @@ -55,7 +55,7 @@ public: void removeFilter(EntityItemID entityID); bool filter(glm::vec3& position, EntityItemProperties& propertiesIn, EntityItemProperties& propertiesOut, bool& wasChanged, - EntityTree::FilterType filterType, EntityItemID& entityID, const EntityItemPointer& existingEntity); + EntityTree::FilterType filterType, EntityItemID& entityID, EntityItemPointer& existingEntity); signals: void filterAdded(EntityItemID id, bool success); diff --git a/libraries/entities/src/EntityEditPacketSender.cpp b/libraries/entities/src/EntityEditPacketSender.cpp index aaaf7d645a..dbb3ab076e 100644 --- a/libraries/entities/src/EntityEditPacketSender.cpp +++ b/libraries/entities/src/EntityEditPacketSender.cpp @@ -73,12 +73,8 @@ void EntityEditPacketSender::queueEditEntityMessage(PacketType type, if (properties.getEntityHostType() == entity::HostType::AVATAR) { if (!_myAvatar) { qCWarning(entities) << "Suppressing entity edit message: cannot send avatar entity edit with no myAvatar"; - } else if (properties.getOwningAvatarID() == _myAvatar->getID() || properties.getOwningAvatarID() == AVATAR_SELF_ID) { - // this is a local avatar-entity --> update our avatar-data rather than sending to the entity-server - // Note: we store AVATAR_SELF_ID in EntityItem::_owningAvatarID and we usually - // store the actual sessionUUID in EntityItemProperties::_owningAvatarID. - // However at this context we check for both cases just in case. Really we just want to know - // where to route the data: entity-server or avatar-mixer. + } else if (properties.getOwningAvatarID() == _myAvatar->getID()) { + // this is an avatar-based entity --> update our avatar-data rather than sending to the entity-server queueEditAvatarEntityMessage(entityTree, entityItemID); } else { qCWarning(entities) << "Suppressing entity edit message: cannot send avatar entity edit for another avatar"; diff --git a/libraries/entities/src/EntityItem.cpp b/libraries/entities/src/EntityItem.cpp index 15aacd934c..598ac17510 100644 --- a/libraries/entities/src/EntityItem.cpp +++ b/libraries/entities/src/EntityItem.cpp @@ -1347,7 +1347,7 @@ EntityItemProperties EntityItem::getProperties(const EntityPropertyFlags& desire COPY_ENTITY_PROPERTY_TO_PROPERTIES(created, getCreated); COPY_ENTITY_PROPERTY_TO_PROPERTIES(lastEditedBy, getLastEditedBy); COPY_ENTITY_PROPERTY_TO_PROPERTIES(entityHostType, getEntityHostType); - COPY_ENTITY_PROPERTY_TO_PROPERTIES(owningAvatarID, getOwningAvatarIDForProperties); + COPY_ENTITY_PROPERTY_TO_PROPERTIES(owningAvatarID, getOwningAvatarID); COPY_ENTITY_PROPERTY_TO_PROPERTIES(queryAACube, getQueryAACube); COPY_ENTITY_PROPERTY_TO_PROPERTIES(canCastShadow, getCanCastShadow); COPY_ENTITY_PROPERTY_TO_PROPERTIES(isVisibleInSecondaryCamera, isVisibleInSecondaryCamera); @@ -3203,7 +3203,6 @@ void EntityItem::somethingChangedNotification() { }); } -// static void EntityItem::retrieveMarketplacePublicKey() { QNetworkAccessManager& networkAccessManager = NetworkAccessManager::getInstance(); QNetworkRequest networkRequest; @@ -3235,26 +3234,6 @@ void EntityItem::retrieveMarketplacePublicKey() { }); } -void EntityItem::collectChildrenForDelete(SetOfEntities& entitiesToDelete, SetOfEntities& domainEntities, const QUuid& sessionID) const { - // Deleting an entity has consequences for its children, however there are rules dictating what can be deleted. - // This method helps enforce those rules for the children of entity (not for this entity). - for (SpatiallyNestablePointer child : getChildren()) { - if (child && child->getNestableType() == NestableType::Entity) { - EntityItemPointer childEntity = std::static_pointer_cast(child); - // NOTE: null sessionID means "collect ALL known entities", else we only collect: local-entities and authorized avatar-entities - if (sessionID.isNull() || childEntity->isLocalEntity() || (childEntity->isAvatarEntity() && - (childEntity->isMyAvatarEntity() || childEntity->getOwningAvatarID() == sessionID))) { - if (entitiesToDelete.find(childEntity) == entitiesToDelete.end()) { - entitiesToDelete.insert(childEntity); - childEntity->collectChildrenForDelete(entitiesToDelete, domainEntities, sessionID); - } - } else if (childEntity->isDomainEntity()) { - domainEntities.insert(childEntity); - } - } - } -} - void EntityItem::setSpaceIndex(int32_t index) { assert(_spaceIndex == -1); _spaceIndex = index; @@ -3419,7 +3398,6 @@ void EntityItem::prepareForSimulationOwnershipBid(EntityItemProperties& properti properties.setSimulationOwner(Physics::getSessionUUID(), priority); setPendingOwnershipPriority(priority); - // ANDREW TODO: figure out if it would be OK to NOT bother set these properties here properties.setEntityHostType(getEntityHostType()); properties.setOwningAvatarID(getOwningAvatarID()); setLastBroadcast(now); // for debug/physics status icons @@ -3431,27 +3409,9 @@ bool EntityItem::isWearable() const { } bool EntityItem::isMyAvatarEntity() const { - return _hostType == entity::HostType::AVATAR && AVATAR_SELF_ID == _owningAvatarID; + return _hostType == entity::HostType::AVATAR && Physics::getSessionUUID() == _owningAvatarID; }; -QUuid EntityItem::getOwningAvatarIDForProperties() const { - if (isMyAvatarEntity()) { - // NOTE: we always store AVATAR_SELF_ID for MyAvatar's avatar entities, - // however for EntityItemProperties to be consumed by outside contexts (e.g. JS) - // we use the actual "sessionUUID" which is conveniently cached in the Physics namespace - return Physics::getSessionUUID(); - } - return _owningAvatarID; -} - -void EntityItem::setOwningAvatarID(const QUuid& owningAvatarID) { - if (!owningAvatarID.isNull() && owningAvatarID == Physics::getSessionUUID()) { - _owningAvatarID = AVATAR_SELF_ID; - } else { - _owningAvatarID = owningAvatarID; - } -} - void EntityItem::addGrab(GrabPointer grab) { enableNoBootstrap(); SpatiallyNestable::addGrab(grab); diff --git a/libraries/entities/src/EntityItem.h b/libraries/entities/src/EntityItem.h index fef198c006..3274379ee9 100644 --- a/libraries/entities/src/EntityItem.h +++ b/libraries/entities/src/EntityItem.h @@ -18,7 +18,6 @@ #include #include -#include #include // for EncodeBitstreamParams class #include // for OctreeElement::AppendState @@ -50,7 +49,6 @@ typedef std::shared_ptr EntityTreePointer; typedef std::shared_ptr EntityDynamicPointer; typedef std::shared_ptr EntityTreeElementPointer; using EntityTreeElementExtraEncodeDataPointer = std::shared_ptr; -using SetOfEntities = QSet; #define DONT_ALLOW_INSTANTIATION virtual void pureVirtualFunctionPlaceHolder() = 0; #define ALLOW_INSTANTIATION virtual void pureVirtualFunctionPlaceHolder() override { }; @@ -516,8 +514,7 @@ public: // if this entity is an avatar entity, which avatar is it associated with? QUuid getOwningAvatarID() const { return _owningAvatarID; } - QUuid getOwningAvatarIDForProperties() const; - void setOwningAvatarID(const QUuid& owningAvatarID); + virtual void setOwningAvatarID(const QUuid& owningAvatarID) { _owningAvatarID = owningAvatarID; } virtual bool wantsHandControllerPointerEvents() const { return false; } virtual bool wantsKeyboardFocus() const { return false; } @@ -543,8 +540,6 @@ public: static QString _marketplacePublicKey; static void retrieveMarketplacePublicKey(); - void collectChildrenForDelete(SetOfEntities& entitiesToDelete, SetOfEntities& domainEntities, const QUuid& sessionID) const; - float getBoundingRadius() const { return _boundingRadius; } void setSpaceIndex(int32_t index); int32_t getSpaceIndex() const { return _spaceIndex; } diff --git a/libraries/entities/src/EntityItemProperties.cpp b/libraries/entities/src/EntityItemProperties.cpp index ae2e83affe..2b8f2b4c14 100644 --- a/libraries/entities/src/EntityItemProperties.cpp +++ b/libraries/entities/src/EntityItemProperties.cpp @@ -3936,7 +3936,7 @@ bool EntityItemProperties::decodeCloneEntityMessage(const QByteArray& buffer, in processedBytes = 0; if (NUM_BYTES_RFC4122_UUID * 2 > packetLength) { - qCDebug(entities) << "EntityItemProperties::decodeCloneEntityMessage().... bailing because not enough bytes in buffer"; + qCDebug(entities) << "EntityItemProperties::processEraseMessageDetails().... bailing because not enough bytes in buffer"; return false; // bail to prevent buffer overflow } diff --git a/libraries/entities/src/EntityScriptingInterface.cpp b/libraries/entities/src/EntityScriptingInterface.cpp index 1ca6a5804f..3305d9ba00 100644 --- a/libraries/entities/src/EntityScriptingInterface.cpp +++ b/libraries/entities/src/EntityScriptingInterface.cpp @@ -480,11 +480,17 @@ QUuid EntityScriptingInterface::addEntityInternal(const EntityItemProperties& pr _activityTracking.addedEntityCount++; + auto nodeList = DependencyManager::get(); + auto sessionID = nodeList->getSessionUUID(); + EntityItemProperties propertiesWithSimID = properties; propertiesWithSimID.setEntityHostType(entityHostType); if (entityHostType == entity::HostType::AVATAR) { - // only allow adding our own avatar entities from script - propertiesWithSimID.setOwningAvatarID(AVATAR_SELF_ID); + if (sessionID.isNull()) { + // null sessionID is unacceptable in this case + sessionID = AVATAR_SELF_ID; + } + propertiesWithSimID.setOwningAvatarID(sessionID); } else if (entityHostType == entity::HostType::LOCAL) { // For now, local entities are always collisionless // TODO: create a separate, local physics simulation that just handles local entities (and MyAvatar?) @@ -492,8 +498,6 @@ QUuid EntityScriptingInterface::addEntityInternal(const EntityItemProperties& pr } // the created time will be set in EntityTree::addEntity by recordCreationTime() - auto nodeList = DependencyManager::get(); - auto sessionID = nodeList->getSessionUUID(); propertiesWithSimID.setLastEditedBy(sessionID); bool scalesWithParent = propertiesWithSimID.getScalesWithParent(); @@ -801,7 +805,7 @@ QUuid EntityScriptingInterface::editEntity(const QUuid& id, const EntityItemProp return; } - if (entity->isAvatarEntity() && !entity->isMyAvatarEntity()) { + if (entity->isAvatarEntity() && entity->getOwningAvatarID() != sessionID && entity->getOwningAvatarID() != AVATAR_SELF_ID) { // don't edit other avatar's avatarEntities properties = EntityItemProperties(); return; @@ -966,52 +970,43 @@ void EntityScriptingInterface::deleteEntity(const QUuid& id) { _activityTracking.deletedEntityCount++; - if (!_entityTree) { - return; - } - EntityItemID entityID(id); + bool shouldSendDeleteToServer = true; // If we have a local entity tree set, then also update it. - SetOfEntities entitiesToDeleteImmediately; - SetOfEntities domainEntities; - _entityTree->withWriteLock([&] { - EntityItemPointer entity = _entityTree->findEntityByEntityItemID(entityID); - if (entity) { - if (entity->isAvatarEntity() && !entity->isMyAvatarEntity()) { - // don't delete other avatar's avatarEntities - return; - } - if (entity->getLocked()) { - return; - } + if (_entityTree) { + _entityTree->withWriteLock([&] { + EntityItemPointer entity = _entityTree->findEntityByEntityItemID(entityID); + if (entity) { - // Deleting an entity has consequences for linked children: some can be deleted but others can't. - // Local- and my-avatar-entities can be deleted immediately, but other-avatar-entities can't be deleted - // by this context, and domain-entity deletes must rountrip through the entity-server for authorization. - // So we recurse down the linked hierarchy and snarf children into two categories: - // (a) entitiesToDeleteImmediately and (b) domainEntntities. - if (entity->isDomainEntity()) { - domainEntities.insert(entity); - } else { - entitiesToDeleteImmediately.insert(entity); - const auto sessionID = DependencyManager::get()->getSessionUUID(); - entity->collectChildrenForDelete(entitiesToDeleteImmediately, domainEntities, sessionID); - } - if (!entitiesToDeleteImmediately.empty()) { - _entityTree->deleteEntitiesByPointer(entitiesToDeleteImmediately); - } - } - }); + auto nodeList = DependencyManager::get(); + const QUuid myNodeID = nodeList->getSessionUUID(); + if (entity->isAvatarEntity() && entity->getOwningAvatarID() != myNodeID) { + // don't delete other avatar's avatarEntities + shouldSendDeleteToServer = false; + return; + } - foreach (auto entity, entitiesToDeleteImmediately) { - if (entity->isMyAvatarEntity()) { - getEntityPacketSender()->getMyAvatar()->clearAvatarEntity(entityID, false); - } + if (entity->getLocked()) { + shouldSendDeleteToServer = false; + } else { + // only delete local entities, server entities will round trip through the server filters + if (!entity->isDomainEntity() || _entityTree->isServerlessMode()) { + shouldSendDeleteToServer = false; + _entityTree->deleteEntity(entityID); + + if (entity->isAvatarEntity() && getEntityPacketSender()->getMyAvatar()) { + getEntityPacketSender()->getMyAvatar()->clearAvatarEntity(entityID, false); + } + } + } + } + }); } - // finally ask entity-server to delete domainEntities - foreach (auto entity, domainEntities) { - getEntityPacketSender()->queueEraseEntityMessage(entity->getID()); + + // if at this point, we know the id, and we should still delete the entity, send the update to the entity server + if (shouldSendDeleteToServer) { + getEntityPacketSender()->queueEraseEntityMessage(entityID); } } @@ -1676,7 +1671,7 @@ bool EntityScriptingInterface::actionWorker(const QUuid& entityID, return; } - if (entity->isAvatarEntity() && !entity->isMyAvatarEntity()) { + if (entity->isAvatarEntity() && entity->getOwningAvatarID() != myNodeID) { return; } diff --git a/libraries/entities/src/EntitySimulation.cpp b/libraries/entities/src/EntitySimulation.cpp index 5576f21cc5..9f81572a4a 100644 --- a/libraries/entities/src/EntitySimulation.cpp +++ b/libraries/entities/src/EntitySimulation.cpp @@ -19,36 +19,41 @@ void EntitySimulation::setEntityTree(EntityTreePointer tree) { if (_entityTree && _entityTree != tree) { - _entitiesToSort.clear(); - _simpleKinematicEntities.clear(); - _changedEntities.clear(); - _entitiesToUpdate.clear(); _mortalEntities.clear(); _nextExpiry = std::numeric_limits::max(); + _entitiesToUpdate.clear(); + _entitiesToSort.clear(); + _simpleKinematicEntities.clear(); } _entityTree = tree; } void EntitySimulation::updateEntities() { - PerformanceTimer perfTimer("EntitySimulation::updateEntities"); QMutexLocker lock(&_mutex); uint64_t now = usecTimestampNow(); + PerformanceTimer perfTimer("EntitySimulation::updateEntities"); // these methods may accumulate entries in _entitiesToBeDeleted expireMortalEntities(now); callUpdateOnEntitiesThatNeedIt(now); moveSimpleKinematics(now); + updateEntitiesInternal(now); sortEntitiesThatMoved(); - processDeadEntities(); } -void EntitySimulation::removeEntityFromInternalLists(EntityItemPointer entity) { - // remove from all internal lists except _deadEntitiesToRemoveFromTree +void EntitySimulation::takeDeadEntities(SetOfEntities& entitiesToDelete) { + QMutexLocker lock(&_mutex); + entitiesToDelete.swap(_deadEntities); + _deadEntities.clear(); +} + +void EntitySimulation::removeEntityInternal(EntityItemPointer entity) { + // remove from all internal lists except _deadEntities + _mortalEntities.remove(entity); + _entitiesToUpdate.remove(entity); _entitiesToSort.remove(entity); _simpleKinematicEntities.remove(entity); _allEntities.remove(entity); - _entitiesToUpdate.remove(entity); - _mortalEntities.remove(entity); entity->setSimulated(false); } @@ -57,9 +62,10 @@ void EntitySimulation::prepareEntityForDelete(EntityItemPointer entity) { assert(entity->isDead()); if (entity->isSimulated()) { QMutexLocker lock(&_mutex); - removeEntityFromInternalLists(entity); + entity->clearActions(getThisPointer()); + removeEntityInternal(entity); if (entity->getElement()) { - _deadEntitiesToRemoveFromTree.insert(entity); + _deadEntities.insert(entity); _entityTree->cleanupCloneIDs(entity->getEntityItemID()); } } @@ -143,7 +149,10 @@ void EntitySimulation::sortEntitiesThatMoved() { _entitiesToSort.clear(); } -void EntitySimulation::addEntityToInternalLists(EntityItemPointer entity) { +void EntitySimulation::addEntity(EntityItemPointer entity) { + QMutexLocker lock(&_mutex); + assert(entity); + entity->deserializeActions(); if (entity->isMortal()) { _mortalEntities.insert(entity); uint64_t expiry = entity->getExpiry(); @@ -154,14 +163,10 @@ void EntitySimulation::addEntityToInternalLists(EntityItemPointer entity) { if (entity->needsToCallUpdate()) { _entitiesToUpdate.insert(entity); } + addEntityInternal(entity); + _allEntities.insert(entity); entity->setSimulated(true); -} - -void EntitySimulation::addEntity(EntityItemPointer entity) { - QMutexLocker lock(&_mutex); - assert(entity); - addEntityToInternalLists(entity); // DirtyFlags are used to signal changes to entities that have already been added, // so we can clear them for this entity which has just been added. @@ -213,14 +218,16 @@ void EntitySimulation::processChangedEntity(const EntityItemPointer& entity) { void EntitySimulation::clearEntities() { QMutexLocker lock(&_mutex); - _entitiesToSort.clear(); - _simpleKinematicEntities.clear(); - _changedEntities.clear(); - _allEntities.clear(); - _deadEntitiesToRemoveFromTree.clear(); - _entitiesToUpdate.clear(); _mortalEntities.clear(); _nextExpiry = std::numeric_limits::max(); + _entitiesToUpdate.clear(); + _entitiesToSort.clear(); + _simpleKinematicEntities.clear(); + + clearEntitiesInternal(); + + _allEntities.clear(); + _deadEntities.clear(); } void EntitySimulation::moveSimpleKinematics(uint64_t now) { @@ -256,22 +263,25 @@ void EntitySimulation::moveSimpleKinematics(uint64_t now) { } } -void EntitySimulation::processDeadEntities() { - if (_deadEntitiesToRemoveFromTree.empty()) { - return; - } - SetOfEntities entitiesToDeleteImmediately; - // NOTE: dummyList will be empty because this base-class implementation is only used server-side - // for which ATM we only process domain-entities, and since we are passing nullSessionID for authorization - // EntityItem::collectChildrenForDelete() will not collect domain-entities into this side list. - SetOfEntities dummyList; - QUuid nullSessionID; - foreach (auto entity, _deadEntitiesToRemoveFromTree) { - entitiesToDeleteImmediately.insert(entity); - entity->collectChildrenForDelete(entitiesToDeleteImmediately, dummyList, nullSessionID); - } - if (_entityTree) { - _entityTree->deleteEntitiesByPointer(entitiesToDeleteImmediately); - } - _deadEntitiesToRemoveFromTree.clear(); +void EntitySimulation::addDynamic(EntityDynamicPointer dynamic) { + QMutexLocker lock(&_dynamicsMutex); + _dynamicsToAdd += dynamic; +} + +void EntitySimulation::removeDynamic(const QUuid dynamicID) { + QMutexLocker lock(&_dynamicsMutex); + _dynamicsToRemove += dynamicID; +} + +void EntitySimulation::removeDynamics(QList dynamicIDsToRemove) { + QMutexLocker lock(&_dynamicsMutex); + foreach(QUuid uuid, dynamicIDsToRemove) { + _dynamicsToRemove.insert(uuid); + } +} + +void EntitySimulation::applyDynamicChanges() { + QMutexLocker lock(&_dynamicsMutex); + _dynamicsToAdd.clear(); + _dynamicsToRemove.clear(); } diff --git a/libraries/entities/src/EntitySimulation.h b/libraries/entities/src/EntitySimulation.h index 646e5a0f67..1dd0369561 100644 --- a/libraries/entities/src/EntitySimulation.h +++ b/libraries/entities/src/EntitySimulation.h @@ -16,14 +16,17 @@ #include #include +#include #include #include +#include "EntityDynamicInterface.h" #include "EntityItem.h" #include "EntityTree.h" using EntitySimulationPointer = std::shared_ptr; +using SetOfEntities = QSet; using VectorOfEntities = QVector; // the EntitySimulation needs to know when these things change on an entity, @@ -44,8 +47,8 @@ const int DIRTY_SIMULATION_FLAGS = class EntitySimulation : public QObject, public std::enable_shared_from_this { public: - EntitySimulation() : _mutex(QMutex::Recursive), _nextExpiry(std::numeric_limits::max()), _entityTree(nullptr) { } - virtual ~EntitySimulation() { setEntityTree(nullptr); } + EntitySimulation() : _mutex(QMutex::Recursive), _entityTree(NULL), _nextExpiry(std::numeric_limits::max()) { } + virtual ~EntitySimulation() { setEntityTree(NULL); } inline EntitySimulationPointer getThisPointer() const { return std::const_pointer_cast(shared_from_this()); @@ -54,12 +57,12 @@ public: /// \param tree pointer to EntityTree which is stored internally void setEntityTree(EntityTreePointer tree); - virtual void updateEntities(); + void updateEntities(); - // FIXME: remove these - virtual void addDynamic(EntityDynamicPointer dynamic) {} - virtual void removeDynamic(const QUuid dynamicID) {} - virtual void applyDynamicChanges() {}; + virtual void addDynamic(EntityDynamicPointer dynamic); + virtual void removeDynamic(const QUuid dynamicID); + virtual void removeDynamics(QList dynamicIDsToRemove); + virtual void applyDynamicChanges(); /// \param entity pointer to EntityItem to be added /// \sideeffect sets relevant backpointers in entity, but maybe later when appropriate data structures are locked @@ -69,22 +72,27 @@ public: /// call this whenever an entity was changed from some EXTERNAL event (NOT by the EntitySimulation itself) void changeEntity(EntityItemPointer entity); - virtual void clearEntities(); + void clearEntities(); void moveSimpleKinematics(uint64_t now); EntityTreePointer getEntityTree() { return _entityTree; } + virtual void takeDeadEntities(SetOfEntities& entitiesToDelete); + + /// \param entity pointer to EntityItem that needs to be put on the entitiesToDelete list and removed from others. virtual void prepareEntityForDelete(EntityItemPointer entity); void processChangedEntities(); - virtual void queueEraseDomainEntities(const SetOfEntities& domainEntities) const { } protected: - virtual void addEntityToInternalLists(EntityItemPointer entity); - virtual void removeEntityFromInternalLists(EntityItemPointer entity); + // These pure virtual methods are protected because they are not to be called will-nilly. The base class + // calls them in the right places. + virtual void updateEntitiesInternal(uint64_t now) = 0; + virtual void addEntityInternal(EntityItemPointer entity) = 0; + virtual void removeEntityInternal(EntityItemPointer entity); virtual void processChangedEntity(const EntityItemPointer& entity); - virtual void processDeadEntities(); + virtual void clearEntitiesInternal() = 0; void expireMortalEntities(uint64_t now); void callUpdateOnEntitiesThatNeedIt(uint64_t now); @@ -94,21 +102,27 @@ protected: SetOfEntities _entitiesToSort; // entities moved by simulation (and might need resort in EntityTree) SetOfEntities _simpleKinematicEntities; // entities undergoing non-colliding kinematic motion - SetOfEntities _deadEntitiesToRemoveFromTree; + QList _dynamicsToAdd; + QSet _dynamicsToRemove; + QMutex _dynamicsMutex { QMutex::Recursive }; + +protected: + SetOfEntities _deadEntities; // dead entities that might still be in the _entityTree private: void moveSimpleKinematics(); + // back pointer to EntityTree structure + EntityTreePointer _entityTree; + // We maintain multiple lists, each for its distinct purpose. // An entity may be in more than one list. std::unordered_set _changedEntities; // all changes this frame SetOfEntities _allEntities; // tracks all entities added the simulation - SetOfEntities _entitiesToUpdate; // entities that need to call EntityItem::update() SetOfEntities _mortalEntities; // entities that have an expiry uint64_t _nextExpiry; - // back pointer to EntityTree structure - EntityTreePointer _entityTree; + SetOfEntities _entitiesToUpdate; // entities that need to call EntityItem::update() }; #endif // hifi_EntitySimulation_h diff --git a/libraries/entities/src/EntityTree.cpp b/libraries/entities/src/EntityTree.cpp index f44f2eb7c5..6c12c6d019 100644 --- a/libraries/entities/src/EntityTree.cpp +++ b/libraries/entities/src/EntityTree.cpp @@ -98,15 +98,14 @@ void EntityTree::eraseDomainAndNonOwnedEntities() { if (element) { element->cleanupDomainAndNonOwnedEntities(); } - if (!getIsServer()) { - if (entity->isLocalEntity() || entity->isMyAvatarEntity()) { - savedEntities[entity->getEntityItemID()] = entity; - } else { - int32_t spaceIndex = entity->getSpaceIndex(); - if (spaceIndex != -1) { - // stale spaceIndices will be freed later - _staleProxies.push_back(spaceIndex); - } + + if (entity->isLocalEntity() || (entity->isAvatarEntity() && entity->getOwningAvatarID() == getMyAvatarSessionUUID())) { + savedEntities[entity->getEntityItemID()] = entity; + } else { + int32_t spaceIndex = entity->getSpaceIndex(); + if (spaceIndex != -1) { + // stale spaceIndices will be freed later + _staleProxies.push_back(spaceIndex); } } } @@ -122,7 +121,7 @@ void EntityTree::eraseDomainAndNonOwnedEntities() { foreach (EntityItemWeakPointer entityItem, _needsParentFixup) { auto entity = entityItem.lock(); - if (entity && (entity->isLocalEntity() || entity->isMyAvatarEntity())) { + if (entity && (entity->isLocalEntity() || (entity->isAvatarEntity() && entity->getOwningAvatarID() == getMyAvatarSessionUUID()))) { needParentFixup.push_back(entityItem); } } @@ -145,12 +144,10 @@ void EntityTree::eraseAllOctreeElements(bool createNewRoot) { if (element) { element->cleanupEntities(); } - if (!getIsServer()) { - int32_t spaceIndex = entity->getSpaceIndex(); - if (spaceIndex != -1) { - // assume stale spaceIndices will be freed later - _staleProxies.push_back(spaceIndex); - } + int32_t spaceIndex = entity->getSpaceIndex(); + if (spaceIndex != -1) { + // assume stale spaceIndices will be freed later + _staleProxies.push_back(spaceIndex); } } }); @@ -608,21 +605,61 @@ void EntityTree::setSimulation(EntitySimulationPointer simulation) { } void EntityTree::deleteEntity(const EntityItemID& entityID, bool force, bool ignoreWarnings) { - // NOTE: can be called without lock because deleteEntitiesByID() will lock - QSet ids; - ids << entityID; - deleteEntitiesByID(ids, force, ignoreWarnings); + EntityTreeElementPointer containingElement = getContainingElement(entityID); + if (!containingElement) { + if (!ignoreWarnings) { + qCWarning(entities) << "EntityTree::deleteEntity() on non-existent entityID=" << entityID; + } + return; + } + + EntityItemPointer existingEntity = containingElement->getEntityWithEntityItemID(entityID); + if (!existingEntity) { + if (!ignoreWarnings) { + qCWarning(entities) << "EntityTree::deleteEntity() on non-existant entity item with entityID=" << entityID; + } + return; + } + + if (existingEntity->getLocked() && !force) { + if (!ignoreWarnings) { + qCDebug(entities) << "ERROR! EntityTree::deleteEntity() trying to delete locked entity. entityID=" << entityID; + } + return; + } + + cleanupCloneIDs(entityID); + unhookChildAvatar(entityID); + emit deletingEntity(entityID); + emit deletingEntityPointer(existingEntity.get()); + + // NOTE: callers must lock the tree before using this method + DeleteEntityOperator theOperator(getThisPointer(), entityID); + + existingEntity->forEachDescendant([&](SpatiallyNestablePointer descendant) { + auto descendantID = descendant->getID(); + theOperator.addEntityIDToDeleteList(descendantID); + emit deletingEntity(descendantID); + EntityItemPointer descendantEntity = std::dynamic_pointer_cast(descendant); + if (descendantEntity) { + emit deletingEntityPointer(descendantEntity.get()); + } + }); + + recurseTreeWithOperator(&theOperator); + processRemovedEntities(theOperator); + _isDirty = true; } void EntityTree::unhookChildAvatar(const EntityItemID entityID) { - if (!getIsServer()) { - EntityItemPointer entity = findEntityByEntityItemID(entityID); - entity->forEachDescendant([&](SpatiallyNestablePointer child) { - if (child->getNestableType() == NestableType::Avatar) { - child->setParentID(nullptr); - } - }); - } + + EntityItemPointer entity = findEntityByEntityItemID(entityID); + + entity->forEachDescendant([&](SpatiallyNestablePointer child) { + if (child->getNestableType() == NestableType::Avatar) { + child->setParentID(nullptr); + } + }); } void EntityTree::cleanupCloneIDs(const EntityItemID& entityID) { @@ -647,100 +684,39 @@ void EntityTree::cleanupCloneIDs(const EntityItemID& entityID) { } } -void EntityTree::recursivelyFilterAndCollectForDelete(const EntityItemPointer& entity, SetOfEntities& entitiesToDelete, bool force) const { - // tree must be read-locked before calling this method - //TODO: assert(treeIsLocked); - assert(entity); - if (entity->getElement() && (entitiesToDelete.find(entity) == entitiesToDelete.end())) { - // filter - bool allowed = force; - if (!allowed) { - bool wasChanged = false; - auto startFilter = usecTimestampNow(); - EntityItemProperties dummyProperties; - allowed = force || filterProperties(entity, dummyProperties, dummyProperties, wasChanged, FilterType::Delete); - auto endFilter = usecTimestampNow(); - _totalFilterTime += endFilter - startFilter; - } - if (allowed) { - entitiesToDelete.insert(entity); - for (SpatiallyNestablePointer child : entity->getChildren()) { - if (child && child->getNestableType() == NestableType::Entity) { - EntityItemPointer childEntity = std::static_pointer_cast(child); - recursivelyFilterAndCollectForDelete(childEntity, entitiesToDelete, force); - } - } - } - } -} - -void EntityTree::deleteEntitiesByID(const QSet& ids, bool force, bool ignoreWarnings) { - // this method has two paths: - // (a) entity-server: applies delete filter - // (b) interface-client: deletes local- and my-avatar-entities immediately, submits domainEntity deletes to the entity-server - if (getIsServer()) { - withWriteLock([&] { - SetOfEntities entitiesToDelete; - for (auto id : ids) { - EntityItemPointer entity; - { - QReadLocker locker(&_entityMapLock); - entity = _entityMap.value(id); - } - if (entity) { - recursivelyFilterAndCollectForDelete(entity, entitiesToDelete, force); - } - } - if (!entitiesToDelete.empty()) { - deleteEntitiesByPointer(entitiesToDelete); - } - }); - } else { - SetOfEntities entitiesToDelete; - SetOfEntities domainEntities; - QUuid sessionID = DependencyManager::get()->getSessionUUID(); - withWriteLock([&] { - for (auto id : ids) { - EntityItemPointer entity; - { - QReadLocker locker(&_entityMapLock); - entity = _entityMap.value(id); - } - if (entity) { - if (entity->isDomainEntity()) { - domainEntities.insert(entity); - } else if (entity->isLocalEntity() || entity->isMyAvatarEntity()) { - entitiesToDelete.insert(entity); - entity->collectChildrenForDelete(entitiesToDelete, domainEntities, sessionID); - } - } - } - if (!entitiesToDelete.empty()) { - deleteEntitiesByPointer(entitiesToDelete); - } - }); - if (!domainEntities.empty() && _simulation) { - // interface-client can't delete domainEntities outright, they must roundtrip through the entity-server - _simulation->queueEraseDomainEntities(domainEntities); - } - } -} - -void EntityTree::deleteEntitiesByPointer(const SetOfEntities& entities) { - // tree must be write-locked before calling this method - //TODO: assert(treeIsLocked); - // NOTE: there is no entity validation (i.e. is entity in tree?) nor snarfing of children beyond this point. - // Get those done BEFORE calling this method. - for (auto entity : entities) { - cleanupCloneIDs(entity->getID()); - } +void EntityTree::deleteEntities(QSet entityIDs, bool force, bool ignoreWarnings) { + // NOTE: callers must lock the tree before using this method DeleteEntityOperator theOperator(getThisPointer()); - for (auto entity : entities) { - if (entity->getElement()) { - theOperator.addEntityToDeleteList(entity); - emit deletingEntity(entity->getID()); - emit deletingEntityPointer(entity.get()); + foreach(const EntityItemID& entityID, entityIDs) { + EntityTreeElementPointer containingElement = getContainingElement(entityID); + if (!containingElement) { + if (!ignoreWarnings) { + qCWarning(entities) << "EntityTree::deleteEntities() on non-existent entityID=" << entityID; + } + continue; } + + EntityItemPointer existingEntity = containingElement->getEntityWithEntityItemID(entityID); + if (!existingEntity) { + if (!ignoreWarnings) { + qCWarning(entities) << "EntityTree::deleteEntities() on non-existent entity item with entityID=" << entityID; + } + continue; + } + + if (existingEntity->getLocked() && !force) { + if (!ignoreWarnings) { + qCDebug(entities) << "ERROR! EntityTree::deleteEntities() trying to delete locked entity. entityID=" << entityID; + } + continue; + } + + // tell our delete operator about this entityID + cleanupCloneIDs(entityID); + unhookChildAvatar(entityID); + theOperator.addEntityIDToDeleteList(entityID); + emit deletingEntity(entityID); + emit deletingEntityPointer(existingEntity.get()); } if (!theOperator.getEntities().empty()) { @@ -751,11 +727,23 @@ void EntityTree::deleteEntitiesByPointer(const SetOfEntities& entities) { } void EntityTree::processRemovedEntities(const DeleteEntityOperator& theOperator) { - // NOTE: assume tree already write-locked because this method only called in deleteEntitiesByPointer() quint64 deletedAt = usecTimestampNow(); const RemovedEntities& entities = theOperator.getEntities(); foreach(const EntityToDeleteDetails& details, entities) { EntityItemPointer theEntity = details.entity; + + if (getIsServer()) { + QSet childrenIDs; + theEntity->forEachChild([&](SpatiallyNestablePointer child) { + if (child->getNestableType() == NestableType::Entity) { + childrenIDs += child->getID(); + } + }); + deleteEntities(childrenIDs, true, true); + } + + theEntity->die(); + if (getIsServer()) { removeCertifiedEntityOnServer(theEntity); @@ -763,24 +751,19 @@ void EntityTree::processRemovedEntities(const DeleteEntityOperator& theOperator) QWriteLocker recentlyDeletedEntitiesLocker(&_recentlyDeletedEntitiesLock); _recentlyDeletedEntityItemIDs.insert(deletedAt, theEntity->getEntityItemID()); } else { - theEntity->forEachDescendant([&](SpatiallyNestablePointer child) { - if (child->getNestableType() == NestableType::Avatar) { - child->setParentID(nullptr); - } - }); - // on the client side, we also remember that we deleted this entity, we don't care about the time trackDeletedEntity(theEntity->getEntityItemID()); - - int32_t spaceIndex = theEntity->getSpaceIndex(); - if (spaceIndex != -1) { - // stale spaceIndices will be freed later - _staleProxies.push_back(spaceIndex); - } } + if (theEntity->isSimulated()) { _simulation->prepareEntityForDelete(theEntity); } + + int32_t spaceIndex = theEntity->getSpaceIndex(); + if (spaceIndex != -1) { + // stale spaceIndices will be freed later + _staleProxies.push_back(spaceIndex); + } } } @@ -1386,7 +1369,7 @@ void EntityTree::fixupTerseEditLogging(EntityItemProperties& properties, QList(); if (entityEditFilters) { @@ -1766,9 +1749,9 @@ void EntityTree::processChallengeOwnershipPacket(ReceivedMessage& message, const } } -// NOTE: Caller must lock the tree before calling this. int EntityTree::processEditPacketData(ReceivedMessage& message, const unsigned char* editData, int maxLength, const SharedNodePointer& senderNode) { + if (!getIsServer()) { qCWarning(entities) << "EntityTree::processEditPacketData() should only be called on a server tree."; return 0; @@ -2234,9 +2217,7 @@ void EntityTree::fixupNeedsParentFixups() { void EntityTree::deleteDescendantsOfAvatar(QUuid avatarID) { if (_childrenOfAvatars.contains(avatarID)) { - bool force = true; - bool ignoreWarnings = true; - deleteEntitiesByID(_childrenOfAvatars[avatarID], force, ignoreWarnings); + deleteEntities(_childrenOfAvatars[avatarID]); _childrenOfAvatars.remove(avatarID); } } @@ -2268,6 +2249,22 @@ void EntityTree::update(bool simulate) { if (simulate && _simulation) { withWriteLock([&] { _simulation->updateEntities(); + { + PROFILE_RANGE(simulation_physics, "Deletes"); + SetOfEntities deadEntities; + _simulation->takeDeadEntities(deadEntities); + if (!deadEntities.empty()) { + // translate into list of ID's + QSet idsToDelete; + + for (auto entity : deadEntities) { + idsToDelete.insert(entity->getEntityItemID()); + } + + // delete these things the roundabout way + deleteEntities(idsToDelete, true); + } + } }); } } @@ -2356,17 +2353,12 @@ bool EntityTree::shouldEraseEntity(EntityItemID entityID, const SharedNodePointe return allowed; } + +// TODO: consider consolidating processEraseMessageDetails() and processEraseMessage() int EntityTree::processEraseMessage(ReceivedMessage& message, const SharedNodePointer& sourceNode) { - // NOTE: this is only called by the interface-client on receipt of deleteEntity message from entity-server. - // Which means this is a state synchronization message from the the entity-server. It is saying - // "The following domain-entities have already been deleted". While need to perform sanity checking - // (e.g. verify these are domain entities) permissions need NOT checked for the domain-entities. - assert(!getIsServer()); - // TODO: remove this stuff out of EntityTree:: and into interface-client code. #ifdef EXTRA_ERASE_DEBUGGING qCDebug(entities) << "EntityTree::processEraseMessage()"; #endif - SetOfEntities consequentialDomainEntities; withWriteLock([&] { message.seek(sizeof(OCTREE_PACKET_FLAGS) + sizeof(OCTREE_PACKET_SEQUENCE) + sizeof(OCTREE_PACKET_SENT_TIME)); @@ -2374,9 +2366,10 @@ int EntityTree::processEraseMessage(ReceivedMessage& message, const SharedNodePo message.readPrimitive(&numberOfIDs); if (numberOfIDs > 0) { - QSet idsToDelete; + QSet entityItemIDsToDelete; for (size_t i = 0; i < numberOfIDs; i++) { + if (NUM_BYTES_RFC4122_UUID > message.getBytesLeftToRead()) { qCDebug(entities) << "EntityTree::processEraseMessage().... bailing because not enough bytes in buffer"; break; // bail to prevent buffer overflow @@ -2388,85 +2381,64 @@ int EntityTree::processEraseMessage(ReceivedMessage& message, const SharedNodePo #endif EntityItemID entityItemID(entityID); - idsToDelete << entityItemID; - } - // domain-entity deletion can trigger deletion of other entities the entity-server doesn't know about - // so we must recurse down the children and collect consequential deletes however - // we must first identify all domain-entities in idsToDelete so as to not overstep entity-server's authority - SetOfEntities domainEntities; - for (auto id : idsToDelete) { - EntityItemPointer entity = _entityMap.value(id); - if (entity && entity->isDomainEntity()) { - domainEntities.insert(entity); + if (shouldEraseEntity(entityID, sourceNode)) { + entityItemIDsToDelete << entityItemID; + cleanupCloneIDs(entityItemID); } } - // now we recurse domain-entities children and snarf consequential entities - auto nodeList = DependencyManager::get(); - QUuid sessionID = nodeList->getSessionUUID(); - // NOTE: normally a null sessionID would be bad, as that would cause the collectDhildrenForDelete() method below - // to snarf domain entities for which the interface-client is not authorized to delete without explicit instructions - // from the entity-server, however it is ok here because that would mean: - // (a) interface-client is not connected to a domain which means... - // (b) we should never get here (since this would correspond to a message from the entity-server) but... - // (c) who cares? When not connected to a domain the interface-client can do whatever it wants. - SetOfEntities entitiesToDelete; - for (auto entity : domainEntities) { - entitiesToDelete.insert(entity); - entity->collectChildrenForDelete(entitiesToDelete, consequentialDomainEntities, sessionID); - } - - if (!entitiesToDelete.empty()) { - deleteEntitiesByPointer(entitiesToDelete); - } + deleteEntities(entityItemIDsToDelete, true, true); } }); - if (!consequentialDomainEntities.empty() && _simulation) { - _simulation->queueEraseDomainEntities(consequentialDomainEntities); - } return message.getPosition(); } // This version skips over the header -// NOTE: Caller must write-lock the tree before calling this. +// NOTE: Caller must lock the tree before calling this. +// TODO: consider consolidating processEraseMessageDetails() and processEraseMessage() int EntityTree::processEraseMessageDetails(const QByteArray& dataByteArray, const SharedNodePointer& sourceNode) { - //TODO: assert(treeIsLocked); - assert(getIsServer()); #ifdef EXTRA_ERASE_DEBUGGING qCDebug(entities) << "EntityTree::processEraseMessageDetails()"; #endif + const unsigned char* packetData = (const unsigned char*)dataByteArray.constData(); + const unsigned char* dataAt = packetData; size_t packetLength = dataByteArray.size(); size_t processedBytes = 0; uint16_t numberOfIds = 0; // placeholder for now - memcpy(&numberOfIds, dataByteArray.constData(), sizeof(numberOfIds)); + memcpy(&numberOfIds, dataAt, sizeof(numberOfIds)); + dataAt += sizeof(numberOfIds); processedBytes += sizeof(numberOfIds); if (numberOfIds > 0) { - QSet ids; + QSet entityItemIDsToDelete; - // extract ids from packet for (size_t i = 0; i < numberOfIds; i++) { + + if (processedBytes + NUM_BYTES_RFC4122_UUID > packetLength) { qCDebug(entities) << "EntityTree::processEraseMessageDetails().... bailing because not enough bytes in buffer"; break; // bail to prevent buffer overflow } QByteArray encodedID = dataByteArray.mid((int)processedBytes, NUM_BYTES_RFC4122_UUID); - QUuid id = QUuid::fromRfc4122(encodedID); + QUuid entityID = QUuid::fromRfc4122(encodedID); + dataAt += encodedID.size(); processedBytes += encodedID.size(); #ifdef EXTRA_ERASE_DEBUGGING - qCDebug(entities) << " ---- EntityTree::processEraseMessageDetails() contains id:" << id; + qCDebug(entities) << " ---- EntityTree::processEraseMessageDetails() contains id:" << entityID; #endif - EntityItemID entityID(id); - ids << entityID; - } + EntityItemID entityItemID(entityID); - bool force = sourceNode->isAllowedEditor(); - bool ignoreWarnings = true; - deleteEntitiesByID(ids, force, ignoreWarnings); + if (shouldEraseEntity(entityID, sourceNode)) { + entityItemIDsToDelete << entityItemID; + cleanupCloneIDs(entityItemID); + } + + } + deleteEntities(entityItemIDsToDelete, true, true); } return (int)processedBytes; } diff --git a/libraries/entities/src/EntityTree.h b/libraries/entities/src/EntityTree.h index 6574b9d601..9108f8d8d2 100644 --- a/libraries/entities/src/EntityTree.h +++ b/libraries/entities/src/EntityTree.h @@ -126,9 +126,7 @@ public: void unhookChildAvatar(const EntityItemID entityID); void cleanupCloneIDs(const EntityItemID& entityID); void deleteEntity(const EntityItemID& entityID, bool force = false, bool ignoreWarnings = true); - - void deleteEntitiesByID(const QSet& entityIDs, bool force = false, bool ignoreWarnings = true); - void deleteEntitiesByPointer(const SetOfEntities& entities); + void deleteEntities(QSet entityIDs, bool force = false, bool ignoreWarnings = true); EntityItemPointer findEntityByID(const QUuid& id) const; EntityItemPointer findEntityByEntityItemID(const EntityItemID& entityID) const; @@ -293,7 +291,6 @@ signals: protected: - void recursivelyFilterAndCollectForDelete(const EntityItemPointer& entity, SetOfEntities& entitiesToDelete, bool force) const; void processRemovedEntities(const DeleteEntityOperator& theOperator); bool updateEntity(EntityItemPointer entity, const EntityItemProperties& properties, const SharedNodePointer& senderNode = SharedNodePointer(nullptr)); @@ -342,12 +339,12 @@ protected: int _totalEditMessages = 0; int _totalUpdates = 0; int _totalCreates = 0; - mutable quint64 _totalDecodeTime = 0; - mutable quint64 _totalLookupTime = 0; - mutable quint64 _totalUpdateTime = 0; - mutable quint64 _totalCreateTime = 0; - mutable quint64 _totalLoggingTime = 0; - mutable quint64 _totalFilterTime = 0; + quint64 _totalDecodeTime = 0; + quint64 _totalLookupTime = 0; + quint64 _totalUpdateTime = 0; + quint64 _totalCreateTime = 0; + quint64 _totalLoggingTime = 0; + quint64 _totalFilterTime = 0; // these performance statistics are only used in the client void resetClientEditStats(); @@ -367,7 +364,7 @@ protected: float _maxTmpEntityLifetime { DEFAULT_MAX_TMP_ENTITY_LIFETIME }; - bool filterProperties(const EntityItemPointer& existingEntity, EntityItemProperties& propertiesIn, EntityItemProperties& propertiesOut, bool& wasChanged, FilterType filterType) const; + bool filterProperties(EntityItemPointer& existingEntity, EntityItemProperties& propertiesIn, EntityItemProperties& propertiesOut, bool& wasChanged, FilterType filterType); bool _hasEntityEditFilter{ false }; QStringList _entityScriptSourceWhitelist; diff --git a/libraries/entities/src/EntityTreeElement.cpp b/libraries/entities/src/EntityTreeElement.cpp index 0096319081..60eaafc0dd 100644 --- a/libraries/entities/src/EntityTreeElement.cpp +++ b/libraries/entities/src/EntityTreeElement.cpp @@ -705,7 +705,7 @@ void EntityTreeElement::cleanupDomainAndNonOwnedEntities() { withWriteLock([&] { EntityItems savedEntities; foreach(EntityItemPointer entity, _entityItems) { - if (!(entity->isLocalEntity() || entity->isMyAvatarEntity())) { + if (!(entity->isLocalEntity() || (entity->isAvatarEntity() && entity->getOwningAvatarID() == getTree()->getMyAvatarSessionUUID()))) { entity->preDelete(); entity->_element = NULL; } else { diff --git a/libraries/entities/src/SimpleEntitySimulation.cpp b/libraries/entities/src/SimpleEntitySimulation.cpp index d64efdf87f..b8e3df2d03 100644 --- a/libraries/entities/src/SimpleEntitySimulation.cpp +++ b/libraries/entities/src/SimpleEntitySimulation.cpp @@ -47,17 +47,14 @@ void SimpleEntitySimulation::clearOwnership(const QUuid& ownerID) { } } -void SimpleEntitySimulation::updateEntities() { - EntitySimulation::updateEntities(); - QMutexLocker lock(&_mutex); - uint64_t now = usecTimestampNow(); +void SimpleEntitySimulation::updateEntitiesInternal(uint64_t now) { expireStaleOwnerships(now); stopOwnerlessEntities(now); } -void SimpleEntitySimulation::addEntityToInternalLists(EntityItemPointer entity) { - EntitySimulation::addEntityToInternalLists(entity); +void SimpleEntitySimulation::addEntityInternal(EntityItemPointer entity) { if (entity->getSimulatorID().isNull()) { + QMutexLocker lock(&_mutex); if (entity->getDynamic()) { // we don't allow dynamic objects to move without an owner so nothing to do here } else if (entity->isMovingRelativeToParent()) { @@ -68,6 +65,7 @@ void SimpleEntitySimulation::addEntityToInternalLists(EntityItemPointer entity) } } } else { + QMutexLocker lock(&_mutex); _entitiesWithSimulationOwner.insert(entity); _nextStaleOwnershipExpiry = glm::min(_nextStaleOwnershipExpiry, entity->getSimulationOwnershipExpiry()); @@ -81,10 +79,10 @@ void SimpleEntitySimulation::addEntityToInternalLists(EntityItemPointer entity) } } -void SimpleEntitySimulation::removeEntityFromInternalLists(EntityItemPointer entity) { +void SimpleEntitySimulation::removeEntityInternal(EntityItemPointer entity) { + EntitySimulation::removeEntityInternal(entity); _entitiesWithSimulationOwner.remove(entity); _entitiesThatNeedSimulationOwner.remove(entity); - EntitySimulation::removeEntityFromInternalLists(entity); } void SimpleEntitySimulation::processChangedEntity(const EntityItemPointer& entity) { @@ -137,11 +135,10 @@ void SimpleEntitySimulation::processChangedEntity(const EntityItemPointer& entit entity->clearDirtyFlags(); } -void SimpleEntitySimulation::clearEntities() { +void SimpleEntitySimulation::clearEntitiesInternal() { QMutexLocker lock(&_mutex); _entitiesWithSimulationOwner.clear(); _entitiesThatNeedSimulationOwner.clear(); - EntitySimulation::clearEntities(); } void SimpleEntitySimulation::sortEntitiesThatMoved() { diff --git a/libraries/entities/src/SimpleEntitySimulation.h b/libraries/entities/src/SimpleEntitySimulation.h index e984b72ed4..1b240a8bf0 100644 --- a/libraries/entities/src/SimpleEntitySimulation.h +++ b/libraries/entities/src/SimpleEntitySimulation.h @@ -23,16 +23,16 @@ using SimpleEntitySimulationPointer = std::shared_ptr; class SimpleEntitySimulation : public EntitySimulation { public: SimpleEntitySimulation() : EntitySimulation() { } - ~SimpleEntitySimulation() { clearEntities(); } + ~SimpleEntitySimulation() { clearEntitiesInternal(); } void clearOwnership(const QUuid& ownerID); - void clearEntities() override; - void updateEntities() override; protected: - void addEntityToInternalLists(EntityItemPointer entity) override; - void removeEntityFromInternalLists(EntityItemPointer entity) override; + void updateEntitiesInternal(uint64_t now) override; + void addEntityInternal(EntityItemPointer entity) override; + void removeEntityInternal(EntityItemPointer entity) override; void processChangedEntity(const EntityItemPointer& entity) override; + void clearEntitiesInternal() override; void sortEntitiesThatMoved() override; diff --git a/libraries/physics/src/EntityMotionState.cpp b/libraries/physics/src/EntityMotionState.cpp index f3d129871f..e48f0603bd 100644 --- a/libraries/physics/src/EntityMotionState.cpp +++ b/libraries/physics/src/EntityMotionState.cpp @@ -62,7 +62,7 @@ EntityMotionState::EntityMotionState(btCollisionShape* shape, EntityItemPointer // rather than pass the legit shape pointer to the ObjectMotionState ctor above. setShape(shape); - if (_entity->isAvatarEntity() && !_entity->isMyAvatarEntity()) { + if (_entity->isAvatarEntity() && _entity->getOwningAvatarID() != Physics::getSessionUUID()) { // avatar entities are always thus, so we cache this fact in _ownershipState _ownershipState = EntityMotionState::OwnershipState::Unownable; } @@ -407,8 +407,8 @@ bool EntityMotionState::shouldSendUpdate(uint32_t simulationStep) { // NOTE: we expect _entity and _body to be valid in this context, since shouldSendUpdate() is only called // after doesNotNeedToSendUpdate() returns false and that call should return 'true' if _entity or _body are NULL. - // this case is prevented by setting _ownershipState to OwnershipState::Unownable in EntityMotionState::ctor - assert(!(_entity->isAvatarEntity() && !_entity->isMyAvatarEntity())); + // this case is prevented by setting _ownershipState to UNOWNABLE in EntityMotionState::ctor + assert(!(_entity->isAvatarEntity() && _entity->getOwningAvatarID() != Physics::getSessionUUID())); if (_entity->getTransitingWithAvatar()) { return false; @@ -768,7 +768,7 @@ uint8_t EntityMotionState::computeFinalBidPriority() const { } bool EntityMotionState::isLocallyOwned() const { - return _entity->getSimulatorID() == Physics::getSessionUUID() || _entity->isMyAvatarEntity(); + return _entity->getSimulatorID() == Physics::getSessionUUID(); } bool EntityMotionState::isLocallyOwnedOrShouldBe() const { @@ -786,21 +786,13 @@ void EntityMotionState::setRegion(uint8_t region) { } void EntityMotionState::initForBid() { - if (_ownershipState != EntityMotionState::OwnershipState::Unownable) { - _ownershipState = EntityMotionState::OwnershipState::PendingBid; - } + assert(_ownershipState != EntityMotionState::OwnershipState::Unownable); + _ownershipState = EntityMotionState::OwnershipState::PendingBid; } void EntityMotionState::initForOwned() { - if (_ownershipState != EntityMotionState::OwnershipState::Unownable) { - _ownershipState = EntityMotionState::OwnershipState::LocallyOwned; - } -} - -void EntityMotionState::clearOwnershipState() { - if (_ownershipState != OwnershipState::Unownable) { - _ownershipState = OwnershipState::NotLocallyOwned; - } + assert(_ownershipState != EntityMotionState::OwnershipState::Unownable); + _ownershipState = EntityMotionState::OwnershipState::LocallyOwned; } void EntityMotionState::clearObjectVelocities() const { diff --git a/libraries/physics/src/EntityMotionState.h b/libraries/physics/src/EntityMotionState.h index be6f5c0658..7456837777 100644 --- a/libraries/physics/src/EntityMotionState.h +++ b/libraries/physics/src/EntityMotionState.h @@ -107,7 +107,7 @@ protected: uint64_t getNextBidExpiry() const { return _nextBidExpiry; } void initForBid(); void initForOwned(); - void clearOwnershipState(); + void clearOwnershipState() { _ownershipState = OwnershipState::NotLocallyOwned; } void updateServerPhysicsVariables(); bool remoteSimulationOutOfSync(uint32_t simulationStep); diff --git a/libraries/physics/src/PhysicalEntitySimulation.cpp b/libraries/physics/src/PhysicalEntitySimulation.cpp index 0375e1dfd9..df8c3fa32e 100644 --- a/libraries/physics/src/PhysicalEntitySimulation.cpp +++ b/libraries/physics/src/PhysicalEntitySimulation.cpp @@ -40,9 +40,14 @@ void PhysicalEntitySimulation::init( } // begin EntitySimulation overrides -void PhysicalEntitySimulation::addEntityToInternalLists(EntityItemPointer entity) { - EntitySimulation::addEntityToInternalLists(entity); - entity->deserializeActions(); // TODO: do this elsewhere +void PhysicalEntitySimulation::updateEntitiesInternal(uint64_t now) { + // Do nothing here because the "internal" update the PhysicsEngine::stepSimulation() which is done elsewhere. +} + +void PhysicalEntitySimulation::addEntityInternal(EntityItemPointer entity) { + QMutexLocker lock(&_mutex); + assert(entity); + assert(!entity->isDead()); uint8_t region = _space->getRegion(entity->getSpaceIndex()); bool maybeShouldBePhysical = (region < workload::Region::R3 || region == workload::Region::UNKNOWN) && entity->shouldBePhysical(); bool canBeKinematic = region <= workload::Region::R3; @@ -61,20 +66,23 @@ void PhysicalEntitySimulation::addEntityToInternalLists(EntityItemPointer entity } } -void PhysicalEntitySimulation::removeEntityFromInternalLists(EntityItemPointer entity) { - _entitiesToAddToPhysics.remove(entity); - EntityMotionState* motionState = static_cast(entity->getPhysicsInfo()); - if (motionState) { - removeOwnershipData(motionState); - _entitiesToRemoveFromPhysics.insert(entity); - } - if (entity->isDead() && entity->getElement()) { - _deadEntitiesToRemoveFromTree.insert(entity); +void PhysicalEntitySimulation::removeEntityInternal(EntityItemPointer entity) { + if (entity->isSimulated()) { + EntitySimulation::removeEntityInternal(entity); + _entitiesToAddToPhysics.remove(entity); + + EntityMotionState* motionState = static_cast(entity->getPhysicsInfo()); + if (motionState) { + removeOwnershipData(motionState); + _entitiesToRemoveFromPhysics.insert(entity); + } + if (entity->isDead() && entity->getElement()) { + _deadEntities.insert(entity); + } } if (entity->isAvatarEntity()) { _deadAvatarEntities.insert(entity); } - EntitySimulation::removeEntityFromInternalLists(entity); } void PhysicalEntitySimulation::removeOwnershipData(EntityMotionState* motionState) { @@ -107,6 +115,18 @@ void PhysicalEntitySimulation::clearOwnershipData() { _bids.clear(); } +void PhysicalEntitySimulation::takeDeadEntities(SetOfEntities& deadEntities) { + QMutexLocker lock(&_mutex); + for (auto entity : _deadEntities) { + EntityMotionState* motionState = static_cast(entity->getPhysicsInfo()); + if (motionState) { + _entitiesToRemoveFromPhysics.insert(entity); + } + } + _deadEntities.swap(deadEntities); + _deadEntities.clear(); +} + void PhysicalEntitySimulation::takeDeadAvatarEntities(SetOfEntities& deadEntities) { _deadAvatarEntities.swap(deadEntities); _deadAvatarEntities.clear(); @@ -170,44 +190,11 @@ void PhysicalEntitySimulation::processChangedEntity(const EntityItemPointer& ent } } -void PhysicalEntitySimulation::processDeadEntities() { - if (_deadEntitiesToRemoveFromTree.empty()) { - return; - } - PROFILE_RANGE(simulation_physics, "Deletes"); - SetOfEntities entitiesToDeleteImmediately; - SetOfEntities domainEntities; - QUuid sessionID = Physics::getSessionUUID(); - QMutexLocker lock(&_mutex); - for (auto entity : _deadEntitiesToRemoveFromTree) { - EntityMotionState* motionState = static_cast(entity->getPhysicsInfo()); - if (motionState) { - _entitiesToRemoveFromPhysics.insert(entity); - } - if (entity->isDomainEntity()) { - domainEntities.insert(entity); - } else if (entity->isLocalEntity() || entity->isMyAvatarEntity()) { - entitiesToDeleteImmediately.insert(entity); - entity->collectChildrenForDelete(entitiesToDeleteImmediately, domainEntities, sessionID); - } - } - _deadEntitiesToRemoveFromTree.clear(); - - // interface-client can't delete domainEntities outright, they must roundtrip through the entity-server - for (auto entity : domainEntities) { - _entityPacketSender->queueEraseEntityMessage(entity->getID()); - } - if (!entitiesToDeleteImmediately.empty()) { - getEntityTree()->deleteEntitiesByPointer(entitiesToDeleteImmediately); - } -} - -void PhysicalEntitySimulation::clearEntities() { +void PhysicalEntitySimulation::clearEntitiesInternal() { // TODO: we should probably wait to lock the _physicsEngine so we don't mess up data structures // while it is in the middle of a simulation step. As it is, we're probably in shutdown mode // anyway, so maybe the simulation was already properly shutdown? Cross our fingers... - QMutexLocker lock(&_mutex); // remove the objects (aka MotionStates) from physics _physicsEngine->removeSetOfObjects(_physicalObjects); @@ -229,23 +216,11 @@ void PhysicalEntitySimulation::clearEntities() { _entitiesToAddToPhysics.clear(); _incomingChanges.clear(); _entitiesToDeleteLater.clear(); - - EntitySimulation::clearEntities(); -} - -void PhysicalEntitySimulation::queueEraseDomainEntities(const SetOfEntities& domainEntities) const { - if (_entityPacketSender) { - for (auto domainEntity : domainEntities) { - assert(domainEntity->isDomainEntity()); - _entityPacketSender->queueEraseEntityMessage(domainEntity->getID()); - } - } } // virtual void PhysicalEntitySimulation::prepareEntityForDelete(EntityItemPointer entity) { - // DANGER! this can be called on any thread - // do no dirty deeds here --> assemble list for later + // this can be called on any thread assert(entity); assert(entity->isDead()); QMutexLocker lock(&_mutex); @@ -253,11 +228,11 @@ void PhysicalEntitySimulation::prepareEntityForDelete(EntityItemPointer entity) } void PhysicalEntitySimulation::removeDeadEntities() { - // DANGER! only ever call this on the main thread + // only ever call this on the main thread QMutexLocker lock(&_mutex); for (auto& entity : _entitiesToDeleteLater) { entity->clearActions(getThisPointer()); - EntitySimulation::prepareEntityForDelete(entity); + removeEntityInternal(entity); } _entitiesToDeleteLater.clear(); } @@ -672,16 +647,10 @@ void PhysicalEntitySimulation::addDynamic(EntityDynamicPointer dynamic) { "dynamic that was already in _physicsEngine"; } } - QMutexLocker lock(&_dynamicsMutex); - _dynamicsToAdd += dynamic; + EntitySimulation::addDynamic(dynamic); } } -void PhysicalEntitySimulation::removeDynamic(const QUuid dynamicID) { - QMutexLocker lock(&_dynamicsMutex); - _dynamicsToRemove += dynamicID; -} - void PhysicalEntitySimulation::applyDynamicChanges() { QList dynamicsFailedToAdd; if (_physicsEngine) { @@ -696,8 +665,8 @@ void PhysicalEntitySimulation::applyDynamicChanges() { } } } - _dynamicsToAdd.clear(); - _dynamicsToRemove.clear(); + // applyDynamicChanges will clear _dynamicsToRemove and _dynamicsToAdd + EntitySimulation::applyDynamicChanges(); } // put back the ones that couldn't yet be added diff --git a/libraries/physics/src/PhysicalEntitySimulation.h b/libraries/physics/src/PhysicalEntitySimulation.h index a3bd60b96e..f5213f7fef 100644 --- a/libraries/physics/src/PhysicalEntitySimulation.h +++ b/libraries/physics/src/PhysicalEntitySimulation.h @@ -19,7 +19,6 @@ #include #include -#include #include #include #include @@ -59,24 +58,22 @@ public: void init(EntityTreePointer tree, PhysicsEnginePointer engine, EntityEditPacketSender* packetSender); void setWorkloadSpace(const workload::SpacePointer space) { _space = space; } - void addDynamic(EntityDynamicPointer dynamic) override; - void removeDynamic(const QUuid dynamicID) override; - void applyDynamicChanges() override; + virtual void addDynamic(EntityDynamicPointer dynamic) override; + virtual void applyDynamicChanges() override; + virtual void takeDeadEntities(SetOfEntities& deadEntities) override; void takeDeadAvatarEntities(SetOfEntities& deadEntities); - virtual void clearEntities() override; - void queueEraseDomainEntities(const SetOfEntities& domainEntities) const override; - signals: void entityCollisionWithEntity(const EntityItemID& idA, const EntityItemID& idB, const Collision& collision); protected: // only called by EntitySimulation // overrides for EntitySimulation - void addEntityToInternalLists(EntityItemPointer entity) override; - void removeEntityFromInternalLists(EntityItemPointer entity) override; + virtual void updateEntitiesInternal(uint64_t now) override; + virtual void addEntityInternal(EntityItemPointer entity) override; + virtual void removeEntityInternal(EntityItemPointer entity) override; void processChangedEntity(const EntityItemPointer& entity) override; - void processDeadEntities() override; + virtual void clearEntitiesInternal() override; void removeOwnershipData(EntityMotionState* motionState); void clearOwnershipData(); @@ -124,13 +121,8 @@ private: VectorOfEntityMotionStates _owned; VectorOfEntityMotionStates _bids; - SetOfEntities _deadAvatarEntities; // to remove from Avatar's lists + SetOfEntities _deadAvatarEntities; std::vector _entitiesToDeleteLater; - - QList _dynamicsToAdd; - QSet _dynamicsToRemove; - QMutex _dynamicsMutex { QMutex::Recursive }; - workload::SpacePointer _space; uint64_t _nextBidExpiry; uint32_t _lastStepSendPackets { 0 }; diff --git a/libraries/shared/src/PhysicsHelpers.cpp b/libraries/shared/src/PhysicsHelpers.cpp index b7f5242429..092b9d078a 100644 --- a/libraries/shared/src/PhysicsHelpers.cpp +++ b/libraries/shared/src/PhysicsHelpers.cpp @@ -10,12 +10,10 @@ // #include "PhysicsHelpers.h" - +#include "NumericalConstants.h" #include -#include "NumericalConstants.h" #include "PhysicsCollisionGroups.h" -#include "SharedUtil.h" // This chunk of code was copied from Bullet-2.82, so we include the Bullet license here: /* @@ -93,7 +91,7 @@ int32_t Physics::getDefaultCollisionMask(int32_t group) { QUuid _sessionID; void Physics::setSessionUUID(const QUuid& sessionID) { - _sessionID = sessionID.isNull() ? AVATAR_SELF_ID : sessionID; + _sessionID = sessionID; } const QUuid& Physics::getSessionUUID() { diff --git a/libraries/shared/src/SpatialParentFinder.h b/libraries/shared/src/SpatialParentFinder.h index 8300359b65..c19babbc7f 100644 --- a/libraries/shared/src/SpatialParentFinder.h +++ b/libraries/shared/src/SpatialParentFinder.h @@ -21,7 +21,7 @@ using SpatiallyNestableWeakPointer = std::weak_ptr; using SpatiallyNestablePointer = std::shared_ptr; class SpatialParentTree { public: - virtual SpatiallyNestablePointer findByID(const QUuid& id) const = 0; + virtual SpatiallyNestablePointer findByID(const QUuid& id) const { return nullptr; } }; class SpatialParentFinder : public Dependency { diff --git a/tests/octree/src/ModelTests.cpp b/tests/octree/src/ModelTests.cpp index 1ab32217d9..f3e17a56a5 100644 --- a/tests/octree/src/ModelTests.cpp +++ b/tests/octree/src/ModelTests.cpp @@ -363,8 +363,7 @@ void EntityTests::entityTreeTests(bool verbose) { } quint64 startDelete = usecTimestampNow(); - bool force = true; - tree.deleteEntity(entityID, force); + tree.deleteEntity(entityID); quint64 endDelete = usecTimestampNow(); totalElapsedDelete += (endDelete - startDelete); @@ -447,9 +446,7 @@ void EntityTests::entityTreeTests(bool verbose) { } quint64 startDelete = usecTimestampNow(); - bool force = true; - bool ignoreWarnings = true; - tree.deleteEntitiesByID(entitiesToDelete, force, ignoreWarnings); + tree.deleteEntities(entitiesToDelete); quint64 endDelete = usecTimestampNow(); totalElapsedDelete += (endDelete - startDelete);