Ticket #930: ticket930-poc.patch

source/simulation2/components/CCmpObstructionManager.cpp

@@ -250 +250 @@
         UnitShape shape = { ent, x, z, r, flags, group };
         u32 id = m_UnitShapeNext++;
         m_UnitShapes[id] = shape;
-        MakeDirtyUnit(flags);
+        MakeDirtyUnit(shape);
 
         m_UnitSubdivision.Add(id, CFixedVector2D(x - r, z - r), CFixedVector2D(x + r, z + r));
 
@@ -267 +267 @@
         StaticShape shape = { ent, x, z, u, v, w/2, h/2, flags };
         u32 id = m_StaticShapeNext++;
         m_StaticShapes[id] = shape;
-        MakeDirtyStatic(flags);
+        MakeDirtyStatic(shape);
 
         CFixedVector2D center(x, z);
         CFixedVector2D bbHalfSize = Geometry::GetHalfBoundingBox(u, v, CFixedVector2D(w/2, h/2));
@@ -312 +312 @@
             shape.x = x;
             shape.z = z;
 
-            MakeDirtyUnit(shape.flags);
+            MakeDirtyUnit(shape);
         }
         else
         {
@@ -336 +336 @@
             shape.u = u;
             shape.v = v;
 
-            MakeDirtyStatic(shape.flags);
+            MakeDirtyStatic(shape);
         }
     }
 
@@ -378 +378 @@
                 CFixedVector2D(shape.x - shape.r, shape.z - shape.r),
                 CFixedVector2D(shape.x + shape.r, shape.z + shape.r));
 
-            MakeDirtyUnit(shape.flags);
+            MakeDirtyUnit(shape);
             m_UnitShapes.erase(TAG_TO_INDEX(tag));
         }
         else
@@ -389 +389 @@
             CFixedVector2D bbHalfSize = Geometry::GetHalfBoundingBox(shape.u, shape.v, CFixedVector2D(shape.hw, shape.hh));
             m_StaticSubdivision.Remove(TAG_TO_INDEX(tag), center - bbHalfSize, center + bbHalfSize);
 
-            MakeDirtyStatic(shape.flags);
+            MakeDirtyStatic(shape);
             m_StaticShapes.erase(TAG_TO_INDEX(tag));
         }
     }
@@ -420 +420 @@
 
     virtual bool Rasterise(Grid<u8>& grid);
     virtual void GetObstructionsInRange(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, std::vector<ObstructionSquare>& squares);
+    void GetShapesInRange(entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, std::map<u32, UnitShape>& outUnitShapes, std::map<u32, StaticShape>& outStaticShapes);
     virtual bool FindMostImportantObstruction(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t r, ObstructionSquare& square);
 
     virtual void SetPassabilityCircular(bool enabled)
@@ -444 +445 @@
     // if a grid has a lower DirtyID then it needs to be updated.
 
     size_t m_DirtyID;
+    entity_pos_t m_DirtyX0;
+    entity_pos_t m_DirtyZ0;
+    entity_pos_t m_DirtyX1;
+    entity_pos_t m_DirtyZ1;
+    // XXX: this probably breaks if used with multiple independently-dirtyable grids
 
     /**
      * Mark all previous Rasterise()d grids as dirty, and the debug display.
@@ -453 +459 @@
     {
         ++m_DirtyID;
         m_DebugOverlayDirty = true;
+        m_DirtyX0 = m_WorldX0;
+        m_DirtyZ0 = m_WorldZ0;
+        m_DirtyX1 = m_WorldX1;
+        m_DirtyZ1 = m_WorldZ1;
     }
 
     /**
@@ -468 +478 @@
      * Mark all previous Rasterise()d grids as dirty, if they depend on this shape.
      * Call this when a static shape has changed.
      */
-    void MakeDirtyStatic(flags_t flags)
+    void MakeDirtyStatic(const StaticShape& shape)
     {
-        if (flags & (FLAG_BLOCK_PATHFINDING|FLAG_BLOCK_FOUNDATION))
+        if (shape.flags & (FLAG_BLOCK_PATHFINDING|FLAG_BLOCK_FOUNDATION))
+        {
             ++m_DirtyID;
+            CFixedVector2D halfSize(shape.hw, shape.hh);
+            CFixedVector2D halfBound = Geometry::GetHalfBoundingBox(shape.u, shape.v, halfSize);
+            m_DirtyX0 = std::min(m_DirtyX0, shape.x - halfBound.X);
+            m_DirtyZ0 = std::min(m_DirtyZ0, shape.z - halfBound.Y);
+            m_DirtyX1 = std::max(m_DirtyX1, shape.x + halfBound.X);
+            m_DirtyZ1 = std::max(m_DirtyZ1, shape.z + halfBound.Y);
+        }
 
         m_DebugOverlayDirty = true;
     }
@@ -480 +498 @@
      * Mark all previous Rasterise()d grids as dirty, if they depend on this shape.
      * Call this when a unit shape has changed.
      */
-    void MakeDirtyUnit(flags_t flags)
+    void MakeDirtyUnit(const UnitShape& shape)
     {
-        if (flags & (FLAG_BLOCK_PATHFINDING|FLAG_BLOCK_FOUNDATION))
+        if (shape.flags & (FLAG_BLOCK_PATHFINDING|FLAG_BLOCK_FOUNDATION))
+        {
             ++m_DirtyID;
+            entity_pos_t r = shape.r;
+            m_DirtyX0 = std::min(m_DirtyX0, shape.x - r);
+            m_DirtyZ0 = std::min(m_DirtyZ0, shape.z - r);
+            m_DirtyX1 = std::max(m_DirtyX1, shape.x + r);
+            m_DirtyZ1 = std::max(m_DirtyZ1, shape.z + r);
+        }
 
         m_DebugOverlayDirty = true;
     }
@@ -708 +733 @@
     if (!IsDirty(grid))
         return false;
 
-    PROFILE("Rasterise");
+    PROFILE3("Rasterise");
+    TIMER(L"Rasterise");
 
     grid.m_DirtyID = m_DirtyID;
 
@@ -716 +742 @@
     // What we should perhaps do is have some kind of quadtree storing Shapes so it's
     // quick to invalidate and update small numbers of tiles
 
-    grid.reset();
+//  grid.reset();
 
     // For tile-based pathfinding:
     // Since we only count tiles whose centers are inside the square,
@@ -733 +759 @@
     // so we need to expand by at least 1/sqrt(2) of a tile
     entity_pos_t expandFoundation = (entity_pos_t::FromInt(CELL_SIZE) * 3) / 4;
 
-    for (std::map<u32, StaticShape>::iterator it = m_StaticShapes.begin(); it != m_StaticShapes.end(); ++it)
+
+//  debug_printf(L"# Rasterising region %f %f %f %f\n", m_DirtyX0.ToFloat(), m_DirtyZ0.ToFloat(), m_DirtyX1.ToFloat(), m_DirtyZ1.ToFloat());
+
+    // XXX: if it's a large region (e.g. the whole map changed), we should just
+    // reset the entire grid and redraw every shape, instead of doing GetShapesInRange etc
+
+    // XXX: we should do a fancier dirty-rectangles, so if there were two small changes
+    // on opposite sides of the map we won't have to re-rasterise all the tiles in between
+
+    u16 dirtyI0, dirtyJ0, dirtyI1, dirtyJ1;
+    entity_pos_t dirtyExpand = std::max(expandPathfinding, expandFoundation) * 2; // expand by hopefully enough to avoid missing some edges (XXX: this might not be right)
+    NearestTile(m_DirtyX0 - dirtyExpand, m_DirtyZ0 - dirtyExpand, dirtyI0, dirtyJ0, grid.m_W, grid.m_H);
+    NearestTile(m_DirtyX1 + dirtyExpand, m_DirtyZ1 + dirtyExpand, dirtyI1, dirtyJ1, grid.m_W, grid.m_H);
+
+    grid.reset(dirtyI0, dirtyJ0, dirtyI1, dirtyJ1);
+
+    std::map<u32, StaticShape> staticShapes;
+    std::map<u32, UnitShape> unitShapes;
+    GetShapesInRange(m_DirtyX0 - dirtyExpand*2, m_DirtyZ0 - dirtyExpand*2, m_DirtyX1 + dirtyExpand*2, m_DirtyZ1 + dirtyExpand*2, unitShapes, staticShapes);
+    // XXX: should make GetShapesInRange only return shapes with the appropriate flags
+    // XXX: to minimise memory allocation, should return shape lists as std::vector<u32>
+    // instead of creating a std::map and copying the actual shape structs.
+    // Or we could just use m_StaticSubdivision.GetInRange directly here.
+
+    // Reset dirty region to empty
+    m_DirtyX0 = m_WorldX1;
+    m_DirtyZ0 = m_WorldZ1;
+    m_DirtyX1 = m_WorldX0;
+    m_DirtyZ1 = m_WorldZ0;
+
+    for (std::map<u32, StaticShape>::iterator it = staticShapes.begin(); it != staticShapes.end(); ++it)
     {
         CFixedVector2D center(it->second.x, it->second.z);
 
@@ -778 +834 @@
         }
     }
 
-    for (std::map<u32, UnitShape>::iterator it = m_UnitShapes.begin(); it != m_UnitShapes.end(); ++it)
+    for (std::map<u32, UnitShape>::iterator it = unitShapes.begin(); it != unitShapes.end(); ++it)
     {
         CFixedVector2D center(it->second.x, it->second.z);
 
@@ -816 +872 @@
 
     if (m_PassabilityCircular)
     {
-        for (u16 j = 0; j < grid.m_H; ++j)
+        for (u16 j = dirtyJ0; j < dirtyJ1; ++j)
         {
-            for (u16 i = 0; i < grid.m_W; ++i)
+            for (u16 i = dirtyI0; i < dirtyI1; ++i)
             {
                 // Based on CCmpRangeManager::LosIsOffWorld
                 // but tweaked since it's tile-based instead.
@@ -840 +896 @@
         NearestTile(m_WorldX0, m_WorldZ0, i0, j0, grid.m_W, grid.m_H);
         NearestTile(m_WorldX1, m_WorldZ1, i1, j1, grid.m_W, grid.m_H);
 
+        // XXX: use dirty region
         for (u16 j = 0; j < grid.m_H; ++j)
             for (u16 i = 0; i < i0+edgeSize; ++i)
                 grid.set(i, j, edgeFlags);
@@ -906 +963 @@
     }
 }
 
+void CCmpObstructionManager::GetShapesInRange(entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, std::map<u32, UnitShape>& outUnitShapes, std::map<u32, StaticShape>& outStaticShapes)
+{
+    ENSURE(x0 <= x1 && z0 <= z1);
+
+    std::vector<u32> unitShapes = m_UnitSubdivision.GetInRange(CFixedVector2D(x0, z0), CFixedVector2D(x1, z1));
+    for (size_t i = 0; i < unitShapes.size(); ++i)
+    {
+        std::map<u32, UnitShape>::iterator it = m_UnitShapes.find(unitShapes[i]);
+        ENSURE(it != m_UnitShapes.end());
+
+        entity_pos_t r = it->second.r;
+
+        // Skip this object if it's completely outside the requested range
+        if (it->second.x + r < x0 || it->second.x - r > x1 || it->second.z + r < z0 || it->second.z - r > z1)
+            continue;
+
+        outUnitShapes.insert(*it);
+    }
+
+    std::vector<u32> staticShapes = m_StaticSubdivision.GetInRange(CFixedVector2D(x0, z0), CFixedVector2D(x1, z1));
+    for (size_t i = 0; i < staticShapes.size(); ++i)
+    {
+        std::map<u32, StaticShape>::iterator it = m_StaticShapes.find(staticShapes[i]);
+        ENSURE(it != m_StaticShapes.end());
+
+        entity_pos_t r = it->second.hw + it->second.hh; // overestimate the max dist of an edge from the center
+
+        // Skip this object if its overestimated bounding box is completely outside the requested range
+        if (it->second.x + r < x0 || it->second.x - r > x1 || it->second.z + r < z0 || it->second.z - r > z1)
+            continue;
+
+        outStaticShapes.insert(*it);
+    }
+}
+
 bool CCmpObstructionManager::FindMostImportantObstruction(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t r, ObstructionSquare& square)
 {
     std::vector<ObstructionSquare> squares;

source/simulation2/helpers/Grid.h

@@ -80 +80 @@
             memset(m_Data, 0, m_W*m_H*sizeof(T));
     }
 
+    // Reset all tiles i0 <= i <= i1, j0 <= j <= j1
+    void reset(int i0, int j0, int i1, int j1)
+    {
+        ENSURE(0 <= i0 && i0 < m_W && 0 <= i1 && i1 < m_W && 0 <= j0 && j0 < m_H && 0 <= j1 && j1 < m_H);
+        for (int j = j0; j <= j1; ++j)
+            for (int i = i0; i <= i1; ++i)
+                m_Data[j*m_W + i] = 0;
+    }
+
     void set(int i, int j, const T& value)
     {
 #if GRID_BOUNDS_DEBUG