Ticket #2023: const.patch

source/graphics/UnitAnimation.cpp

@@ -144 +144 @@
     }
 }
 
-void CUnitAnimation::Update(float time)
+void CUnitAnimation::Update(const float time)
 {
     // Advance all of the prop models independently
-    for (std::vector<SModelAnimState>::iterator it = m_AnimStates.begin(); it != m_AnimStates.end(); ++it)
+    std::vector<SModelAnimState>::iterator itend = m_AnimStates.end();
+    for (std::vector<SModelAnimState>::iterator it = m_AnimStates.begin(); it != itend; ++it)
     {
-        CSkeletonAnimDef* animDef = it->anims[it->animIdx]->m_AnimDef;
+        const CSkeletonAnimDef * const animDef = it->anims[it->animIdx]->m_AnimDef;
         if (animDef == NULL)
             continue; // ignore static animations
+        const CSkeletonAnim * const anim = it->anims[it->animIdx];
 
-        float duration = animDef->GetDuration();
+        const float duration = animDef->GetDuration();
 
-        float actionPos = it->anims[it->animIdx]->m_ActionPos;
-        float loadPos = it->anims[it->animIdx]->m_ActionPos2;
-        bool hasActionPos = (actionPos != -1.f);
-        bool hasLoadPos = (loadPos != -1.f);
+        const float actionPos = anim->m_ActionPos;
+        const float loadPos = anim->m_ActionPos2;
+        const bool hasActionPos = (actionPos != -1.f);
+        const bool hasLoadPos = (loadPos != -1.f);
 
         // Find the current animation speed
         float speed;
         if (m_SyncRepeatTime && hasActionPos)
             speed = duration / m_SyncRepeatTime;
         else
-            speed = m_Speed * it->anims[it->animIdx]->m_Speed;
+            speed = m_Speed * anim->m_Speed;
 
         // Convert from real time to scaled animation time
-        float advance = time * speed;
+        const float advance = time * speed;
 
         // If we're going to advance past the load point in this update, then load the ammo
         if (hasLoadPos && !it->pastLoadPos && it->time + advance >= loadPos)
@@ -209 +211 @@
             // If there's a choice of multiple animations, pick a new random one
             if (it->anims.size() > 1)
             {
-                size_t newAnimIdx = rand(0, it->anims.size());
+                const size_t newAnimIdx = rand(0, it->anims.size());
                 if (newAnimIdx != it->animIdx)
                 {
                     it->animIdx = newAnimIdx;
@@ -227 +229 @@
             // If we've finished the current animation and don't want to loop...
 
             // Update to very nearly the end of the last frame (but not quite the end else we'll wrap around when skinning)
-            float nearlyEnd = duration - 1.f;
+            const float nearlyEnd = duration - 1.f;
             if (fabs(it->time - nearlyEnd) > 1.f)
             {
                 it->time = nearlyEnd;

source/simulation2/system/ComponentManager.h

@@ -261 +261 @@
     // TODO: some of these should be vectors
     std::map<ComponentTypeId, ComponentType> m_ComponentTypesById;
     std::vector<boost::unordered_map<entity_id_t, IComponent*> > m_ComponentsByInterface; // indexed by InterfaceId
+    // TODO: specially this the seccond of this one, which burdens broadcast performance exponentially with entities
     std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> > m_ComponentsByTypeId;
     std::map<MessageTypeId, std::vector<ComponentTypeId> > m_LocalMessageSubscriptions;
     std::map<MessageTypeId, std::vector<ComponentTypeId> > m_GlobalMessageSubscriptions;

source/simulation2/system/ComponentManager.cpp

@@ -735 +735 @@
     }
 }
 
-IComponent* CComponentManager::QueryInterface(entity_id_t ent, InterfaceId iid) const
+IComponent* CComponentManager::QueryInterface(const entity_id_t ent, const InterfaceId iid) const
 {
     if ((size_t)iid >= m_ComponentsByInterface.size())
     {
@@ -814 +814 @@
 void CComponentManager::BroadcastMessage(const CMessage& msg) const
 {
     // Send the message to components of all entities that subscribed locally to this message
-    std::map<MessageTypeId, std::vector<ComponentTypeId> >::const_iterator it;
-    it = m_LocalMessageSubscriptions.find(msg.GetType());
-    if (it != m_LocalMessageSubscriptions.end())
+    std::map<MessageTypeId, std::vector<ComponentTypeId> >::const_iterator it = m_LocalMessageSubscriptions.find(msg.GetType()),
+        itend =  m_LocalMessageSubscriptions.end();
+    if (it != itend)
     {
-        std::vector<ComponentTypeId>::const_iterator ctit = it->second.begin();
-        for (; ctit != it->second.end(); ++ctit)
+        std::vector<ComponentTypeId>::const_iterator ctit = it->second.begin(),  cend = it->second.end();
+        for (; ctit != cend; ++ctit)
         {
             // Find the component instances of this type (if any)
             std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::const_iterator emap = m_ComponentsByTypeId.find(*ctit);
@@ -827 +827 @@
                 continue;
 
             // Send the message to all of them
-            std::map<entity_id_t, IComponent*>::const_iterator eit = emap->second.begin();
-            for (; eit != emap->second.end(); ++eit)
+            // TODO: switch from map to a contigous container (ie vector)
+            // as that's very slow and very impacting performance
+            std::map<entity_id_t, IComponent*>::const_iterator eit = emap->second.begin(),  eiteend = emap->second.end();
+            for (; eit != eiteend; ++eit)
                 eit->second->HandleMessage(msg, false);
         }
     }

source/maths/BoundingBoxAligned.cpp

@@ -149 +149 @@
         // Now find the extreme points by considering the product of the
         // min and max with each component of matrix
         for(int j=0;j<3;j++) {
-            float a=m(i,j)*m_Data[0][j];
-            float b=m(i,j)*m_Data[1][j];
+            const float a=m(i,j)*m_Data[0][j];
+            const float b=m(i,j)*m_Data[1][j];
 
             if (a<b) {
                 result[0][i]+=a;

source/maths/BoundingBoxOriented.cpp

@@ -50 +50 @@
     float tMin = -FLT_MAX;
     float tMax = FLT_MAX;
 
-    CVector3D p = m_Center - origin;
+    const CVector3D p (m_Center - origin);
 
     for (int i = 0; i < 3; ++i)
     {
         // test the ray for intersections with the slab whose normal vector is m_Basis[i]
-        float e = m_Basis[i].Dot(p); // distance between the ray origin and the box center projected onto the slab normal
-        float f = m_Basis[i].Dot(dir); // cosine of the angle between the slab normal and the ray direction
+        const float e = m_Basis[i].Dot(p); // distance between the ray origin and the box center projected onto the slab normal
+        const float f = m_Basis[i].Dot(dir); // cosine of the angle between the slab normal and the ray direction
 
         if(fabsf(f) > 1e-10f)
         {
             // Determine the distances t1 and t2 from the origin of the ray to the points where it intersects
             // the slab. See docs/ray_intersect.pdf for why/how this works.
-            float invF = 1.f/f;
+            const float invF = 1.f/f;
             float t1 = (e + m_HalfSizes[i]) * invF;
             float t2 = (e - m_HalfSizes[i]) * invF;
 
             // make sure t1 <= t2, swap if necessary
             if (t1 > t2)
             {
-                float tmp = t1;
+                const float tmp = t1;
                 t1 = t2;
                 t2 = tmp;
             }
-
             // update the overall tMin and tMax if necessary
             if (t1 > tMin) tMin = t1;
             if (t2 < tMax) tMax = t2;
-
+            
             // try to break out of the loop as fast as possible by checking for some conditions
-            if (tMin > tMax) return false; // ray misses the box
-            if (tMax < 0) return false; // box is behind the ray origin
+            if (tMin > tMax) 
+                return false; // ray misses the box
+            if (tMax < 0) 
+                return false; // box is behind the ray origin
         }
         else
         {

source/tools/atlas/GameInterface/Brushes.cpp

@@ -52 +52 @@
         --max_j_inclusive;
     }
 
-    void ProcessTile(ssize_t i, ssize_t j)
+    void ProcessTile(const ssize_t i, const ssize_t j)
     {
         ssize_t i0, j0;
         m_Brush->GetBottomLeft(i0, j0);
         // Colour this tile based on the average of the surrounding vertices
-        float avg = (
+        const float avg = (
             m_Brush->Get(i-i0, j-j0)   + m_Brush->Get(i-i0+1, j-j0) +
             m_Brush->Get(i-i0, j-j0+1) + m_Brush->Get(i-i0+1, j-j0+1)
         ) / 4.f;

source/tools/atlas/AtlasObject/AtlasObjectText.cpp

@@ -19 +19 @@
 #include "AtlasObjectImpl.h"
 #include "AtlasObject.h"
 
-static std::wstring ConvertRecursive(const AtNode::Ptr obj, bool use_brackets = true)
+static std::wstring ConvertRecursive(const AtNode::Ptr& obj, bool use_brackets = true)
 {
     // Convert (1, ()) into "1"
     // Convert (3, (d: (...), e: (...))) into "3 (conv(...), conv(...))"

source/main.cpp

@@ -299 +299 @@
     ogl_WarnIfError();
 
     // get elapsed time
-    const double time = timer_Time();
-    g_frequencyFilter->Update(time);
+#if 0
     // .. old method - "exact" but contains jumps
-#if 0
     static double last_time;
     const double time = timer_Time();
-    const float TimeSinceLastFrame = (float)(time-last_time);
+    const float realTimeSinceLastFrame = (float)(time-last_time);
     last_time = time;
     ONCE(return);   // first call: set last_time and return
 
-    // .. new method - filtered and more smooth, but errors may accumulate
 #else
+    // .. new method - filtered and more smooth, 
+    // but errors does accumulate
+    // and profiler ms/frame are false.
+    const double time = timer_Time();
+    g_frequencyFilter->Update(time);
     const float realTimeSinceLastFrame = 1.0 / g_frequencyFilter->SmoothedFrequency();
 #endif
     ENSURE(realTimeSinceLastFrame > 0.0f);

source/renderer/OverlayRenderer.cpp

@@ -233 +233 @@
     // won't be very large or very variable
     
     // Empty the batch rendering data structures, but keep their key mappings around for the next frames
-    for (OverlayRendererInternals::QuadBatchMap::iterator it = m->quadBatchMap.begin(); it != m->quadBatchMap.end(); it++)
+    for (OverlayRendererInternals::QuadBatchMap::iterator it = m->quadBatchMap.begin(); it != m->quadBatchMap.end(); ++it)
     {
         QuadBatchData& quadBatchData = (it->second);
         quadBatchData.m_Quads.clear();
@@ -505 +505 @@
         GLsizei indexStride = m->quadIndices.GetStride();
         GLsizei vertexStride = m->quadVertices.GetStride();
 
-        for (OverlayRendererInternals::QuadBatchMap::iterator it = m->quadBatchMap.begin(); it != m->quadBatchMap.end(); it++)
+        for (OverlayRendererInternals::QuadBatchMap::iterator it = m->quadBatchMap.begin(); it != m->quadBatchMap.end(); ++it)
         {
             QuadBatchData& batchRenderData = it->second;
             const size_t batchNumQuads = batchRenderData.m_NumRenderQuads;

source/renderer/TerrainOverlay.h

@@ -123 +123 @@
      * @param i  <i>i</i> coordinate of tile being processed
      * @param j  <i>j</i> coordinate of tile being processed
      */
-    virtual void ProcessTile(ssize_t i, ssize_t j) = 0;
+    virtual void ProcessTile(const ssize_t i, const ssize_t j) = 0;
 
     /**
      * Draw a filled quad on top of the current tile.

source/renderer/VertexArray.cpp

@@ -225 +225 @@
     
     //debug_printf(L"Layouting VertexArray\n");
     
-    for (ssize_t idx = m_Attributes.size()-1; idx >= 0; --idx)
+    for (size_t idx = 0; idx < m_Attributes.size(); ++idx)
     {
         Attribute* attr = m_Attributes[idx];
-        
         if (!attr->type || !attr->elems)
             continue;
     

source/renderer/ModelRenderer.cpp

@@ -422 +422 @@
 
     {
         PROFILE3("bucketing by material");
-
-        for (size_t i = 0; i < m->submissions.size(); ++i)
+        const size_t submissionsSize = m->submissions.size();
+        for (size_t i = 0; i < submissionsSize; ++i)
         {
             CModel* model = m->submissions[i];
             
             CShaderDefines defs = model->GetMaterial().GetShaderDefines();
             CShaderConditionalDefines condefs = model->GetMaterial().GetConditionalDefines();
             
-            for (size_t j = 0; j < condefs.GetSize(); ++j)
+            const size_t defssSize = condefs.GetSize();
+            for (size_t j = 0; j < defssSize; ++j)
             {
                 CShaderConditionalDefines::CondDefine &item = condefs.GetItem(j);
-                int type = item.m_CondType;
+                const int type = item.m_CondType;
                 switch (type)
                 {
                     case DCOND_DISTANCE:
                     {
-                        CVector3D modelpos = model->GetTransform().GetTranslation();
-                        float dist = worldToCam.Transform(modelpos).Z;
+                        const CVector3D modelpos (model->GetTransform().GetTranslation());
+                        const float dist = worldToCam.Transform(modelpos).Z;
                         
-                        float dmin = item.m_CondArgs[0];
-                        float dmax = item.m_CondArgs[1];
+                        const float dmin = item.m_CondArgs[0];
+                        const float dmax = item.m_CondArgs[1];
                         
                         if ((dmin < 0 || dist >= dmin) && (dmax < 0 || dist < dmax))
                             defs.Add(item.m_DefName.c_str(), item.m_DefValue.c_str());

source/renderer/TerrainRenderer.cpp

@@ -591 +591 @@
 
 ///////////////////////////////////////////////////////////////////
 // Scissor rectangle of water patches
-CBoundingBoxAligned TerrainRenderer::ScissorWater(const CMatrix3D &viewproj)
+CBoundingBoxAligned TerrainRenderer::ScissorWater(const CMatrix3D& viewproj)
 {
     CBoundingBoxAligned scissor;
     for (size_t i = 0; i < m->visiblePatches.size(); ++i)