/***
*
*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
*	
*	This product contains software technology licensed from Id 
*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
*	All Rights Reserved.
*
*   Use, distribution, and modification of this source code and/or resulting
*   object code is restricted to non-commercial enhancements to products from
*   Valve LLC.  All other use, distribution, or modification is prohibited
*   without written permission from Valve LLC.
*
****/
//
// util.cpp
//
// implementation of class-less helper functions
//

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdarg.h>

#include "hud.h"
#include "cl_util.h"
#include <stringlib.h>
#include "com_model.h"
#include "triangleapi.h"
#include <mathlib.h>
#include "gl_local.h"
#include "event_api.h"
#include "r_efx.h"
#include "pmtrace.h"
#include "gl_studio.h"
#include "gl_world.h"

static byte	decompressed[MAX_MAP_LEAFS/8];
	
/*
=============
pfnAlertMessage

=============
*/
void ALERT( ALERT_TYPE level, const char *szFmt, ... )
{
	char	buffer[2048];	// must support > 1k messages
	va_list	args;

	if( developer_level <= DEV_NONE )
		return;

	if( level == at_aiconsole && developer_level < DEV_EXTENDED )
		return;

	va_start( args, szFmt );
	Q_vsnprintf( buffer, 2048, szFmt, args );
	va_end( args );

	if( level == at_warning )
	{
		gEngfuncs.Con_Printf( va( "^3Warning:^7 %s", buffer ));
	}
	else if( level == at_error  )
	{
		gEngfuncs.Con_Printf( va( "^1Error:^7 %s", buffer ));
	} 
	else
	{
		gEngfuncs.Con_Printf( buffer );
	}
}

/*
====================
Sys LoadGameDLL

====================
*/
bool Sys_LoadLibrary( const char* dllname, dllhandle_t* handle, const dllfunc_t *fcts )
{
	if( !handle ) return false;

	const dllfunc_t *gamefunc;

	// Initializations
	for( gamefunc = fcts; gamefunc && gamefunc->name != NULL; gamefunc++ )
		*gamefunc->func = NULL;

	char dllpath[128];

	// is direct path used ?
	if( dllname[0] == '*' ) Q_strncpy( dllpath, dllname + 1, sizeof( dllpath ));
	else Q_snprintf( dllpath, sizeof( dllpath ), "%s/cl_dlls/%s", gEngfuncs.pfnGetGameDirectory(), dllname );

	dllhandle_t dllhandle = LoadLibrary( dllpath );
        
	// No DLL found
	if( !dllhandle ) return false;

	// Get the function adresses
	for( gamefunc = fcts; gamefunc && gamefunc->name != NULL; gamefunc++ )
	{
		if( !( *gamefunc->func = (void *)Sys_GetProcAddress( dllhandle, gamefunc->name )))
		{
			Sys_FreeLibrary( &dllhandle );
			return false;
		}
	}          

	ALERT( at_aiconsole, "%s loaded succesfully!\n", (dllname[0] == '*') ? (dllname+1) : (dllname));
	*handle = dllhandle;

	return true;
}

void *Sys_GetProcAddress( dllhandle_t handle, const char *name )
{
	return (void *)GetProcAddress( handle, name );
}

void Sys_FreeLibrary( dllhandle_t *handle )
{
	if( !handle || !*handle )
		return;

	FreeLibrary( *handle );
	*handle = NULL;
}

bool Sys_RemoveFile( const char *path )
{
	char	real_path[1024];
	int	iRet = false;

	if( !path || !*path )
		return false;

	Q_snprintf( real_path, sizeof( real_path ), "%s/%s", gEngfuncs.pfnGetGameDirectory(), path );
	COM_FixSlashes( real_path );
	iRet = remove( real_path );

	return (iRet == 0) ? true : false;
}

/*
=============
WorldToScreen

convert world coordinates (x,y,z) into screen (x, y)
=============
*/
int WorldToScreen( const Vector &world, Vector &screen )
{
	int retval = R_WorldToScreen( world, screen );

	screen[0] =  0.5f * screen[0] * (float)RI->view.port[2];
	screen[1] = -0.5f * screen[1] * (float)RI->view.port[3];
	screen[0] += 0.5f * (float)RI->view.port[2];
	screen[1] += 0.5f * (float)RI->view.port[3];

	return retval;
}

//=================
//   UTIL_IsPlayer
//=================
bool UTIL_IsPlayer( int idx )
{
	if ( idx >= 1 && idx <= gEngfuncs.GetMaxClients() )
		return true;
	return false;
}


//=================
//     UTIL_IsLocal
//=================
bool UTIL_IsLocal( int idx )
{
	return gEngfuncs.pEventAPI->EV_IsLocal( idx - 1 ) ? true : false;
}

//=================
//     UTIL_WeaponAnimation
//=================
void UTIL_WeaponAnimation( int iAnim, float framerate )
{
	cl_entity_t *view = GET_VIEWMODEL();

	gEngfuncs.pEventAPI->EV_WeaponAnimation( iAnim, view->curstate.body );

	view->curstate.framerate = framerate;
	view->curstate.scale = 1.0f;
#if 0
	// just for test Glow Shell effect
	view->curstate.renderfx = kRenderFxGlowShell;
	view->curstate.rendercolor.r = 255;
	view->curstate.rendercolor.g = 255;
	view->curstate.rendercolor.b = 255;
	view->curstate.renderamt = 100;
#endif	
}

void UTIL_StudioDecal( const char *pDecalName, pmtrace_t *pTrace, const Vector &vecSrc )
{
	g_StudioRenderer.StudioDecalShoot( pTrace, pDecalName, false );
}

/*
====================
SPRITE_GetList

====================
*/
char *ParseHudSprite( char *pfile, char *psz, client_sprite_t *result )
{
	client_sprite_t tempSprite;
	int x = 0, y = 0, width = 0, height = 0;
	int section = 0;
	char token[256];
	
	memset( &tempSprite, 0, sizeof( tempSprite ));
	memset( result, 0, sizeof( *result ));
          
	while( pfile )
	{
		pfile = COM_ParseFile( pfile, token );	

		if( !Q_stricmp( token, psz ))
		{
			pfile = COM_ParseFile( pfile, token );	
			if( !Q_stricmp( token, "{" )) section = 1;
		}

		if( section )
		{
			if( !Q_stricmp( token, "}" ))
				break; // end section
			
			if( !Q_stricmp( token, "file" )) 
			{                                          
				pfile = COM_ParseFile( pfile, token );
				Q_strcpy( tempSprite.szSprite, token );
				void *testSprite;

				if(( testSprite = gEngfuncs.COM_LoadFile( tempSprite.szSprite, 5, NULL )) != NULL )
				{
					gEngfuncs.COM_FreeFile( testSprite );

					// fill structure at default
					HSPRITE m_hSprite = SPR_Load( tempSprite.szSprite );

					width = SPR_Width( m_hSprite, 0 );
					height = SPR_Height( m_hSprite, 0 );
					x = y = 0;
				}
				else
				{
					return pfile;
				}
			}
			else if( !Q_stricmp( token, "name" )) 
			{                                          
				pfile = COM_ParseFile( pfile, token );
				Q_strcpy( tempSprite.szName, token );
			}
			else if( !Q_stricmp( token, "x" )) 
			{                                          
				pfile = COM_ParseFile( pfile, token );
				x = Q_atoi( token );
			}
			else if( !Q_stricmp( token, "y" )) 
			{                                          
				pfile = COM_ParseFile( pfile, token );
				y = Q_atoi( token );
			}
			else if( !Q_stricmp( token, "width" )) 
			{                                          
				pfile = COM_ParseFile( pfile, token );
				width = Q_atoi( token );
			}
			else if( !Q_stricmp( token, "height" )) 
			{                                          
				pfile = COM_ParseFile( pfile, token );
				height = Q_atoi( token );
			}
		}
	}

	if( !section )
		return pfile; // data not found

	// calculate sprite position
	tempSprite.rc.left = x;
	tempSprite.rc.right = x + width; 
	tempSprite.rc.top = y;
	tempSprite.rc.bottom = y + height;

	// write resolution for backward compatibility
	if( ScreenWidth < 640 )
		tempSprite.iRes = 320;
	else tempSprite.iRes = 640;

	*result = tempSprite;

	return pfile;
}

client_sprite_t *SPR2_GetList( char *psz, int *piCount )
{
	int iSprCount = 0;
	char *afile = (char *)gEngfuncs.COM_LoadFile( psz, 5, NULL );

	if( !afile )
	{
		*piCount = iSprCount;
		return NULL;
	}
	
	char token[256];
	char *pfile = afile;

	while( pfile )
	{
		// calculate count of sprites
		pfile = COM_ParseFile( pfile, token );

		if( !Q_stricmp( token, "hudsprite" ))
			iSprCount++;
	}

          client_sprite_t *phud = new client_sprite_t[iSprCount];
	pfile = afile;
          
	for( int i = 0; i < iSprCount; i++ )
	{
		pfile = ParseHudSprite( pfile, "hudsprite", &phud[i] );
	}
          
          gEngfuncs.COM_FreeFile( afile );
          
          *piCount = iSprCount;

	return phud;
}

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

LEAF LISTING

NOTE: this code ripped out from Xash3D
======================================================================
*/
static void Mod_BoxLeafnums_r( leaflist_t *ll, mnode_t *node, model_t *worldmodel )
{
	int	s;

	while( 1 )
	{
		if( node->contents == CONTENTS_SOLID )
			return;

		if( node->contents < 0 )
		{
			mleaf_t	*leaf = (mleaf_t *)node;

			// it's a leaf!
			if( ll->count >= ll->maxcount )
			{
				ll->overflowed = true;
				return;
			}

			ll->list[ll->count++] = leaf->cluster;
			return;
		}
	
		s = BOX_ON_PLANE_SIDE( ll->mins, ll->maxs, node->plane );

		if( s == 1 )
		{
			node = node->children[0];
		}
		else if( s == 2 )
		{
			node = node->children[1];
		}
		else
		{
			// go down both
			if( ll->headnode == NULL )
				ll->headnode = node;
			Mod_BoxLeafnums_r( ll, node->children[0], worldmodel );
			node = node->children[1];
		}
	}
}

/*
==================
Mod_BoxLeafnums
==================
*/
int Mod_BoxLeafnums( const Vector &mins, const Vector &maxs, short *list, int listsize, mnode_t **headnode )
{
	leaflist_t ll;
	model_t	*worldmodel;

	worldmodel = gEngfuncs.GetEntityByIndex( 0 )->model;
	if( headnode ) *headnode = NULL;

	if( !worldmodel )
		return 0;

	ll.mins = mins;
	ll.maxs = maxs;
	ll.count = 0;
	ll.maxcount = listsize;
	ll.list = list;
	ll.headnode = NULL;
	ll.overflowed = false;

	Mod_BoxLeafnums_r( &ll, worldmodel->nodes, worldmodel );

	if( headnode )
		*headnode = ll.headnode;
	return ll.count;
}

/*
=============
Mod_HeadnodeVisible
=============
*/
bool Mod_HeadnodeVisible( mnode_t *node, const byte *visbits )
{
	if( !node || node->contents == CONTENTS_SOLID )
		return false;

	if( node->contents < 0 )
	{
		if( CHECKVISBIT( visbits, ((mleaf_t *)node)->cluster ))
			return true;
		return false;
	}

	if( Mod_HeadnodeVisible( node->children[0], visbits ))
		return true;

	return Mod_HeadnodeVisible( node->children[1], visbits );
}

/*
=============
Mod_BoxVisible

Returns true if any leaf in boxspace
is potentially visible
=============
*/
bool Mod_BoxVisible( const Vector &mins, const Vector &maxs, const byte *visbits )
{
	short leafList[48];
	leaflist_t ll;

	if( !visbits ) return true;

	ll.maxcount = ARRAYSIZE( leafList );
	ll.list = leafList;
	ll.headnode = NULL;
	ll.overflowed = false;
	ll.mins = mins;
	ll.maxs = maxs;
	ll.count = 0;

	Mod_BoxLeafnums_r( &ll, worldmodel->nodes, worldmodel );

	for( int i = 0; i < ll.count; i++ )
	{
		if( CHECKVISBIT( visbits, leafList[i] ))
			return true;
	}

	if( !ll.overflowed )
		return false; // invisible

	// overflowed? go by headnode
	if( Mod_HeadnodeVisible( ll.headnode, visbits ))
		return true;

	return false;
}

/*
===================
Mod_DecompressVis
===================
*/
void Mod_DecompressVis( const byte *in, byte *pvs )
{
	int	c;
	byte	*out;
	int	row;

	row = (worldmodel->numleafs+7)>>3;	
	out = pvs;

	if( !in )
	{	// no vis info, so make all visible
		while( row )
		{
			*out++ = 0xff;
			row--;
		}
		return;
	}

	do
	{
		if( *in )
		{
			*out++ = *in++;
			continue;
		}

		c = in[1];
		in += 2;
		while( c )
		{
			*out++ = 0;
			c--;
		}
	} while( out - pvs < row );
}

byte *Mod_LeafPVS( mleaf_t *leaf, model_t *model )
{
	if( !model || !leaf || leaf == model->leafs || !model->visdata )
		Mod_DecompressVis( NULL, decompressed );
	else Mod_DecompressVis( leaf->compressed_vis, decompressed );

	return decompressed;
}

/*
==================
Mod_PointInLeaf

==================
*/
mleaf_t *Mod_PointInLeaf( const Vector &p, mnode_t *node )
{
	while( 1 )
	{
		if( node->contents < 0 )
			return (mleaf_t *)node;
		node = node->children[PlaneDiff( p, node->plane ) < 0];
	}

	// never reached
	return NULL;
}

bool Mod_PointInSolid( const Vector &p )
{
	return (Mod_PointInLeaf( p, worldmodel->nodes )->contents == CONTENTS_SOLID) ? true : false;
}

byte *Mod_GetCurrentVis( void )
{
	return RI->view.pvsarray;
}

bool Mod_CheckBoxVisible( const Vector &absmin, const Vector &absmax )
{
	return Mod_BoxVisible( absmin, absmax, Mod_GetCurrentVis( ));
}

bool Mod_CheckEntityPVS( cl_entity_t *ent )
{
	if( !ent || !ent->index )
		return false;	// not exist on the client

	if( ent->curstate.messagenum != r_currentMessageNum )
		return false;	// already culled by server

	Vector mins = ent->curstate.origin + ent->curstate.mins;
	Vector maxs = ent->curstate.origin + ent->curstate.maxs;

	return Mod_BoxVisible( mins, maxs, Mod_GetCurrentVis( ));
}

bool Mod_CheckEntityLeafPVS( const Vector &absmin, const Vector &absmax, mleaf_t *leaf )
{
	return Mod_BoxVisible( absmin, absmax, Mod_GetCurrentVis( ));
}

bool Mod_CheckTempEntityPVS( TEMPENTITY *pTemp )
{
	if( !pTemp ) return false; // not exist on the client

	Vector mins = pTemp->entity.curstate.origin + pTemp->entity.curstate.mins;
	Vector maxs = pTemp->entity.curstate.origin + pTemp->entity.curstate.maxs;

	return Mod_BoxVisible( mins, maxs, Mod_GetCurrentVis( ));
}

model_t *Mod_Handle( int modelIndex )
{
	return IEngineStudio.GetModelByIndex( modelIndex );
}

int Mod_GetType( int modelIndex )
{
	model_t 	*m_pModel;

	m_pModel = IEngineStudio.GetModelByIndex( modelIndex );
	if( m_pModel == NULL )
		return mod_bad;

	return m_pModel->type;
}

/*
===================
Mod_GetFrames
===================
*/
void Mod_GetFrames( int modelIndex, int &numFrames )
{
	model_t 	*m_pModel;

	m_pModel = IEngineStudio.GetModelByIndex( modelIndex );

	if( !m_pModel )
	{
		numFrames = 1;
		return;
	}

	numFrames = m_pModel->numframes;
	if( numFrames < 1 ) numFrames = 1;
}

/*
==============
GetVisCache

decompress visibility string
==============
*/
mleaf_t *GetVisCache( mleaf_t *lastleaf, mleaf_t *leaf, byte *pvs )
{
	// get the PVS for the pos to limit the number of checks
	if( !worldmodel->visdata )
	{
		if( leaf != lastleaf )
		{
			memset( pvs, 255, (worldmodel->numleafs + 7) / 8 );
			leaf = worldmodel->leafs;
		}
	}
	else if( leaf != lastleaf )
	{
		if( leaf == worldmodel->leafs )
			memset( pvs, 0, (worldmodel->numleafs + 7) / 8 );
		else Mod_DecompressVis( leaf->compressed_vis, pvs );
		lastleaf = leaf;
	}

	return lastleaf;
}

/*
==============
SetDLightVis

Init dlight visibility
==============
*/
void SetDLightVis( mworldlight_t *wl, int leafnum )
{
	if( !wl->pvs )
		wl->pvs = (byte *)Mem_Alloc( (worldmodel->numleafs + 7) / 8 );
	GetVisCache( NULL, worldmodel->leafs + leafnum, wl->pvs );
}

/*
==============
MergeDLightVis

Merge dlight vis with another leaf
==============
*/
void MergeDLightVis( mworldlight_t *wl, int leafnum )
{
	if( !wl->pvs )
	{
		SetDLightVis( wl, leafnum );
	}
	else
	{
		byte	pvs[(MAX_MAP_LEAFS + 7) / 8];
	
		GetVisCache( NULL, worldmodel->leafs + leafnum, pvs );

		// merge both vis graphs
		for( int i = 0; i < (worldmodel->numleafs + 7) / 8; i++ )
			wl->pvs[i] |= pvs[i];
	}
}

#define MAX_POLYGON_POINTS	64
#define PLANESIDE_FRONT	1
#define PLANESIDE_BACK	2
#define PLANESIDE_ON	3

/*
==================
R_ClipPolygon
==================
*/
bool R_ClipPolygon( int numPoints, Vector *points, const mplane_t *plane, int *numClipped, Vector *clipped )
{
	float	dists[MAX_POLYGON_POINTS];
	int	sides[MAX_POLYGON_POINTS];
	bool	frontSide, backSide;
	float	frac;
	int	i;

	if( numPoints >= MAX_POLYGON_POINTS - 2 )
		HOST_ERROR( "R_ClipPolygon: MAX_POLYGON_POINTS hit\n" );

	*numClipped = 0;

	// Determine sides for each point
	frontSide = false;
	backSide = false;

	for( i = 0; i < numPoints; i++ )
	{
		dists[i] = PlaneDiff( points[i], plane );

		if( dists[i] > ON_EPSILON )
		{
			sides[i] = PLANESIDE_FRONT;
			frontSide = true;
			continue;
		}

		if( dists[i] < -ON_EPSILON )
		{
			sides[i] = PLANESIDE_BACK;
			backSide = true;
			continue;
		}

		sides[i] = PLANESIDE_ON;
	}

	if( !frontSide )
		return false;	// Not clipped

	if( !backSide )
	{
		*numClipped = numPoints;
		memcpy( clipped, points, numPoints * sizeof( Vector ));

		return true;
	}

	// xlip it
	points[i] = points[0];
	dists[i] = dists[0];
	sides[i] = sides[0];

	for( i = 0; i < numPoints; i++ )
	{
		if( sides[i] == PLANESIDE_ON )
		{
			clipped[(*numClipped)++] = points[i];
			continue;
		}

		if( sides[i] == PLANESIDE_FRONT )
			clipped[(*numClipped)++] = points[i];

		if( sides[i+1] == PLANESIDE_ON || sides[i+1] == sides[i] )
			continue;

		if( dists[i] == dists[i+1] )
		{
			clipped[(*numClipped)++] = points[i];
		}
		else
		{
			frac = dists[i] / (dists[i] - dists[i+1]);
			clipped[(*numClipped)++] = points[i] + (points[i+1] - points[i]) * frac;
		}
	}

	return true;
}

/*
==================
R_SplitPolygon
==================
*/
void R_SplitPolygon( int numPoints, Vector *points, const mplane_t *plane, int *numFront, Vector *front, int *numBack, Vector *back )
{
	float	dists[MAX_POLYGON_POINTS];
	int	sides[MAX_POLYGON_POINTS];
	bool	frontSide, backSide;
	Vector	mid;
	float	frac;
	int	i;

	if( numPoints >= MAX_POLYGON_POINTS - 2 )
		HOST_ERROR( "R_SplitPolygon: MAX_POLYGON_POINTS hit\n" );

	*numFront = 0;
	*numBack = 0;

	// Determine sides for each point
	frontSide = false;
	backSide = false;

	for( i = 0; i < numPoints; i++ )
	{
		dists[i] = PlaneDiff( points[i], plane );

		if( dists[i] > ON_EPSILON )
		{
			sides[i] = PLANESIDE_FRONT;
			frontSide = true;
			continue;
		}

		if( dists[i] < -ON_EPSILON )
		{
			sides[i] = PLANESIDE_BACK;
			backSide = true;
			continue;
		}

		sides[i] = PLANESIDE_ON;
	}

	if( !frontSide )
	{
		*numBack = numPoints;
		memcpy( back, points, numPoints * sizeof( Vector ));
		return;
	}

	if( !backSide )
	{
		*numFront = numPoints;
		memcpy( front, points, numPoints * sizeof( Vector ));
		return;
	}

	// split it
	points[i] = points[0];

	dists[i] = dists[0];
	sides[i] = sides[0];

	for( i = 0; i < numPoints; i++ )
	{
		if( sides[i] == PLANESIDE_ON )
		{
			front[(*numFront)++] = points[i];
			back[(*numBack)++] = points[i];
			continue;
		}

		if( sides[i] == PLANESIDE_FRONT )
			front[(*numFront)++] = points[i];

		if( sides[i] == PLANESIDE_BACK )
			back[(*numBack)++] = points[i];

		if( sides[i+1] == PLANESIDE_ON || sides[i+1] == sides[i] )
			continue;

		if( dists[i] == dists[i+1] )
		{
			front[(*numFront)++] = points[i];
			back[(*numBack)++] = points[i];
		}
		else
		{
			frac = dists[i] / (dists[i] - dists[i+1]);
			mid = points[i] + (points[i+1] - points[i]) * frac;
			front[(*numFront)++] = mid;
			back[(*numBack)++] = mid;
		}
	}
}

/*
==================
R_TransformWorldToDevice
==================
*/
void R_TransformWorldToDevice( const Vector &world, Vector &ndc )
{
	Vector4D	clip;
	float	scale;

	clip[0] = world[0] * RI->view.worldProjectionMatrix[0][0] + world[1] * RI->view.worldProjectionMatrix[1][0] + world[2] * RI->view.worldProjectionMatrix[2][0] + RI->view.worldProjectionMatrix[3][0];
	clip[1] = world[0] * RI->view.worldProjectionMatrix[0][1] + world[1] * RI->view.worldProjectionMatrix[1][1] + world[2] * RI->view.worldProjectionMatrix[2][1] + RI->view.worldProjectionMatrix[3][1];
	clip[2] = world[0] * RI->view.worldProjectionMatrix[0][2] + world[1] * RI->view.worldProjectionMatrix[1][2] + world[2] * RI->view.worldProjectionMatrix[2][2] + RI->view.worldProjectionMatrix[3][2];
	clip[3] = world[0] * RI->view.worldProjectionMatrix[0][3] + world[1] * RI->view.worldProjectionMatrix[1][3] + world[2] * RI->view.worldProjectionMatrix[2][3] + RI->view.worldProjectionMatrix[3][3];

	if( clip[3] == 0.0f )
	{
		ndc[0] = clip[0];
		ndc[1] = clip[1];
		ndc[2] = -1.0f;
	}
	else
	{
		scale = 1.0f / clip[3];
		ndc[0] = clip[0] * scale;
		ndc[1] = clip[1] * scale;
		ndc[2] = clip[2] * scale;
	}
}

/*
==================
R_TransformDeviceToScreen
==================
*/
void R_TransformDeviceToScreen( const Vector &ndc, Vector &screen )
{
	screen[0] = (ndc[0] * 0.5f + 0.5f) * (RI->view.port[2] - RI->view.port[0]) + RI->view.port[0];
	screen[1] = (ndc[1] * 0.5f + 0.5f) * (RI->view.port[3] - RI->view.port[1]) + RI->view.port[1];
	screen[2] = (ndc[2] * 0.5f + 0.5f);
}

/*
==================
R_ScissorForBounds
==================
*/
static bool R_ScissorForBounds( const Vector bbox[8], float *x, float *y, float *w, float *h )
{
	static int	cornerIndices[6][4] = {{3, 2, 6, 7}, {0, 1, 5, 4}, {2, 3, 1, 0}, {4, 5, 7, 6}, {1, 3, 7, 5}, {2, 0, 4, 6}};
	Vector		points[2][MAX_POLYGON_POINTS];
	float		ix1, iy1, ix2, iy2;
	float		x1, y1, x2, y2;
	int		numPoints;
	Vector		bounds[2];
	Vector		ndc;
	int		pingPong = 0;
	int		i, j;

	// Clip the light volume to the view frustum
	ClearBounds( bounds[0], bounds[1] );

	for( i = 0; i < 6; i++ )
	{
		numPoints = 4;

		points[pingPong][0] = bbox[cornerIndices[i][0]];
		points[pingPong][1] = bbox[cornerIndices[i][1]];
		points[pingPong][2] = bbox[cornerIndices[i][2]];
		points[pingPong][3] = bbox[cornerIndices[i][3]];

		for( j = 0; j < FRUSTUM_PLANES; j++ )
		{
			if( !FBitSet( RI->view.frustum.GetClipFlags(), BIT( j )))
				continue;

			if( !R_ClipPolygon( numPoints, points[pingPong], RI->view.frustum.GetPlane( j ), &numPoints, points[!pingPong] ))
				break;

			pingPong ^= 1;
		}

		if( j != FRUSTUM_PLANES )
			continue;

		// Add the clipped points
		for( j = 0; j < numPoints; j++ )
		{
			// Transform into normalized device coordinates
			R_TransformWorldToDevice( points[pingPong][j], ndc );

			// Add it
			AddPointToBounds( ndc, bounds[0], bounds[1] );
		}
	}

	// If completely clipped away, clear the scissor
	if( BoundsIsCleared( bounds[0], bounds[1] ))
		return false;

	// Transform into screen space
	R_TransformDeviceToScreen( bounds[0], bounds[0] );
	R_TransformDeviceToScreen( bounds[1], bounds[1] );

	x1 = bounds[0].x - 1.0f;
	y1 = bounds[0].y - 1.0f;
	x2 = bounds[1].x + 1.0f;
	y2 = bounds[1].y + 1.0f;

	ix1 = Q_max( x1, RI->view.port[0] );
	ix2 = Q_min( x2, RI->view.port[2] );
	iy1 = Q_max( y1, RI->view.port[1] );
	iy2 = Q_min( y2, RI->view.port[3] );

	*x = ix1 + 1.0f;
	*y = RI->view.port[3] - iy2; // stupid OpenGL bug
	*w = ix2 - ix1 - 1.0f;
	*h = iy2 - iy1 - 1.0f;

	// headshield issues
	if( ix1 >= ix2 || iy1 >= iy2 )
		return false;
	return true;
}

void R_BoundsForAABB( const Vector &absmin, const Vector &absmax, Vector bbox[8] )
{
	ASSERT( bbox != NULL );

	// compute a full bounding box
	for( int i = 0; i < 8; i++ )
	{
  		bbox[i][0] = ( i & 1 ) ? absmin[0] : absmax[0];
  		bbox[i][1] = ( i & 2 ) ? absmin[1] : absmax[1];
  		bbox[i][2] = ( i & 4 ) ? absmin[2] : absmax[2];
	}
}

bool R_ScissorForAABB( const Vector &absmin, const Vector &absmax, float *x, float *y, float *w, float *h )
{
	Vector bbox[8];

	R_BoundsForAABB( absmin, absmax, bbox );

	return R_ScissorForBounds( bbox, x, y, w, h );
}

bool R_ScissorForFrustum( CFrustum *frustum, float *x, float *y, float *w, float *h )
{
	Vector bbox[8];

	frustum->ComputeFrustumCorners( bbox );

	// NOTE: disable farplane because dynamic zFar
	RI->view.frustum.DisablePlane( FRUSTUM_FAR );
	bool result = R_ScissorForBounds( bbox, x, y, w, h );
	RI->view.frustum.EnablePlane( FRUSTUM_FAR );

	return result;
}

bool R_AABBToScreen( const Vector &absmin, const Vector &absmax, Vector2D &scrmin, Vector2D &scrmax, wrect_t *rect )
{
	float x, y, w, h;
	Vector bbox[8];

	R_BoundsForAABB( absmin, absmax, bbox );
	ClearBounds( scrmin, scrmax );

	if( !R_ScissorForBounds( bbox, &x, &y, &w, &h ))
	{
		if( rect ) memset( rect, 0, sizeof( *rect ));
		return false;
          }

	// copy rectangle
	if( rect )
	{
		rect->left = x;
		rect->right = RI->view.port[3] - h - y; // left bottom corner
		rect->top = w;
		rect->bottom = h;
	}

	// compute a bounding box
	AddPointToBounds( Vector2D( x, y ), scrmin, scrmax );
	AddPointToBounds( Vector2D( x + w, y ), scrmin, scrmax );
	AddPointToBounds( Vector2D( x, y + h ), scrmin, scrmax );
	AddPointToBounds( Vector2D( x + w, y + h ), scrmin, scrmax );

	return true;
}

// debug thing
void R_DrawScissorRectangle( float x, float y, float w, float h )
{
	GL_BindTexture( GL_TEXTURE0, tr.whiteTexture );
	pglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
	GL_Setup2D();

	pglColor3f( 1, 0.5, 0 );

	pglBegin( GL_LINES );
		pglVertex2f( x, y );
		pglVertex2f( x + w, y );
		pglVertex2f( x, y );
		pglVertex2f( x, y + h );
		pglVertex2f( x + w, y );
		pglVertex2f( x + w, y + h );
		pglVertex2f( x, y + h );
		pglVertex2f( x + w, y + h );
	pglEnd();

	GL_Setup3D();
}

//-----------------------------------------------------------------------------
// This returns the diameter of the sphere in pixels based on 
// the current model, view, + projection matrices and viewport.
//-----------------------------------------------------------------------------
static float ComputePixelDiameterOfSphere( const Vector& vecAbsOrigin, float flRadius )
{
	// This is sort of faked, but it's faster that way
	// FIXME: Also, there's a much faster way to do this with similar triangles
	// but I want to make sure it exactly matches the current matrices, so
	// for now, I do it this conservative way
	Vector4D testPoint1 = vecAbsOrigin + GetVUp() * flRadius;
	Vector4D testPoint2 = vecAbsOrigin + GetVUp() * -flRadius;
	Vector4D clipPos1 = RI->view.worldProjectionMatrix.VectorTransform( testPoint1 );
	Vector4D clipPos2 = RI->view.worldProjectionMatrix.VectorTransform( testPoint2 );

	if( clipPos1.w >= 0.001f )
	{
		clipPos1.y /= clipPos1.w;
	}
	else
	{
		clipPos1.y *= 1000.0f;
	}

	if( clipPos2.w >= 0.001f )
	{
		clipPos2.y /= clipPos2.w;
	}
	else
	{
		clipPos2.y *= 1000.0f;
	}

	// The divide-by-two here is because y goes from -1 to 1 in projection space
	return RI->view.port[3] * fabs( clipPos2.y - clipPos1.y ) / 2.0f;
}

float ComputePixelWidthOfSphere( const Vector& vecOrigin, float flRadius )
{
	return ComputePixelDiameterOfSphere( vecOrigin, flRadius ) * 2.0f;
}

HSPRITE LoadSprite(const char *pszName)
{
	int i;
	char sz[256]; 

	if (ScreenWidth < 640)
		i = 320;
	else
		i = 640;

	sprintf(sz, pszName, i);

	return SPR_Load(sz);
}

void Physic_SweepTest( cl_entity_t *pTouch, const Vector &start, const Vector &mins, const Vector &maxs, const Vector &end, trace_t *tr )
{
	if( !pTouch->model || !pTouch->model->cache.data )
	{
		// bad model?
		tr->allsolid = false;
		return;
	}

	Vector trace_mins, trace_maxs, bounds[2];
	UTIL_MoveBounds( start, mins, maxs, end, trace_mins, trace_maxs );

	if( !R_StudioGetBounds( pTouch, bounds ))
	{
		tr->allsolid = false;
		return;
	}

	// NOTE: pmove code completely ignore a bounds checking. So we need to do it here
	if( !BoundsIntersect( trace_mins, trace_maxs, bounds[0], bounds[1] ))
	{
		tr->allsolid = false;
		return;
	}

	CMeshDesc	*bodyMesh = UTIL_GetCollisionMesh( pTouch->curstate.modelindex );

	if( !bodyMesh )
	{
		tr->allsolid = false;
		return;
	}

	mmesh_t *pMesh = bodyMesh->GetMesh();
	areanode_t *pHeadNode = bodyMesh->GetHeadNode();
	entity_state_t *pev = &pTouch->curstate;

	if( !pMesh )
	{
		// failed to build mesh for some reasons, so skip them
		tr->allsolid = false;
		return;
	}

	TraceMesh	trm;	// a name like Doom3 :-)

	trm.SetTraceMesh( pMesh, pHeadNode, pTouch->curstate.modelindex );
	trm.SetMeshOrientation( pev->origin, pev->angles, pev->startpos );
	trm.SetupTrace( start, mins, maxs, end, tr );

	if( trm.DoTrace( ))
	{
		if( tr->fraction < 1.0f || tr->startsolid )
			tr->ent = (edict_t *)pTouch;	// g-cont. no need, really. i'm leave this just for fun
		tr->surf = trm.GetLastHitSurface();
	}
}

#define GAMMA		( 2.2f )		// Valve Software gamma
#define INVGAMMA		( 1.0f / 2.2f )	// back to 1.0

static float	texturetolinear[256];	// texture (0..255) to linear (0..1)
static int	lineartotexture[1024];	// linear (0..1) to texture (0..255)

void BuildGammaTable( void )
{
	int	i;
	float	g1, g3;
	float	g = bound( 0.5f, GAMMA, 3.0f );

	g = 1.0 / g;
	g1 = GAMMA * g; 
	g3 = 0.125f;

	for( i = 0; i < 256; i++ )
	{
		// convert from nonlinear texture space (0..255) to linear space (0..1)
		texturetolinear[i] =  pow( i / 255.0f, GAMMA );
	}

	for( i = 0; i < 1024; i++ )
	{
		// convert from linear space (0..1) to nonlinear texture space (0..255)
		lineartotexture[i] =  pow( i / 1023.0, INVGAMMA ) * 255;
	}
}

// convert texture to linear 0..1 value
float TextureToLinear( int c ) { return texturetolinear[bound( 0, c, 255 )]; }

// convert texture to linear 0..1 value
int LinearToTexture( float f ) { return lineartotexture[bound( 0, (int)(f * 1023), 1023 )]; }

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

	LEGACY STUFF

  moved here from studio_util.cpp
===============================================================================
*/
/*
====================
AngleMatrix

====================
*/
void AngleMatrix (const float *angles, float (*matrix)[4] )
{
	float		angle;
	float		sr, sp, sy, cr, cp, cy;
	
	angle = angles[YAW] * (M_PI*2 / 360);
	sy = sin(angle);
	cy = cos(angle);
	angle = angles[PITCH] * (M_PI*2 / 360);
	sp = sin(angle);
	cp = cos(angle);
	angle = angles[ROLL] * (M_PI*2 / 360);
	sr = sin(angle);
	cr = cos(angle);

	// matrix = (YAW * PITCH) * ROLL
	matrix[0][0] = cp*cy;
	matrix[1][0] = cp*sy;
	matrix[2][0] = -sp;
	matrix[0][1] = sr*sp*cy+cr*-sy;
	matrix[1][1] = sr*sp*sy+cr*cy;
	matrix[2][1] = sr*cp;
	matrix[0][2] = (cr*sp*cy+-sr*-sy);
	matrix[1][2] = (cr*sp*sy+-sr*cy);
	matrix[2][2] = cr*cp;
	matrix[0][3] = 0.0;
	matrix[1][3] = 0.0;
	matrix[2][3] = 0.0;
}

/*
====================
VectorTransform

====================
*/
void VectorTransform (const float *in1, float in2[3][4], float *out)
{
	out[0] = DotProduct(in1, in2[0]) + in2[0][3];
	out[1] = DotProduct(in1, in2[1]) + in2[1][3];
	out[2] = DotProduct(in1, in2[2]) + in2[2][3];
}

vec3_t vec3_origin( 0, 0, 0 );

float Length(const float *v)
{
	int		i;
	float	length;
	
	length = 0;
	for (i=0 ; i< 3 ; i++)
		length += v[i]*v[i];
	length = sqrt (length);		// FIXME

	return length;
}

void VectorAngles( const float *forward, float *angles )
{
	float	tmp, yaw, pitch;
	
	if (forward[1] == 0 && forward[0] == 0)
	{
		yaw = 0;
		if (forward[2] > 0)
			pitch = 90;
		else
			pitch = 270;
	}
	else
	{
		yaw = (atan2(forward[1], forward[0]) * 180 / M_PI);
		if (yaw < 0)
			yaw += 360;

		tmp = sqrt (forward[0]*forward[0] + forward[1]*forward[1]);
		pitch = (atan2(forward[2], tmp) * 180 / M_PI);
		if (pitch < 0)
			pitch += 360;
	}
	
	angles[0] = pitch;
	angles[1] = yaw;
	angles[2] = 0;
}

float VectorNormalize (float *v)
{
	float	length, ilength;

	length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
	length = sqrt (length);		// FIXME

	if (length)
	{
		ilength = 1/length;
		v[0] *= ilength;
		v[1] *= ilength;
		v[2] *= ilength;
	}
		
	return length;

}

void VectorScale (const float *in, float scale, float *out)
{
	out[0] = in[0]*scale;
	out[1] = in[1]*scale;
	out[2] = in[2]*scale;
}

void VectorMA (const float *veca, float scale, const float *vecb, float *vecc)
{
	vecc[0] = veca[0] + scale*vecb[0];
	vecc[1] = veca[1] + scale*vecb[1];
	vecc[2] = veca[2] + scale*vecb[2];
}

float PackColor( const color24 &color )
{
	return (float)((double)((color.r << 16) | (color.g << 8) | color.b) / (double)(1 << 24));
}

color24 UnpackColor( float pack )
{
	Vector color = Vector( 1.0f, 256.0f, 65536.0f ) * pack;

	// same as fract( color )
	color.x = color.x - floor( color.x );
	color.y = color.y - floor( color.y );
	color.z = color.z - floor( color.z );

	return color24( color.x * 256, color.y * 256, color.z * 256 );
}