/* -------------------------------------------------------------------------------

Copyright (C) 1999-2007 id Software, Inc. and contributors.
For a list of contributors, see the accompanying CONTRIBUTORS file.

This file is part of GtkRadiant.

GtkRadiant 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.

GtkRadiant 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 GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

----------------------------------------------------------------------------------

This code has been altered significantly from its original form, to support
several games based on the Quake III Arena engine, in the form of "Q3Map2."

------------------------------------------------------------------------------- */



/* marker */
#define FOG_C



/* dependencies */
#include "q3map2.h"



int             numFogFragments;
int             numFogPatchFragments;



/*
DrawSurfToMesh()
converts a patch drawsurface to a mesh_t
*/

mesh_t         *DrawSurfToMesh(mapDrawSurface_t * ds)
{
	mesh_t         *m;


	m = safe_malloc(sizeof(*m));
	m->width = ds->patchWidth;
	m->height = ds->patchHeight;
	m->verts = safe_malloc(sizeof(m->verts[0]) * m->width * m->height);
	memcpy(m->verts, ds->verts, sizeof(m->verts[0]) * m->width * m->height);

	return m;
}



/*
SplitMeshByPlane()
chops a mesh by a plane
*/

void SplitMeshByPlane(mesh_t * in, vec3_t normal, float dist, mesh_t ** front, mesh_t ** back)
{
	int             w, h, split = -1;
	float           d[MAX_PATCH_SIZE][MAX_PATCH_SIZE];
	bspDrawVert_t  *dv, *v1, *v2;
	int             c_front, c_back, c_on;
	mesh_t         *f, *b;
	int             i;
	float           frac;
	int             frontApprox, backApprox;

	for(i = 0; i < 2; i++)
	{
		dv = in->verts;
		c_front = 0;
		c_back = 0;
		c_on = 0;
		for(h = 0; h < in->height; h++)
		{
			for(w = 0; w < in->width; w++, dv++)
			{
				d[h][w] = DotProduct(dv->xyz, normal) - dist;
				if(d[h][w] > ON_EPSILON)
				{
					c_front++;
				}
				else if(d[h][w] < -ON_EPSILON)
				{
					c_back++;
				}
				else
				{
					c_on++;
				}
			}
		}

		*front = NULL;
		*back = NULL;

		if(!c_front)
		{
			*back = in;
			return;
		}
		if(!c_back)
		{
			*front = in;
			return;
		}

		// find a split point
		split = -1;
		for(w = 0; w < in->width - 1; w++)
		{
			if((d[0][w] < 0) != (d[0][w + 1] < 0))
			{
				if(split == -1)
				{
					split = w;
					break;
				}
			}
		}

		if(split == -1)
		{
			if(i == 1)
			{
				Sys_FPrintf(SYS_VRB, "No crossing points in patch\n");
				*front = in;
				return;
			}

			in = TransposeMesh(in);
			InvertMesh(in);
			continue;
		}

		// make sure the split point stays the same for all other rows
		for(h = 1; h < in->height; h++)
		{
			for(w = 0; w < in->width - 1; w++)
			{
				if((d[h][w] < 0) != (d[h][w + 1] < 0))
				{
					if(w != split)
					{
						Sys_Printf("multiple crossing points for patch -- can't clip\n");
						*front = in;
						return;
					}
				}
			}
			if((d[h][split] < 0) == (d[h][split + 1] < 0))
			{
				Sys_Printf("differing crossing points for patch -- can't clip\n");
				*front = in;
				return;
			}
		}

		break;
	}


	// create two new meshes
	f = safe_malloc(sizeof(*f));
	f->width = split + 2;
	if(!(f->width & 1))
	{
		f->width++;
		frontApprox = 1;
	}
	else
	{
		frontApprox = 0;
	}
	if(f->width > MAX_PATCH_SIZE)
	{
		Error("MAX_PATCH_SIZE after split");
	}
	f->height = in->height;
	f->verts = safe_malloc(sizeof(f->verts[0]) * f->width * f->height);

	b = safe_malloc(sizeof(*b));
	b->width = in->width - split;
	if(!(b->width & 1))
	{
		b->width++;
		backApprox = 1;
	}
	else
	{
		backApprox = 0;
	}
	if(b->width > MAX_PATCH_SIZE)
	{
		Error("MAX_PATCH_SIZE after split");
	}
	b->height = in->height;
	b->verts = safe_malloc(sizeof(b->verts[0]) * b->width * b->height);

	if(d[0][0] > 0)
	{
		*front = f;
		*back = b;
	}
	else
	{
		*front = b;
		*back = f;
	}

	// distribute the points
	for(w = 0; w < in->width; w++)
	{
		for(h = 0; h < in->height; h++)
		{
			if(w <= split)
			{
				f->verts[h * f->width + w] = in->verts[h * in->width + w];
			}
			else
			{
				b->verts[h * b->width + w - split + backApprox] = in->verts[h * in->width + w];
			}
		}
	}

	// clip the crossing line
	for(h = 0; h < in->height; h++)
	{
		dv = &f->verts[h * f->width + split + 1];
		v1 = &in->verts[h * in->width + split];
		v2 = &in->verts[h * in->width + split + 1];

		frac = d[h][split] / (d[h][split] - d[h][split + 1]);

		/* interpolate */
		//% for( i = 0; i < 10; i++ )
		//%     dv->xyz[ i ] = v1->xyz[ i ] + frac * (v2->xyz[ i ] - v1->xyz[ i ]);
		//% dv->xyz[10] = 0;    // set all 4 colors to 0
		LerpDrawVertAmount(v1, v2, frac, dv);

		if(frontApprox)
		{
			f->verts[h * f->width + split + 2] = *dv;
		}
		b->verts[h * b->width] = *dv;
		if(backApprox)
		{
			b->verts[h * b->width + 1] = *dv;
		}
	}

	/*
	   PrintMesh( in );
	   Sys_Printf("\n");
	   PrintMesh( f );
	   Sys_Printf("\n");
	   PrintMesh( b );
	   Sys_Printf("\n");
	 */

	FreeMesh(in);
}


/*
ChopPatchSurfaceByBrush()
chops a patch up by a fog brush
*/

qboolean ChopPatchSurfaceByBrush(entity_t * e, mapDrawSurface_t * ds, brush_t * b)
{
	int             i, j;
	side_t         *s;
	plane_t        *plane;
	mesh_t         *outside[MAX_BRUSH_SIDES];
	int             numOutside;
	mesh_t         *m, *front, *back;
	mapDrawSurface_t *newds;

	m = DrawSurfToMesh(ds);
	numOutside = 0;

	// only split by the top and bottom planes to avoid
	// some messy patch clipping issues

	for(i = 4; i <= 5; i++)
	{
		s = &b->sides[i];
		plane = &mapplanes[s->planenum];

		SplitMeshByPlane(m, plane->normal, plane->dist, &front, &back);

		if(!back)
		{
			// nothing actually contained inside
			for(j = 0; j < numOutside; j++)
			{
				FreeMesh(outside[j]);
			}
			return qfalse;
		}
		m = back;

		if(front)
		{
			if(numOutside == MAX_BRUSH_SIDES)
			{
				Error("MAX_BRUSH_SIDES");
			}
			outside[numOutside] = front;
			numOutside++;
		}
	}

	/* all of outside fragments become separate drawsurfs */
	numFogPatchFragments += numOutside;
	for(i = 0; i < numOutside; i++)
	{
		/* transpose and invert the chopped patch (fixes potential crash. fixme: why?) */
		outside[i] = TransposeMesh(outside[i]);
		InvertMesh(outside[i]);

		/* ydnar: do this the hacky right way */
		newds = AllocDrawSurface(SURFACE_PATCH);
		memcpy(newds, ds, sizeof(*ds));
		newds->patchWidth = outside[i]->width;
		newds->patchHeight = outside[i]->height;
		newds->numVerts = outside[i]->width * outside[i]->height;
		newds->verts = safe_malloc(newds->numVerts * sizeof(*newds->verts));
		memcpy(newds->verts, outside[i]->verts, newds->numVerts * sizeof(*newds->verts));

		/* free the source mesh */
		FreeMesh(outside[i]);
	}

	/* only rejigger this patch if it was chopped */
	//% Sys_Printf( "Inside: %d x %d\n", m->width, m->height );
	if(numOutside > 0)
	{
		/* transpose and invert the chopped patch (fixes potential crash. fixme: why?) */
		m = TransposeMesh(m);
		InvertMesh(m);

		/* replace ds with m */
		ds->patchWidth = m->width;
		ds->patchHeight = m->height;
		ds->numVerts = m->width * m->height;
		free(ds->verts);
		ds->verts = safe_malloc(ds->numVerts * sizeof(*ds->verts));
		memcpy(ds->verts, m->verts, ds->numVerts * sizeof(*ds->verts));
	}

	/* free the source mesh and return */
	FreeMesh(m);
	return qtrue;
}



/*
WindingFromDrawSurf()
creates a winding from a surface's verts
*/

winding_t      *WindingFromDrawSurf(mapDrawSurface_t * ds)
{
	winding_t      *w;
	int             i;

	// we use the first point of the surface, maybe something more clever would be useful
	// (actually send the whole draw surface would be cool?)
	if(ds->numVerts >= MAX_POINTS_ON_WINDING)
	{
		int             max = ds->numVerts;
		vec3_t          p[256];

		if(max > 256)
			max = 256;

		for(i = 0; i < max; i++)
		{
			VectorCopy(ds->verts[i].xyz, p[i]);
		}

#if defined(USE_XML)
		xml_Winding("WindingFromDrawSurf failed: MAX_POINTS_ON_WINDING exceeded", p, max, qtrue);
#endif
	}

	w = AllocWinding(ds->numVerts);
	w->numpoints = ds->numVerts;
	for(i = 0; i < ds->numVerts; i++)
	{
		VectorCopy(ds->verts[i].xyz, w->p[i]);
	}
	return w;
}



/*
ChopFaceSurfaceByBrush()
chops up a face drawsurface by a fog brush, with a potential fragment left inside
*/

qboolean ChopFaceSurfaceByBrush(entity_t * e, mapDrawSurface_t * ds, brush_t * b)
{
	int             i, j;
	side_t         *s;
	plane_t        *plane;
	winding_t      *w;
	winding_t      *front, *back;
	winding_t      *outside[MAX_BRUSH_SIDES];
	int             numOutside;
	mapDrawSurface_t *newds;


	/* dummy check */
	if(ds->sideRef == NULL || ds->sideRef->side == NULL)
		return qfalse;

	/* initial setup */
	w = WindingFromDrawSurf(ds);
	numOutside = 0;

	/* chop by each brush side */
	for(i = 0; i < b->numsides; i++)
	{
		/* get brush side and plane */
		s = &b->sides[i];
		plane = &mapplanes[s->planenum];

		/* handle coplanar outfacing (don't fog) */
		if(ds->sideRef->side->planenum == s->planenum)
			return qfalse;

		/* handle coplanar infacing (keep inside) */
		if((ds->sideRef->side->planenum ^ 1) == s->planenum)
			continue;

		/* general case */
		ClipWindingEpsilon(w, plane->normal, plane->dist, ON_EPSILON, &front, &back);
		FreeWinding(w);

		if(back == NULL)
		{
			/* nothing actually contained inside */
			for(j = 0; j < numOutside; j++)
				FreeWinding(outside[j]);
			return qfalse;
		}

		if(front != NULL)
		{
			if(numOutside == MAX_BRUSH_SIDES)
				Error("MAX_BRUSH_SIDES");
			outside[numOutside] = front;
			numOutside++;
		}

		w = back;
	}

	/* fixme: celshaded surface fragment errata */

	/* all of outside fragments become separate drawsurfs */
	numFogFragments += numOutside;
	s = ds->sideRef->side;
	for(i = 0; i < numOutside; i++)
	{
		newds = DrawSurfaceForSide(e, ds->mapBrush, s, outside[i]);
		newds->fogNum = ds->fogNum;
		FreeWinding(outside[i]);
	}

	/* ydnar: the old code neglected to snap to 0.125 for the fragment
	   inside the fog brush, leading to sparklies. this new code does
	   the right thing and uses the original surface's brush side */

	/* build a drawsurf for it */
	newds = DrawSurfaceForSide(e, ds->mapBrush, s, w);
	if(newds == NULL)
		return qfalse;

	/* copy new to original */
	ClearSurface(ds);
	memcpy(ds, newds, sizeof(mapDrawSurface_t));

	/* didn't really add a new drawsurface... :) */
	numMapDrawSurfs--;

	/* return ok */
	return qtrue;
}



/*
FogDrawSurfaces()
call after the surface list has been pruned, before tjunction fixing
*/

void FogDrawSurfaces(entity_t * e)
{
	int             i, j, k, fogNum;
	fog_t          *fog;
	mapDrawSurface_t *ds;
	vec3_t          mins, maxs;
	int             fogged, numFogged;
	int             numBaseDrawSurfs;


	/* note it */
	Sys_FPrintf(SYS_VRB, "----- FogDrawSurfs -----\n");

	/* reset counters */
	numFogged = 0;
	numFogFragments = 0;

	/* walk fog list */
	for(fogNum = 0; fogNum < numMapFogs; fogNum++)
	{
		/* get fog */
		fog = &mapFogs[fogNum];

		/* clip each surface into this, but don't clip any of the resulting fragments to the same brush */
		numBaseDrawSurfs = numMapDrawSurfs;
		for(i = 0; i < numBaseDrawSurfs; i++)
		{
			/* get the drawsurface */
			ds = &mapDrawSurfs[i];

			/* no fog? */
			if(ds->shaderInfo->noFog)
				continue;

			/* global fog doesn't have a brush */
			if(fog->brush == NULL)
			{
				/* don't re-fog already fogged surfaces */
				if(ds->fogNum >= 0)
					continue;
				fogged = 1;
			}
			else
			{
				/* find drawsurface bounds */
				ClearBounds(mins, maxs);
				for(j = 0; j < ds->numVerts; j++)
					AddPointToBounds(ds->verts[j].xyz, mins, maxs);

				/* check against the fog brush */
				for(k = 0; k < 3; k++)
				{
					if(mins[k] > fog->brush->maxs[k])
						break;
					if(maxs[k] < fog->brush->mins[k])
						break;
				}

				/* no intersection? */
				if(k < 3)
					continue;

				/* ydnar: gs mods: handle the various types of surfaces */
				switch (ds->type)
				{
						/* handle brush faces */
					case SURFACE_FACE:
						fogged = ChopFaceSurfaceByBrush(e, ds, fog->brush);
						break;

						/* handle patches */
					case SURFACE_PATCH:
						fogged = ChopPatchSurfaceByBrush(e, ds, fog->brush);
						break;

						/* handle triangle surfaces (fixme: split triangle surfaces) */
					case SURFACE_TRIANGLES:
					case SURFACE_FORCED_META:
					case SURFACE_META:
						fogged = 1;
						break;

						/* no fogging */
					default:
						fogged = 0;
						break;
				}
			}

			/* is this surface fogged? */
			if(fogged)
			{
				numFogged += fogged;
				ds->fogNum = fogNum;
			}
		}
	}

	/* emit some statistics */
	Sys_FPrintf(SYS_VRB, "%9d fog polygon fragments\n", numFogFragments);
	Sys_FPrintf(SYS_VRB, "%9d fog patch fragments\n", numFogPatchFragments);
	Sys_FPrintf(SYS_VRB, "%9d fogged drawsurfs\n", numFogged);
}



/*
FogForPoint() - ydnar
gets the fog number for a point in space
*/

int FogForPoint(vec3_t point, float epsilon)
{
	int             fogNum, i, j;
	float           dot;
	qboolean        inside;
	brush_t        *brush;
	plane_t        *plane;


	/* start with bogus fog num */
	fogNum = defaultFogNum;

	/* walk the list of fog volumes */
	for(i = 0; i < numMapFogs; i++)
	{
		/* sof2: global fog doesn't reference a brush */
		if(mapFogs[i].brush == NULL)
		{
			fogNum = i;
			continue;
		}

		/* get fog brush */
		brush = mapFogs[i].brush;

		/* check point against all planes */
		inside = qtrue;
		for(j = 0; j < brush->numsides && inside; j++)
		{
			plane = &mapplanes[brush->sides[j].planenum];	/* note usage of map planes here */
			dot = DotProduct(point, plane->normal);
			dot -= plane->dist;
			if(dot > epsilon)
				inside = qfalse;
		}

		/* if inside, return the fog num */
		if(inside)
		{
			//% Sys_Printf( "FogForPoint: %f, %f, %f in fog %d\n", point[ 0 ], point[ 1 ], point[ 2 ], i );
			return i;
		}
	}

	/* if the point made it this far, it's not inside any fog volumes (or inside global fog) */
	return fogNum;
}



/*
FogForBounds() - ydnar
gets the fog number for a bounding box
*/

int FogForBounds(vec3_t mins, vec3_t maxs, float epsilon)
{
	int             fogNum, i, j;
	float           highMin, lowMax, volume, bestVolume;
	vec3_t          fogMins, fogMaxs, overlap;
	brush_t        *brush;


	/* start with bogus fog num */
	fogNum = defaultFogNum;

	/* init */
	bestVolume = 0.0f;

	/* walk the list of fog volumes */
	for(i = 0; i < numMapFogs; i++)
	{
		/* sof2: global fog doesn't reference a brush */
		if(mapFogs[i].brush == NULL)
		{
			fogNum = i;
			continue;
		}

		/* get fog brush */
		brush = mapFogs[i].brush;

		/* get bounds */
		fogMins[0] = brush->mins[0] - epsilon;
		fogMins[1] = brush->mins[1] - epsilon;
		fogMins[2] = brush->mins[2] - epsilon;
		fogMaxs[0] = brush->maxs[0] + epsilon;
		fogMaxs[1] = brush->maxs[1] + epsilon;
		fogMaxs[2] = brush->maxs[2] + epsilon;

		/* check against bounds */
		for(j = 0; j < 3; j++)
		{
			if(mins[j] > fogMaxs[j] || maxs[j] < fogMins[j])
				break;
			highMin = mins[j] > fogMins[j] ? mins[j] : fogMins[j];
			lowMax = maxs[j] < fogMaxs[j] ? maxs[j] : fogMaxs[j];
			overlap[j] = lowMax - highMin;
			if(overlap[j] < 1.0f)
				overlap[j] = 1.0f;
		}

		/* no overlap */
		if(j < 3)
			continue;

		/* get volume */
		volume = overlap[0] * overlap[1] * overlap[2];

		/* test against best volume */
		if(volume > bestVolume)
		{
			bestVolume = volume;
			fogNum = i;
		}
	}

	/* if the point made it this far, it's not inside any fog volumes (or inside global fog) */
	return fogNum;
}



/*
CreateMapFogs() - ydnar
generates a list of map fogs
*/

void CreateMapFogs(void)
{
	int             i;
	entity_t       *entity;
	brush_t        *brush;
	fog_t          *fog;
	vec3_t          invFogDir;
	const char     *globalFog;


	/* skip? */
	if(nofog)
		return;

	/* note it */
	Sys_FPrintf(SYS_VRB, "--- CreateMapFogs ---\n");

	/* walk entities */
	for(i = 0; i < numEntities; i++)
	{
		/* get entity */
		entity = &entities[i];

		/* walk entity brushes */
		for(brush = entity->brushes; brush != NULL; brush = brush->next)
		{
			/* ignore non-fog brushes */
			if(brush->contentShader->fogParms == qfalse)
				continue;

			/* test limit */
			if(numMapFogs >= MAX_MAP_FOGS)
				Error("Exceeded MAX_MAP_FOGS (%d)", MAX_MAP_FOGS);

			/* set up fog */
			fog = &mapFogs[numMapFogs++];
			fog->si = brush->contentShader;
			fog->brush = brush;
			fog->visibleSide = -1;

			/* if shader specifies an explicit direction, then find a matching brush side with an opposed normal */
			if(VectorLength(fog->si->fogDir))
			{
				/* flip it */
				VectorScale(fog->si->fogDir, -1.0f, invFogDir);

				/* find the brush side */
				for(i = 0; i < brush->numsides; i++)
				{
					if(VectorCompare(invFogDir, mapplanes[brush->sides[i].planenum].normal))
					{
						fog->visibleSide = i;
						//% Sys_Printf( "Brush num: %d Side num: %d\n", fog->brushNum, fog->visibleSide );
						break;
					}
				}
			}
		}
	}

	/* ydnar: global fog */
	globalFog = ValueForKey(&entities[0], "_fog");
	if(globalFog[0] == '\0')
		globalFog = ValueForKey(&entities[0], "fog");
	if(globalFog[0] != '\0')
	{
		/* test limit */
		if(numMapFogs >= MAX_MAP_FOGS)
			Error("Exceeded MAX_MAP_FOGS (%d) trying to add global fog", MAX_MAP_FOGS);

		/* note it */
		Sys_FPrintf(SYS_VRB, "Map has global fog shader %s\n", globalFog);

		/* set up fog */
		fog = &mapFogs[numMapFogs++];
		fog->si = ShaderInfoForShader(globalFog);
		if(fog->si == NULL)
			Error("Invalid shader \"%s\" referenced trying to add global fog", globalFog);
		fog->brush = NULL;
		fog->visibleSide = -1;

		/* set as default fog */
		defaultFogNum = numMapFogs - 1;

		/* mark all worldspawn brushes as fogged */
		for(brush = entities[0].brushes; brush != NULL; brush = brush->next)
			ApplySurfaceParm("fog", &brush->contentFlags, NULL, &brush->compileFlags);
	}

	/* emit some stats */
	Sys_FPrintf(SYS_VRB, "%9d fogs\n", numMapFogs);
}
