]> git.xonotic.org Git - xonotic/darkplaces.git/blobdiff - model_shared.c
Offsetmapping: new "Bias" parameter that sets a custom "null point" instead of always...
[xonotic/darkplaces.git] / model_shared.c
index 0fc772824c4a23e4da119883ab14376c9a31c09c..8a27c672446216e335e302f6e29343e346f257c0 100644 (file)
@@ -1573,15 +1573,31 @@ static void Q3Shader_AddToHash (q3shaderinfo_t* shader)
        {
                if (strcasecmp (entry->shader.name, shader->name) == 0)
                {
-                       unsigned char *start, *end, *start2;
-                       start = (unsigned char *) (&shader->Q3SHADERINFO_COMPARE_START);
-                       end = ((unsigned char *) (&shader->Q3SHADERINFO_COMPARE_END)) + sizeof(shader->Q3SHADERINFO_COMPARE_END);
-                       start2 = (unsigned char *) (&entry->shader.Q3SHADERINFO_COMPARE_START);
-                       if(memcmp(start, start2, end - start))
-                               Con_DPrintf("Shader '%s' already defined, ignoring mismatching redeclaration\n", shader->name);
+                       // redeclaration
+                       if(shader->dpshaderkill)
+                       {
+                               // killed shader is a redeclarion? we can safely ignore it
+                               return;
+                       }
+                       else if(entry->shader.dpshaderkill)
+                       {
+                               // replace the old shader!
+                               // this will skip the entry allocating part
+                               // below and just replace the shader
+                               break;
+                       }
                        else
-                               Con_DPrintf("Shader '%s' already defined\n", shader->name);
-                       return;
+                       {
+                               unsigned char *start, *end, *start2;
+                               start = (unsigned char *) (&shader->Q3SHADERINFO_COMPARE_START);
+                               end = ((unsigned char *) (&shader->Q3SHADERINFO_COMPARE_END)) + sizeof(shader->Q3SHADERINFO_COMPARE_END);
+                               start2 = (unsigned char *) (&entry->shader.Q3SHADERINFO_COMPARE_START);
+                               if(memcmp(start, start2, end - start))
+                                       Con_DPrintf("Shader '%s' already defined, ignoring mismatching redeclaration\n", shader->name);
+                               else
+                                       Con_DPrintf("Shader '%s' already defined\n", shader->name);
+                               return;
+                       }
                }
                lastEntry = entry;
                entry = entry->chain;
@@ -1607,6 +1623,7 @@ static void Q3Shader_AddToHash (q3shaderinfo_t* shader)
 
 extern cvar_t mod_noshader_default_offsetmapping;
 extern cvar_t mod_q3shader_default_offsetmapping;
+extern cvar_t mod_q3shader_default_offsetmapping_bias;
 extern cvar_t mod_q3shader_default_polygonoffset;
 extern cvar_t mod_q3shader_default_polygonfactor;
 void Mod_LoadQ3Shaders(void)
@@ -1623,6 +1640,7 @@ void Mod_LoadQ3Shaders(void)
        char *custsurfaceparmnames[256]; // VorteX: q3map2 has 64 but well, someone will need more
        unsigned long custsurfaceparms[256]; 
        int numcustsurfaceparms;
+       qboolean dpshaderkill;
 
        Mod_FreeQ3Shaders();
 
@@ -1697,6 +1715,7 @@ void Mod_LoadQ3Shaders(void)
                        shader.r_water_wateralpha = 1;
                        shader.offsetmapping = (mod_q3shader_default_offsetmapping.value) ? OFFSETMAPPING_DEFAULT : OFFSETMAPPING_OFF;
                        shader.offsetscale = 1;
+                       shader.offsetbias = bound(0, mod_q3shader_default_offsetmapping_bias.integer, 255);
                        shader.specularscalemod = 1;
                        shader.specularpowermod = 1;
                        shader.biaspolygonoffset = mod_q3shader_default_polygonoffset.value;
@@ -2079,6 +2098,58 @@ void Mod_LoadQ3Shaders(void)
                                        strlcpy(shader.dpreflectcube, parameter[1], sizeof(shader.dpreflectcube));
                                else if (!strcasecmp(parameter[0], "dpmeshcollisions"))
                                        shader.dpmeshcollisions = true;
+                               // this sets dpshaderkill to true if dpshaderkillifcvarzero was used, and to false if dpnoshaderkillifcvarzero was used
+                               else if (((dpshaderkill = !strcasecmp(parameter[0], "dpshaderkillifcvarzero")) || !strcasecmp(parameter[0], "dpnoshaderkillifcvarzero")) && numparameters >= 2)
+                               {
+                                       if (Cvar_VariableValue(parameter[1]) == 0.0f)
+                                               shader.dpshaderkill = dpshaderkill;
+                               }
+                               // this sets dpshaderkill to true if dpshaderkillifcvar was used, and to false if dpnoshaderkillifcvar was used
+                               else if (((dpshaderkill = !strcasecmp(parameter[0], "dpshaderkillifcvar")) || !strcasecmp(parameter[0], "dpnoshaderkillifcvar")) && numparameters >= 2)
+                               {
+                                       const char *op = NULL;
+                                       if (numparameters >= 3)
+                                               op = parameter[2];
+                                       if(!op)
+                                       {
+                                               if (Cvar_VariableValue(parameter[1]) != 0.0f)
+                                                       shader.dpshaderkill = dpshaderkill;
+                                       }
+                                       else if (numparameters >= 4 && !strcmp(op, "=="))
+                                       {
+                                               if (Cvar_VariableValue(parameter[1]) == atof(parameter[3]))
+                                                       shader.dpshaderkill = dpshaderkill;
+                                       }
+                                       else if (numparameters >= 4 && !strcmp(op, "!="))
+                                       {
+                                               if (Cvar_VariableValue(parameter[1]) != atof(parameter[3]))
+                                                       shader.dpshaderkill = dpshaderkill;
+                                       }
+                                       else if (numparameters >= 4 && !strcmp(op, ">"))
+                                       {
+                                               if (Cvar_VariableValue(parameter[1]) > atof(parameter[3]))
+                                                       shader.dpshaderkill = dpshaderkill;
+                                       }
+                                       else if (numparameters >= 4 && !strcmp(op, "<"))
+                                       {
+                                               if (Cvar_VariableValue(parameter[1]) < atof(parameter[3]))
+                                                       shader.dpshaderkill = dpshaderkill;
+                                       }
+                                       else if (numparameters >= 4 && !strcmp(op, ">="))
+                                       {
+                                               if (Cvar_VariableValue(parameter[1]) >= atof(parameter[3]))
+                                                       shader.dpshaderkill = dpshaderkill;
+                                       }
+                                       else if (numparameters >= 4 && !strcmp(op, "<="))
+                                       {
+                                               if (Cvar_VariableValue(parameter[1]) <= atof(parameter[3]))
+                                                       shader.dpshaderkill = dpshaderkill;
+                                       }
+                                       else
+                                       {
+                                               Con_DPrintf("%s parsing warning: unknown dpshaderkillifcvar op \"%s\", or not enough arguments\n", search->filenames[fileindex], op);
+                                       }
+                               }
                                else if (!strcasecmp(parameter[0], "sky") && numparameters >= 2)
                                {
                                        // some q3 skies don't have the sky parm set
@@ -2159,17 +2230,20 @@ void Mod_LoadQ3Shaders(void)
                                {
                                        shader.rtlightambient = atof(parameter[1]);
                                }
-                               else if (!strcasecmp(parameter[0], "dpoffsetmapping") && numparameters >= 3)
+                               else if (!strcasecmp(parameter[0], "dpoffsetmapping") && numparameters >= 2)
                                {
                                        if (!strcasecmp(parameter[1], "disable") || !strcasecmp(parameter[1], "none") || !strcasecmp(parameter[1], "off"))
                                                shader.offsetmapping = OFFSETMAPPING_OFF;
-                                       else if (!strcasecmp(parameter[1], "default"))
+                                       else if (!strcasecmp(parameter[1], "default") || !strcasecmp(parameter[1], "normal"))
                                                shader.offsetmapping = OFFSETMAPPING_DEFAULT;
                                        else if (!strcasecmp(parameter[1], "linear"))
                                                shader.offsetmapping = OFFSETMAPPING_LINEAR;
                                        else if (!strcasecmp(parameter[1], "relief"))
                                                shader.offsetmapping = OFFSETMAPPING_RELIEF;
-                                       shader.offsetscale = atof(parameter[2]);
+                                       if (numparameters >= 3)
+                                               shader.offsetscale = atof(parameter[2]);
+                                       if (numparameters >= 4)
+                                               shader.offsetbias = bound(0, atoi(parameter[3]), 255);
                                }
                                else if (!strcasecmp(parameter[0], "deformvertexes") && numparameters >= 2)
                                {
@@ -2211,6 +2285,9 @@ void Mod_LoadQ3Shaders(void)
                                        }
                                }
                        }
+                       // hide this shader if a cvar said it should be killed
+                       if (shader.dpshaderkill)
+                               shader.numlayers = 0;
                        // pick the primary layer to render with
                        if (shader.numlayers)
                        {
@@ -2290,8 +2367,10 @@ qboolean Mod_LoadTextureFromQ3Shader(texture_t *texture, const char *name, qbool
        // unless later loaded from the shader
        texture->offsetmapping = (mod_noshader_default_offsetmapping.value) ? OFFSETMAPPING_DEFAULT : OFFSETMAPPING_OFF;
        texture->offsetscale = 1;
+       texture->offsetbias = 0;
        texture->specularscalemod = 1;
        texture->specularpowermod = 1; 
+       texture->rtlightambient = 0;
        // WHEN ADDING DEFAULTS HERE, REMEMBER TO SYNC TO SHADER LOADING ABOVE
        // HERE, AND Q1BSP LOADING
        // JUST GREP FOR "specularscalemod = 1".
@@ -2439,6 +2518,7 @@ nothing                GL_ZERO GL_ONE
                Vector2Copy(shader->r_water_waterscroll, texture->r_water_waterscroll);
                texture->offsetmapping = shader->offsetmapping;
                texture->offsetscale = shader->offsetscale;
+               texture->offsetbias = shader->offsetbias;
                texture->specularscalemod = shader->specularscalemod;
                texture->specularpowermod = shader->specularpowermod;
                texture->rtlightambient = shader->rtlightambient;
@@ -2490,6 +2570,8 @@ nothing                GL_ZERO GL_ONE
 
                if (shader->dpmeshcollisions)
                        texture->basematerialflags |= MATERIALFLAG_MESHCOLLISIONS;
+               if (shader->dpshaderkill && developer_extra.integer)
+                       Con_DPrintf("^1%s:^7 killing shader ^3\"%s\" because of cvar\n", loadmodel->name, name);
        }
        else if (!strcmp(texture->name, "noshader") || !texture->name[0])
        {