Ticket #3410: corners-complete_v2.patch

source/simulation2/components/CCmpObstructionManager.cpp

@@ -465 +465 @@
     virtual bool TestStaticShape(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w, entity_pos_t h, std::vector<entity_id_t>* out);
     virtual bool TestUnitShape(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t r, std::vector<entity_id_t>* out);
 
-    virtual void Rasterize(Grid<NavcellData>& grid, const std::vector<PathfinderPassability>& passClasses, bool fullUpdate);
+    virtual void Rasterize(Grid<NavcellData>& grid, Grid<CornerPassability>& cornerGrid, const std::vector<PathfinderPassability>& passClasses, bool fullUpdate);
     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);
     virtual void GetUnitsOnObstruction(const ObstructionSquare& square, std::vector<entity_id_t>& out, const IObstructionTestFilter& filter);
 
@@ -647 +647 @@
         return (m_WorldX0 <= p.X && p.X <= m_WorldX1 && m_WorldZ0 <= p.Y && p.Y <= m_WorldZ1);
     }
 
-    void RasterizeHelper(Grid<NavcellData>& grid, ICmpObstructionManager::flags_t requireMask, bool fullUpdate, pass_class_t appliedMask, entity_pos_t clearance = fixed::Zero());
+    void RasterizeHelper(Grid<NavcellData>& grid, Grid<CornerPassability>& cornerGrid, ICmpObstructionManager::flags_t requireMask, bool fullUpdate, pass_class_t appliedMask, entity_pos_t clearance = fixed::Zero());
 };
 
 REGISTER_COMPONENT_TYPE(ObstructionManager)
@@ -826 +826 @@
         return false; // didn't collide, if we got this far
 }
 
-void CCmpObstructionManager::Rasterize(Grid<NavcellData>& grid, const std::vector<PathfinderPassability>& passClasses, bool fullUpdate)
+void CCmpObstructionManager::Rasterize(Grid<NavcellData>& grid, Grid<CornerPassability>& cornerGrid, const std::vector<PathfinderPassability>& passClasses, bool fullUpdate)
 {
     PROFILE3("Rasterize");
 
@@ -836 +836 @@
     // Pass classes will get shapes rasterized on them depending on their Obstruction value.
     // Classes with another value than "pathfinding" should not use Clearance.
 
-    std::map<entity_pos_t, u16> pathfindingMasks;
-    u16 foundationMask = 0;
+    std::map<entity_pos_t, pass_class_t> pathfindingMasks;
+    pass_class_t foundationMask = 0;
     for (const PathfinderPassability& passability : passClasses)
     {
         switch (passability.m_Obstructions)
@@ -863 +863 @@
     // so they should be the only ones rasterized using with the help of m_Dirty*Shapes vectors.
 
     for (auto& maskPair : pathfindingMasks)
-        RasterizeHelper(grid, FLAG_BLOCK_PATHFINDING, fullUpdate, maskPair.second, maskPair.first);
+        RasterizeHelper(grid, cornerGrid, FLAG_BLOCK_PATHFINDING, fullUpdate, maskPair.second, maskPair.first);
 
-    RasterizeHelper(grid, FLAG_BLOCK_FOUNDATION, fullUpdate, foundationMask);
+    RasterizeHelper(grid, cornerGrid, FLAG_BLOCK_FOUNDATION, fullUpdate, foundationMask);
 
     m_DirtyStaticShapes.clear();
     m_DirtyUnitShapes.clear();
 }
 
-void CCmpObstructionManager::RasterizeHelper(Grid<NavcellData>& grid, ICmpObstructionManager::flags_t requireMask, bool fullUpdate, pass_class_t appliedMask, entity_pos_t clearance)
+void CCmpObstructionManager::RasterizeHelper(Grid<NavcellData>& grid, Grid<CornerPassability>& cornerGrid, ICmpObstructionManager::flags_t requireMask, bool fullUpdate, pass_class_t appliedMask, entity_pos_t clearance)
 {
+    ENSURE(grid.m_W == cornerGrid.m_W && grid.m_H == cornerGrid.m_H);
+
     for (auto& pair : m_StaticShapes)
     {
         const StaticShape& shape = pair.second;
@@ -886 +888 @@
         ObstructionSquare square = { shape.x, shape.z, shape.u, shape.v, shape.hw, shape.hh };
         SimRasterize::Spans spans;
         SimRasterize::RasterizeRectWithClearance(spans, square, clearance, Pathfinding::NAVCELL_SIZE);
-        for (SimRasterize::Span& span : spans)
+        for (const SimRasterize::Span& span : spans)
         {
             i16 j = Clamp(span.j, (i16)0, (i16)(grid.m_H-1));
             i16 i0 = std::max(span.i0, (i16)0);
             i16 i1 = std::min(span.i1, (i16)grid.m_W);
 
             for (i16 i = i0; i < i1; ++i)
-                grid.set(i, j, grid.get(i, j) | appliedMask);
+                Pathfinding::CombinedGridsSet(grid, cornerGrid, i, j, span.corners[i-span.i0], appliedMask);
         }
     }
 
@@ -913 +915 @@
         Pathfinding::NearestNavcell(center.X + r, center.Y + r, i1, j1, grid.m_W, grid.m_H);
         for (u16 j = j0+1; j < j1; ++j)
             for (u16 i = i0+1; i < i1; ++i)
-                grid.set(i, j, grid.get(i, j) | appliedMask);
+                Pathfinding::CombinedGridsSet(grid, cornerGrid, i, j, Pathfinding::PassableCorner::NONE, appliedMask);
     }
 }
 
@@ -1011 +1013 @@
         {
             if (j == span.j && span.i0 <= i && i < span.i1)
             {
-                out.push_back(shape.entity);
-                break;
+                if (span.corners[i-span.i0] == Pathfinding::PassableCorner::NONE)
+                {
+                    out.push_back(shape.entity);
+                    break;
+                }
             }
         }
     }

source/simulation2/components/CCmpPathfinder.cpp

@@ -50 +50 @@
     m_MapSize = 0;
     m_Grid = NULL;
     m_TerrainOnlyGrid = NULL;
+    m_CornerGrid = NULL;
+    m_TerrainOnlyCornerGrid = NULL;
 
     m_ObstructionsDirty.Clean();
     m_PreserveUpdateInformations = false;
@@ -107 +109 @@
 
     SAFE_DELETE(m_Grid);
     SAFE_DELETE(m_TerrainOnlyGrid);
+    SAFE_DELETE(m_CornerGrid);
+    SAFE_DELETE(m_TerrainOnlyCornerGrid);
 }
 
 struct SerializeLongRequest
@@ -266 +270 @@
  * Euclidean distances; currently it effectively does dist=max(dx,dy) instead.
  * This would only really be a problem for big clearances.
  */
-static void ExpandImpassableCells(Grid<NavcellData>& grid, u16 clearance, pass_class_t mask)
+static void ExpandImpassableCells(Grid<NavcellData>& grid, Grid<CornerPassability>& cornerGrid, u16 clearance, pass_class_t mask)
 {
     PROFILE3("ExpandImpassableCells");
 
@@ -314 +318 @@
         {
             // Add the mask if blocked by at least one nearby cell
             if (numBlocked)
-                grid.set(i, j, grid.get(i, j) | mask);
+                Pathfinding::CombinedGridsSet(grid, cornerGrid, i, j, Pathfinding::PassableCorner::NONE, mask);
 
             // Slide the numBlocked window along:
             // remove the old j-clearance value, add the new (j+1)+clearance
@@ -464 +468 @@
     {
         SAFE_DELETE(m_Grid);
         SAFE_DELETE(m_TerrainOnlyGrid);
+        SAFE_DELETE(m_CornerGrid);
+        SAFE_DELETE(m_TerrainOnlyCornerGrid);
     }
 
     // Initialise the terrain data when first needed
@@ -472 +478 @@
         m_MapSize = terrainSize;
         m_Grid = new Grid<NavcellData>(m_MapSize * Pathfinding::NAVCELLS_PER_TILE, m_MapSize * Pathfinding::NAVCELLS_PER_TILE);
         m_TerrainOnlyGrid = new Grid<NavcellData>(m_MapSize * Pathfinding::NAVCELLS_PER_TILE, m_MapSize * Pathfinding::NAVCELLS_PER_TILE);
+        m_CornerGrid = new Grid<CornerPassability>(m_MapSize * Pathfinding::NAVCELLS_PER_TILE, m_MapSize * Pathfinding::NAVCELLS_PER_TILE);
+        m_TerrainOnlyCornerGrid = new Grid<CornerPassability>(m_MapSize * Pathfinding::NAVCELLS_PER_TILE, m_MapSize * Pathfinding::NAVCELLS_PER_TILE);
 
         m_ObstructionsDirty.dirty = true;
         m_ObstructionsDirty.globallyDirty = true;
@@ -493 +501 @@
         TerrainUpdateHelper();
 
         *m_Grid = *m_TerrainOnlyGrid;
+        *m_CornerGrid = *m_TerrainOnlyCornerGrid;
 
         m_TerrainDirty = false;
         m_ObstructionsDirty.globalRecompute = true;
@@ -503 +512 @@
         ENSURE(m_Grid->m_W == m_TerrainOnlyGrid->m_W && m_Grid->m_H == m_TerrainOnlyGrid->m_H);
         memcpy(m_Grid->m_Data, m_TerrainOnlyGrid->m_Data, (m_Grid->m_W)*(m_Grid->m_H)*sizeof(NavcellData));
 
+        ENSURE(m_CornerGrid->m_W == m_TerrainOnlyCornerGrid->m_W && m_CornerGrid->m_H == m_TerrainOnlyCornerGrid->m_H);
+        memcpy(m_CornerGrid->m_Data, m_TerrainOnlyCornerGrid->m_Data, (m_CornerGrid->m_W)*(m_CornerGrid->m_H)*sizeof(CornerPassability));
+
         m_ObstructionsDirty.globallyDirty = true;
     }
     else
     {
         ENSURE(m_Grid->m_W == m_ObstructionsDirty.dirtinessGrid.m_W && m_Grid->m_H == m_ObstructionsDirty.dirtinessGrid.m_H);
+        ENSURE(m_CornerGrid->m_W == m_ObstructionsDirty.dirtinessGrid.m_W && m_CornerGrid->m_H == m_ObstructionsDirty.dirtinessGrid.m_H);
         ENSURE(m_Grid->m_W == m_TerrainOnlyGrid->m_W && m_Grid->m_H == m_TerrainOnlyGrid->m_H);
+        ENSURE(m_CornerGrid->m_W == m_TerrainOnlyCornerGrid->m_W && m_CornerGrid->m_H == m_TerrainOnlyCornerGrid->m_H);
 
         for (u16 i = 0; i < m_ObstructionsDirty.dirtinessGrid.m_W; ++i)
             for (u16 j = 0; j < m_ObstructionsDirty.dirtinessGrid.m_H; ++j)
                 if (m_ObstructionsDirty.dirtinessGrid.get(i, j) == 1)
+                {
                     m_Grid->set(i, j, m_TerrainOnlyGrid->get(i, j));
+                    m_CornerGrid->set(i, j, m_TerrainOnlyCornerGrid->get(i, j));
+                }
     }
 
     // Add obstructions onto the grid
-    cmpObstructionManager->Rasterize(*m_Grid, m_PassClasses, m_ObstructionsDirty.globalRecompute);
+    cmpObstructionManager->Rasterize(*m_Grid, *m_CornerGrid, m_PassClasses, m_ObstructionsDirty.globalRecompute);
 
     // Update the long-range pathfinder
     if (m_ObstructionsDirty.globallyDirty)
     {
         std::map<std::string, pass_class_t> nonPathfindingPassClasses, pathfindingPassClasses;
         GetPassabilityClasses(nonPathfindingPassClasses, pathfindingPassClasses);
-        m_LongPathfinder.Reload(m_Grid, nonPathfindingPassClasses, pathfindingPassClasses);
+        m_LongPathfinder.Reload(m_Grid, nonPathfindingPassClasses, pathfindingPassClasses, m_CornerGrid);
     }
     else
-        m_LongPathfinder.Update(m_Grid, m_ObstructionsDirty.dirtinessGrid);
+        m_LongPathfinder.Update(m_Grid, m_ObstructionsDirty.dirtinessGrid, m_CornerGrid);
 
     // Notify the units that their current paths can be invalid now.
     // The passability map will be globally dirty after init, or rejoining, loading a saved game, etc.
@@ -565 +582 @@
         m_MapSize = terrainSize;
 
         SAFE_DELETE(m_TerrainOnlyGrid);
+        SAFE_DELETE(m_TerrainOnlyCornerGrid);
         m_TerrainOnlyGrid = new Grid<NavcellData>(m_MapSize * Pathfinding::NAVCELLS_PER_TILE, m_MapSize * Pathfinding::NAVCELLS_PER_TILE);
+        m_TerrainOnlyCornerGrid = new Grid<CornerPassability>(m_MapSize * Pathfinding::NAVCELLS_PER_TILE, m_MapSize * Pathfinding::NAVCELLS_PER_TILE);
     }
 
     Grid<u16> shoreGrid = ComputeShoreGrid();
@@ -601 +620 @@
 
             // Compute the passability for every class for this cell
             NavcellData t = 0;
+            CornerPassability c = 0;
             for (PathfinderPassability& passability : m_PassClasses)
+            {
                 if (!passability.IsPassable(depth, slope, shoredist))
+                {
+                    Pathfinding::SetPassableCornerBits(c, Pathfinding::PassableCorner::NONE, passability.m_Mask);
                     t |= passability.m_Mask;
+                }
+            }
 
             m_TerrainOnlyGrid->set(i, j, t);
+            m_TerrainOnlyCornerGrid->set(i, j, c);
         }
     }
 
@@ -636 +662 @@
                     + (j*2 + 1 - h)*(j*2 + 1 - h);
 
                 if (dist2 >= (w - 2*edgeSize) * (h - 2*edgeSize))
-                    m_TerrainOnlyGrid->set(i, j, m_TerrainOnlyGrid->get(i, j) | edgeMask);
+                    Pathfinding::CombinedGridsSet(*m_TerrainOnlyGrid, *m_TerrainOnlyCornerGrid, i, j, Pathfinding::PassableCorner::NONE, edgeMask);
             }
         }
     }
@@ -644 +670 @@
     {
         for (u16 j = 0; j < h; ++j)
             for (u16 i = 0; i < edgeSize; ++i)
-                m_TerrainOnlyGrid->set(i, j, m_TerrainOnlyGrid->get(i, j) | edgeMask);
+                Pathfinding::CombinedGridsSet(*m_TerrainOnlyGrid, *m_TerrainOnlyCornerGrid, i, j, Pathfinding::PassableCorner::NONE, edgeMask);
         for (u16 j = 0; j < h; ++j)
             for (u16 i = w-edgeSize+1; i < w; ++i)
-                m_TerrainOnlyGrid->set(i, j, m_TerrainOnlyGrid->get(i, j) | edgeMask);
+                Pathfinding::CombinedGridsSet(*m_TerrainOnlyGrid, *m_TerrainOnlyCornerGrid, i, j, Pathfinding::PassableCorner::NONE, edgeMask);
         for (u16 j = 0; j < edgeSize; ++j)
             for (u16 i = edgeSize; i < w-edgeSize+1; ++i)
-                m_TerrainOnlyGrid->set(i, j, m_TerrainOnlyGrid->get(i, j) | edgeMask);
+                Pathfinding::CombinedGridsSet(*m_TerrainOnlyGrid, *m_TerrainOnlyCornerGrid, i, j, Pathfinding::PassableCorner::NONE, edgeMask);
         for (u16 j = h-edgeSize+1; j < h; ++j)
             for (u16 i = edgeSize; i < w-edgeSize+1; ++i)
-                m_TerrainOnlyGrid->set(i, j, m_TerrainOnlyGrid->get(i, j) | edgeMask);
+                Pathfinding::CombinedGridsSet(*m_TerrainOnlyGrid, *m_TerrainOnlyCornerGrid, i, j, Pathfinding::PassableCorner::NONE, edgeMask);
     }
 
     if (!expandPassability)
@@ -670 +696 @@
             continue;
 
         int clearance = (passability.m_Clearance / Pathfinding::NAVCELL_SIZE).ToInt_RoundToInfinity();
-        ExpandImpassableCells(*m_TerrainOnlyGrid, clearance, passability.m_Mask);
+        ExpandImpassableCells(*m_TerrainOnlyGrid, *m_TerrainOnlyCornerGrid, clearance, passability.m_Mask);
     }
 }
 

source/simulation2/components/CCmpPathfinder_Common.h

@@ -108 +108 @@
     u16 m_MapSize; // tiles per side
     Grid<NavcellData>* m_Grid; // terrain/passability information
     Grid<NavcellData>* m_TerrainOnlyGrid; // same as m_Grid, but only with terrain, to avoid some recomputations
+    Grid<CornerPassability>* m_CornerGrid; // corner terrain/passability information
+    Grid<CornerPassability>* m_TerrainOnlyCornerGrid; // same as m_CornerGrid, but only with terrain, to avoid some recomputations
 
     // Update data, used for clever updates and then stored for the AI manager
     GridUpdateInformation m_ObstructionsDirty;

source/simulation2/components/ICmpObstructionManager.h

@@ -205 +205 @@
 
     /**
      * Convert the current set of shapes onto a navcell grid, for all passability classes contained in @p passClasses.
+     * Also computes the corner passabilities for each of those navcells.
      * If @p fullUpdate is false, the function will only go through dirty shapes.
      * Shapes are expanded by the @p passClasses clearances, by ORing their masks onto the @p grid.
      */
-    virtual void Rasterize(Grid<NavcellData>& grid, const std::vector<PathfinderPassability>& passClasses, bool fullUpdate) = 0;
+    virtual void Rasterize(Grid<NavcellData>& grid, Grid<CornerPassability>& cornerGrid, const std::vector<PathfinderPassability>& passClasses, bool fullUpdate) = 0;
 
     /**
      * Gets dirtiness information and resets it afterwards. Then it's the role of CCmpPathfinder

source/simulation2/helpers/LongPathfinder.cpp

@@ -965 +965 @@
     {
         PathfindTile& n = state.tiles->get(ip, jp);
         entity_pos_t x, z;
-        Pathfinding::NavcellCenter(ip, jp, x, z);
+        GetPassablePoint(ip, jp, x, z, passClass);
         path.m_Waypoints.emplace_back(Waypoint{ x, z });
 
         // Follow the predecessor link
         ip = n.GetPredI(ip);
         jp = n.GetPredJ(jp);
     }
-    // The last waypoint is slightly incorrect (it's not the goal but the center
-    // of the navcell of the goal), so replace it
+    // The last waypoint is slightly incorrect, we have to replace it by the goal position
     if (!path.m_Waypoints.empty())
         path.m_Waypoints.front() = { state.goal.x, state.goal.z };
 
@@ -986 +985 @@
     m_DebugGoal = state.goal;
 }
 
+void LongPathfinder::GetPassablePoint(u16 i, u16 j, entity_pos_t& x, entity_pos_t& z, pass_class_t passClass) const
+{
+    if (m_CornerGrid)
+        Pathfinding::NavcellCorner(i, j, x, z, Pathfinding::GetPassableCorner(m_CornerGrid->get(i, j), passClass));
+    else
+        Pathfinding::NavcellCenter(i, j, x, z);
+}
+
 void LongPathfinder::ImprovePathWaypoints(WaypointPath& path, pass_class_t passClass, entity_pos_t maxDist, entity_pos_t x0, entity_pos_t z0)
 {
     if (path.m_Waypoints.empty())

source/simulation2/helpers/LongPathfinder.h

@@ -185 +185 @@
 
     void Reload(Grid<NavcellData>* passabilityGrid,
         const std::map<std::string, pass_class_t>& nonPathfindingPassClassMasks, 
-        const std::map<std::string, pass_class_t>& pathfindingPassClassMasks)
+        const std::map<std::string, pass_class_t>& pathfindingPassClassMasks,
+        Grid<CornerPassability>* cornerGrid = NULL)
     {
         m_Grid = passabilityGrid;
+
+        if (cornerGrid)
+        {
+            ASSERT(passabilityGrid->m_W == cornerGrid->m_W && passabilityGrid.m_H == cornerGrid.m_H);
+            m_CornerGrid = cornerGrid;
+        }
+
         ASSERT(passabilityGrid->m_H == passabilityGrid->m_W);
         m_GridSize = passabilityGrid->m_W;
 
@@ -196 +204 @@
         m_PathfinderHier.Recompute(passabilityGrid, nonPathfindingPassClassMasks, pathfindingPassClassMasks);
     }
 
-    void Update(Grid<NavcellData>* passabilityGrid, const Grid<u8>& dirtinessGrid)
+    void Update(Grid<NavcellData>* passabilityGrid, const Grid<u8>& dirtinessGrid, Grid<CornerPassability>* cornerGrid = NULL)
     {
         m_Grid = passabilityGrid;
+        
+        if (cornerGrid)
+        {
+            ASSERT(passabilityGrid->m_W == cornerGrid->m_W && passabilityGrid.m_H == cornerGrid.m_H);
+            m_CornerGrid = cornerGrid;
+        }
+
         ASSERT(passabilityGrid->m_H == passabilityGrid->m_W);
         ASSERT(m_GridSize == passabilityGrid->m_H);
 
@@ -250 +265 @@
     }
 
     Grid<NavcellData>* m_Grid;
+    Grid<CornerPassability>* m_CornerGrid;
     u16 m_GridSize;
 
     // Debugging - output from last pathfind operation:
@@ -285 +301 @@
     // Helper functions for ComputePath
 
     /**
+     * Use the corner grid, if any, to determine a passable point of the cell.
+     */
+    void GetPassablePoint(u16 i, u16 j, entity_pos_t& x, entity_pos_t& z, pass_class_t passClass) const;
+
+    /**
      * Given a path with an arbitrary collection of waypoints, updates the
      * waypoints to be nicer. Calls "Testline" between waypoints
      * so that bended paths can become straight if there's nothing in between

source/simulation2/helpers/Pathfinding.h

@@ -102 +102 @@
 #define PASS_CLASS_MASK_FROM_INDEX(id) ((pass_class_t)(1u << id))
 #define SPECIAL_PASS_CLASS PASS_CLASS_MASK_FROM_INDEX((PASS_CLASS_BITS-1)) // 16th bit, used for special in-place computations
 
+typedef u64 CornerPassability; // 3 bits (see Pathfinding::PassableCorner) per passability class (up to PASS_CLASS_BITS)
+
 namespace Pathfinding
 {
     /**
@@ -245 +247 @@
                 j += dj;
         }
     }
+
+    /**
+     * Corner passability values for a given passability class. Takes 3 bits.
+     *
+     * A cell can be passable but with an obstruction crossing it, so we
+     * have to determine one of the corners that is actually accessible.
+     */
+    enum PassableCorner
+    {
+        ALL = 0x0,
+        NONE = 0x1,
+        TOP_LEFT = 0x2,
+        TOP_RIGHT = 0x3,
+        BOTTOM_LEFT = 0x4,
+        BOTTOM_RIGHT = 0x5
+    };
+
+    inline void NavcellCorner(u16 i, u16 j, entity_pos_t& x, entity_pos_t& z, const PassableCorner& corner)
+    {
+        switch (corner)
+        {
+        case Pathfinding::ALL:
+        case Pathfinding::NONE: // this could happen when leaving an impassable
+            NavcellCenter(i, j, x, z);
+            return;
+        case Pathfinding::TOP_LEFT:
+            x = entity_pos_t::FromInt(i).Multiply(NAVCELL_SIZE);
+            z = entity_pos_t::FromInt(j).Multiply(NAVCELL_SIZE);
+            return;
+        case Pathfinding::TOP_RIGHT:
+            x = entity_pos_t::FromInt(i+1).Multiply(NAVCELL_SIZE);
+            z = entity_pos_t::FromInt(j).Multiply(NAVCELL_SIZE);
+            return;
+        case Pathfinding::BOTTOM_LEFT:
+            x = entity_pos_t::FromInt(i).Multiply(NAVCELL_SIZE);
+            z = entity_pos_t::FromInt(j+1).Multiply(NAVCELL_SIZE);
+            return;
+        case Pathfinding::BOTTOM_RIGHT:
+            x = entity_pos_t::FromInt(i+1).Multiply(NAVCELL_SIZE);
+            z = entity_pos_t::FromInt(j+1).Multiply(NAVCELL_SIZE);
+            return;
+        default:
+            LOGWARNING("Unknown corner passability");
+            return;
+        }
+    }
+
+    inline PassableCorner GetPassableCorner(const CornerPassability& cornerPassability, pass_class_t passClass)
+    {
+        // Determine the bit position in the mask
+        ENSURE(passClass);
+        int i = 0;
+        while (!(passClass & (1u << i)))
+            ++i;
+
+        PassableCorner ret = static_cast<PassableCorner>((cornerPassability >> 3*i) & 0x7);
+        return ret;
+    }
+
+    inline void SetPassableCornerBits(CornerPassability& cornerPassability, const PassableCorner& passableCorner, pass_class_t mask)
+    {
+        // This function will be called by Rasterize so it has to support incremental overwritings:
+        // - ALL can only overwrite ALL (so it doesn't do anything)
+        // - single corner values can overwrite single corner values (consistent with the rasterization code) and ALL
+        // - NONE can overwrite anything
+
+        if (passableCorner == PassableCorner::ALL)
+            return; // nothing to actually do
+
+        for (int i = 0; i < PASS_CLASS_BITS; ++i)
+        {
+            if (!(mask & (0x1 << i)))
+                continue;
+
+            PassableCorner oldValue = static_cast<PassableCorner>((cornerPassability >> 3*i) & 0x7);
+            if (passableCorner != PassableCorner::NONE && oldValue == PassableCorner::NONE)
+                continue; // can't overwrite
+
+            cornerPassability &= (~(0x7 << 3*i)); // erase
+            cornerPassability |= passableCorner << 3*i;
+        }
+    }
+
+    // Apply @p mask onto both grids in adapted ways.
+    inline void CombinedGridsSet(Grid<NavcellData>& grid, Grid<CornerPassability>& cornerGrid, int i, int j, const PassableCorner& cornerValue, pass_class_t mask)
+    {
+        if (cornerValue == PassableCorner::NONE)
+            grid.set(i, j, grid.get(i, j) | mask);
+
+        CornerPassability cornerPassability = cornerGrid.get(i, j);
+        Pathfinding::SetPassableCornerBits(cornerPassability, cornerValue, mask);
+        cornerGrid.set(i, j, cornerPassability);
+    }
 }
 
 /*

source/simulation2/helpers/Rasterize.cpp

@@ -41 +41 @@
 
     for (i16 j = j0; j < j1; ++j)
     {
-        // Find the min/max range of cells that are strictly inside the square+clearance.
-        // (Since the square+clearance is a convex shape, we can just test each
-        // corner of each cell is inside the shape.)
-        // (TODO: This potentially does a lot of redundant work.)
+        // Find the min/max range of cells that are inside the square+clearance.
+        // Since the square+clearance is a convex shape, we can just rely on corners for everything.
+
+        std::vector<Pathfinding::PassableCorner> corners;
+        corners.reserve(i1 - i0);
+
+        bool foundTouchingCell = false;
         i16 spanI0 = std::numeric_limits<i16>::max();
         i16 spanI1 = std::numeric_limits<i16>::min();
         for (i16 i = i0; i < i1; ++i)
         {
+            Pathfinding::PassableCorner corner = Pathfinding::PassableCorner::NONE;
+            int cornerCount = 0;
+
             if (Geometry::DistanceToSquare(
                 CFixedVector2D(cellSize*i, cellSize*j) - CFixedVector2D(shape.x, shape.z),
                 shape.u, shape.v, CFixedVector2D(shape.hw, shape.hh), true) > clearance)
             {
-                continue;
+                corner = Pathfinding::PassableCorner::TOP_LEFT;
+                ++cornerCount;
             }
 
             if (Geometry::DistanceToSquare(
                 CFixedVector2D(cellSize*(i+1), cellSize*j) - CFixedVector2D(shape.x, shape.z),
                 shape.u, shape.v, CFixedVector2D(shape.hw, shape.hh), true) > clearance)
             {
-                continue;
+                corner = Pathfinding::PassableCorner::TOP_RIGHT;
+                ++cornerCount;
             }
 
             if (Geometry::DistanceToSquare(
                 CFixedVector2D(cellSize*i, cellSize*(j+1)) - CFixedVector2D(shape.x, shape.z),
                 shape.u, shape.v, CFixedVector2D(shape.hw, shape.hh), true) > clearance)
             {
-                continue;
+                corner = Pathfinding::PassableCorner::BOTTOM_LEFT;
+                ++cornerCount;
             }
 
             if (Geometry::DistanceToSquare(
                 CFixedVector2D(cellSize*(i+1), cellSize*(j+1)) - CFixedVector2D(shape.x, shape.z),
                 shape.u, shape.v, CFixedVector2D(shape.hw, shape.hh), true) > clearance)
             {
-                continue;
+                corner = Pathfinding::PassableCorner::BOTTOM_RIGHT;
+                ++cornerCount;
             }
 
-            spanI0 = std::min(spanI0, i);
-            spanI1 = std::max(spanI1, (i16)(i+1));
+            if (cornerCount == 4)
+                corner = Pathfinding::PassableCorner::ALL;
+
+            if (!foundTouchingCell)
+            {
+                if (corner == Pathfinding::PassableCorner::ALL)
+                    continue;
+
+                foundTouchingCell = true;
+                spanI0 = i;
+                spanI1 = i+1;
+                corners.push_back(corner);
+            }
+            else
+            {
+                spanI1 = i+1;
+                corners.push_back(corner);
+            }
         }
 
         // Add non-empty spans onto the list
-        if (spanI0 < spanI1)
+        if (foundTouchingCell)
         {
-            Span span = { spanI0, spanI1, j };
-            spans.push_back(span);
+            ENSURE(spanI0 < spanI1 && corners.size() == (size_t)(spanI1-spanI0));
+            spans.emplace_back(Span{ spanI0, spanI1, j, corners });
         }
     }
 }

source/simulation2/helpers/Rasterize.h

@@ -1 @@
-/* Copyright (C) 2012 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
@@ -29 +29 @@
 {
 
 /**
- * Represents the set of cells (i,j) where i0 <= i < i1
+ * Represents the set of cells (i,j) where i0 <= i < i1.
+ * The corner passability of the cell (i0+k,j) is corners[k].
  */
 struct Span
 {
     i16 i0;
     i16 i1;
     i16 j;
+    std::vector<Pathfinding::PassableCorner> corners;
 };
 
 typedef std::vector<Span> Spans;
@@ -43 +45 @@
 /**
  * Converts an ObstructionSquare @p shape (a rotated rectangle),
  * expanded by the given @p clearance,
- * into a list of spans of cells that are strictly inside the shape.
+ * into a list of spans of cells that are at least partially inside the shape.
+ * The caller must check corner passability values for each cell inside a span
+ * to determine whether they are strictly inside the shape.
  */
 void RasterizeRectWithClearance(Spans& spans,
     const ICmpObstructionManager::ObstructionSquare& shape,