Ticket #2430: newSubdivision.patch

source/simulation2/helpers/Spatial_2.h

@@ +1 @@
+/* Copyright (C) 2010 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_SPATIAL2
+#define INCLUDED_SPATIAL2
+
+#include "simulation2/system/Component.h"
+#include "simulation2/serialization/SerializeTemplates.h"
+#include "ps/CLogger.h"
+
+/**
+ * A basic subdivision scheme for finding entities in range
+ * Items are stored in vectors in fixed-size divisions.
+ * Items have a size (min/max values of their axis-aligned bounding box)
+ * If that size is higher than a subdivision's size, they're stored in the "general" vector
+ * This means that if too many objects have a size that's big, it'll end up being slow
+ * We want subdivisions to be as small as possible yet contain as many items as possible.
+ * I have currently set it to "30", which is bigger than most buildings and entities.
+ *
+ * When adding, deleting or moving, you need to supply the position
+ * the item was added at, otherwise it might check the wrong subdivision and fail.
+ *
+ * If a unit size were to change, it would need to be updated, but that doesn't happen for now.
+ *
+ * Using a template because why not.
+ */
+template<typename T>
+class SpatialTree
+{
+    std::vector<T> m_OverSizedData;
+    // fixed size array of subdivisions.
+    std::vector<T>* m_SpatialDivisionsData;
+    // number of columns in the above array
+    size_t m_ArrayWidth;
+    // size of subdivisions, used to deduce m_ArrayWidth
+    int m_SubdivisionSize;
+    
+public:
+    SpatialTree() : m_SubdivisionSize(30)
+    {
+    }
+    ~SpatialTree()
+    {
+    }
+    // copy constructor
+    SpatialTree(const SpatialTree& other) : m_SubdivisionSize(30)
+    {
+        Create(other.m_ArrayWidth);
+        std::copy(other.m_SpatialDivisionsData, other.m_SpatialDivisionsData+m_ArrayWidth*m_ArrayWidth, m_SpatialDivisionsData);
+    }
+    SpatialTree& operator=(const SpatialTree& other)
+    {
+        if (this != &other)
+        {
+            Reset(other.m_ArrayWidth);
+            std::copy(other.m_SpatialDivisionsData, other.m_SpatialDivisionsData+m_ArrayWidth*m_ArrayWidth, m_SpatialDivisionsData);
+        }
+        return *this;
+    }
+    
+    // Create a spatial tree of the map.
+    void Create(size_t arrayWidth)
+    {
+        if (m_SpatialDivisionsData) delete[] m_SpatialDivisionsData;
+        // figure the number of divisions we want
+        m_ArrayWidth = arrayWidth;
+        m_SpatialDivisionsData = new std::vector<T>[m_ArrayWidth*m_ArrayWidth];
+        m_OverSizedData.clear();
+    }
+    
+    void Reset(size_t x, size_t y)
+    {
+        if (y > x)
+            Create(y/m_SubdivisionSize);
+        else
+            Create(x/m_SubdivisionSize);
+    }
+    
+    /**
+     * Equivalence test (ignoring order of items within each subdivision)
+     */
+    bool operator==(const SpatialTree& other)
+    {
+        if (m_ArrayWidth != other.m_ArrayWidth)
+            return false;
+        if (m_OverSizedData != other.m_OverSizedData)
+            return false;
+        for (size_t idx = 0; idx < m_ArrayWidth*m_ArrayWidth; ++idx)
+            if (m_SpatialDivisionsData[idx] != other.m_SpatialDivisionsData[idx])
+                return false;
+        return true;
+    }
+    
+    inline bool operator!=(const SpatialTree& rhs)
+    {
+        return !(*this == rhs);
+    }
+    
+    /**
+     * Add an item.
+     * The item must not already be present.
+     */
+    void Add(const T item, CFixedVector2D position, u16 size)
+    {
+        if (size > m_SubdivisionSize)
+        {
+            if (std::find(m_OverSizedData.begin(),m_OverSizedData.end(), item) == m_OverSizedData.end())
+                m_OverSizedData.push_back(item);
+        } else {
+            // find the proper subdivision.
+            int X = (position.X / m_SubdivisionSize).ToInt_RoundToZero();
+            int Y = (position.Y / m_SubdivisionSize).ToInt_RoundToZero();
+            std::vector<T>& subdivision = m_SpatialDivisionsData[X+Y*m_ArrayWidth];
+            if (std::find(subdivision.begin(),subdivision.end(), item) == subdivision.end())
+            {
+                // add it since it's unique.
+                subdivision.push_back(item);
+            }
+        }
+    }
+    
+    /**
+     * Remove an item.
+     * Position must be where we expect to find it, or we won't find it.
+     */
+    void Remove(const T item, CFixedVector2D position, u16 size)
+    {
+        if (size > m_SubdivisionSize)
+        {
+            typename std::vector<T>::iterator itr = std::find(m_OverSizedData.begin(),m_OverSizedData.end(), item);
+            if (itr != m_OverSizedData.end())
+                m_OverSizedData.erase(itr);
+        } else {
+            // find the proper subdivision.
+            size_t X = (position.X / m_SubdivisionSize).ToInt_RoundToZero();
+            size_t Y = (position.Y / m_SubdivisionSize).ToInt_RoundToZero();
+            std::vector<T>& subdivision = m_SpatialDivisionsData[X+Y*m_ArrayWidth];
+            typename std::vector<T>::iterator itr = std::find(subdivision.begin(),subdivision.end(), item);
+            if (itr != subdivision.end())
+            {
+                subdivision.erase(itr);
+            }
+        }
+    }
+    
+    /**
+     * Equivalent to Remove() then Add(), but slightly faster.
+     * In particular for big objects nothing needs to be done.
+     */
+    void Move(const T item, CFixedVector2D oldPosition, CFixedVector2D newPosition, u16 size)
+    {
+        if (size <= m_SubdivisionSize)
+        {
+            // find the proper subdivision.
+            size_t oldX = (oldPosition.X / m_SubdivisionSize).ToInt_RoundToZero();
+            size_t oldY = (oldPosition.Y / m_SubdivisionSize).ToInt_RoundToZero();
+            size_t newX = (newPosition.X / m_SubdivisionSize).ToInt_RoundToZero();
+            size_t newY = (newPosition.Y / m_SubdivisionSize).ToInt_RoundToZero();
+            std::vector<T>& subdivision = m_SpatialDivisionsData[oldX+oldY*m_ArrayWidth];
+            typename std::vector<T>::iterator itr = std::find(subdivision.begin(),subdivision.end(), item);
+            if (itr != subdivision.end())
+            {
+                subdivision.erase(itr);
+                // since we've found it, we'll assume the query is OK and add it directly.
+                m_SpatialDivisionsData[newX+newY*m_ArrayWidth].push_back(item);
+            }
+        }
+    }
+    
+    /**
+     * Returns a list of item that are either in the square
+     * or really quite close to it.
+     * The data is garanteed to be unique but is unsorted.
+     * It's the responsibility of the querier to do proper distance checking.
+     */
+    void GetInRange(std::vector<T>& out, CFixedVector2D posMin, CFixedVector2D posMax)
+    {
+        size_t minX = (posMin.X / m_SubdivisionSize).ToInt_RoundToZero();
+        size_t maxX = (posMax.X / m_SubdivisionSize).ToInt_RoundToZero();
+        size_t minY = (posMin.Y / m_SubdivisionSize).ToInt_RoundToZero();
+        size_t maxY = (posMax.Y / m_SubdivisionSize).ToInt_RoundToZero();
+        // Now expand the subdivisions by One so we make sure that we've got all elements potentially in range.
+        // also abuse ternary operators because I like to pretend I'm a good C++ developer.
+        minX > 0? --minX : 0;
+        minX < m_ArrayWidth? ++maxX : 0;
+        minY > 0? --minY : 0;
+        minY < m_ArrayWidth? ++maxY : 0;
+        // assume out is clean
+        for (size_t Y = minY; Y < maxY; ++Y)
+            for (size_t X = minX; X < maxX; ++X)
+            {
+                std::vector<T>& subdivision = m_SpatialDivisionsData[X+Y*m_ArrayWidth];
+                if (subdivision.size() != 0)
+                    out.insert(out.end(), subdivision.begin(), subdivision.end());
+            }
+    }
+
+    /**
+     * Returns a sorted list of unique items that includes all items
+     * within the given circular distance of the given point and a few more.
+     */
+    void GetNear(std::vector<T>& out, CFixedVector2D pos, entity_pos_t range)
+    {
+        // TODO: be cleverer and return a circular pattern of divisions,
+        // not this square over-approximation
+        CFixedVector2D r(range, range);
+        GetInRange(out, pos - r, pos + r);
+    }
+    
+    int GetDivisionSize() { return m_SubdivisionSize; };
+    int GetWidth() { return m_ArrayWidth; };
+};
+
+#endif // INCLUDED_SPATIAL2

source/simulation2/components/CCmpRangeManager.cpp

@@ -28 +28 @@
 #include "simulation2/components/ICmpVision.h"
 #include "simulation2/components/ICmpWaterManager.h"
 #include "simulation2/helpers/Render.h"
-#include "simulation2/helpers/Spatial.h"
 
 #include "graphics/Overlay.h"
 #include "graphics/Terrain.h"
@@ -131 +130 @@
 static std::map<entity_id_t, EntityParabolicRangeOutline> ParabolicRangesOutlines;
 
 /**
- * Representation of an entity, with the data needed for queries.
- */
-struct EntityData
-{
-    EntityData() : retainInFog(0), owner(-1), inWorld(0), flags(1) { }
-    entity_pos_t x, z;
-    entity_pos_t visionRange;
-    u8 retainInFog; // boolean
-    i8 owner;
-    u8 inWorld; // boolean
-    u8 flags; // See GetEntityFlagMask
-};
-
-cassert(sizeof(EntityData) == 16);
-
-/**
  * Serialization helper template for Query
  */
 struct SerializeQuery
@@ -193 +176 @@
     template<typename S>
     void operator()(S& serialize, const char* UNUSED(name), EntityData& value)
     {
+        serialize.NumberU32_Unbounded("id", value.id);
         serialize.NumberFixed_Unbounded("x", value.x);
         serialize.NumberFixed_Unbounded("z", value.z);
         serialize.NumberFixed_Unbounded("vision", value.visionRange);
+        serialize.NumberU16_Unbounded("size", value.size);
         serialize.NumberU8("retain in fog", value.retainInFog, 0, 1);
         serialize.NumberI8_Unbounded("owner", value.owner);
         serialize.NumberU8("in world", value.inWorld, 0, 1);
@@ -274 +259 @@
     std::map<tag_t, Query> m_Queries;
     EntityMap<EntityData> m_EntityData;
 
-    SpatialSubdivision m_Subdivision; // spatial index of m_EntityData
+    SpatialTree<const EntityData*> m_Subdivision; // spatial index of m_EntityData
+    std::vector<const EntityData*> queryResultVector;
 
     // LOS state:
     static const player_id_t MAX_LOS_PLAYER_ID = 16;
@@ -328 +314 @@
         m_LosRevealAll.resize(MAX_LOS_PLAYER_ID+2,false);
         m_SharedLosMasks.resize(MAX_LOS_PLAYER_ID+2,0);
 
+        queryResultVector.reserve(12000);
+        
         m_LosCircular = false;
         m_TerrainVerticesPerSide = 0;
 
@@ -395 +383 @@
             if (!cmpPosition)
                 break;
 
-            // The newly-created entity will have owner -1 and position out-of-world
-            // (any initialisation of those values will happen later), so we can just
-            // use the default-constructed EntityData here
-            EntityData entdata;
-
+            // initialization of position-related values happens later.
+            EntityData entdata(ent);
+            
             // Store the LOS data, if any
             CmpPtr<ICmpVision> cmpVision(GetSimContext(), ent);
             if (cmpVision)
@@ -407 +393 @@
                 entdata.visionRange = cmpVision->GetRange();
                 entdata.retainInFog = (cmpVision->GetRetainInFog() ? 1 : 0);
             }
+            
+            // Store the size data, if any
+            CmpPtr<ICmpObstruction> cmpObstruction(GetSimContext(), ent);
+            if (cmpObstruction)
+            {
+                ICmpObstructionManager::ObstructionSquare out;
+                cmpObstruction->GetObstructionSquare(out);
+                size_t size = (out.hh.Square() + out.hw.Square()).Sqrt().ToInt_RoundToInfinity();
+                // avoid overflow, it doesn't really matter as long as this is above subdivision size.
+                if (size > 65530)
+                    size = 65530;
+                entdata.size = (u16)size;
+            }
 
             // Remember this entity
             m_EntityData.insert(ent, entdata);
@@ -429 +428 @@
                 {
                     CFixedVector2D from(it->second.x, it->second.z);
                     CFixedVector2D to(msgData.x, msgData.z);
-                    m_Subdivision.Move(ent, from, to);
+                    m_Subdivision.Move(&it->second, from, to, it->second.size);
                     LosMove(it->second.owner, it->second.visionRange, from, to);
                 }
                 else
                 {
                     CFixedVector2D to(msgData.x, msgData.z);
-                    m_Subdivision.Add(ent, to);
+                    m_Subdivision.Add(&it->second, to, it->second.size);
                     LosAdd(it->second.owner, it->second.visionRange, to);
                 }
 
@@ -448 +447 @@
                 if (it->second.inWorld)
                 {
                     CFixedVector2D from(it->second.x, it->second.z);
-                    m_Subdivision.Remove(ent, from);
+                    m_Subdivision.Remove(&it->second, from, it->second.size);
                     LosRemove(it->second.owner, it->second.visionRange, from);
                 }
 
@@ -494 +493 @@
                 break;
 
             if (it->second.inWorld)
-                m_Subdivision.Remove(ent, CFixedVector2D(it->second.x, it->second.z));
+                m_Subdivision.Remove(&it->second, CFixedVector2D(it->second.x, it->second.z), it->second.size);
 
             // This will be called after Ownership's OnDestroy, so ownership will be set
             // to -1 already and we don't have to do a LosRemove here
@@ -573 +572 @@
 
         std::vector<std::vector<u16> > oldPlayerCounts = m_LosPlayerCounts;
         std::vector<u32> oldStateRevealed = m_LosStateRevealed;
-        SpatialSubdivision oldSubdivision = m_Subdivision;
+        SpatialTree<const EntityData*> oldSubdivision = m_Subdivision;
 
         ResetDerivedData(true);
 
@@ -601 +600 @@
             debug_warn(L"inconsistent subdivs");
     }
 
-    SpatialSubdivision* GetSubdivision()
+    SpatialTree<const EntityData*>* GetSubdivision()
     {
-        return & m_Subdivision;
+        return &m_Subdivision;
     }
 
     // Reinitialise subdivisions and LOS data, based on entity data
@@ -661 +660 @@
 
     void ResetSubdivisions(entity_pos_t x1, entity_pos_t z1)
     {
-        // Use 8x8 tile subdivisions
-        // (TODO: find the optimal number instead of blindly guessing)
-        m_Subdivision.Reset(x1, z1, entity_pos_t::FromInt(8*TERRAIN_TILE_SIZE));
+        m_Subdivision.Reset(x1.ToInt_RoundToInfinity(), z1.ToInt_RoundToInfinity());
 
         for (EntityMap<EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
         {
             if (it->second.inWorld)
-                m_Subdivision.Add(it->first, CFixedVector2D(it->second.x, it->second.z));
+                m_Subdivision.Add(&it->second, CFixedVector2D(it->second.x, it->second.z), it->second.size);
         }
     }
 
@@ -939 +936 @@
             CFixedVector3D pos3d = cmpSourcePosition->GetPosition()+
                 CFixedVector3D(entity_pos_t::Zero(), q.elevationBonus, entity_pos_t::Zero()) ;
             // Get a quick list of entities that are potentially in range, with a cutoff of 2*maxRange
-            SpatialQueryArray ents;
-            m_Subdivision.GetNear(ents, pos, q.maxRange*2);
+            queryResultVector.clear();
+            m_Subdivision.GetNear(queryResultVector, pos, q.maxRange*2);
 
-            for (int i = 0; i < ents.size(); ++i)
+            for (size_t i = 0; i < queryResultVector.size(); ++i)
             {
-                EntityMap<EntityData>::const_iterator it = m_EntityData.find(ents[i]);
-                ENSURE(it != m_EntityData.end());
+                //EntityMap<EntityData>::const_iterator it = m_EntityData.find(ents[i]);
+                //ENSURE(it != m_EntityData.end());
 
-                if (!TestEntityQuery(q, it->first, it->second))
+                if (!TestEntityQuery(q, queryResultVector[i]->id, *queryResultVector[i]))
                     continue;
 
-                CmpPtr<ICmpPosition> cmpSecondPosition(GetSimContext(), ents[i]);
+                CmpPtr<ICmpPosition> cmpSecondPosition(GetSimContext(), queryResultVector[i]->id);
                 if (!cmpSecondPosition || !cmpSecondPosition->IsInWorld())
                     continue;
                 CFixedVector3D secondPosition = cmpSecondPosition->GetPosition();
 
                 // Restrict based on precise distance
                 if (!InParabolicRange(
-                        CFixedVector3D(it->second.x, secondPosition.Y, it->second.z)
+                        CFixedVector3D(queryResultVector[i]->x, secondPosition.Y, queryResultVector[i]->z)
                             - pos3d,
                         q.maxRange))
                     continue;
 
                 if (!q.minRange.IsZero())
                 {
-                    int distVsMin = (CFixedVector2D(it->second.x, it->second.z) - pos).CompareLength(q.minRange);
+                    int distVsMin = (CFixedVector2D(queryResultVector[i]->x, queryResultVector[i]->z) - pos).CompareLength(q.minRange);
                     if (distVsMin < 0)
                         continue;
                 }
 
-                r.push_back(it->first);
+                r.push_back(queryResultVector[i]->id);
             }
         }
         // check a regular range (i.e. not the entire world, and not parabolic)
         else
         {
             // Get a quick list of entities that are potentially in range
-            SpatialQueryArray ents;
-            m_Subdivision.GetNear(ents, pos, q.maxRange);
+            queryResultVector.clear();
+            m_Subdivision.GetNear(queryResultVector, pos, q.maxRange);
 
-            for (int i = 0; i < ents.size(); ++i)
+            for (size_t i = 0; i < queryResultVector.size(); ++i)
             {
-                EntityMap<EntityData>::const_iterator it = m_EntityData.find(ents[i]);
-                ENSURE(it != m_EntityData.end());
+                //EntityMap<EntityData>::const_iterator it = m_EntityData.find(ents[i]);
+                //ENSURE(it != m_EntityData.end());
 
-                if (!TestEntityQuery(q, it->first, it->second))
+                if (!TestEntityQuery(q, queryResultVector[i]->id, *queryResultVector[i]))
                     continue;
 
                 // Restrict based on precise distance
-                int distVsMax = (CFixedVector2D(it->second.x, it->second.z) - pos).CompareLength(q.maxRange);
+                int distVsMax = (CFixedVector2D(queryResultVector[i]->x, queryResultVector[i]->z) - pos).CompareLength(q.maxRange);
                 if (distVsMax > 0)
                     continue;
 
                 if (!q.minRange.IsZero())
                 {
-                    int distVsMin = (CFixedVector2D(it->second.x, it->second.z) - pos).CompareLength(q.minRange);
+                    int distVsMin = (CFixedVector2D(queryResultVector[i]->x, queryResultVector[i]->z) - pos).CompareLength(q.minRange);
                     if (distVsMin < 0)
                         continue;
                 }
 
-                r.push_back(it->first);
+                r.push_back(queryResultVector[i]->id);
             }
         }
     }
@@ -1264 +1261 @@
             }
 
             // render subdivision grid
-            float divSize = m_Subdivision.GetDivisionSize().ToFloat();
+            int divSize = m_Subdivision.GetDivisionSize();
             int width = m_Subdivision.GetWidth();
-            int height = m_Subdivision.GetHeight();
             for (int x = 0; x < width; ++x)
             {
-                for (int y = 0; y < height; ++y)
+                for (int y = 0; y < width; ++y)
                 {
                     m_DebugOverlayLines.push_back(SOverlayLine());
                     m_DebugOverlayLines.back().m_Color = subdivColour;

source/simulation2/components/ICmpRangeManager.h

@@ -24 +24 @@
 #include "simulation2/system/Interface.h"
 #include "simulation2/helpers/Position.h"
 #include "simulation2/helpers/Player.h"
-#include "simulation2/helpers/Spatial.h"
+#include "simulation2/helpers/Spatial_2.h"
 
 #include "graphics/Terrain.h" // for TERRAIN_TILE_SIZE
 
@@ -65 +65 @@
  * sent to the entity once per turn if anybody has entered or left the range since the last RangeUpdate.
  * Queries can be disabled, in which case no message will be sent.
  */
+
+/**
+ * Representation of an entity, with the data needed for queries.
+ */
+struct EntityData
+{
+    EntityData() : retainInFog(0), owner(-1), inWorld(0), flags(1) { }
+    EntityData(entity_id_t ID) : retainInFog(0), owner(-1), inWorld(0), flags(1), id(ID) { }
+    entity_id_t id;
+    entity_pos_t x, z;
+    entity_pos_t visionRange;
+    u16 size;
+    u8 retainInFog; // boolean
+    i8 owner;
+    u8 inWorld; // boolean
+    u8 flags; // See GetEntityFlagMask
+};
+
+cassert(sizeof(EntityData) == 24);
+
 class ICmpRangeManager : public IComponent
 {
 public:
@@ -77 +97 @@
      * Access the spatial subdivision kept by the range manager.
      * @return pointer to spatial subdivision structure.
      */
-    virtual SpatialSubdivision* GetSubdivision() = 0;
+    virtual SpatialTree<const EntityData*>* GetSubdivision() = 0;
 
     /**
      * Set the bounds of the world.

source/simulation2/helpers/Selection.cpp

@@ -27 +27 @@
 #include "simulation2/components/ICmpTemplateManager.h"
 #include "simulation2/components/ICmpSelectable.h"
 #include "simulation2/components/ICmpVisual.h"
-#include "simulation2/helpers/Spatial.h"
 #include "ps/CLogger.h"
 #include "ps/Profiler2.h"
 
@@ -49 +48 @@
     CFixedVector2D pos(fixed::FromFloat(pos3d.X), fixed::FromFloat(pos3d.Z));
 
     // Get a rough group of entities using our approximated origin.
-    SpatialQueryArray ents;
+    std::vector<const EntityData*> ents;
     cmpRangeManager->GetSubdivision()->GetNear(ents, pos, entity_pos_t::FromInt(range));
 
     // Filter for relevent entities and calculate precise distances.
     std::vector<std::pair<float, entity_id_t> > hits; // (dist^2, entity) pairs
-    for (int i = 0; i < ents.size(); ++i)
+    for (size_t i = 0; i < ents.size(); ++i)
     {
-        CmpPtr<ICmpSelectable> cmpSelectable(simulation, ents[i]);
+        CmpPtr<ICmpSelectable> cmpSelectable(simulation, ents[i]->id);
         if (!cmpSelectable)
             continue;
 
@@ -107 +106 @@
         CVector3D closest = origin + dir * (center - origin).Dot(dir);
         dist2 = (closest - center).LengthSquared();
 
-        hits.push_back(std::make_pair(dist2, ents[i]));
+        hits.push_back(std::make_pair(dist2, ents[i]->id));
     }
 
     // Sort hits by distance