reenabled R_UpdateAllTextureInfo calls when lighting the world model

[xonotic/darkplaces.git] / model_shared.c

diff --git a/model_shared.c b/model_shared.c
index a162eda85066299194b8dfe312d6c4a5fa984784..9deebc5ab343e2eb448b66a2fba746329b738972 100644 (file)
--- a/model_shared.c
+++ b/model_shared.c
@@ -44,6 +44,7 @@ typedef struct q3shader_data_s
 {
   memexpandablearray_t hash_entries;
   q3shader_hash_entry_t hash[Q3SHADER_HASH_SIZE];
+  memexpandablearray_t char_ptrs;
 } q3shader_data_t;
 static q3shader_data_t* q3shader_data;
 
@@ -244,6 +245,18 @@ model_t *Mod_LoadModel(model_t *mod, qboolean crash, qboolean checkdisk, qboolea
        VectorSet(mod->rotatedmins, -mod->radius, -mod->radius, -mod->radius);
        VectorSet(mod->rotatedmaxs, mod->radius, mod->radius, mod->radius);
 
+       // if we're loading a worldmodel, then this is a level change
+       if (mod->isworldmodel)
+       {
+               // clear out any stale submodels or worldmodels lying around
+               // if we did this clear before now, an error might abort loading and
+               // leave things in a bad state
+               Mod_RemoveStaleWorldModels(mod);
+               // reload q3 shaders, to make sure they are ready to go for this level
+               // (including any models loaded for this level)
+               Mod_LoadQ3Shaders();
+       }
+
        if (buf)
        {
                char *bufend = (char *)buf + filesize;
@@ -1126,11 +1139,13 @@ static void Q3Shaders_Clear()
                sizeof (q3shader_data_t));
        Mem_ExpandableArray_NewArray (&q3shader_data->hash_entries, 
                q3shaders_mem, sizeof (q3shader_hash_entry_t), 256);
+       Mem_ExpandableArray_NewArray (&q3shader_data->char_ptrs,
+               q3shaders_mem, sizeof (char**), 256);
 }
 
 static void Q3Shader_AddToHash (q3shaderinfo_t* shader)
 {
-       unsigned short hash = CRC_Block (shader->name, strlen (shader->name));
+       unsigned short hash = CRC_Block_CaseInsensitive ((const unsigned char *)shader->name, strlen (shader->name));
        q3shader_hash_entry_t* entry = q3shader_data->hash + (hash % Q3SHADER_HASH_SIZE);
        q3shader_hash_entry_t* lastEntry = NULL;
        while (entry != NULL)
@@ -1151,7 +1166,7 @@ static void Q3Shader_AddToHash (q3shaderinfo_t* shader)
                        q3shader_hash_entry_t* newEntry = (q3shader_hash_entry_t*)
                          Mem_ExpandableArray_AllocRecord (&q3shader_data->hash_entries);
                        
-                       while (entry->chain != NULL) entry = entry->chain;
+                       while (lastEntry->chain != NULL) lastEntry = lastEntry->chain;
                        lastEntry->chain = newEntry;
                        newEntry->chain = NULL;
                        lastEntry = newEntry;
@@ -1306,7 +1321,9 @@ void Mod_LoadQ3Shaders(void)
                                                                layer->clampmap = true;
                                                        layer->numframes = 1;
                                                        layer->framerate = 1;
-                                                       strlcpy(layer->texturename[0], parameter[1], sizeof(layer->texturename));
+                                                       layer->texturename = (char**)Mem_ExpandableArray_AllocRecord (
+                                                               &q3shader_data->char_ptrs);
+                                                       layer->texturename[0] = Mem_strdup (q3shaders_mem, parameter[1]);
                                                        if (!strcasecmp(parameter[1], "$lightmap"))
                                                                shader.lighting = true;
                                                }
@@ -1315,8 +1332,9 @@ void Mod_LoadQ3Shaders(void)
                                                        int i;
                                                        layer->numframes = min(numparameters - 2, TEXTURE_MAXFRAMES);
                                                        layer->framerate = atof(parameter[1]);
+                                                       layer->texturename = Mem_Alloc (q3shaders_mem, sizeof (char*) * layer->numframes);
                                                        for (i = 0;i < layer->numframes;i++)
-                                                               strlcpy(layer->texturename[i], parameter[i + 2], sizeof(layer->texturename));
+                                                               layer->texturename[i] = Mem_strdup (q3shaders_mem, parameter[i + 2]);
                                                }
                                                else if (numparameters >= 2 && !strcasecmp(parameter[0], "rgbgen"))
                                                {
@@ -1629,7 +1647,8 @@ void Mod_LoadQ3Shaders(void)
                                        shader.primarylayer = 1;
                                }
                                // now see if the lightmap came first, and if so choose the second texture instead
-                               if (!strcasecmp(shader.layers[shader.primarylayer].texturename[0], "$lightmap"))
+                               if ((shader.layers[shader.primarylayer].texturename != NULL)
+                                 && !strcasecmp(shader.layers[shader.primarylayer].texturename[0], "$lightmap"))
                                {
                                        shader.backgroundlayer = -1;
                                        shader.primarylayer = 1;
@@ -1647,7 +1666,7 @@ void Mod_LoadQ3Shaders(void)
 
 q3shaderinfo_t *Mod_LookupQ3Shader(const char *name)
 {
-       unsigned short hash = CRC_Block (name, strlen (name));
+       unsigned short hash = CRC_Block_CaseInsensitive ((const unsigned char *)name, strlen (name));
        q3shader_hash_entry_t* entry = q3shader_data->hash + (hash % Q3SHADER_HASH_SIZE);
        while (entry != NULL)
        {
@@ -1698,7 +1717,7 @@ qboolean Mod_LoadTextureFromQ3Shader(texture_t *texture, const char *name, qbool
                if (shader->textureflags & Q3TEXTUREFLAG_TWOSIDED)
                        texture->basematerialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
                if (shader->textureflags & Q3TEXTUREFLAG_POLYGONOFFSET)
-                       texture->basepolygonoffset -= 2;
+                       texture->biaspolygonoffset -= 2;
                if (shader->textureflags & Q3TEXTUREFLAG_REFRACTION)
                        texture->basematerialflags |= MATERIALFLAG_REFRACTION;
                if (shader->textureflags & Q3TEXTUREFLAG_REFLECTION)