Ticket #2430: newSubdivision.2.patch

source/simulation2/components/CCmpObstruction.cpp

@@ -470 +470 @@
             pos = cmpPosition->GetPreviousPosition2D();
         else
             pos = cmpPosition->GetPosition2D();
-        if (m_Type == STATIC)
-            out = cmpObstructionManager->GetStaticShapeObstruction(pos.X, pos.Y, cmpPosition->GetRotation().Y, m_Size0, m_Size1);
-        else if (m_Type == UNIT)
+        if (m_Type == UNIT)
             out = cmpObstructionManager->GetUnitShapeObstruction(pos.X, pos.Y, m_Size0);
         else
             out = cmpObstructionManager->GetStaticShapeObstruction(pos.X, pos.Y, cmpPosition->GetRotation().Y, m_Size0, m_Size1);
@@ -487 +485 @@
             return entity_pos_t::Zero();
     }
 
+    virtual entity_pos_t GetSize()
+    {
+        if (m_Type == UNIT)
+            return m_Size0;
+        else
+            return CFixedVector2D(m_Size0 / 2, m_Size1 / 2).Length();
+    }
+
     virtual bool IsControlPersistent()
     {
         return m_ControlPersist;

source/simulation2/components/CCmpRangeManager.cpp

@@ -32 +32 @@
 #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"
@@ -172 +171 @@
  */
 struct EntityData
 {
-    EntityData() : visibilities(0), retainInFog(0), owner(-1), inWorld(0), flags(1), scriptedVisibility(0) { }
+    EntityData() : visibilities(0), size(0), retainInFog(0), owner(-1), inWorld(0), flags(1), scriptedVisibility(0) { }
     entity_pos_t x, z;
     entity_pos_t visionRange;
     u32 visibilities; // 2-bit visibility, per player
+    u32 size;
     u8 retainInFog; // boolean
     i8 owner;
     u8 inWorld; // boolean
@@ -183 +183 @@
     u8 scriptedVisibility; // boolean, see ComputeLosVisibility
 };
 
-cassert(sizeof(EntityData) == 24);
+cassert(sizeof(EntityData) == 28);
 
 /**
  * Serialization helper template for Query
@@ -236 +236 @@
         serialize.NumberFixed_Unbounded("z", value.z);
         serialize.NumberFixed_Unbounded("vision", value.visionRange);
         serialize.NumberU32_Unbounded("visibilities", value.visibilities);
+        serialize.NumberU32_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);
@@ -314 +315 @@
     std::map<tag_t, Query> m_Queries;
     EntityMap<EntityData> m_EntityData;
 
-    SpatialSubdivision m_Subdivision; // spatial index of m_EntityData
+    FastSpatialSubdivision m_Subdivision; // spatial index of m_EntityData
 
     // LOS state:
     static const player_id_t MAX_LOS_PLAYER_ID = 16;
@@ -461 +462 @@
             if (cmpVisibility)
                 entdata.retainInFog = (cmpVisibility->GetRetainInFog() ? 1 : 0);
 
+            // Store the size
+            CmpPtr<ICmpObstruction> cmpObstruction(GetSimContext(), ent);
+            if (cmpObstruction)
+                entdata.size = cmpObstruction->GetSize().ToInt_RoundToInfinity();
+
             // Remember this entity
             m_EntityData.insert(ent, entdata);
             break;
@@ -482 +488 @@
                 {
                     CFixedVector2D from(it->second.x, it->second.z);
                     CFixedVector2D to(msgData.x, msgData.z);
-                    m_Subdivision.Move(ent, from, to);
+                    m_Subdivision.Move(ent, from, to, it->second.size);
                     LosMove(it->second.owner, it->second.visionRange, from, to);
                     i32 oldLosTile = PosToLosTilesHelper(it->second.x, it->second.z);
                     i32 newLosTile = PosToLosTilesHelper(msgData.x, msgData.z);
@@ -495 +501 @@
                 else
                 {
                     CFixedVector2D to(msgData.x, msgData.z);
-                    m_Subdivision.Add(ent, to);
+                    m_Subdivision.Add(ent, to, it->second.size);
                     LosAdd(it->second.owner, it->second.visionRange, to);
                     AddToTile(PosToLosTilesHelper(msgData.x, msgData.z), ent);
                 }
@@ -509 +515 @@
                 if (it->second.inWorld)
                 {
                     CFixedVector2D from(it->second.x, it->second.z);
-                    m_Subdivision.Remove(ent, from);
+                    m_Subdivision.Remove(ent, from, it->second.size);
                     LosRemove(it->second.owner, it->second.visionRange, from);
                     RemoveFromTile(PosToLosTilesHelper(it->second.x, it->second.z), ent);
                 }
@@ -559 +565 @@
 
             if (it->second.inWorld)
             {
-                m_Subdivision.Remove(ent, CFixedVector2D(it->second.x, it->second.z));
+                m_Subdivision.Remove(ent, CFixedVector2D(it->second.x, it->second.z), it->second.size);
                 RemoveFromTile(PosToLosTilesHelper(it->second.x, it->second.z), ent);
             }
 
@@ -640 +646 @@
 
         std::vector<std::vector<u16> > oldPlayerCounts = m_LosPlayerCounts;
         std::vector<u32> oldStateRevealed = m_LosStateRevealed;
-        SpatialSubdivision oldSubdivision = m_Subdivision;
+        FastSpatialSubdivision oldSubdivision = m_Subdivision;
         std::vector<std::set<entity_id_t> > oldLosTiles = m_LosTiles;
 
         ResetDerivedData(true);
@@ -671 +677 @@
             debug_warn(L"inconsistent los tiles");
     }
 
-    SpatialSubdivision* GetSubdivision()
+    FastSpatialSubdivision* GetSubdivision()
     {
-        return & m_Subdivision;
+        return &m_Subdivision;
     }
 
     // Reinitialise subdivisions and LOS data, based on entity data
@@ -744 +750 @@
 
     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, z1);
 
         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->first, CFixedVector2D(it->second.x, it->second.z), it->second.size);
         }
     }
 
@@ -1347 +1351 @@
             }
 
             // render subdivision grid
-            float divSize = m_Subdivision.GetDivisionSize().ToFloat();
-            int width = m_Subdivision.GetWidth();
-            int height = m_Subdivision.GetHeight();
-            for (int x = 0; x < width; ++x)
+            float divSize = m_Subdivision.GetDivisionSize();
+            int size = m_Subdivision.GetWidth();
+            for (int x = 0; x < size; ++x)
             {
-                for (int y = 0; y < height; ++y)
+                for (int y = 0; y < size; ++y)
                 {
                     m_DebugOverlayLines.push_back(SOverlayLine());
                     m_DebugOverlayLines.back().m_Color = subdivColor;

source/simulation2/components/ICmpObstruction.h

@@ -52 +52 @@
      */
     virtual bool GetPreviousObstructionSquare(ICmpObstructionManager::ObstructionSquare& out) = 0;
 
+    virtual entity_pos_t GetSize() = 0;
+
     virtual entity_pos_t GetUnitRadius() = 0;
 
     virtual bool IsControlPersistent() = 0;

source/simulation2/components/ICmpRangeManager.h

@@ -77 +77 @@
      * Access the spatial subdivision kept by the range manager.
      * @return pointer to spatial subdivision structure.
      */
-    virtual SpatialSubdivision* GetSubdivision() = 0;
+    virtual FastSpatialSubdivision* GetSubdivision() = 0;
 
     /**
      * Set the bounds of the world.

source/simulation2/helpers/Selection.cpp

@@ -28 +28 @@
 #include "simulation2/components/ICmpSelectable.h"
 #include "simulation2/components/ICmpVisual.h"
 #include "simulation2/components/ICmpUnitRenderer.h"
-#include "simulation2/helpers/Spatial.h"
 #include "ps/CLogger.h"
 #include "ps/Profiler2.h"
 

source/simulation2/helpers/Spatial.h

@@ -1 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2015 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -32 +32 @@
  * Move/Remove are called with the same coordinates originally passed
  * to Add (since this class doesn't remember which divisions an item
  * occupies).
- *
- * (TODO: maybe an adaptive quadtree would be better than fixed sizes?)
  */
 class SpatialSubdivision
 {
@@ -66 +64 @@
     uint32_t m_DivisionsW;
     uint32_t m_DivisionsH;
 
-    friend struct SerializeSubDivisionGrid;
     friend struct SerializeSpatialSubdivision;
 
 public:
@@ -346 +343 @@
     }
 };
 
+
+/**
+ * A basic square subdivision scheme for finding entities in range
+ * More efficient than SpatialSubdivision, but a bit less precise 
+ * (so the querier will get more entities to perform tests on).
+ *
+ * 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.
+ *
+ * It is the caller's responsibility to ensure items are only added once, aren't removed 
+ * unless they've been added, etc, and that Move/Remove are called with the same coordinates
+ * originally passed to Add (since this class doesn't remember which divisions an item
+ * occupies).
+ *
+ * TODO: If a unit size were to change, it would need to be updated (that doesn't happen for now)
+ */
+class FastSpatialSubdivision
+{
+private:
+    static const int SUBDIVISION_SIZE = 20; // bigger than most buildings and entities
+
+    std::vector<entity_id_t> m_OverSizedData;
+    std::vector<entity_id_t>* m_SpatialDivisionsData;   // fixed size array of subdivisions
+    size_t m_ArrayWidth; // number of columns in m_SpatialDivisionsData
+
+    inline size_t Index(fixed position)
+    {
+        return (position / SUBDIVISION_SIZE).ToInt_RoundToZero();
+    }
+
+    inline size_t SubdivisionIdx(CFixedVector2D position)
+    {
+        return Index(position.X) + Index(position.Y)*m_ArrayWidth;
+    }
+
+    /**
+     * Efficiently erase from a vector by swapping with the last element and popping it.
+     * Returns true if the element was found and erased, else returns false.
+     */
+    bool EraseFrom(std::vector<entity_id_t>& vector, entity_id_t item)
+    {
+        auto it = std::find(vector.begin(), vector.end(), item);
+        if (it == vector.end())
+            return false;
+
+        if ((int)vector.size() > 1)
+            *it = vector.back();
+        vector.pop_back();
+        return true;
+    }
+
+public:
+    FastSpatialSubdivision() : 
+        m_SpatialDivisionsData(NULL), m_ArrayWidth(0) 
+    {
+    }
+
+    FastSpatialSubdivision(const FastSpatialSubdivision& other) : 
+        m_SpatialDivisionsData(NULL), m_ArrayWidth(0)
+    {
+        Reset(other.m_ArrayWidth);
+        std::copy(&other.m_SpatialDivisionsData[0], &other.m_SpatialDivisionsData[m_ArrayWidth*m_ArrayWidth], m_SpatialDivisionsData);
+    }
+
+    ~FastSpatialSubdivision()
+    {
+        if (m_SpatialDivisionsData)
+            delete[] m_SpatialDivisionsData;
+    }
+
+    void Reset(size_t arrayWidth)
+    {
+        if (m_SpatialDivisionsData)
+            SAFE_ARRAY_DELETE(m_SpatialDivisionsData);
+
+        m_ArrayWidth = arrayWidth;
+        m_SpatialDivisionsData = new std::vector<entity_id_t>[m_ArrayWidth*m_ArrayWidth];
+        m_OverSizedData.clear();
+    }
+
+    void Reset(fixed w, fixed h)
+    {
+        Reset(std::max(Index(w), Index(h)) + 1);
+    }
+
+    FastSpatialSubdivision& operator=(const FastSpatialSubdivision& other)
+    {
+        if (this != &other)
+        {
+            Reset(other.m_ArrayWidth);
+            std::copy(&other.m_SpatialDivisionsData[0], &other.m_SpatialDivisionsData[m_ArrayWidth*m_ArrayWidth], m_SpatialDivisionsData);
+        }
+        return *this;
+    }
+
+    bool operator==(const FastSpatialSubdivision& 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 FastSpatialSubdivision& rhs)
+    {
+        return !(*this == rhs);
+    }
+
+    /**
+     * Add an item.
+     */
+    void Add(entity_id_t item, CFixedVector2D position, u32 size)
+    {
+        if (size > SUBDIVISION_SIZE)
+        {
+            if (std::find(m_OverSizedData.begin(), m_OverSizedData.end(), item) == m_OverSizedData.end())
+                m_OverSizedData.push_back(item);
+        }
+        else 
+        {
+            std::vector<entity_id_t>& subdivision = m_SpatialDivisionsData[SubdivisionIdx(position)];
+            if (std::find(subdivision.begin(), subdivision.end(), item) == subdivision.end())
+                subdivision.push_back(item);
+        }
+    }
+
+    /**
+     * Remove an item.
+     * Position must be where we expect to find it, or we won't find it.
+     */
+    void Remove(entity_id_t item, CFixedVector2D position, u32 size)
+    {
+        if (size > SUBDIVISION_SIZE)
+            EraseFrom(m_OverSizedData, item);
+        else 
+        {
+            std::vector<entity_id_t>& subdivision = m_SpatialDivisionsData[SubdivisionIdx(position)];
+            EraseFrom(subdivision, item);
+        }
+    }
+
+    /**
+     * Equivalent to Remove() then Add(), but slightly faster.
+     * In particular for big objects nothing needs to be done.
+     */
+    void Move(entity_id_t item, CFixedVector2D oldPosition, CFixedVector2D newPosition, u32 size)
+    {       
+        if (size > SUBDIVISION_SIZE)
+            return;
+        if (SubdivisionIdx(newPosition) == SubdivisionIdx(oldPosition))
+            return;
+
+        std::vector<entity_id_t>& oldSubdivision = m_SpatialDivisionsData[SubdivisionIdx(oldPosition)];
+        if (EraseFrom(oldSubdivision, item))
+        {
+            std::vector<entity_id_t>& newSubdivision = m_SpatialDivisionsData[SubdivisionIdx(newPosition)];
+            newSubdivision.push_back(item);
+        }
+    }
+
+    /**
+     * Returns a sorted list of items that are either in the square or close to it.
+     * It's the responsibility of the querier to do proper distance checking.
+     */
+    void GetInRange(std::vector<entity_id_t>& out, CFixedVector2D posMin, CFixedVector2D posMax)
+    {
+        size_t minX = Index(posMin.X);
+        size_t minY = Index(posMin.Y);
+        size_t maxX = Index(posMax.X) + 1;
+        size_t maxY = Index(posMax.Y) + 1;
+
+        // Now expand the subdivisions by one so we make sure we've got all elements potentially in range.
+        // Also make sure min >= 0 and max <= width
+        minX = minX > 0 ? minX-1 : 0;
+        minY = minY > 0 ? minY-1 : 0;
+        maxX = maxX < m_ArrayWidth ? maxX+1 : m_ArrayWidth;
+        maxY = maxY < m_ArrayWidth ? maxY+1 : m_ArrayWidth;
+
+        ENSURE(out.empty() && "GetInRange: out is not clean");
+
+        // Add oversized items, they can be anywhere
+        out.insert(out.end(), m_OverSizedData.begin(), m_OverSizedData.end());
+
+        for (size_t Y = minY; Y < maxY; ++Y)
+        {
+            for (size_t X = minX; X < maxX; ++X)
+            {
+                std::vector<entity_id_t>& subdivision = m_SpatialDivisionsData[X + Y*m_ArrayWidth];
+                if (!subdivision.empty())
+                    out.insert(out.end(), subdivision.begin(), subdivision.end());
+            }
+        }
+
+        std::sort(out.begin(), out.end());
+    }
+
+    /**
+     * Returns a sorted list of items that are either in the circle or close to it.
+     * It's the responsibility of the querier to do proper distance checking.
+     */
+    void GetNear(std::vector<entity_id_t>& out, CFixedVector2D pos, entity_pos_t range)
+    {
+        // Because the subdivision size is rather big wrt typical ranges, 
+        // this square over-approximation is hopefully not too bad.
+        CFixedVector2D r(range, range);
+        GetInRange(out, pos - r, pos + r);
+    }
+
+    size_t GetDivisionSize() const
+    {
+        return SUBDIVISION_SIZE;
+    }
+
+    size_t GetWidth() const 
+    { 
+        return m_ArrayWidth; 
+    }
+};
+
 #endif // INCLUDED_SPATIAL