support the upcoming -DSND_MODPLUG_STATIC flag

[xonotic/darkplaces.git] / gl_rmain.c

diff --git a/gl_rmain.c b/gl_rmain.c
index f75c34b6eea62dffad9f170201cb25eec8fb09d7..091e7e6298b5cad116bf523d03e29a02a92720eb 100644 (file)
--- a/gl_rmain.c
+++ b/gl_rmain.c
@@ -247,18 +247,24 @@ void FOG_clear(void)
                Cvar_Set("gl_fogblue", "0.3");
        }
        r_refdef.fog_density = r_refdef.fog_red = r_refdef.fog_green = r_refdef.fog_blue = 0.0f;
+       r_refdef.fog_start = 0;
+       r_refdef.fog_end = 1000000000;
 }
 
-float FogPoint_World(const vec3_t p)
+float FogForDistance(vec_t dist)
 {
-       unsigned int fogmasktableindex = (unsigned int)(VectorDistance((p), r_view.origin) * r_refdef.fogmasktabledistmultiplier);
+       unsigned int fogmasktableindex = (unsigned int)(bound(0, dist - r_refdef.fog_start, r_refdef.fog_end - r_refdef.fog_start) * r_refdef.fogmasktabledistmultiplier);
        return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
 }
 
+float FogPoint_World(const vec3_t p)
+{
+       return FogForDistance(VectorDistance((p), r_view.origin));
+}
+
 float FogPoint_Model(const vec3_t p)
 {
-       unsigned int fogmasktableindex = (unsigned int)(VectorDistance((p), rsurface.modelorg) * r_refdef.fogmasktabledistmultiplier);
-       return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
+       return FogForDistance(VectorDistance((p), rsurface.modelorg));
 }
 
 static void R_BuildBlankTextures(void)
@@ -604,6 +610,8 @@ static const char *builtinshaderstring =
 "uniform float OffsetMapping_Scale;\n"
 "uniform float OffsetMapping_Bias;\n"
 "uniform float FogRangeRecip;\n"
+"uniform float FogStart;\n"
+"uniform float FogLength;\n"
 "\n"
 "uniform myhalf AmbientScale;\n"
 "uniform myhalf DiffuseScale;\n"
@@ -847,17 +855,18 @@ static const char *builtinshaderstring =
 "# endif\n"
 "#endif\n"
 "\n"
-"#ifdef USEFOG\n"
-"      // apply fog\n"
-"      color.rgb = mix(FogColor, color.rgb, myhalf(texture2D(Texture_FogMask, myhvec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0))));\n"
-"#endif\n"
-"\n"
 "#ifdef USECONTRASTBOOST\n"
 "      color.rgb = color.rgb / (ContrastBoostCoeff * color.rgb + myhvec3(1, 1, 1));\n"
 "#endif\n"
 "\n"
 "      color.rgb *= SceneBrightness;\n"
 "\n"
+"#ifdef USEFOG\n"
+"      // apply fog\n"
+"      color.rgb = mix(FogColor, color.rgb, myhalf(texture2D(Texture_FogMask, myhvec2(max(0.0, min(length(EyeVectorModelSpace) - FogStart, FogLength))*FogRangeRecip, 0.0))));\n"
+//"      color.rgb = mix(FogColor, color.rgb, myhalf(texture2D(Texture_FogMask, myhvec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0))));\n"
+"#endif\n"
+"\n"
 "      gl_FragColor = vec4(color);\n"
 "}\n"
 "#endif // MODE_REFRACTION\n"
@@ -950,6 +959,8 @@ typedef struct r_glsl_permutation_s
        int loc_Color_Pants;
        int loc_Color_Shirt;
        int loc_FogRangeRecip;
+       int loc_FogStart;
+       int loc_FogLength;
        int loc_AmbientScale;
        int loc_DiffuseScale;
        int loc_SpecularScale;
@@ -1081,6 +1092,8 @@ static void R_GLSL_CompilePermutation(const char *filename, int permutation, int
                p->loc_Color_Pants         = qglGetUniformLocationARB(p->program, "Color_Pants");
                p->loc_Color_Shirt         = qglGetUniformLocationARB(p->program, "Color_Shirt");
                p->loc_FogRangeRecip       = qglGetUniformLocationARB(p->program, "FogRangeRecip");
+               p->loc_FogStart            = qglGetUniformLocationARB(p->program, "FogStart");
+               p->loc_FogLength           = qglGetUniformLocationARB(p->program, "FogLength");
                p->loc_AmbientScale        = qglGetUniformLocationARB(p->program, "AmbientScale");
                p->loc_DiffuseScale        = qglGetUniformLocationARB(p->program, "DiffuseScale");
                p->loc_SpecularPower       = qglGetUniformLocationARB(p->program, "SpecularPower");
@@ -1393,21 +1406,6 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
                if (rsurface.rtlight || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD))
                        qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
                else
-               /*
-               {
-                       vec3_t fogvec;
-                       //   color.rgb *= SceneBrightness;
-                       VectorScale(r_refdef.fogcolor, r_view.colorscale, fogvec);
-                       if(r_glsl_permutation->loc_ContrastBoostCoeff >= 0) // need to support contrast boost
-                       {
-                               //   color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
-                               fogvec[0] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[0] + 1);
-                               fogvec[1] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[1] + 1);
-                               fogvec[2] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[2] + 1);
-                       }
-                       qglUniform3fARB(r_glsl_permutation->loc_FogColor, fogvec[0], fogvec[1], fogvec[2]);
-               }
-               */
                        qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
        }
        if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.modelorg[0], rsurface.modelorg[1], rsurface.modelorg[2]);
@@ -1426,6 +1424,8 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
                        qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
        }
        if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, r_refdef.fograngerecip);
+       if (r_glsl_permutation->loc_FogStart >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogStart, r_refdef.fog_start);
+       if (r_glsl_permutation->loc_FogLength >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogLength, r_refdef.fog_end - r_refdef.fog_start);
        if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower);
        if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
        if (r_glsl_permutation->loc_DistortScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_DistortScaleRefractReflect, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor);
@@ -3111,6 +3111,8 @@ void R_Bloom_MakeTexture(void)
        }
 }
 
+static void R_UpdateFogColor(void); // needs to be called before HDR subrender too, as that changes colorscale!
+
 void R_HDR_RenderBloomTexture(void)
 {
        int oldwidth, oldheight;
@@ -3128,6 +3130,9 @@ void R_HDR_RenderBloomTexture(void)
        r_view.colorscale = r_bloom_colorscale.value * r_hdr_scenebrightness.value;
        if (r_hdr.integer)
                r_view.colorscale /= r_hdr_range.value;
+
+       R_UpdateFogColor();
+
        r_waterstate.numwaterplanes = 0;
        R_RenderScene(r_waterstate.enabled);
        r_view.showdebug = true;
@@ -3216,6 +3221,32 @@ void R_RenderScene(qboolean addwaterplanes);
 
 matrix4x4_t r_waterscrollmatrix;
 
+static void R_UpdateFogColor(void) // needs to be called before HDR subrender too, as that changes colorscale!
+{
+       if (r_refdef.fog_density)
+       {
+               r_refdef.fogcolor[0] = r_refdef.fog_red;
+               r_refdef.fogcolor[1] = r_refdef.fog_green;
+               r_refdef.fogcolor[2] = r_refdef.fog_blue;
+
+               {
+                       vec3_t fogvec;
+                       //   color.rgb *= SceneBrightness;
+                       VectorScale(r_refdef.fogcolor, r_view.colorscale, fogvec);
+                       if(r_glsl.integer && (r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)) // need to support contrast boost
+                       {
+                               //   color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
+                               fogvec[0] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[0] + 1);
+                               fogvec[1] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[1] + 1);
+                               fogvec[2] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[2] + 1);
+                       }
+                       r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
+                       r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
+                       r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
+               }
+       }
+}
+
 void R_UpdateVariables(void)
 {
        R_Textures_Frame();
@@ -3265,12 +3296,16 @@ void R_UpdateVariables(void)
                        r_refdef.fog_blue = 0;
                }
        }
-       if (r_refdef.fog_density)
+
+       if (r_refdef.fog_start >= r_refdef.fog_end || r_refdef.fog_start < 0)
        {
-               r_refdef.fogcolor[0] = bound(0.0f, r_refdef.fog_red  , 1.0f);
-               r_refdef.fogcolor[1] = bound(0.0f, r_refdef.fog_green, 1.0f);
-               r_refdef.fogcolor[2] = bound(0.0f, r_refdef.fog_blue , 1.0f);
+               r_refdef.fog_start = 0;
+               r_refdef.fog_end = 1000000000;
+               // TODO update fog cvars here too
        }
+
+       R_UpdateFogColor();
+
        if (r_refdef.fog_density)
        {
                r_refdef.fogenabled = true;
@@ -3826,7 +3861,7 @@ void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, rtexture_
                R_Mesh_TexBind(0, R_GetTexture(fogtexture));
                GL_BlendFunc(blendfunc1, GL_ONE);
                fog = 1 - fog;
-               GL_Color(r_refdef.fogcolor[0] * fog * r_view.colorscale, r_refdef.fogcolor[1] * fog * r_view.colorscale, r_refdef.fogcolor[2] * fog * r_view.colorscale, ca);
+               GL_Color(r_refdef.fogcolor[0] * fog, r_refdef.fogcolor[1] * fog, r_refdef.fogcolor[2] * fog, ca);
                R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
        }
 }
@@ -6211,35 +6246,38 @@ void R_DrawDebugModel(entity_render_t *ent)
                                }
                                if (r_shownormals.value > 0)
                                {
-                                       GL_Color(r_view.colorscale, 0, 0, 1);
                                        qglBegin(GL_LINES);
                                        for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
                                        {
                                                VectorCopy(rsurface.vertex3f + l * 3, v);
+                                               GL_Color(r_view.colorscale, 0, 0, 1);
                                                qglVertex3f(v[0], v[1], v[2]);
                                                VectorMA(v, r_shownormals.value, rsurface.svector3f + l * 3, v);
+                                               GL_Color(r_view.colorscale, 1, 1, 1);
                                                qglVertex3f(v[0], v[1], v[2]);
                                        }
                                        qglEnd();
                                        CHECKGLERROR
-                                       GL_Color(0, 0, r_view.colorscale, r_shownormals.value);
                                        qglBegin(GL_LINES);
                                        for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
                                        {
                                                VectorCopy(rsurface.vertex3f + l * 3, v);
+                                               GL_Color(0, r_view.colorscale, 0, 1);
                                                qglVertex3f(v[0], v[1], v[2]);
                                                VectorMA(v, r_shownormals.value, rsurface.tvector3f + l * 3, v);
+                                               GL_Color(r_view.colorscale, 1, 1, 1);
                                                qglVertex3f(v[0], v[1], v[2]);
                                        }
                                        qglEnd();
                                        CHECKGLERROR
-                                       GL_Color(0, r_view.colorscale, 0, r_shownormals.value);
                                        qglBegin(GL_LINES);
                                        for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
                                        {
                                                VectorCopy(rsurface.vertex3f + l * 3, v);
+                                               GL_Color(0, 0, r_view.colorscale, 1);
                                                qglVertex3f(v[0], v[1], v[2]);
                                                VectorMA(v, r_shownormals.value, rsurface.normal3f + l * 3, v);
+                                               GL_Color(r_view.colorscale, 1, 1, 1);
                                                qglVertex3f(v[0], v[1], v[2]);
                                        }
                                        qglEnd();