100% untested: additionally apply mastervolume to ambient sound channels

[xonotic/darkplaces.git] / model_shared.c

diff --git a/model_shared.c b/model_shared.c
index 482cfe791b6a7b2bcacbdccf86564f9a1c1b65ed..74af7c5975a982412dc68f663cddac656c2fbb07 100644 (file)
--- a/model_shared.c
+++ b/model_shared.c
@@ -28,6 +28,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "polygon.h"
 
 cvar_t r_mipskins = {CVAR_SAVE, "r_mipskins", "0", "mipmaps model skins so they render faster in the distance and do not display noise artifacts, can cause discoloration of skins if they contain undesirable border colors"};
+cvar_t r_mipnormalmaps = {CVAR_SAVE, "r_mipnormalmaps", "1", "mipmaps normalmaps (turning it off looks sharper but may have aliasing)"};
 cvar_t mod_generatelightmaps_unitspersample = {CVAR_SAVE, "mod_generatelightmaps_unitspersample", "8", "lightmap resolution"};
 cvar_t mod_generatelightmaps_borderpixels = {CVAR_SAVE, "mod_generatelightmaps_borderpixels", "2", "extra space around polygons to prevent sampling artifacts"};
 cvar_t mod_generatelightmaps_texturesize = {CVAR_SAVE, "mod_generatelightmaps_texturesize", "1024", "size of lightmap textures"};
@@ -160,6 +161,7 @@ void Mod_Init (void)
        Mod_SpriteInit();
 
        Cvar_RegisterVariable(&r_mipskins);
+       Cvar_RegisterVariable(&r_mipnormalmaps);
        Cvar_RegisterVariable(&mod_generatelightmaps_unitspersample);
        Cvar_RegisterVariable(&mod_generatelightmaps_borderpixels);
        Cvar_RegisterVariable(&mod_generatelightmaps_texturesize);
@@ -1601,6 +1603,8 @@ static void Q3Shader_AddToHash (q3shaderinfo_t* shader)
 }
 
 extern cvar_t mod_q3shader_default_offsetmapping;
+extern cvar_t mod_q3shader_default_polygonoffset;
+extern cvar_t mod_q3shader_default_polygonfactor;
 void Mod_LoadQ3Shaders(void)
 {
        int j;
@@ -1691,6 +1695,8 @@ void Mod_LoadQ3Shaders(void)
                        shader.offsetscale = 1;
                        shader.specularscalemod = 1;
                        shader.specularpowermod = 1;
+                       shader.biaspolygonoffset = mod_q3shader_default_polygonoffset.value;
+                       shader.biaspolygonfactor = mod_q3shader_default_polygonfactor.value;
 
                        strlcpy(shader.name, com_token, sizeof(shader.name));
                        if (!COM_ParseToken_QuakeC(&text, false) || strcasecmp(com_token, "{"))
@@ -2091,6 +2097,18 @@ void Mod_LoadQ3Shaders(void)
                                        shader.textureflags |= Q3TEXTUREFLAG_NOPICMIP;
                                else if (!strcasecmp(parameter[0], "polygonoffset"))
                                        shader.textureflags |= Q3TEXTUREFLAG_POLYGONOFFSET;
+                               else if (!strcasecmp(parameter[0], "dppolygonoffset"))
+                               {
+                                       shader.textureflags |= Q3TEXTUREFLAG_POLYGONOFFSET;
+                                       if(numparameters >= 2)
+                                       {
+                                               shader.biaspolygonfactor = atof(parameter[1]);
+                                               if(numparameters >= 3)
+                                                       shader.biaspolygonoffset = atof(parameter[2]);
+                                               else
+                                                       shader.biaspolygonoffset = 0;
+                                       }
+                               }
                                else if (!strcasecmp(parameter[0], "dprefract") && numparameters >= 5)
                                {
                                        shader.textureflags |= Q3TEXTUREFLAG_REFRACTION;
@@ -2118,6 +2136,11 @@ void Mod_LoadQ3Shaders(void)
                                        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], "dpwaterscroll") && numparameters >= 3)
+                               {
+                                       shader.r_water_waterscroll[0] = 1/atof(parameter[1]);
+                                       shader.r_water_waterscroll[1] = 1/atof(parameter[2]);
+                               }
                                else if (!strcasecmp(parameter[0], "dpglossintensitymod") && numparameters >= 2)
                                {
                                        shader.specularscalemod = atof(parameter[1]);
@@ -2236,7 +2259,7 @@ q3shaderinfo_t *Mod_LookupQ3Shader(const char *name)
 qboolean Mod_LoadTextureFromQ3Shader(texture_t *texture, const char *name, qboolean warnmissing, qboolean fallback, int defaulttexflags)
 {
        int j;
-       int texflagsmask;
+       int texflagsmask, texflagsor;
        qboolean success = true;
        q3shaderinfo_t *shader;
        if (!name)
@@ -2249,6 +2272,11 @@ qboolean Mod_LoadTextureFromQ3Shader(texture_t *texture, const char *name, qbool
                texflagsmask &= ~TEXF_PICMIP;
        if(!(defaulttexflags & TEXF_COMPRESS))
                texflagsmask &= ~TEXF_COMPRESS;
+       texflagsor = 0;
+       if(defaulttexflags & TEXF_ISWORLD)
+               texflagsor |= TEXF_ISWORLD;
+       if(defaulttexflags & TEXF_ISSPRITE)
+               texflagsor |= TEXF_ISSPRITE;
        // unless later loaded from the shader
        texture->offsetmapping = (mod_q3shader_default_offsetmapping.value) ? OFFSETMAPPING_DEFAULT : OFFSETMAPPING_OFF;
        texture->offsetscale = 1;
@@ -2265,7 +2293,7 @@ qboolean Mod_LoadTextureFromQ3Shader(texture_t *texture, const char *name, qbool
                texture->surfaceparms = shader->surfaceparms;
 
                // allow disabling of picmip or compression by defaulttexflags
-               texture->textureflags = shader->textureflags & texflagsmask;
+               texture->textureflags = (shader->textureflags & texflagsmask) | texflagsor;
 
                if (shader->surfaceparms & Q3SURFACEPARM_SKY)
                {
@@ -2286,7 +2314,10 @@ 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->biaspolygonoffset -= 2;
+               {
+                       texture->biaspolygonoffset += shader->biaspolygonoffset;
+                       texture->biaspolygonfactor += shader->biaspolygonfactor;
+               }
                if (shader->textureflags & Q3TEXTUREFLAG_REFRACTION)
                        texture->basematerialflags |= MATERIALFLAG_REFRACTION;
                if (shader->textureflags & Q3TEXTUREFLAG_REFLECTION)
@@ -2353,7 +2384,7 @@ nothing                GL_ZERO GL_ONE
                                {
                                        texture->skinframes[j] = NULL;
                                }
-                               else if (!(texture->skinframes[j] = R_SkinFrame_LoadExternal(primarylayer->texturename[j], primarylayer->texflags & texflagsmask, false)))
+                               else if (!(texture->skinframes[j] = R_SkinFrame_LoadExternal(primarylayer->texturename[j], (primarylayer->texflags & texflagsmask) | texflagsor, false)))
                                {
                                        Con_Printf("^1%s:^7 could not load texture ^3\"%s\"^7 (frame %i) for shader ^2\"%s\"\n", loadmodel->name, primarylayer->texturename[j], j, texture->name);
                                        texture->skinframes[j] = R_SkinFrame_LoadMissing();
@@ -2374,7 +2405,7 @@ nothing                GL_ZERO GL_ONE
                                {
                                        texture->skinframes[j] = NULL;
                                }
-                               else if (!(texture->backgroundskinframes[j] = R_SkinFrame_LoadExternal(backgroundlayer->texturename[j], backgroundlayer->texflags & texflagsmask, false)))
+                               else if (!(texture->backgroundskinframes[j] = R_SkinFrame_LoadExternal(backgroundlayer->texturename[j], (backgroundlayer->texflags & texflagsmask) | texflagsor, false)))
                                {
                                        Con_Printf("^1%s:^7 could not load texture ^3\"%s\"^7 (background frame %i) for shader ^2\"%s\"\n", loadmodel->name, backgroundlayer->texturename[j], j, texture->name);
                                        texture->backgroundskinframes[j] = R_SkinFrame_LoadMissing();
@@ -2393,6 +2424,7 @@ nothing                GL_ZERO GL_ONE
                texture->reflectfactor = shader->reflectfactor;
                Vector4Copy(shader->reflectcolor4f, texture->reflectcolor4f);
                texture->r_water_wateralpha = shader->r_water_wateralpha;
+               Vector2Copy(shader->r_water_waterscroll, texture->r_water_waterscroll);
                texture->offsetmapping = shader->offsetmapping;
                texture->offsetscale = shader->offsetscale;
                texture->specularscalemod = shader->specularscalemod;