revert my change and fix the types on Black's changes, which were the

[xonotic/darkplaces.git] / model_shared.c

diff --git a/model_shared.c b/model_shared.c
index a162eda85066299194b8dfe312d6c4a5fa984784..9899adcf1653b9e9362132a83b0f211a727b5fca 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;
@@ -264,7 +277,6 @@ model_t *Mod_LoadModel(model_t *mod, qboolean crash, qboolean checkdisk, qboolea
                else if (!memcmp(buf, "DARKPLACESMODEL", 16)) Mod_DARKPLACESMODEL_Load(mod, buf, bufend);
                else if (!memcmp(buf, "ACTRHEAD", 8)) Mod_PSKMODEL_Load(mod, buf, bufend);
                else if (strlen(mod->name) >= 4 && !strcmp(mod->name - 4, ".map")) Mod_MAP_Load(mod, buf, bufend);
-               else if (!memcmp(buf, "MCBSPpad", 8)) Mod_Q1BSP_Load(mod, buf, bufend);
                else if (num == BSPVERSION || num == 30) Mod_Q1BSP_Load(mod, buf, bufend);
                else Con_Printf("Mod_LoadModel: model \"%s\" is of unknown/unsupported type\n", mod->name);
                Mem_Free(buf);
@@ -1126,11 +1138,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 +1165,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;
@@ -1193,6 +1207,7 @@ void Mod_LoadQ3Shaders(void)
                        Vector4Set(shader.refractcolor4f, 1, 1, 1, 1);
                        shader.reflectfactor = 1;
                        Vector4Set(shader.reflectcolor4f, 1, 1, 1, 1);
+                       shader.r_water_wateralpha = 1;
 
                        strlcpy(shader.name, com_token, sizeof(shader.name));
                        if (!COM_ParseToken_QuakeC(&text, false) || strcasecmp(com_token, "{"))
@@ -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"))
                                                {
@@ -1565,7 +1583,7 @@ void Mod_LoadQ3Shaders(void)
                                        shader.reflectfactor = atof(parameter[1]);
                                        Vector4Set(shader.reflectcolor4f, atof(parameter[2]), atof(parameter[3]), atof(parameter[4]), atof(parameter[5]));
                                }
-                               else if (!strcasecmp(parameter[0], "dp_water") && numparameters >= 11)
+                               else if (!strcasecmp(parameter[0], "dp_water") && numparameters >= 12)
                                {
                                        shader.textureflags |= Q3TEXTUREFLAG_WATERSHADER;
                                        shader.reflectmin = atof(parameter[1]);
@@ -1574,6 +1592,7 @@ void Mod_LoadQ3Shaders(void)
                                        shader.reflectfactor = atof(parameter[4]);
                                        Vector4Set(shader.refractcolor4f, atof(parameter[5]), atof(parameter[6]), atof(parameter[7]), 1);
                                        Vector4Set(shader.reflectcolor4f, atof(parameter[8]), atof(parameter[9]), atof(parameter[10]), 1);
+                                       shader.r_water_wateralpha = atof(parameter[11]);
                                }
                                else if (!strcasecmp(parameter[0], "deformvertexes") && numparameters >= 2)
                                {
@@ -1629,7 +1648,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 +1667,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)
        {
@@ -1676,7 +1696,7 @@ qboolean Mod_LoadTextureFromQ3Shader(texture_t *texture, const char *name, qbool
                texture->basematerialflags = 0;
                if (shader->surfaceparms & Q3SURFACEPARM_SKY)
                {
-                       texture->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
+                       texture->basematerialflags = MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
                        if (shader->skyboxname[0])
                        {
                                // quake3 seems to append a _ to the skybox name, so this must do so as well
@@ -1684,21 +1704,15 @@ qboolean Mod_LoadTextureFromQ3Shader(texture_t *texture, const char *name, qbool
                        }
                }
                else if ((texture->surfaceflags & Q3SURFACEFLAG_NODRAW) || shader->numlayers == 0)
-                       texture->basematerialflags |= MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW;
-               else if (shader->surfaceparms & Q3SURFACEPARM_LAVA)
-                       texture->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOSHADOW;
-               else if (shader->surfaceparms & Q3SURFACEPARM_SLIME)
-                       texture->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW;
-               else if (shader->surfaceparms & Q3SURFACEPARM_WATER)
-                       texture->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW;
+                       texture->basematerialflags = MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW;
                else
-                       texture->basematerialflags |= MATERIALFLAG_WALL;
+                       texture->basematerialflags = MATERIALFLAG_WALL;
                if (shader->layers[0].alphatest)
                        texture->basematerialflags |= MATERIALFLAG_ALPHATEST | MATERIALFLAG_NOSHADOW;
                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)
@@ -1794,6 +1808,7 @@ nothing                GL_ZERO GL_ONE
                Vector4Copy(shader->refractcolor4f, texture->refractcolor4f);
                texture->reflectfactor = shader->reflectfactor;
                Vector4Copy(shader->reflectcolor4f, texture->reflectcolor4f);
+               texture->r_water_wateralpha = shader->r_water_wateralpha;
        }
        else if (!strcmp(texture->name, "noshader"))
        {