Optimize: Improved load time with large maps (memory allocation of ve…

…rtexillums).

doomsday/engine/portable/include/rend_bias.h

@@ -85,7 +85,7 @@ void            SB_Register(void);
 void            SB_InitForMap(const char* uniqueId);
 void            SB_InitVertexIllum(vertexillum_t* villum);
 
-struct biassurface_s* SB_CreateSurface(uint num);
+struct biassurface_s* SB_CreateSurface(void);
 void            SB_DestroySurface(struct biassurface_s* bsuf);
 void            SB_SurfaceMoved(struct biassurface_s* bsuf);
 

doomsday/engine/portable/src/r_world.c

@@ -598,8 +598,20 @@ plane_t* R_NewPlaneForSector(sector_t* sec)
             }
             Z_Free(ssec->bsuf);
         }
+
         if(!ddMapSetup)
-            newList[n] = SB_CreateSurface(ssec->numVertices);
+        {
+            uint                i;
+            biassurface_t*      bsuf = SB_CreateSurface();
+
+            bsuf->size = ssec->numVertices;
+            bsuf->illum = Z_Calloc(sizeof(vertexillum_t) * bsuf->size, PU_MAP, 0);
+
+            for(i = 0; i < bsuf->size; ++i)
+                SB_InitVertexIllum(&bsuf->illum[i]);
+
+            newList[n] = bsuf;
+        }
 
         ssec->bsuf = newList;
 

doomsday/engine/portable/src/rend_bias.c

@@ -141,18 +141,10 @@ static __inline void freeBiasSurface(biassurface_t* bsuf)
     M_Free(bsuf);
 }
 
-biassurface_t* SB_CreateSurface(uint num)
+biassurface_t* SB_CreateSurface(void)
 {
-    uint                i;
     biassurface_t*      bsuf = allocBiasSurface();
 
-    bsuf->illum = Z_Calloc(sizeof(vertexillum_t) * num, PU_MAP, 0);
-    bsuf->size = num;
-    for(i = 0; i < bsuf->size; ++i)
-    {
-        SB_InitVertexIllum(&bsuf->illum[i]);
-    }
-
     // Link it in to the global list.
     bsuf->next = surfaces;
     surfaces = bsuf;
@@ -327,6 +319,8 @@ void SB_Clear(void)
  */
 void SB_InitForMap(const char* uniqueID)
 {
+    uint                startTime = Sys_GetRealTime();
+
     int                 i;
     ded_light_t*        def;
 
@@ -356,7 +350,42 @@ void SB_InitForMap(const char* uniqueID)
     // Create biassurfaces for all current worldmap surfaces.
     {
     uint                i;
+    size_t              numVertIllums = 0;
+    vertexillum_t*      illums;
 
+    // First, determine the total number of vertexillum_ts we need.
+    for(i = 0; i < numSegs; ++i)
+        if(segs[i].lineDef)
+            numVertIllums++;
+
+    numVertIllums *= 3 * 4;
+
+    for(i = 0; i < numSectors; ++i)
+    {
+        sector_t*           sec = &sectors[i];
+        subsector_t**       ssecPtr = sec->ssectors;
+
+        while(*ssecPtr)
+        {
+            subsector_t*        ssec = *ssecPtr;
+            numVertIllums += ssec->numVertices * sec->planeCount;
+            *ssecPtr++;
+        }
+    }
+
+    for(i = 0; i < numPolyObjs; ++i)
+    {
+        polyobj_t*          po = polyObjs[i];
+
+        numVertIllums += po->numSegs * 3 * 4;
+    }
+
+    // Allocate and initialize the vertexillum_ts.
+    illums = Z_Calloc(sizeof(vertexillum_t) * numVertIllums, PU_MAP, 0);
+    for(i = 0; i < numVertIllums; ++i)
+        SB_InitVertexIllum(&illums[i]);
+
+    // Allocate bias surfaces and attach vertexillum_ts.
     for(i = 0; i < numSegs; ++i)
     {
         seg_t*              seg = &segs[i];
@@ -366,7 +395,15 @@ void SB_InitForMap(const char* uniqueID)
             continue;
 
         for(j = 0; j < 3; ++j)
-            seg->bsuf[j] = SB_CreateSurface(4);
+        {
+            biassurface_t*      bsuf = SB_CreateSurface();
+
+            bsuf->size = 4;
+            bsuf->illum = illums;
+            illums += 4;
+
+            seg->bsuf[j] = bsuf;
+        }
     }
 
     for(i = 0; i < numSectors; ++i)
@@ -380,7 +417,16 @@ void SB_InitForMap(const char* uniqueID)
             uint                j;
 
             for(j = 0; j < sec->planeCount; ++j)
-                ssec->bsuf[j] = SB_CreateSurface(ssec->numVertices);
+            {
+                biassurface_t*      bsuf = SB_CreateSurface();
+
+                bsuf->size = ssec->numVertices;
+                bsuf->illum = illums;
+                illums += ssec->numVertices;
+
+                ssec->bsuf[j] = bsuf;
+            }
+
             *ssecPtr++;
         }
     }
@@ -396,10 +442,22 @@ void SB_InitForMap(const char* uniqueID)
             int                 k;
 
             for(k = 0; k < 3; ++k)
-                seg->bsuf[k] = SB_CreateSurface(4);
+            {
+                biassurface_t*      bsuf = SB_CreateSurface();
+
+                bsuf->size = 4;
+                bsuf->illum = illums;
+                illums += 4;
+
+                seg->bsuf[k] = bsuf;
+            }
         }
     }
     }
+
+    // How much time did we spend?
+    VERBOSE(Con_Message("SB_InitForMap: Done in %.2f seconds.\n",
+                        (Sys_GetRealTime() - startTime) / 1000.0f));
 }
 
 void SB_SetColor(float* dest, float* src)