Ticket #2022: cleanedupTerr.patch

components/CCmpTerritoryManager.cpp

@@ -88 +88 @@
     // connected flag in bit 6 (TERRITORY_CONNECTED_MASK);
     // processed flag in bit 7 (TERRITORY_PROCESSED_MASK)
     Grid<u8>* m_Territories;
+    Grid<u8>* m_InfluenceGrid;
+
+    // wraitii: Defining these as part of the object allows to avoid a few temporaries
+    // wraitii: at least Kuranes says so.
+    std::vector<std::pair<player_id_t, Grid<u32>* > > playerGrids;
+
+    std::map<player_id_t, std::vector<entity_id_t> > influenceEntities;
+    std::vector<entity_id_t> rootInfluenceEntities;
+
+    std::vector<std::pair<u16, u16> > tileStack;
+
+    // this is regularly used as a gridu32
+    std::deque<Grid<u32>* > grid32Pool;
 
     // Set to true when territories change; will send a TerritoriesChanged message
     // during the Update phase
@@ -113 +126 @@
     virtual void Init(const CParamNode& UNUSED(paramNode))
     {
         m_Territories = NULL;
+        m_InfluenceGrid = NULL;
         m_DebugOverlay = NULL;
 //      m_DebugOverlay = new TerritoryOverlay(*this);
         m_BoundaryLinesDirty = true;
@@ -135 +149 @@
     virtual void Deinit()
     {
         SAFE_DELETE(m_Territories);
+        SAFE_DELETE(m_InfluenceGrid);
         SAFE_DELETE(m_DebugOverlay);
+        for(std::deque<Grid<u32>* >::iterator it = grid32Pool.begin(); it != grid32Pool.end(); ++it )
+            delete *it;
     }
 
     virtual void Serialize(ISerializer& UNUSED(serialize))
@@ -345 +362 @@
 
     u16 tilesW = cmpTerrain->GetTilesPerSide();
     u16 tilesH = cmpTerrain->GetTilesPerSide();
-
-    m_Territories = new Grid<u8>(tilesW, tilesH);
+    
+    if (!m_Territories)
+        m_Territories = new Grid<u8>(tilesW, tilesH);
+    else
+        m_Territories->reset();
 
     // Compute terrain-passability-dependent costs per tile
-    Grid<u8> influenceGrid(tilesW, tilesH);
+    if (!m_InfluenceGrid)
+        m_InfluenceGrid = new Grid<u8>(tilesW, tilesH);
+    else
+        m_InfluenceGrid->reset();
 
     CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
     ICmpPathfinder::pass_class_t passClassDefault = cmpPathfinder->GetPassabilityClass("default");
     ICmpPathfinder::pass_class_t passClassUnrestricted = cmpPathfinder->GetPassabilityClass("unrestricted");
 
+
     const Grid<u16>& passGrid = cmpPathfinder->GetPassabilityGrid();
+
+    // wraitii: locality changes, perhaps unecessary
+    u16* passGridData = passGrid.m_Data;
+    u8* influenceGridData = m_InfluenceGrid->m_Data;
+    u32 gridSize = tilesH * tilesW;
+
     for (u16 j = 0; j < tilesH; ++j)
     {
         for (u16 i = 0; i < tilesW; ++i)
@@ -368 +398 @@
                 cost = m_ImpassableCost;
             else
                 cost = 1;
-            influenceGrid.set(i, j, cost);
+            m_InfluenceGrid->set(i, j, cost);
         }
     }
 
@@ -376 +406 @@
     CComponentManager::InterfaceList influences = GetSimContext().GetComponentManager().GetEntitiesWithInterface(IID_TerritoryInfluence);
 
     // Allow influence entities to override the terrain costs
-    RasteriseInfluences(influences, influenceGrid);
+    RasteriseInfluences(influences, *m_InfluenceGrid);
 
     // Split influence entities into per-player lists, ignoring any with invalid properties
-    std::map<player_id_t, std::vector<entity_id_t> > influenceEntities;
-    std::vector<entity_id_t> rootInfluenceEntities;
-    for (CComponentManager::InterfaceList::iterator it = influences.begin(); it != influences.end(); ++it)
+    influenceEntities.clear();
+    rootInfluenceEntities.clear();
+    const CComponentManager::InterfaceList::const_iterator itiEnd = influences.end();
+    for (CComponentManager::InterfaceList::const_iterator it = influences.begin(); it != itiEnd; ++it)
     {
         // Ignore any with no weight or radius (to avoid divide-by-zero later)
         ICmpTerritoryInfluence* cmpTerritoryInfluence = static_cast<ICmpTerritoryInfluence*>(it->second);
@@ -413 +444 @@
     }
 
     // For each player, store the sum of influences on each tile
-    std::vector<std::pair<player_id_t, Grid<u32> > > playerGrids;
+    playerGrids.clear();    // start by resetting.
+
     // TODO: this is a large waste of memory; we don't really need to store
     // all the intermediate grids
 
-    for (std::map<player_id_t, std::vector<entity_id_t> >::iterator it = influenceEntities.begin(); it != influenceEntities.end(); ++it)
+    OpenQueue openTiles;
+    Grid<u32>* entityGrid = new Grid<u32>(tilesW, tilesH);
+    
+    const std::map<player_id_t, std::vector<entity_id_t> >::iterator itieEnd = influenceEntities.end();
+    for (std::map<player_id_t, std::vector<entity_id_t> >::iterator it = influenceEntities.begin(); it != itieEnd; ++it)
     {
-        Grid<u32> playerGrid(tilesW, tilesH);
+        Grid<u32>* playerGrid = new Grid<u32>(tilesW, tilesH);
 
-        std::vector<entity_id_t>& ents = it->second;
-        for (std::vector<entity_id_t>::iterator eit = ents.begin(); eit != ents.end(); ++eit)
+        std::vector<entity_id_t> &ents = it->second;
+        std::vector<entity_id_t>::const_iterator eitEnd = ents.end();       
+        for (std::vector<entity_id_t>::const_iterator eit = ents.begin(); eit != eitEnd; ++eit)
         {
             // Compute the influence map of the current entity, then add it to the player grid
-
-            Grid<u32> entityGrid(tilesW, tilesH);
+            entityGrid->reset();
 
             CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), *eit);
             CFixedVector2D pos = cmpPosition->GetPosition2D();
@@ -442 +478 @@
             // when doing all the sums
 
             // Initialise the tile under the entity
-            entityGrid.set(i, j, weight);
-            OpenQueue openTiles;
-            OpenQueue::Item tile = { std::make_pair((u16)i, (i16)j), weight };
+            entityGrid->set(i, j, weight);
+            OpenQueue::Item tile = { std::make_pair(i, j), weight };
             openTiles.push(tile);
 
             // Expand influences outwards
-            FloodFill(entityGrid, influenceGrid, openTiles, falloff);
+            FloodFill(*entityGrid, *m_InfluenceGrid, openTiles, falloff);
 
             // TODO: we should do a sparse grid and only add the non-zero regions, for performance
-            for (u16 j = 0; j < entityGrid.m_H; ++j)
-                for (u16 i = 0; i < entityGrid.m_W; ++i)
-                    playerGrid.set(i, j, playerGrid.get(i, j) + entityGrid.get(i, j));
+            for (u16 j = 0; j < entityGrid->m_H; ++j)
+                for (u16 i = 0; i < entityGrid->m_W; ++i)
+                    playerGrid->set(i, j, playerGrid->get(i, j) + entityGrid->get(i, j));
         }
 
         playerGrids.push_back(std::make_pair(it->first, playerGrid));
@@ -467 +502 @@
             u32 bestWeight = 0;
             for (size_t k = 0; k < playerGrids.size(); ++k)
             {
-                u32 w = playerGrids[k].second.get(i, j);
+                u32 w = playerGrids[k].second->get(i, j);
                 if (w > bestWeight)
                 {
                     player_id_t id = playerGrids[k].first;
@@ -479 +514 @@
     }
 
     // Detect territories connected to a 'root' influence (typically a civ center)
-    // belonging to their player, and mark them with the connected flag
-    for (std::vector<entity_id_t>::iterator it = rootInfluenceEntities.begin(); it != rootInfluenceEntities.end(); ++it)
+    // belonging to their player, and mark them with the connected flag, 
+
+    // wraitii: those two things moved ouy of the loop.
+    // probably useless obfuscation if the vector is small enough.
+    Grid<u8>& grid = *m_Territories;
+    u16 maxi = (u16)(grid.m_W-1);
+    u16 maxj = (u16)(grid.m_H-1);
+    std::vector<entity_id_t>::const_iterator itrEnd = rootInfluenceEntities.end();
+    for (std::vector<entity_id_t>::const_iterator it = rootInfluenceEntities.begin(); it != itrEnd; ++it)
     {
         // (These components must be valid else the entities wouldn't be added to this list)
         CmpPtr<ICmpOwnership> cmpOwnership(GetSimContext(), *it);
@@ -492 +534 @@
 
         u8 owner = (u8)cmpOwnership->GetOwner();
 
-        if (m_Territories->get(i, j) != owner)
+        if (grid.get(i, j) != owner)
             continue;
 
         // TODO: would be nice to refactor some of the many flood fill
         // algorithms in this component
-
-        Grid<u8>& grid = *m_Territories;
-
-        u16 maxi = (u16)(grid.m_W-1);
-        u16 maxj = (u16)(grid.m_H-1);
-
-        std::vector<std::pair<u16, u16> > tileStack;
-
 #define MARK_AND_PUSH(i, j) STMT(grid.set(i, j, owner | TERRITORY_CONNECTED_MASK); tileStack.push_back(std::make_pair(i, j)); )
 
         MARK_AND_PUSH(i, j);
@@ -560 +594 @@
 
 void CCmpTerritoryManager::RasteriseInfluences(CComponentManager::InterfaceList& infls, Grid<u8>& grid)
 {
-    for (CComponentManager::InterfaceList::iterator it = infls.begin(); it != infls.end(); ++it)
+    
+    CComponentManager::InterfaceList::const_iterator itEnd = infls.end();
+    for (CComponentManager::InterfaceList::const_iterator it = infls.begin(); it != itEnd; ++it)
     {
         ICmpTerritoryInfluence* cmpTerritoryInfluence = static_cast<ICmpTerritoryInfluence*>(it->second);
 
@@ -691 +727 @@
         m_BoundaryLinesDirty = false;
     }
 
+    // wraitii: this has been moved out of the loop, probably with reason.
+    float alpha = 0.2f + 0.8f * fabsf((float)cos(m_AnimTime * M_PI));// TODO: should let artists tweak this
     for (size_t i = 0; i < m_BoundaryLines.size(); ++i)
     {
         if (!m_BoundaryLines[i].connected)
         {
             CColor c = m_BoundaryLines[i].color;
-            c.a *= 0.2f + 0.8f * fabsf((float)cos(m_AnimTime * M_PI)); // TODO: should let artists tweak this
+            c.a *= alpha; 
             m_BoundaryLines[i].overlay.m_Color = c;
         }
     }
@@ -714 +752 @@
 
 player_id_t CCmpTerritoryManager::GetOwner(entity_pos_t x, entity_pos_t z)
 {
-    u16 i, j;
     CalculateTerritories();
     if (!m_Territories)
         return 0;
 
+    // wraitii: this was moved to be closer to where it's used. OK.
+    u16 i, j;
     NearestTile(x, z, i, j, m_Territories->m_W, m_Territories->m_H);
     return m_Territories->get(i, j) & TERRITORY_PLAYER_MASK;
 }
 
 bool CCmpTerritoryManager::IsConnected(entity_pos_t x, entity_pos_t z)
 {
-    u16 i, j;
     CalculateTerritories();
     if (!m_Territories)
         return false;
 
+    // wraitii: this was moved to be closer to where it's used. OK.
+    u16 i, j;
     NearestTile(x, z, i, j, m_Territories->m_W, m_Territories->m_H);
     return (m_Territories->get(i, j) & TERRITORY_CONNECTED_MASK) != 0;
 }
@@ -762 +802 @@
     case 6:  RenderTile(CColor(1, 0, 1, a), false); break;
     default: RenderTile(CColor(1, 1, 1, a), false); break;
     }
-}
+}
+ No newline at end of file

helpers/Grid.h

@@ -76 +76 @@
         delete[] m_Data;
     }
 
-    void reset()
+    inline void reset()
     {
         if (m_Data)
             memset(m_Data, 0, m_W*m_H*sizeof(T));
     }
 
-    void set(int i, int j, const T& value)
+    inline void set(int i, int j, const T& value)
     {
 #if GRID_BOUNDS_DEBUG
         ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
 #endif
         m_Data[j*m_W + i] = value;
     }
+    
+    inline void add(int i, int j, T val) 
+    {
+#if GRID_BOUNDS_DEBUG
+        ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
+#endif
+        m_Data[j*m_W + i] += val;
+    }
+    inline void getPtr(int i, int j) 
+    {
+#if GRID_BOUNDS_DEBUG
+        ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
+#endif
+        return m_Data[j*m_W + i];
+    }
 
-    T& get(int i, int j) const
+    inline T&  get(int i, int j) const
     {
 #if GRID_BOUNDS_DEBUG
         ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
@@ -144 +159 @@
         delete[] m_Data;
     }
 
-    void reset()
+    inline void reset()
     {
         for (size_t i = 0; i < (size_t)(m_BW*m_BH); ++i)
             delete[] m_Data[i];
@@ -152 +167 @@
         memset(m_Data, 0, m_BW*m_BH*sizeof(T*));
     }
 
-    void set(int i, int j, const T& value)
+    inline void set(int i, int j, const T& value)
     {
 #if GRID_BOUNDS_DEBUG
         ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
@@ -160 +175 @@
         GetBucket(i, j)[(j % BucketSize)*BucketSize + (i % BucketSize)] = value;
     }
 
-    T& get(int i, int j)
+    inline T& get(int i, int j)
     {
 #if GRID_BOUNDS_DEBUG
         ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);