Ticket #1707: RangeManagerOpt.2.patch

trunk/source/simulation2/serialization/SerializeTemplates.h

@@ -24 +24 @@
  */
 
 #include "simulation2/components/ICmpPathfinder.h"
+#include "simulation2/helpers/EntityMap.h"
 
 template<typename ELEM>
 struct SerializeVector
@@ -87 +88 @@
     }
 };
 
+template<typename VS>
+struct SerializeEntityMap
+{
+    template<typename V>
+    void operator()(ISerializer& serialize, const char* UNUSED(name), EntityMap<V>& value)
+    {
+        size_t len = value.size();
+        serialize.NumberU32_Unbounded("length", (u32)len);
+        for (typename EntityMap<V>::iterator it = value.begin(); it != value.end(); ++it)
+        {
+            serialize.NumberU32_Unbounded("key", it->first);
+            VS()(serialize, "value", it->second);
+        }
+    }
+
+    template<typename V>
+    void operator()(IDeserializer& deserialize, const char* UNUSED(name), EntityMap<V>& value)
+    {
+        value.clear();
+        u32 len;
+        deserialize.NumberU32_Unbounded("length", len);
+        for (size_t i = 0; i < len; ++i)
+        {
+            entity_id_t k;
+            deserialize.NumberU32_Unbounded("key", k);
+            V v; 
+            VS()(deserialize, "value", v);
+            value.insert(std::make_pair(k, v));
+        }
+    }
+};
+
 // We have to order the map before serializing to make things consistent
 template<typename KS, typename VS>
 struct SerializeUnorderedMap

trunk/source/simulation2/components/CCmpRangeManager.cpp

@@ -26 +26 @@
 #include "simulation2/components/ICmpVision.h"
 #include "simulation2/helpers/Render.h"
 #include "simulation2/helpers/Spatial.h"
+#include "simulation2/helpers/EntityMap.h"
 
 #include "graphics/Overlay.h"
 #include "graphics/Terrain.h"
@@ -149 +150 @@
  */
 struct EntityDistanceOrdering
 {
-    EntityDistanceOrdering(const std::map<entity_id_t, EntityData>& entities, const CFixedVector2D& source) :
+    EntityDistanceOrdering(const EntityMap<EntityData>& entities, const CFixedVector2D& source) :
         m_EntityData(entities), m_Source(source)
     {
     }
@@ -163 +164 @@
         return (vecA.CompareLength(vecB) < 0);
     }
 
-    const std::map<entity_id_t, EntityData>& m_EntityData;
+    const EntityMap<EntityData>& m_EntityData;
     CFixedVector2D m_Source;
 
 private:
@@ -210 +211 @@
     // Range query state:
     tag_t m_QueryNext; // next allocated id
     std::map<tag_t, Query> m_Queries;
-    std::map<entity_id_t, EntityData> m_EntityData;
+    EntityMap<EntityData> m_EntityData;
     SpatialSubdivision<entity_id_t> m_Subdivision; // spatial index of m_EntityData
 
     // LOS state:
@@ -288 +289 @@
 
         serialize.NumberU32_Unbounded("query next", m_QueryNext);
         SerializeMap<SerializeU32_Unbounded, SerializeQuery>()(serialize, "queries", m_Queries);
-        SerializeMap<SerializeU32_Unbounded, SerializeEntityData>()(serialize, "entity data", m_EntityData);
+        SerializeEntityMap<SerializeEntityData>()(serialize, "entity data", m_EntityData);
 
         SerializeMap<SerializeI32_Unbounded, SerializeBool>()(serialize, "los reveal all", m_LosRevealAll);
         serialize.Bool("los circular", m_LosCircular);
@@ -359 +360 @@
             const CMessagePositionChanged& msgData = static_cast<const CMessagePositionChanged&> (msg);
             entity_id_t ent = msgData.entity;
 
-            std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
+            EntityMap<EntityData>::iterator it = m_EntityData.find(ent);
 
             // Ignore if we're not already tracking this entity
             if (it == m_EntityData.end())
@@ -406 +407 @@
             const CMessageOwnershipChanged& msgData = static_cast<const CMessageOwnershipChanged&> (msg);
             entity_id_t ent = msgData.entity;
 
-            std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
+            EntityMap<EntityData>::iterator it = m_EntityData.find(ent);
 
             // Ignore if we're not already tracking this entity
             if (it == m_EntityData.end())
@@ -429 +430 @@
             const CMessageDestroy& msgData = static_cast<const CMessageDestroy&> (msg);
             entity_id_t ent = msgData.entity;
 
-            std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
+            EntityMap<EntityData>::iterator it = m_EntityData.find(ent);
 
             // Ignore if we're not already tracking this entity
             if (it == m_EntityData.end())
@@ -451 +452 @@
             const CMessageVisionRangeChanged& msgData = static_cast<const CMessageVisionRangeChanged&> (msg);
             entity_id_t ent = msgData.entity;
 
-            std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
+            EntityMap<EntityData>::iterator it = m_EntityData.find(ent);
 
             // Ignore if we're not already tracking this entity
             if (it == m_EntityData.end())
@@ -576 +577 @@
         m_LosStateRevealed.clear();
         m_LosStateRevealed.resize(m_TerrainVerticesPerSide*m_TerrainVerticesPerSide);
 
-        for (std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+        for (EntityMap<EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
         {
             if (it->second.inWorld)
                 LosAdd(it->second.owner, it->second.visionRange, CFixedVector2D(it->second.x, it->second.z));
@@ -602 +603 @@
         // (TODO: find the optimal number instead of blindly guessing)
         m_Subdivision.Reset(x1, z1, entity_pos_t::FromInt(8*TERRAIN_TILE_SIZE));
 
-        for (std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+        for (EntityMap<EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
         {
-            if (it->second.inWorld)
+            if (it->second.inWorld) // also checks validity as default is false.
                 m_Subdivision.Add(it->first, CFixedVector2D(it->second.x, it->second.z));
         }
     }
@@ -723 +724 @@
 
         u32 ownerMask = CalcOwnerMask(player);
 
-        for (std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+        for (EntityMap<EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
         {
             // Check owner and add to list if it matches
-            if (CalcOwnerMask(it->second.owner) & ownerMask)
+            if (it->first != INVALID_ENTITY && CalcOwnerMask(it->second.owner) & ownerMask)
                 entities.push_back(it->first);
         }
 
@@ -834 +835 @@
         // Special case: range -1.0 means check all entities ignoring distance
         if (q.maxRange == entity_pos_t::FromInt(-1))
         {
-            for (std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+            for (EntityMap<EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
             {
+                if (it->first == INVALID_ENTITY)
+                    continue;
                 if (!TestEntityQuery(q, it->first, it->second))
                     continue;
 
@@ -845 +848 @@
         else
         {
             // Get a quick list of entities that are potentially in range
-            std::vector<entity_id_t> ents = m_Subdivision.GetNear(pos, q.maxRange);
+            std::vector<entity_id_t> ents = m_Subdivision.GetNearUnsorted(pos, q.maxRange);
 
             for (size_t i = 0; i < ents.size(); ++i)
             {
-                std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.find(ents[i]);
+                EntityMap<EntityData>::const_iterator it = m_EntityData.find(ents[i]);
                 ENSURE(it != m_EntityData.end());
 
                 if (!TestEntityQuery(q, it->first, it->second))
@@ -975 +978 @@
 
     virtual void SetEntityFlag(entity_id_t ent, std::string identifier, bool value)
     {
-        std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
+        EntityMap<EntityData>::iterator it = m_EntityData.find(ent);
 
         // We don't have this entity
         if (it == m_EntityData.end())

trunk/source/simulation2/helpers/Spatial.h

@@ -215 +215 @@
 
         return GetInRange(pos - CFixedVector2D(range, range), pos + CFixedVector2D(range, range));
     }
+    
+    /**
+     * Returns a list of items that includes all items
+     * within the given axis-aligned square range.
+     * This version is unsorted, which is faster if that's not required.
+     * However the result might contain some entities twice or more.
+     */
+    std::vector<T> GetInRangeUnsorted(CFixedVector2D posMin, CFixedVector2D posMax)
+    {
+        std::vector<T> ret;
+        
+        ENSURE(posMin.X <= posMax.X && posMin.Y <= posMax.Y);
+        
+        u32 i0 = GetI0(posMin.X);
+        u32 j0 = GetJ0(posMin.Y);
+        u32 i1 = GetI1(posMax.X);
+        u32 j1 = GetJ1(posMax.Y);
+        for (u32 j = j0; j <= j1; ++j)
+        {
+            for (u32 i = i0; i <= i1; ++i)
+            {
+                std::vector<T>& div = m_Divisions[i + j*m_DivisionsW];
+                ret.insert(ret.end(), div.begin(), div.end());
+            }
+        }
+        return ret;
+    }
+    
+    /**
+     * Returns a sorted list of unique items that includes all items
+     * within the given circular distance of the given point.
+     * This returns unsorted results.
+     */
+    std::vector<T> GetNearUnsorted(CFixedVector2D pos, entity_pos_t range)
+    {
+        // TODO: be cleverer and return a circular pattern of divisions,
+        // not this square over-approximation
+        
+        return GetInRangeUnsorted(pos - CFixedVector2D(range, range), pos + CFixedVector2D(range, range));
+    }
 
 private:
     // Helper functions for translating coordinates into division indexes

trunk/source/simulation2/helpers/EntityMap.h

@@ +1 @@
+#ifndef INCLUDED_ENTITYMAP
+#define INCLUDED_ENTITYMAP
+
+/**
+ * A fast replacement for map<entity_id_t, T>.
+ * We make the following assumptions:
+ *  - entity id's (keys) are unique and are inserted in increasing order
+ *  - an entity id that was removed is never added again
+ *  - modifications (add / delete) are far less frequent then look-ups
+ *  - preformance for iteration is important
+ */
+template<typename T> class EntityMap
+{
+public:
+    // Map interface:
+    // Member types
+    typedef entity_id_t key_type;
+    typedef T mapped_type;
+    typedef std::pair<entity_id_t, T> value_type;
+
+    typedef typename std::vector<value_type>::difference_type difference_type;
+    typedef typename std::vector<value_type>::size_type size_type;
+
+    typedef typename std::vector<value_type>::iterator iterator;
+    typedef typename std::vector<value_type>::const_iterator const_iterator;
+
+private:
+    std::vector<value_type> m_Data;
+    size_t m_Size;
+
+public:
+    inline EntityMap() : m_Data(), m_Size(0)
+    {
+    }
+
+    inline EntityMap(const EntityMap& m) : m_Data(m.m_Data), m_Size(m.m_Size)
+    {
+    }
+
+    // Iterators
+
+    inline iterator begin()
+    {
+        iterator it(m_Data.begin());
+        if (size() != 0 && it->first == INVALID_ENTITY)
+            while (it != end() && (it++)->first == INVALID_ENTITY);
+        return it;
+    }
+    inline iterator end()
+    {
+        if (size() == 0) return begin();
+        return m_Data.end();
+    }
+    inline const_iterator begin() const
+    {
+        const_iterator it(m_Data.begin());
+        if (size() != 0 && it->first == INVALID_ENTITY)
+            while (it != end() && (it++)->first == INVALID_ENTITY);
+        return it;
+    }
+    inline const_iterator end() const
+    {
+        if (size() == 0) return begin();
+        return m_Data.end();
+    }
+
+    // Capacity
+    inline bool empty() const                   { return m_Size == 0;   }
+    inline size_type size() const               { return m_Size;        }
+
+    // Modification
+    std::pair<iterator, bool> insert(const value_type& val)
+    {
+        difference_type index = val.first;
+        bool new_index = false; // was a new element created?
+        if (index >= (int)m_Data.size())
+        {
+            m_Data.resize(index + 1);
+            new_index = true;
+            ++m_Size;
+        }
+        m_Data[index] = val;
+        return std::make_pair(iterator(&m_Data[index]), new_index); // false: element existed
+    }
+    
+    void erase(iterator it)
+    {
+        // only reliable way right now? or we could try ~T() and memset null?
+        it->first = INVALID_ENTITY; // mark it as 'invalid entity_id'
+        it->second.~T(); // call dtor
+        new (&it->second) T(); // call placement new
+        --m_Size;
+    }
+    
+    size_type erase(const key_type& key)
+    {
+        iterator it = find(key);
+        if (it != end())
+            erase(it);
+        return 1;
+    }
+    
+    inline void swap(EntityMap &map)
+    {
+        m_Data.swap(map.m_Data);
+    }
+
+    inline void clear()
+    {
+        m_Size = 0;
+        m_Data.clear();
+    }
+
+    // Operations
+    inline iterator find(const key_type& key)
+    {
+        if (key < m_Data.size())
+        {
+            const value_type& val = m_Data[key];
+            if (val.first != INVALID_ENTITY) // is this a valid element?
+                return iterator(&m_Data[key]);
+        }
+        return end(); // not found
+    }
+
+    inline const_iterator find(const key_type& key) const
+    {
+        if (key < m_Data.size())
+        {
+            const value_type& val = m_Data[key];
+            if (val.first != INVALID_ENTITY) // is this a valid element?
+                return const_iterator(&m_Data[key]);
+        }
+        return end(); // not found
+    }
+    
+    inline size_type count(const key_type& key) const
+    {
+        return find(key) == end() ? 0 : 1;
+    }
+};
+#endif