theoretical fog from quakespasm

source/gl_fog.c

@@ -1,21 +1,384 @@
+/*
+Copyright (C) 1996-2001 Id Software, Inc.
+Copyright (C) 2002-2009 John Fitzgibbons and others
+Copyright (C) 2007-2008 Kristian Duske
+Copyright (C) 2010-2014 QuakeSpasm developers
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+See the GNU General Public License for more details.
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+//gl_fog.c -- global fog
+
+#include "quakedef.h"
+
+//==============================================================================
+//
+//  GLOBAL FOG
+//
+//==============================================================================
+
+#define DEFAULT_DENSITY 0.0
+#define DEFAULT_GRAY 0.3
+
+float fog_start;
+float fog_end;
+float fog_density_gl;
+float fog_red;
+float fog_green;
+float fog_blue;
+
+float old_density;
+float old_red;
+float old_green;
+float old_blue;
+
+float fade_time; //duration of fade
+float fade_done; //time when fade will be done
+
+/*
+=============
+Fog_Update
+update internal variables
+=============
+*/
+void Fog_Update (float density, float red, float green, float blue, float time)
+{
+	//save previous settings for fade
+	if (time > 0)
+	{
+		//check for a fade in progress
+		if (fade_done > cl.time)
+		{
+			float f;
+
+			f = (fade_done - cl.time) / fade_time;
+			old_density = f * old_density + (1.0 - f) * fog_density_gl;
+			old_red = f * old_red + (1.0 - f) * fog_red;
+			old_green = f * old_green + (1.0 - f) * fog_green;
+			old_blue = f * old_blue + (1.0 - f) * fog_blue;
+		}
+		else
+		{
+			old_density = fog_density_gl;
+			old_red = fog_red;
+			old_green = fog_green;
+			old_blue = fog_blue;
+		}
+	}
+
+	fog_density_gl = density;
+	fog_red = red;
+	fog_green = green;
+	fog_blue = blue;
+	fade_time = time;
+	fade_done = cl.time + time;
+}
+
 /*
 =============
 Fog_ParseServerMessage
-
 handle an SVC_FOG message from server
 =============
 */
 void Fog_ParseServerMessage (void)
 {
-	float start, end, red, green, blue, time;
+	float density, red, green, blue, time;
 
-	start = MSG_ReadByte() / 255.0;
-	end = MSG_ReadByte() / 255.0;
+	density = MSG_ReadByte() / 255.0;
 	red = MSG_ReadByte() / 255.0;
 	green = MSG_ReadByte() / 255.0;
 	blue = MSG_ReadByte() / 255.0;
-	time = MSG_ReadShort() / 100.0;
+	time = max(0.0, MSG_ReadShort() / 100.0);
 
-	// rbaldwin2 -- fixme
-	//Fog_Update (start, end, red, green, blue, time);
+	Fog_Update (density, red, green, blue, time);
+}
+
+/*
+=============
+Fog_FogCommand_f
+handle the 'fog' console command
+=============
+*/
+void Fog_FogCommand_f (void)
+{
+	switch (Cmd_Argc())
+	{
+	default:
+	case 1:
+		Con_Printf("usage:\n");
+		Con_Printf("   fog <density>\n");
+		Con_Printf("   fog <red> <green> <blue>\n");
+		Con_Printf("   fog <density> <red> <green> <blue>\n");
+		Con_Printf("current values:\n");
+		Con_Printf("   \"density\" is \"%f\"\n", fog_density_gl);
+		Con_Printf("   \"red\" is \"%f\"\n", fog_red);
+		Con_Printf("   \"green\" is \"%f\"\n", fog_green);
+		Con_Printf("   \"blue\" is \"%f\"\n", fog_blue);
+		break;
+	case 2:
+		Fog_Update(max(0.0, atof(Cmd_Argv(1))),
+				   fog_red,
+				   fog_green,
+				   fog_blue,
+				   0.0);
+		break;
+	case 3: //TEST
+		Fog_Update(max(0.0, atof(Cmd_Argv(1))),
+				   fog_red,
+				   fog_green,
+				   fog_blue,
+				   atof(Cmd_Argv(2)));
+		break;
+	case 4:
+		Fog_Update(fog_density_gl,
+				   CLAMP(0.0, atof(Cmd_Argv(1)), 1.0),
+				   CLAMP(0.0, atof(Cmd_Argv(2)), 1.0),
+				   CLAMP(0.0, atof(Cmd_Argv(3)), 1.0),
+				   0.0);
+		break;
+	case 5:
+		Fog_Update(max(0.0, atof(Cmd_Argv(1))),
+				   CLAMP(0.0, atof(Cmd_Argv(2)), 1.0),
+				   CLAMP(0.0, atof(Cmd_Argv(3)), 1.0),
+				   CLAMP(0.0, atof(Cmd_Argv(4)), 1.0),
+				   0.0);
+		break;
+	case 6: //TEST
+		Fog_Update(max(0.0, atof(Cmd_Argv(1))),
+				   CLAMP(0.0, atof(Cmd_Argv(2)), 1.0),
+				   CLAMP(0.0, atof(Cmd_Argv(3)), 1.0),
+				   CLAMP(0.0, atof(Cmd_Argv(4)), 1.0),
+				   atof(Cmd_Argv(5)));
+		break;
+	}
+}
+
+/*
+=============
+Fog_ParseWorldspawn
+called at map load
+=============
+*/
+void Fog_ParseWorldspawn (void)
+{
+	char key[128], value[4096];
+	const char *data;
+
+	//initially no fog
+	fog_density_gl = DEFAULT_DENSITY;
+	fog_red = DEFAULT_GRAY;
+	fog_green = DEFAULT_GRAY;
+	fog_blue = DEFAULT_GRAY;
+
+	old_density = DEFAULT_DENSITY;
+	old_red = DEFAULT_GRAY;
+	old_green = DEFAULT_GRAY;
+	old_blue = DEFAULT_GRAY;
+
+	fade_time = 0.0;
+	fade_done = 0.0;
+
+	data = COM_Parse(cl.worldmodel->entities);
+	if (!data)
+		return; // error
+	if (com_token[0] != '{')
+		return; // error
+	while (1)
+	{
+		data = COM_Parse(data);
+		if (!data)
+			return; // error
+		if (com_token[0] == '}')
+			break; // end of worldspawn
+		if (com_token[0] == '_')
+			strcpy(key, com_token + 1);
+		else
+			strcpy(key, com_token);
+		while (key[strlen(key)-1] == ' ') // remove trailing spaces
+			key[strlen(key)-1] = 0;
+		data = COM_Parse(data);
+		if (!data)
+			return; // error
+		strcpy(value, com_token);
+
+		if (!strcmp("fog", key))
+		{
+			sscanf(value, "%f %f %f %f %f", &fog_start, &fog_end, &fog_red, &fog_green, &fog_blue);
+		}
+
+		fog_density_gl = ((fog_end - fog_start))/6000;
+	}
+}
+
+/*
+=============
+Fog_GetColor
+calculates fog color for this frame, taking into account fade times
+=============
+*/
+float *Fog_GetColor (void)
+{
+	static float c[4] = {0.3f, 0.3f, 0.3f, 1.0f};
+#ifndef VITA
+	float f;
+	int i;
+
+	if (fade_done > cl.time)
+	{
+		f = (fade_done - cl.time) / fade_time;
+		c[0] = f * old_red + (1.0 - f) * fog_red;
+		c[1] = f * old_green + (1.0 - f) * fog_green;
+		c[2] = f * old_blue + (1.0 - f) * fog_blue;
+		c[3] = 1.0;
+	}
+	else
+	{
+		c[0] = fog_red;
+		c[1] = fog_green;
+		c[2] = fog_blue;
+		c[3] = 1.0;
+	}
+
+	//find closest 24-bit RGB value, so solid-colored sky can match the fog perfectly
+	for (i=0;i<3;i++)
+		c[i] = (float)(Q_rint(c[i] * 255)) / 255.0f;
+#endif
+	return c;
+}
+
+/*
+=============
+Fog_GetDensity
+returns current density of fog
+=============
+*/
+float Fog_GetDensity (void)
+{
+	float f;
+
+	if (fade_done > cl.time)
+	{
+		f = (fade_done - cl.time) / fade_time;
+		return f * old_density + (1.0 - f) * fog_density_gl;
+	}
+	else
+		return fog_density_gl;
+}
+
+/*
+=============
+Fog_SetupFrame
+called at the beginning of each frame
+=============
+*/
+void Fog_SetupFrame (void)
+{
+	glFogfv(GL_FOG_COLOR, Fog_GetColor());
+	glFogf(GL_FOG_DENSITY, Fog_GetDensity() / 64.0);
+}
+
+/*
+=============
+Fog_EnableGFog
+called before drawing stuff that should be fogged
+=============
+*/
+void Fog_EnableGFog (void)
+{
+	if (Fog_GetDensity() > 0)
+		glEnable(GL_FOG);
+}
+
+/*
+=============
+Fog_DisableGFog
+called after drawing stuff that should be fogged
+=============
+*/
+void Fog_DisableGFog (void)
+{
+	if (Fog_GetDensity() > 0)
+		glDisable(GL_FOG);
+}
+
+/*
+=============
+Fog_StartAdditive
+called before drawing stuff that is additive blended -- sets fog color to black
+=============
+*/
+void Fog_StartAdditive (void)
+{
+	vec3_t color = {0,0,0};
+
+	if (Fog_GetDensity() > 0)
+		glFogfv(GL_FOG_COLOR, color);
+}
+
+/*
+=============
+Fog_StopAdditive
+called after drawing stuff that is additive blended -- restores fog color
+=============
+*/
+void Fog_StopAdditive (void)
+{
+	if (Fog_GetDensity() > 0)
+		glFogfv(GL_FOG_COLOR, Fog_GetColor());
+}
+
+//==============================================================================
+//
+//  INIT
+//
+//==============================================================================
+
+/*
+=============
+Fog_NewMap
+called whenever a map is loaded
+=============
+*/
+void Fog_NewMap (void)
+{
+	Fog_ParseWorldspawn (); //for global fog
+}
+
+/*
+=============
+Fog_Init
+called when quake initializes
+=============
+*/
+void Fog_Init (void)
+{
+	Cmd_AddCommand ("fog",Fog_FogCommand_f);
+
+	//set up global fog
+	fog_density_gl = DEFAULT_DENSITY;
+	fog_red = DEFAULT_GRAY;
+	fog_green = DEFAULT_GRAY;
+	fog_blue = DEFAULT_GRAY;
+
+	Fog_SetupState ();
+}
+
+/*
+=============
+Fog_SetupState
+ 
+ericw -- moved from Fog_Init, state that needs to be setup when a new context is created
+=============
+*/
+void Fog_SetupState (void)
+{
+	glFogi(GL_FOG_MODE, GL_EXP2);
 }

source/gl_rmain.c

@@ -231,6 +231,8 @@ void R_DrawSpriteModel (entity_t *e)
 		right = vright;
 	}
 
+	Fog_DisableGFog ();
+
 	glColor3f (1,1,1);
 
 	GL_DisableMultitexture();
@@ -263,6 +265,8 @@ void R_DrawSpriteModel (entity_t *e)
 	glEnd ();
 
 	glDisable (GL_ALPHA_TEST);
+
+	Fog_EnableGFog ();
 }
 
 /*
@@ -968,6 +972,8 @@ void R_SetupFrame (void)
 	if (cl.maxclients > 1)
 		Cvar_Set ("r_fullbright", "0");
 
+	Fog_SetupFrame (); //johnfitz
+
 	R_AnimateLight ();
 
 	r_framecount++;

source/gl_rmisc.c

@@ -213,6 +213,7 @@ void R_Init (void)
 
 	R_InitParticles ();
 	R_InitParticleTexture ();
+	Fog_Init ();
 
 #ifdef GLTEST
 	Test_Init ();
@@ -397,6 +398,7 @@ void R_NewMap (void)
 	R_ClearParticles ();
 
 	GL_BuildLightmaps ();
+	Fog_NewMap (); // johnfitz -- global fog in worldspawn
 
 	// identify sky texture
 	skytexturenum = -1;

source/gl_rsurf.c

@@ -1372,6 +1372,8 @@ void R_DrawWorld (void)
 #ifdef QUAKE2
 	R_DrawSkyBox ();
 #endif
+
+	Fog_EnableGFog ();
 }
 
 

source/glquake.h

@@ -247,4 +247,17 @@ extern qboolean gl_mtexable;
 void GL_DisableMultitexture(void);
 void GL_EnableMultitexture(void);
 
+//johnfitz -- fog functions called from outside gl_fog.c
+void Fog_ParseServerMessage (void);
+float *Fog_GetColor (void);
+float Fog_GetDensity (void);
+void Fog_EnableGFog (void);
+void Fog_DisableGFog (void);
+void Fog_StartAdditive (void);
+void Fog_StopAdditive (void);
+void Fog_SetupFrame (void);
+void Fog_NewMap (void);
+void Fog_Init (void);
+void Fog_SetupState (void);
+
 qboolean VID_Is8bit(void);

source/mathlib.h

@@ -39,6 +39,8 @@ extern	int nanmask;
 
 #define	IS_NAN(x) (((*(int *)&x)&nanmask)==nanmask)
 
+#define Q_rint(x) ((x) > 0 ? (int)((x) + 0.5) : (int)((x) - 0.5)) //johnfitz -- from joequake
+
 #define DotProduct(x,y) (x[0]*y[0]+x[1]*y[1]+x[2]*y[2])
 #define VectorSubtract(a,b,c) {c[0]=a[0]-b[0];c[1]=a[1]-b[1];c[2]=a[2]-b[2];}
 #define VectorAdd(a,b,c) {c[0]=a[0]+b[0];c[1]=a[1]+b[1];c[2]=a[2]+b[2];}