/*
Copyright (C) 1997-2001 Id Software, Inc.
Copyright (C) 2002-2007 Victor Luchits

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.

*/

// r_surf.c: surface-related refresh code

#include "r_local.h"
#include "mathlib.h"
#include "matrix_lib.h"

static vec3_t	modelorg;       // relative to viewpoint
static vec3_t	modelmins;
static vec3_t	modelmaxs;

/*
=============================================================

BRUSH MODELS

=============================================================
*/

/*
=================
R_SurfPotentiallyVisible
=================
*/
bool R_SurfPotentiallyVisible( msurface_t *surf )
{
	if( surf->facetype == MST_FLARE )
		return true;
	if( surf->flags & SURF_NODRAW )
		return false;
	if( !surf->mesh || R_InvalidMesh( surf->mesh ) )
		return false;
	return true;
}

/*
=================
R_CullSurface
=================
*/
bool R_CullSurface( msurface_t *surf, uint clipflags )
{
	ref_shader_t *shader = surf->shader;

	if(( shader->flags & SHADER_SKY ) && r_fastsky->integer )
		return true;
	if( r_nocull->integer )
		return false;
	if( shader->flags & SHADER_AUTOSPRITE )
		return false;
	// never cull turblent or warp surfaces
	if( shader->tessSize ) return false;
		
	// flare
	if( surf->facetype == MST_FLARE )
	{
		if( r_flares->integer && r_flarefade->value )
		{
			vec3_t origin;

			if( RI.currentmodel != r_worldmodel )
			{
				Matrix3x3_Transform( RI.currententity->axis, surf->origin, origin );
				VectorAdd( origin, RI.currententity->origin, origin );
			}
			else
			{
				VectorCopy( surf->origin, origin );
			}

			// cull it because we don't want to sort unneeded things
			if( ( origin[0] - RI.viewOrigin[0] ) * RI.vpn[0] +
				( origin[1] - RI.viewOrigin[1] ) * RI.vpn[1] +
				( origin[2] - RI.viewOrigin[2] ) * RI.vpn[2] < 0 )
				return true;

			return ( clipflags && R_CullSphere( origin, 1, clipflags ) );
		}
		return true;
	}

	if( surf->facetype == MST_PLANAR && r_faceplanecull->integer &&
		!RI.currententity->outlineHeight && ( shader->flags & (SHADER_CULL_FRONT|SHADER_CULL_BACK)))
	{
		// Vic: I hate q3map2. I really do.
		if( !VectorCompare( surf->plane->normal, vec3_origin ))
		{
			float dist;

			dist = PlaneDiff( modelorg, surf->plane );
			if( ( shader->flags & SHADER_CULL_FRONT ) || ( RI.params & RP_MIRRORVIEW ))
			{
				if( dist <= BACKFACE_EPSILON )
					return true;
			}
			else
			{
				if( dist >= -BACKFACE_EPSILON )
					return true;
			}
		}
	}
	return ( clipflags && R_CullBox( surf->mins, surf->maxs, clipflags ));
}

/*
=================
R_AddSurfaceToList
=================
*/
static meshbuffer_t *R_AddSurfaceToList( msurface_t *surf, unsigned int clipflags )
{
	ref_shader_t *shader;
	meshbuffer_t *mb;

	if( R_CullSurface( surf, clipflags ) )
		return NULL;

	shader = ((r_drawworld->integer == 2) ? R_OcclusionShader() : surf->shader);
	if( shader->flags & SHADER_SKYPARMS )
	{
		bool vis = R_AddSkySurface( surf );
		if(( RI.params & RP_NOSKY ) && vis )
		{
			R_AddMeshToList( MB_MODEL, surf->fog, shader, surf - r_worldbrushmodel->surfaces + 1 );
			RI.params &= ~RP_NOSKY;
		}
		return NULL;
	}

	if( OCCLUSION_QUERIES_ENABLED( RI ) )
	{
		if( shader->flags & SHADER_PORTAL )
			R_SurfOcclusionQueryKey( RI.currententity, surf );
		if( OCCLUSION_OPAQUE_SHADER( shader ) )
			R_AddOccludingSurface( surf, shader );
	}

	c_brush_polys++;
	mb = R_AddMeshToList( surf->facetype == MST_FLARE ? MB_SPRITE : MB_MODEL,
		surf->fog, shader, surf - r_worldbrushmodel->surfaces + 1 );
	RI.surfmbuffers[surf - r_worldbrushmodel->surfaces] = mb;
	return mb;
}

/*
=================
R_CullBrushModel
=================
*/
bool R_CullBrushModel( ref_entity_t *e )
{
	int i;
	bool rotated;
	ref_model_t	*model = e->model;
	mbrushmodel_t *bmodel = ( mbrushmodel_t * )model->extradata;

	if( bmodel->nummodelsurfaces == 0 )
		return true;

	if( !Matrix3x3_Compare( e->axis, matrix3x3_identity ))
	{
		rotated = true;
		for( i = 0; i < 3; i++ )
		{
			modelmins[i] = e->origin[i] - model->radius * e->scale;
			modelmaxs[i] = e->origin[i] + model->radius * e->scale;
		}
		if( R_CullSphere( e->origin, model->radius * e->scale, RI.clipFlags ) )
			return true;
	}
	else
	{
		rotated = false;
		VectorMA( e->origin, e->scale, model->mins, modelmins );
		VectorMA( e->origin, e->scale, model->maxs, modelmaxs );
		if( R_CullBox( modelmins, modelmaxs, RI.clipFlags ) )
			return true;
	}

	if( RI.refdef.flags & ( RDF_PORTALINVIEW|RDF_SKYPORTALINVIEW ) || ( RI.params & RP_SKYPORTALVIEW ))
	{
		if( rotated )
		{
			if( R_VisCullSphere( e->origin, model->radius * e->scale ) )
				return true;
		}
		else
		{
			if( R_VisCullBox( modelmins, modelmaxs ) )
				return true;
		}
	}

	return false;
}

/*
=================
R_AddBrushModelToList
=================
*/
void R_AddBrushModelToList( ref_entity_t *e )
{
	uint		i;
	bool		rotated;
	ref_model_t	*model = e->model;
	mbrushmodel_t	*bmodel = ( mbrushmodel_t * )model->extradata;
	msurface_t	*psurf;
	uint		dlightbits;
	meshbuffer_t	*mb;

	e->outlineHeight = r_worldent->outlineHeight;
	Vector4Copy( r_worldent->outlineColor, e->outlineColor );

	rotated = !Matrix3x3_Compare( e->axis, matrix3x3_identity );
	VectorSubtract( RI.refdef.vieworg, e->origin, modelorg );
	if( rotated )
	{
		vec3_t temp;

		VectorCopy( modelorg, temp );
		Matrix3x3_Transform( e->axis, temp, modelorg );
	}

	dlightbits = 0;
	if(( r_dynamiclight->integer == 1 ) && !r_fullbright->integer && !( RI.params & RP_SHADOWMAPVIEW ))
	{
		for( i = 0; i < r_numDlights; i++ )
		{
			if( BoundsIntersect( modelmins, modelmaxs, r_dlights[i].mins, r_dlights[i].maxs ))
				dlightbits |= ( 1<<i );
		}
	}

	for( i = 0, psurf = bmodel->firstmodelsurface; i < (unsigned)bmodel->nummodelsurfaces; i++, psurf++ )
	{
		if( !R_SurfPotentiallyVisible( psurf ) )
			continue;

		if( RI.params & RP_SHADOWMAPVIEW )
		{
			if( psurf->visframe != r_framecount )
				continue;
			if( ( psurf->shader->sort >= SORT_OPAQUE ) && ( psurf->shader->sort <= SORT_BANNER ) )
			{
				if( prevRI.surfmbuffers[psurf - r_worldbrushmodel->surfaces] )
				{
					if( !R_CullSurface( psurf, 0 ) )
					{
						RI.params |= RP_WORLDSURFVISIBLE;
						prevRI.surfmbuffers[psurf - r_worldbrushmodel->surfaces]->shadowbits |= RI.shadowGroup->bit;
					}
				}
			}
			continue;
		}

		psurf->visframe = r_framecount;
		mb = R_AddSurfaceToList( psurf, 0 );
		if( mb )
		{
			mb->sortkey |= ( ( psurf->superLightStyle+1 ) << 10 );
			if( R_SurfPotentiallyLit( psurf ) )
				mb->dlightbits = dlightbits;
		}
	}
}

/*
=============================================================

WORLD MODEL

=============================================================
*/

/*
================
R_MarkLeafSurfaces
================
*/
static void R_MarkLeafSurfaces( msurface_t **mark, uint clipflags, uint dlightbits )
{
	unsigned int newDlightbits;
	msurface_t *surf;
	meshbuffer_t *mb;

	do
	{
		surf = *mark++;

		// note that R_AddSurfaceToList may set meshBuffer to NULL
		// for world ALL surfaces to prevent referencing to freed memory region
		if( surf->visframe != r_framecount )
		{
			surf->visframe = r_framecount;
			mb = R_AddSurfaceToList( surf, clipflags );
			if( mb )
				mb->sortkey |= ( ( surf->superLightStyle+1 ) << 10 );
		}
		else
		{
			mb = RI.surfmbuffers[surf - r_worldbrushmodel->surfaces];
		}

		newDlightbits = mb ? dlightbits & ~mb->dlightbits : 0;
		if( newDlightbits && R_SurfPotentiallyLit( surf ) )
			mb->dlightbits |= R_AddSurfDlighbits( surf, newDlightbits );
	} while( *mark );
}

/*
================
R_RecursiveWorldNode
================
*/
static void R_RecursiveWorldNode( mnode_t *node, uint clipflags, uint dlightbits )
{
	uint		i, newDlightbits;
	const cplane_t	*clipplane;
	int		clipped;
	mleaf_t		*pleaf;

	while( 1 )
	{
		if( node->pvsframe != r_pvsframecount )
			return;

		if( clipflags )
		{
			for( i = 0, clipplane = RI.frustum; i < 6; i++, clipplane++ )
			{
				if(!(clipflags & (1<<i)))
					continue;

				clipped = BoxOnPlaneSide( node->mins, node->maxs, clipplane );
				if( clipped == 2 ) return;
				if( clipped == 1 ) clipflags &= ~(1<<i);
			}
	}

		if( !node->plane )
			break;

		newDlightbits = 0;
		if( dlightbits )
		{
			float dist;

			for( i = 0; i < r_numDlights; i++ )
			{
				if( !( dlightbits & (1<<i)))
					continue;

				dist = PlaneDiff( r_dlights[i].origin, node->plane );
				if( dist < -r_dlights[i].intensity )
					dlightbits &= ~(1<<i);
				if( dist < r_dlights[i].intensity )
					newDlightbits |= (1<<i);
			}
		}

		R_RecursiveWorldNode( node->children[0], clipflags, dlightbits );

		node = node->children[1];
		dlightbits = newDlightbits;
	}

	// if a leaf node, draw stuff
	pleaf = ( mleaf_t * )node;
	pleaf->visframe = r_framecount;

	// add leaf bounds to view bounds
	for( i = 0; i < 3; i++ )
	{
		RI.visMins[i] = min( RI.visMins[i], pleaf->mins[i] );
		RI.visMaxs[i] = max( RI.visMaxs[i], pleaf->maxs[i] );
	}

	R_MarkLeafSurfaces( pleaf->firstVisSurface, clipflags, dlightbits );
	c_world_leafs++;
}

/*
================
R_MarkShadowLeafSurfaces
================
*/
static void R_MarkShadowLeafSurfaces( msurface_t **mark, unsigned int clipflags )
{
	msurface_t *surf;
	meshbuffer_t *mb;
	const unsigned int bit = RI.shadowGroup->bit;

	do
	{
		surf = *mark++;
		if( surf->flags & ( SURF_NOIMPACT|SURF_NODRAW ) )
			continue;

		mb = prevRI.surfmbuffers[surf - r_worldbrushmodel->surfaces];
		if( !mb || (mb->shadowbits & bit) )
			continue;

		// this surface is visible in previous RI, not marked as shadowed...
		if( ( surf->shader->sort >= SORT_OPAQUE ) && ( surf->shader->sort <= SORT_ALPHATEST ) )
		{	// ...is opaque
			if( !R_CullSurface( surf, clipflags ) )
			{	// and is visible to the light source too
				RI.params |= RP_WORLDSURFVISIBLE;
				mb->shadowbits |= bit;
			}
		}
	} while( *mark );
}

/*
================
R_LinearShadowLeafs
================
*/
static void R_LinearShadowLeafs( void )
{
	uint		i, j;
	uint		cpf;
	const cplane_t	*clipplane;
	mleaf_t		*pleaf;

	for( j = r_worldbrushmodel->numleafs, pleaf = r_worldbrushmodel->leafs; j > 0; j--, pleaf++ )
	{
		if( pleaf->visframe != r_framecount )
			continue;
		if( !( RI.shadowGroup->vis[pleaf->cluster>>3] & ( 1<<( pleaf->cluster&7 ) ) ) )
			continue;

		cpf = RI.clipFlags;

		for( i = 0, clipplane = RI.frustum; i < 6; i++, clipplane++ )
		{
			int clipped = BoxOnPlaneSide( pleaf->mins, pleaf->maxs, clipplane );
			if( clipped == 2 ) break;
			if( clipped == 1 ) cpf &= ~(1<<i);
		}
		if( !i )
		{
			R_MarkShadowLeafSurfaces( pleaf->firstVisSurface, cpf );
			c_world_leafs++;
		}
	}
}

//==================================================================================

int r_surfQueryKeys[MAX_SURF_QUERIES];

/*
===============
R_ClearSurfOcclusionQueryKeys
===============
*/
void R_ClearSurfOcclusionQueryKeys( void )
{
	memset( r_surfQueryKeys, -1, sizeof( r_surfQueryKeys ) );
}

/*
===============
R_SurfOcclusionQueryKey
===============
*/
int R_SurfOcclusionQueryKey( ref_entity_t *e, msurface_t *surf )
{
	int i;
	int *keys = r_surfQueryKeys;
	int key = surf - r_worldbrushmodel->surfaces;

	if( e != r_worldent )
		return -1;

	for( i = 0; i < MAX_SURF_QUERIES; i++ )
	{
		if( keys[i] >= 0 )
		{
			if( keys[i] == key )
				return i;
		}
		else
		{
			keys[i] = key;
			return i;
		}
	}

	return -1;
}

/*
===============
R_SurfIssueOcclusionQueries
===============
*/
void R_SurfIssueOcclusionQueries( void )
{
	int i, *keys = r_surfQueryKeys;
	msurface_t *surf;

	for( i = 0; keys[i] >= 0; i++ )
	{
		surf = &r_worldbrushmodel->surfaces[keys[i]];
		R_IssueOcclusionQuery( R_GetOcclusionQueryNum( OQ_CUSTOM, i ), r_worldent, surf->mins, surf->maxs );
	}
}

//==================================================================================

/*
=============
R_CalcDistancesToFogVolumes
=============
*/
static void R_CalcDistancesToFogVolumes( void )
{
	int i;
	mfog_t *fog;

	for( i = 0, fog = r_worldbrushmodel->fogs; i < r_worldbrushmodel->numfogs; i++, fog++ )
		RI.fog_dist_to_eye[fog - r_worldbrushmodel->fogs] = PlaneDiff( RI.viewOrigin, fog->visibleplane );
}

/*
=============
R_DrawWorld
=============
*/
void R_DrawWorld( void )
{
	int clipflags, msec = 0;
	unsigned int dlightbits;

	if( !r_drawworld->integer )
		return;
	if( !r_worldmodel )
		return;
	if( RI.refdef.flags & RDF_NOWORLDMODEL )
		return;

	VectorCopy( RI.refdef.vieworg, modelorg );

	RI.previousentity = NULL;
	RI.currententity = r_worldent;
	RI.currentmodel = RI.currententity->model;

	if( r_outlines_world->integer && r_viewcluster != -1 )
		RI.currententity->outlineHeight = max( 0.0f, r_outlines_world->value );
	else RI.currententity->outlineHeight = 0.0f;
	Vector4Copy( mapConfig.outlineColor, RI.currententity->outlineColor );

	if( !( RI.params & RP_SHADOWMAPVIEW ) )
	{
		R_AllocMeshbufPointers( &RI );
		Mem_Set( RI.surfmbuffers, 0, r_worldbrushmodel->numsurfaces * sizeof( meshbuffer_t * ));

		R_CalcDistancesToFogVolumes();
	}

	ClearBounds( RI.visMins, RI.visMaxs );

	R_ClearSkyBox();

	if( r_nocull->integer )
		clipflags = 0;
	else clipflags = RI.clipFlags;

	if( r_dynamiclight->integer != 1 || r_fullbright->integer )
		dlightbits = 0;
	else
		dlightbits = r_numDlights < 32 ? ( 1 << r_numDlights ) - 1 : -1;

	if( r_speeds->integer )
		msec = Sys_Milliseconds();
	if( RI.params & RP_SHADOWMAPVIEW )
		R_LinearShadowLeafs ();
	else
		R_RecursiveWorldNode( r_worldbrushmodel->nodes, clipflags, dlightbits );
	if( r_speeds->integer )
		r_world_node += Sys_Milliseconds() - msec;
}

/*
===============
R_MarkLeaves

Mark the leaves and nodes that are in the PVS for the current cluster
===============
*/
void R_MarkLeaves( void )
{
	byte *vis;
	int i;
	mleaf_t	*leaf, **pleaf;
	mnode_t *node;
	int cluster;

	if( RI.refdef.flags & RDF_NOWORLDMODEL )
		return;
	if( r_oldviewcluster == r_viewcluster && ( RI.refdef.flags & RDF_OLDAREABITS ) && !r_novis->integer && r_viewcluster != -1 )
		return;
	if( RI.params & RP_SHADOWMAPVIEW )
		return;

	// development aid to let you run around and see exactly where
	// the pvs ends
	if( r_lockpvs->integer )
		return;

	r_pvsframecount++;
	r_oldviewcluster = r_viewcluster;

	if( r_novis->integer || r_viewcluster == -1 || !r_worldbrushmodel->vis )
	{
		// mark everything
		for( pleaf = r_worldbrushmodel->visleafs, leaf = *pleaf; leaf; leaf = *pleaf++ )
			leaf->pvsframe = r_pvsframecount;
		for( i = 0, node = r_worldbrushmodel->nodes; i < r_worldbrushmodel->numnodes; i++, node++ )
			node->pvsframe = r_pvsframecount;
		return;
	}

	vis = Mod_ClusterPVS( r_viewcluster, r_worldmodel );
	for( pleaf = r_worldbrushmodel->visleafs, leaf = *pleaf; leaf; leaf = *pleaf++ )
	{
		cluster = leaf->cluster;

		// check for door connected areas
		if( RI.refdef.areabits )
		{
			if( !( RI.refdef.areabits[leaf->area>>3] & ( 1<<( leaf->area&7 ) ) ) )
				continue; // not visible
		}

		if( vis[cluster>>3] & ( 1<<( cluster&7 ) ) )
		{
			node = (mnode_t *)leaf;
			do
			{
				if( node->pvsframe == r_pvsframecount )
					break;
				node->pvsframe = r_pvsframecount;
				node = node->parent;
			}
			while( node );
		}
	}
}