Merge pull request #61 from Strife-AI/entity-groups

Store entities in groups for efficient querying/updating

Author: catastropher

src/Memory/DLinkNode.hpp

@@ -11,19 +11,15 @@ struct DLinkedNode
 
     void Unlink()
     {
-        if (owner != nullptr)
-        {
-            prev->next = next;
-            next->prev = prev;
-
-            next = nullptr;
-            prev = nullptr;
-        }
+        prev->next = next;
+        next->prev = prev;
+
+        next = nullptr;
+        prev = nullptr;
     }
 
-    TElement* next;
-    TElement* prev;
-    DLinkedList<TElement>* owner;
+    DLinkedNode<TElement>* next = nullptr;
+    DLinkedNode<TElement>* prev = nullptr;
 };
 
 template<typename T>
@@ -45,7 +41,7 @@ struct DLinkedListIterator
         return !(*this == rhs);
     }
 
-    T& operator*()
+    T* operator*()
     {
         return current->GetElement();
     }
@@ -73,6 +69,7 @@ struct DLinkedList
     using Node = DLinkedNode<T>;
 
     DLinkedList();
+    DLinkedList(const DLinkedList& rhs) = delete;
 
     DLinkedListIterator<T> begin()
     {
@@ -85,7 +82,6 @@ struct DLinkedList
     }
 
     void Append(Node* node);
-    void Remove(Node* node);
     void InsertBefore(Node* node, Node* before);
 
     Node head;
@@ -95,21 +91,12 @@ struct DLinkedList
 template<typename T>
 void DLinkedList<T>::Append(DLinkedList::Node* node)
 {
-    node->owner = this;
-    InsertBefore(&tail);
-}
-
-template<typename T>
-void DLinkedList<T>::Remove(DLinkedList::Node* node)
-{
-    assert(node->owner == this);
+    InsertBefore(node, &tail);
 }
 
 template<typename T>
 void DLinkedList<T>::InsertBefore(Node* node, Node* before)
 {
-    assert(node->owner == nullptr);
-
     before->prev->next = node;
     node->prev = before->prev;
 

src/Scene/Entity.cpp

@@ -194,57 +194,41 @@ void Entity::NotifyMovement()
 }
 
 Entity::Entity()
-    : flags{
-    EntityFlags::EnableUpdate,
-    EntityFlags::EnableFixedUpdate,
-    EntityFlags::EnableServerUpdate,
-    EntityFlags::EnableServerFixedUpdate,
-    EntityFlags::EnableRender,
-    EntityFlags::EnableRenderHud
-}
 {
 
 }
 
+template<typename THookSelector>
+static void DisableHook(Entity* entity, THookSelector selector)
+{
+    auto& entityManager = entity->scene->GetEntityManager();
+    auto set = selector(entityManager);
+    entityManager.scheduledHookRemovals.emplace_back(set, entity->entityGroup);
+}
+
 void Entity::Update(float deltaTime)
 {
-    flags.ResetFlag(EntityFlags::EnableUpdate);
-    FlagsChanged();
+    DisableHook(this, [](auto& em) { return &em.updatables; });
 }
 
 void Entity::ServerUpdate(float deltaTime)
 {
-    flags.ResetFlag(EntityFlags::EnableServerUpdate);
-    FlagsChanged();
+    DisableHook(this, [](auto& em) { return &em.serverUpdatables; });
 }
 
 void Entity::FixedUpdate(float deltaTime)
 {
-    flags.ResetFlag(EntityFlags::EnableFixedUpdate);
-    FlagsChanged();
+    DisableHook(this, [](auto& em) { return &em.fixedUpdatables; });
 }
 
 void Entity::ServerFixedUpdate(float deltaTime)
 {
-    flags.ResetFlag(EntityFlags::EnableServerUpdate);
-    FlagsChanged();
+    DisableHook(this, [](auto& em) { return &em.serverFixedUpdatables; });
 }
 
 void Entity::Render(Renderer* renderer)
 {
-    flags.ResetFlag(EntityFlags::EnableRender);
-    FlagsChanged();
-}
-
-void Entity::RenderHud(Renderer* renderer)
-{
-    flags.ResetFlag(EntityFlags::EnableRenderHud);
-    FlagsChanged();
-}
-
-void Entity::FlagsChanged()
-{
-    scene->GetEntityManager().ScheduleUpdateInterfaces(this);
+    DisableHook(this, [](auto& em) { return &em.renderables; });
 }
 
 Vector2 Entity::ScreenCenter() const

src/Scene/Entity.hpp

@@ -19,19 +19,14 @@
 #include "Memory/DLinkNode.hpp"
 
 class b2Body;
-
 struct IEntityEvent;
 struct MoveResult;
-
 class Renderer;
-
 class Scene;
-
 struct Entity;
-
 class Engine;
-
 struct EntityInstance;
+struct EntityGroup;
 
 struct EntityHeader
 {
@@ -49,13 +44,6 @@ enum class EntityFlags
     EnableBuoyancy = 1,
     WasTeleported = 2,
     CastsShadows = 4,
-
-    EnableUpdate = 8,
-    EnableServerUpdate = 16,
-    EnableFixedUpdate = 32,
-    EnableServerFixedUpdate = 64,
-    EnableRender = 128,
-    EnableRenderHud = 256
 };
 
 struct Entity;
@@ -131,7 +119,6 @@ struct Entity : DLinkedNode<Entity>
     virtual void ServerFixedUpdate(float deltaTime);
 
     virtual void Render(Renderer* renderer);
-    virtual void RenderHud(Renderer* renderer);
 
     /// <summary>
     /// Called when an entity has been added to the scene.
@@ -208,6 +195,7 @@ struct Entity : DLinkedNode<Entity>
     Entity* parent = nullptr;
     Entity* nextSibling = nullptr;
     Entity* children = nullptr;
+    EntityGroup* entityGroup = nullptr;
 
     ISyncVar* syncVarHead = nullptr;
 

src/Scene/EntityManager.cpp

@@ -20,51 +20,50 @@ void EntityManager::RegisterEntity(Entity* entity)
 
     entity->id = header->id;
     entity->header = header;
+
+    // Put into entity group
+    {
+        auto groupIt = entitiesByType.find(entity->type.key);
+
+        if (groupIt == entitiesByType.end())
+        {
+            // We don't know whether the entity is updatable, renderable, etc since there's no way to introspect the vtable
+            // to see if the methods are overridden. So, assume it implements those things and let the base class implementation
+            // turn them off for the group.
+            auto[it, inserted] = entitiesByType.try_emplace(entity->type.key);
+            groupIt = it;
+
+            EntityGroup* group = &it->second;
+
+            updatables.insert(group);
+            fixedUpdatables.insert(group);
+            renderables.insert(group);
+
+            serverUpdatables.insert(group);
+            serverFixedUpdatables.insert(group);
+        }
+
+        groupIt->second.entities.Append(entity);
+        entity->entityGroup = &groupIt->second;
+    }
 }
 
 void EntityManager::UnregisterEntity(Entity* entity)
 {
     entities.erase(entity);
-
-    updatables.erase(entity);
-    fixedUpdatables.erase(entity);
-    serverUpdatables.erase(entity);
-    serverFixedUpdatables.erase(entity);
-    renderables.erase(entity);
-    hudRenderables.erase(entity);
+    entity->Unlink();
 
     EntityHeader* header = entity->header;
     header->id = InvalidEntityHeaderId;
     freeEntityHeaders.Return(header);
 }
 
-static void SetOwnershipBasedOnFlag(std::unordered_set<Entity*>& set, Entity* entity, EntityFlags flag)
-{
-	if(entity->flags.HasFlag(flag)) set.insert(entity);
-	else set.erase(entity);
-}
-
-void EntityManager::AddInterfaces(Entity* entity)
-{
-	SetOwnershipBasedOnFlag(updatables, entity, EntityFlags::EnableUpdate);
-	SetOwnershipBasedOnFlag(fixedUpdatables, entity, EntityFlags::EnableFixedUpdate);
-	SetOwnershipBasedOnFlag(serverUpdatables, entity, EntityFlags::EnableServerUpdate);
-	SetOwnershipBasedOnFlag(serverFixedUpdatables, entity, EntityFlags::EnableServerFixedUpdate);
-	SetOwnershipBasedOnFlag(renderables, entity, EntityFlags::EnableRender);
-	SetOwnershipBasedOnFlag(hudRenderables, entity, EntityFlags::EnableRenderHud);
-}
-
-void EntityManager::ScheduleUpdateInterfaces(Entity* entity)
+void EntityManager::RunHookRemovals()
 {
-	needsUpdatedInterfaces.insert(entity);
-}
-
-void EntityManager::UpdateInterfaces()
-{
-	for (auto entity : needsUpdatedInterfaces)
-	{
-		AddInterfaces(entity);
-	}
+    for (auto& removal : scheduledHookRemovals)
+    {
+        removal.hookSet->erase(removal.entityGroup);
+    }
 
-	needsUpdatedInterfaces.clear();
+    scheduledHookRemovals.clear();
 }