xash3d-fwgs/engine/client/cl_efx.c

#include "common.h"
#include "client.h"
#include "customentity.h"
#include "r_efx.h"
#include "cl_tent.h"
#include "pm_local.h"
#define PART_SIZE	Q_max( 0.5f, cl_draw_particles->value )

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

PARTICLES MANAGEMENT

==============================================================
*/
// particle ramps
static int ramp1[8] = { 0x6f, 0x6d, 0x6b, 0x69, 0x67, 0x65, 0x63, 0x61 };
static int ramp2[8] = { 0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x68, 0x66 };
static int ramp3[6] = { 0x6d, 0x6b, 6, 5, 4, 3 };
static int gSparkRamp[9] = { 0xfe, 0xfd, 0xfc, 0x6f, 0x6e, 0x6d, 0x6c, 0x67, 0x60 };

convar_t		*tracerspeed;
convar_t		*tracerlength;
convar_t		*traceroffset;

particle_t	*cl_active_particles;
particle_t	*cl_active_tracers;
particle_t	*cl_free_particles;
particle_t	*cl_particles = NULL;	// particle pool
static vec3_t	cl_avelocities[NUMVERTEXNORMALS];
static float	cl_lasttimewarn = 0.0f;

/*
================
R_LookupColor

find nearest color in particle palette
================
*/
short GAME_EXPORT R_LookupColor( byte r, byte g, byte b )
{
	int	i, best;
	float	diff, bestdiff;
	float	rf, gf, bf;

	bestdiff = 999999;
	best = -1;

	for( i = 0; i < 256; i++ )
	{
		rf = r - clgame.palette[i].r;
		gf = g - clgame.palette[i].g;
		bf = b - clgame.palette[i].b;

		// convert color to monochrome
		diff = rf * (rf * 0.2f) + gf * (gf * 0.5f) + bf * (bf * 0.3f);

		if ( diff < bestdiff )
		{
			bestdiff = diff;
			best = i;
		}
	}

	return best;
}

/*
================
R_GetPackedColor

in hardware mode does nothing
================
*/
void GAME_EXPORT R_GetPackedColor( short *packed, short color )
{
	if( packed ) *packed = 0;
}

/*
================
CL_InitParticles

================
*/
void CL_InitParticles( void )
{
	int	i;

	cl_particles = Mem_Calloc( cls.mempool, sizeof( particle_t ) * GI->max_particles );
	CL_ClearParticles ();

	// this is used for EF_BRIGHTFIELD
	for( i = 0; i < NUMVERTEXNORMALS; i++ )
	{
		cl_avelocities[i][0] = COM_RandomFloat( 0.0f, 2.55f );
		cl_avelocities[i][1] = COM_RandomFloat( 0.0f, 2.55f );
		cl_avelocities[i][2] = COM_RandomFloat( 0.0f, 2.55f );
	}

	tracerspeed = Cvar_Get( "tracerspeed", "6000", 0, "tracer speed" );
	tracerlength = Cvar_Get( "tracerlength", "0.8", 0, "tracer length factor" );
	traceroffset = Cvar_Get( "traceroffset", "30", 0, "tracer starting offset" );
}

/*
================
CL_ClearParticles

================
*/
void CL_ClearParticles( void )
{
	int	i;

	if( !cl_particles ) return;

	cl_free_particles = cl_particles;
	cl_active_particles = NULL;
	cl_active_tracers = NULL;

	for( i = 0; i < GI->max_particles - 1; i++ )
		cl_particles[i].next = &cl_particles[i+1];

	cl_particles[GI->max_particles-1].next = NULL;
}

/*
================
CL_FreeParticles

================
*/
void CL_FreeParticles( void )
{
	if( cl_particles )
		Mem_Free( cl_particles );
	cl_particles = NULL;
}

/*
================
CL_FreeParticle

move particle to freelist
================
*/
void CL_FreeParticle( particle_t *p )
{
	if( p->deathfunc )
	{
		// call right the deathfunc before die
		p->deathfunc( p );
		p->deathfunc = NULL;
	}

	p->next = cl_free_particles;
	cl_free_particles = p;
}

/*
================
CL_AllocParticleFast

unconditionally give new particle pointer from cl_free_particles
================
*/
particle_t *CL_AllocParticleFast( void )
{
	particle_t *p = NULL;

	if( cl_free_particles )
	{
		p = cl_free_particles;
		cl_free_particles = p->next;
	}

	return p;
}

/*
================
R_AllocParticle

can return NULL if particles is out
================
*/
particle_t * GAME_EXPORT R_AllocParticle( void (*callback)( particle_t*, float ))
{
	particle_t	*p;

	if( !cl_draw_particles->value )
		return NULL;

	// never alloc particles when we not in game
//	if( tr.frametime == 0.0 ) return NULL;

	if( !cl_free_particles )
	{
		if( cl_lasttimewarn < host.realtime )
		{
			// don't spam about overflow
			Con_DPrintf( S_ERROR "Overflow %d particles\n", GI->max_particles );
			cl_lasttimewarn = host.realtime + 1.0f;
		}
		return NULL;
	}

	p = cl_free_particles;
	cl_free_particles = p->next;
	p->next = cl_active_particles;
	cl_active_particles = p;

	// clear old particle
	p->type = pt_static;
	VectorClear( p->vel );
	VectorClear( p->org );
	p->packedColor = 0;
	p->die = cl.time;
	p->color = 0;
	p->ramp = 0;

	if( callback )
	{
		p->type = pt_clientcustom;
		p->callback = callback;
	}

	return p;
}

/*
================
R_AllocTracer

can return NULL if particles is out
================
*/
particle_t *R_AllocTracer( const vec3_t org, const vec3_t vel, float life )
{
	particle_t	*p;

	if( !cl_draw_tracers->value )
		return NULL;

	// never alloc particles when we not in game
	//if( tr.frametime == 0.0 ) return NULL;

	if( !cl_free_particles )
	{
		if( cl_lasttimewarn < host.realtime )
		{
			// don't spam about overflow
			Con_DPrintf( S_ERROR "Overflow %d tracers\n", GI->max_particles );
			cl_lasttimewarn = host.realtime + 1.0f;
		}
		return NULL;
	}

	p = cl_free_particles;
	cl_free_particles = p->next;
	p->next = cl_active_tracers;
	cl_active_tracers = p;

	// clear old particle
	p->type = pt_static;
	VectorCopy( org, p->org );
	VectorCopy( vel, p->vel );
	p->die = cl.time + life;
	p->ramp = tracerlength->value;
	p->color = 4; // select custom color
	p->packedColor = 255; // alpha

	return p;
}
/*
==============================================================

VIEWBEAMS MANAGEMENT

==============================================================
*/
BEAM		*cl_active_beams;
BEAM		*cl_free_beams;
BEAM		*cl_viewbeams = NULL;		// beams pool


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

BEAM ALLOCATE & PROCESSING

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


/*
==============
R_BeamSetAttributes

set beam attributes
==============
*/
static void R_BeamSetAttributes( BEAM *pbeam, float r, float g, float b, float framerate, int startFrame )
{
	pbeam->frame = (float)startFrame;
	pbeam->frameRate = framerate;
	pbeam->r = r;
	pbeam->g = g;
	pbeam->b = b;
}



/*
==============
R_BeamAlloc

==============
*/
BEAM *R_BeamAlloc( void )
{
	BEAM	*pBeam;

	if( !cl_free_beams )
		return NULL;

	pBeam = cl_free_beams;
	cl_free_beams = pBeam->next;
	memset( pBeam, 0, sizeof( *pBeam ));
	pBeam->next = cl_active_beams;
	cl_active_beams = pBeam;
	pBeam->die = cl.time;

	return pBeam;
}

/*
==============
R_BeamFree

==============
*/
void R_BeamFree( BEAM *pBeam )
{
	// free particles that have died off.
	R_FreeDeadParticles( &pBeam->particles );

	// now link into free list;
	pBeam->next = cl_free_beams;
	cl_free_beams = pBeam;
}


/*
================
CL_InitViewBeams

================
*/
void CL_InitViewBeams( void )
{
	cl_viewbeams = Mem_Calloc( cls.mempool, sizeof( BEAM ) * GI->max_beams );
	CL_ClearViewBeams();
}

/*
================
CL_ClearViewBeams

================
*/
void CL_ClearViewBeams( void )
{
	int	i;

	if( !cl_viewbeams ) return;

	// clear beams
	cl_free_beams = cl_viewbeams;
	cl_active_beams = NULL;

	for( i = 0; i < GI->max_beams - 1; i++ )
		cl_viewbeams[i].next = &cl_viewbeams[i+1];
	cl_viewbeams[GI->max_beams - 1].next = NULL;
}

/*
================
CL_FreeViewBeams

================
*/
void CL_FreeViewBeams( void )
{
	if( cl_viewbeams )
		Mem_Free( cl_viewbeams );
	cl_viewbeams = NULL;
}

/*
==============
R_BeamGetEntity

extract entity number from index
handle user entities
==============
*/
cl_entity_t *R_BeamGetEntity( int index )
{
	if( index < 0 )
		return clgame.dllFuncs.pfnGetUserEntity( BEAMENT_ENTITY( -index ));
	return CL_GetEntityByIndex( BEAMENT_ENTITY( index ));
}

/*
==============
CL_KillDeadBeams

==============
*/
void CL_KillDeadBeams( cl_entity_t *pDeadEntity )
{
	BEAM		*pbeam;
	BEAM		*pnewlist;
	BEAM		*pnext;
	particle_t	*pHead;	// build a new list to replace cl_active_beams.

	pbeam = cl_active_beams;	// old list.
	pnewlist = NULL;		// new list.

	while( pbeam )
	{
		cl_entity_t *beament;
		pnext = pbeam->next;

		// link into new list.
		if( R_BeamGetEntity( pbeam->startEntity ) != pDeadEntity )
		{
			pbeam->next = pnewlist;
			pnewlist = pbeam;

			pbeam = pnext;
			continue;
		}

		pbeam->flags &= ~(FBEAM_STARTENTITY | FBEAM_ENDENTITY);

		if( pbeam->type != TE_BEAMFOLLOW )
		{
			// remove beam
			pbeam->die = cl.time - 0.1f;

			// kill off particles
			pHead = pbeam->particles;
			while( pHead )
			{
				pHead->die = cl.time - 0.1f;
				pHead = pHead->next;
			}

			// free the beam
			R_BeamFree( pbeam );
		}
		else
		{
			// stay active
			pbeam->next = pnewlist;
			pnewlist = pbeam;
		}

		pbeam = pnext;
	}

	// We now have a new list with the bogus stuff released.
	cl_active_beams = pnewlist;
}


/*
===============
CL_ReadLineFile_f

Optimized version of pointfile - use beams instead of particles
===============
*/
void CL_ReadLineFile_f( void )
{
	byte *afile;
	char *pfile;
	vec3_t		p1, p2;
	int		count, modelIndex;
	char		filename[MAX_QPATH];
	model_t		*model;
	string		token;

	Q_snprintf( filename, sizeof( filename ), "maps/%s.lin", clgame.mapname );
	afile = FS_LoadFile( filename, NULL, false );

	if( !afile )
	{
		Con_Printf( S_ERROR "couldn't open %s\n", filename );
		return;
	}

	Con_Printf( "Reading %s...\n", filename );

	count = 0;
	pfile = (char *)afile;
	model = CL_LoadModel( DEFAULT_LASERBEAM_PATH, &modelIndex );

	while( 1 )
	{
		pfile = COM_ParseFile( pfile, token, sizeof( token ));
		if( !pfile ) break;
		p1[0] = Q_atof( token );

		pfile = COM_ParseFile( pfile, token, sizeof( token ));
		if( !pfile ) break;
		p1[1] = Q_atof( token );

		pfile = COM_ParseFile( pfile, token, sizeof( token ));
		if( !pfile ) break;
		p1[2] = Q_atof( token );

		pfile = COM_ParseFile( pfile, token, sizeof( token ));
		if( !pfile ) break;

		if( token[0] != '-' )
		{
			Con_Printf( S_ERROR "%s is corrupted\n", filename );
			break;
		}

		pfile = COM_ParseFile( pfile, token, sizeof( token ));
		if( !pfile ) break;
		p2[0] = Q_atof( token );

		pfile = COM_ParseFile( pfile, token, sizeof( token ));
		if( !pfile ) break;
		p2[1] = Q_atof( token );

		pfile = COM_ParseFile( pfile, token, sizeof( token ));
		if( !pfile ) break;
		p2[2] = Q_atof( token );

		count++;

		if( !R_BeamPoints( p1, p2, modelIndex, 0, 2, 0, 255, 0, 0, 0, 255.0f, 0.0f, 0.0f ))
		{
			if( !model || model->type != mod_sprite )
				Con_Printf( S_ERROR "failed to load \"%s\"!\n", DEFAULT_LASERBEAM_PATH );
			else Con_Printf( S_ERROR "not enough free beams!\n" );
			break;
		}
	}

	Mem_Free( afile );

	if( count ) Con_Printf( "%i lines read\n", count );
	else Con_Printf( "map %s has no leaks!\n", clgame.mapname );
}


/*
==============
R_BeamSprite

Create a beam with sprite at the end
Valve legacy
==============
*/
static void CL_BeamSprite( vec3_t start, vec3_t end, int beamIndex, int spriteIndex )
{
	R_BeamPoints( start, end, beamIndex, 0.01f, 0.4f, 0, COM_RandomFloat( 0.5f, 0.655f ), 5.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f );
	R_TempSprite( end, vec3_origin, 0.1f, spriteIndex, kRenderTransAdd, kRenderFxNone, 0.35f, 0.01f, 0.0f );
}


/*
==============
R_BeamSetup

generic function. all beams must be
passed through this
==============
*/
static void R_BeamSetup( BEAM *pbeam, vec3_t start, vec3_t end, int modelIndex, float life, float width, float amplitude, float brightness, float speed )
{
	model_t	*sprite = CL_ModelHandle( modelIndex );

	if( !sprite ) return;

	pbeam->type = BEAM_POINTS;
	pbeam->modelIndex = modelIndex;
	pbeam->frame = 0;
	pbeam->frameRate = 0;
	pbeam->frameCount = sprite->numframes;

	VectorCopy( start, pbeam->source );
	VectorCopy( end, pbeam->target );
	VectorSubtract( end, start, pbeam->delta );

	pbeam->freq = speed * cl.time;
	pbeam->die = life + cl.time;
	pbeam->amplitude = amplitude;
	pbeam->brightness = brightness;
	pbeam->width = width;
	pbeam->speed = speed;

	if( amplitude >= 0.50f )
		pbeam->segments = VectorLength( pbeam->delta ) * 0.25f + 3.0f;	// one per 4 pixels
	else pbeam->segments = VectorLength( pbeam->delta ) * 0.075f + 3.0f;		// one per 16 pixels

	pbeam->pFollowModel = NULL;
	pbeam->flags = 0;
}

/*
==============
CL_BeamAttemptToDie

Check for expired beams
==============
*/
qboolean CL_BeamAttemptToDie( BEAM *pBeam )
{
	Assert( pBeam != NULL );

	// premanent beams never die automatically
	if( FBitSet( pBeam->flags, FBEAM_FOREVER ))
		return false;

	if( pBeam->type == TE_BEAMFOLLOW && pBeam->particles )
	{
		// wait for all trails are dead
		return false;
	}

	// other beams
	if( pBeam->die > cl.time )
		return false;

	return true;
}

/*
==============
R_BeamKill

Remove beam attached to specified entity
and all particle trails (if this is a beamfollow)
==============
*/
void GAME_EXPORT R_BeamKill( int deadEntity )
{
	cl_entity_t	*pDeadEntity;

	pDeadEntity = R_BeamGetEntity( deadEntity );
	if( !pDeadEntity ) return;

	CL_KillDeadBeams( pDeadEntity );
}

/*
==============
CL_ParseViewBeam

handle beam messages
==============
*/
void CL_ParseViewBeam( sizebuf_t *msg, int beamType )
{
	vec3_t	start, end;
	int	modelIndex, startFrame;
	float	frameRate, life, width;
	int	startEnt, endEnt;
	float	noise, speed;
	float	r, g, b, a;

	switch( beamType )
	{
	case TE_BEAMPOINTS:
	case TE_BEAMENTPOINT:
	case TE_BEAMENTS:
		if( beamType == TE_BEAMENTS )
		{
			startEnt = MSG_ReadShort( msg );
			endEnt = MSG_ReadShort( msg );
		}
		else
		{
			if( beamType == TE_BEAMENTPOINT )
			{
				startEnt = MSG_ReadShort( msg );
			}
			else
			{
				start[0] = MSG_ReadCoord( msg );
				start[1] = MSG_ReadCoord( msg );
				start[2] = MSG_ReadCoord( msg );
			}
			end[0] = MSG_ReadCoord( msg );
			end[1] = MSG_ReadCoord( msg );
			end[2] = MSG_ReadCoord( msg );
		}
		modelIndex = MSG_ReadShort( msg );
		startFrame = MSG_ReadByte( msg );
		frameRate = (float)MSG_ReadByte( msg ) * 0.1f;
		life = (float)MSG_ReadByte( msg ) * 0.1f;
		width = (float)MSG_ReadByte( msg ) * 0.1f;
		noise = (float)MSG_ReadByte( msg ) * 0.01f;
		r = (float)MSG_ReadByte( msg ) / 255.0f;
		g = (float)MSG_ReadByte( msg ) / 255.0f;
		b = (float)MSG_ReadByte( msg ) / 255.0f;
		a = (float)MSG_ReadByte( msg ) / 255.0f;
		speed = (float)MSG_ReadByte( msg ) * 0.1f;
		if( beamType == TE_BEAMENTS )
			R_BeamEnts( startEnt, endEnt, modelIndex, life, width, noise, a, speed, startFrame, frameRate, r, g, b );
		else if( beamType == TE_BEAMENTPOINT )
			R_BeamEntPoint( startEnt, end, modelIndex, life, width, noise, a, speed, startFrame, frameRate, r, g, b );
		else
			R_BeamPoints( start, end, modelIndex, life, width, noise, a, speed, startFrame, frameRate, r, g, b );
		break;
	case TE_LIGHTNING:
		start[0] = MSG_ReadCoord( msg );
		start[1] = MSG_ReadCoord( msg );
		start[2] = MSG_ReadCoord( msg );
		end[0] = MSG_ReadCoord( msg );
		end[1] = MSG_ReadCoord( msg );
		end[2] = MSG_ReadCoord( msg );
		life = (float)MSG_ReadByte( msg ) * 0.1f;
		width = (float)MSG_ReadByte( msg ) * 0.1f;
		noise = (float)MSG_ReadByte( msg ) * 0.01f;
		modelIndex = MSG_ReadShort( msg );
		R_BeamLightning( start, end, modelIndex, life, width, noise, 0.6f, 3.5f );
		break;
	case TE_BEAM:
		break;
	case TE_BEAMSPRITE:
		start[0] = MSG_ReadCoord( msg );
		start[1] = MSG_ReadCoord( msg );
		start[2] = MSG_ReadCoord( msg );
		end[0] = MSG_ReadCoord( msg );
		end[1] = MSG_ReadCoord( msg );
		end[2] = MSG_ReadCoord( msg );
		modelIndex = MSG_ReadShort( msg );	// beam model
		startFrame = MSG_ReadShort( msg );	// sprite model
		CL_BeamSprite( start, end, modelIndex, startFrame );
		break;
	case TE_BEAMTORUS:
	case TE_BEAMDISK:
	case TE_BEAMCYLINDER:
		start[0] = MSG_ReadCoord( msg );
		start[1] = MSG_ReadCoord( msg );
		start[2] = MSG_ReadCoord( msg );
		end[0] = MSG_ReadCoord( msg );
		end[1] = MSG_ReadCoord( msg );
		end[2] = MSG_ReadCoord( msg );
		modelIndex = MSG_ReadShort( msg );
		startFrame = MSG_ReadByte( msg );
		frameRate = (float)MSG_ReadByte( msg ) * 0.1f;
		life = (float)MSG_ReadByte( msg ) * 0.1f;
		width = (float)MSG_ReadByte( msg );
		noise = (float)MSG_ReadByte( msg ) * 0.01f;
		r = (float)MSG_ReadByte( msg ) / 255.0f;
		g = (float)MSG_ReadByte( msg ) / 255.0f;
		b = (float)MSG_ReadByte( msg ) / 255.0f;
		a = (float)MSG_ReadByte( msg ) / 255.0f;
		speed = (float)MSG_ReadByte( msg ) * 0.1f;
		R_BeamCirclePoints( beamType, start, end, modelIndex, life, width, noise, a, speed, startFrame, frameRate, r, g, b );
		break;
	case TE_BEAMFOLLOW:
		startEnt = MSG_ReadShort( msg );
		modelIndex = MSG_ReadShort( msg );
		life = (float)MSG_ReadByte( msg ) * 0.1f;
		width = (float)MSG_ReadByte( msg );
		r = (float)MSG_ReadByte( msg ) / 255.0f;
		g = (float)MSG_ReadByte( msg ) / 255.0f;
		b = (float)MSG_ReadByte( msg ) / 255.0f;
		a = (float)MSG_ReadByte( msg ) / 255.0f;
		R_BeamFollow( startEnt, modelIndex, life, width, r, g, b, a );
		break;
	case TE_BEAMRING:
		startEnt = MSG_ReadShort( msg );
		endEnt = MSG_ReadShort( msg );
		modelIndex = MSG_ReadShort( msg );
		startFrame = MSG_ReadByte( msg );
		frameRate = (float)MSG_ReadByte( msg ) * 0.1f;
		life = (float)MSG_ReadByte( msg ) * 0.1f;
		width = (float)MSG_ReadByte( msg ) * 0.1f;
		noise = (float)MSG_ReadByte( msg ) * 0.01f;
		r = (float)MSG_ReadByte( msg ) / 255.0f;
		g = (float)MSG_ReadByte( msg ) / 255.0f;
		b = (float)MSG_ReadByte( msg ) / 255.0f;
		a = (float)MSG_ReadByte( msg ) / 255.0f;
		speed = (float)MSG_ReadByte( msg ) * 0.1f;
		R_BeamRing( startEnt, endEnt, modelIndex, life, width, noise, a, speed, startFrame, frameRate, r, g, b );
		break;
	case TE_BEAMHOSE:
		break;
	case TE_KILLBEAM:
		startEnt = MSG_ReadShort( msg );
		R_BeamKill( startEnt );
		break;
	}
}


/*
==============
R_BeamEnts

Create beam between two ents
==============
*/
BEAM * GAME_EXPORT R_BeamEnts( int startEnt, int endEnt, int modelIndex, float life, float width, float amplitude, float brightness,
	float speed, int startFrame, float framerate, float r, float g, float b )
{
	cl_entity_t	*start, *end;
	BEAM		*pbeam;
	model_t		*mod;

	mod = CL_ModelHandle( modelIndex );

	// need a valid model.
	if( !mod || mod->type != mod_sprite )
		return NULL;

	start = R_BeamGetEntity( startEnt );
	end = R_BeamGetEntity( endEnt );

	if( !start || !end )
		return NULL;

	// don't start temporary beams out of the PVS
	if( life != 0 && ( !start->model || !end->model ))
		return NULL;

	pbeam = R_BeamLightning( vec3_origin, vec3_origin, modelIndex, life, width, amplitude, brightness, speed );
	if( !pbeam ) return NULL;

	pbeam->type = TE_BEAMPOINTS;
	SetBits( pbeam->flags, FBEAM_STARTENTITY | FBEAM_ENDENTITY );
	if( life == 0 ) SetBits( pbeam->flags, FBEAM_FOREVER );

	pbeam->startEntity = startEnt;
	pbeam->endEntity = endEnt;

	R_BeamSetAttributes( pbeam, r, g, b, framerate, startFrame );

	return pbeam;
}

/*
==============
R_BeamPoints

Create beam between two points
==============
*/
BEAM * GAME_EXPORT R_BeamPoints( vec3_t start, vec3_t end, int modelIndex, float life, float width, float amplitude,
	float brightness, float speed, int startFrame, float framerate, float r, float g, float b )
{
	BEAM	*pbeam;

	if( life != 0 && ref.dllFuncs.R_BeamCull( start, end, true ))
		return NULL;

	pbeam = R_BeamAlloc();
	if( !pbeam ) return NULL;

	pbeam->die = cl.time;

	if( modelIndex < 0 )
		return NULL;

	R_BeamSetup( pbeam, start, end, modelIndex, life, width, amplitude, brightness, speed );
	if( life == 0 ) SetBits( pbeam->flags, FBEAM_FOREVER );

	R_BeamSetAttributes( pbeam, r, g, b, framerate, startFrame );

	return pbeam;
}

/*
==============
R_BeamCirclePoints

Create beam cicrle
==============
*/
BEAM * GAME_EXPORT R_BeamCirclePoints( int type, vec3_t start, vec3_t end, int modelIndex, float life, float width,
	float amplitude, float brightness, float speed, int startFrame, float framerate, float r, float g, float b )
{
	BEAM	*pbeam = R_BeamLightning( start, end, modelIndex, life, width, amplitude, brightness, speed );

	if( !pbeam ) return NULL;
	pbeam->type = type;
	if( life == 0 ) SetBits( pbeam->flags, FBEAM_FOREVER );
	R_BeamSetAttributes( pbeam, r, g, b, framerate, startFrame );

	return pbeam;
}


/*
==============
R_BeamEntPoint

Create beam between entity and point
==============
*/
BEAM *GAME_EXPORT R_BeamEntPoint( int startEnt, vec3_t end, int modelIndex, float life, float width, float amplitude,
	float brightness, float speed, int startFrame, float framerate, float r, float g, float b )
{
	BEAM		*pbeam;
	cl_entity_t	*start;

	start = R_BeamGetEntity( startEnt );

	if( !start ) return NULL;

	if( life == 0 && !start->model )
		return NULL;

	pbeam = R_BeamAlloc();
	if ( !pbeam ) return NULL;

	pbeam->die = cl.time;
	if( modelIndex < 0 )
		return NULL;

	R_BeamSetup( pbeam, vec3_origin, end, modelIndex, life, width, amplitude, brightness, speed );

	pbeam->type = TE_BEAMPOINTS;
	SetBits( pbeam->flags, FBEAM_STARTENTITY );
	if( life == 0 ) SetBits( pbeam->flags, FBEAM_FOREVER );
	pbeam->startEntity = startEnt;
	pbeam->endEntity = 0;

	R_BeamSetAttributes( pbeam, r, g, b, framerate, startFrame );

	return pbeam;
}

/*
==============
R_BeamRing

Create beam between two ents
==============
*/
BEAM * GAME_EXPORT R_BeamRing( int startEnt, int endEnt, int modelIndex, float life, float width, float amplitude, float brightness,
	float speed, int startFrame, float framerate, float r, float g, float b )
{
	BEAM		*pbeam;
	cl_entity_t	*start, *end;

	start = R_BeamGetEntity( startEnt );
	end = R_BeamGetEntity( endEnt );

	if( !start || !end )
		return NULL;

	if( life != 0 && ( !start->model || !end->model ))
		return NULL;

	pbeam = R_BeamLightning( vec3_origin, vec3_origin, modelIndex, life, width, amplitude, brightness, speed );
	if( !pbeam ) return NULL;

	pbeam->type = TE_BEAMRING;
	SetBits( pbeam->flags, FBEAM_STARTENTITY | FBEAM_ENDENTITY );
	if( life == 0 ) SetBits( pbeam->flags, FBEAM_FOREVER );
	pbeam->startEntity = startEnt;
	pbeam->endEntity = endEnt;

	R_BeamSetAttributes( pbeam, r, g, b, framerate, startFrame );

	return pbeam;
}

/*
==============
R_BeamFollow

Create beam following with entity
==============
*/
BEAM *GAME_EXPORT R_BeamFollow( int startEnt, int modelIndex, float life, float width, float r, float g, float b, float brightness )
{
	BEAM	*pbeam = R_BeamAlloc();

	if( !pbeam ) return NULL;
	pbeam->die = cl.time;

	if( modelIndex < 0 )
		return NULL;

	R_BeamSetup( pbeam, vec3_origin, vec3_origin, modelIndex, life, width, life, brightness, 1.0f );

	pbeam->type = TE_BEAMFOLLOW;
	SetBits( pbeam->flags, FBEAM_STARTENTITY );
	pbeam->startEntity = startEnt;

	R_BeamSetAttributes( pbeam, r, g, b, 1.0f, 0 );

	return pbeam;
}


/*
==============
R_BeamLightning

template for new beams
==============
*/
BEAM *GAME_EXPORT R_BeamLightning( vec3_t start, vec3_t end, int modelIndex, float life, float width, float amplitude, float brightness, float speed )
{
	BEAM	*pbeam = R_BeamAlloc();

	if( !pbeam ) return NULL;
	pbeam->die = cl.time;

	if( modelIndex < 0 )
		return NULL;

	R_BeamSetup( pbeam, start, end, modelIndex, life, width, amplitude, brightness, speed );

	return pbeam;
}



/*
===============
R_EntityParticles

set EF_BRIGHTFIELD effect
===============
*/
void GAME_EXPORT R_EntityParticles( cl_entity_t *ent )
{
	float		angle;
	float		sr, sp, sy, cr, cp, cy;
	vec3_t		forward;
	particle_t	*p;
	int		i;

	for( i = 0; i < NUMVERTEXNORMALS; i++ )
	{
		p = R_AllocParticle( NULL );
		if( !p ) return;

		angle = cl.time * cl_avelocities[i][0];
		SinCos( angle, &sy, &cy );
		angle = cl.time * cl_avelocities[i][1];
		SinCos( angle, &sp, &cp );
		angle = cl.time * cl_avelocities[i][2];
		SinCos( angle, &sr, &cr );

		VectorSet( forward, cp * cy, cp * sy, -sp );

		p->die = cl.time + 0.001f;
		p->color = 111; // yellow

		VectorMAMAM( 1.0f, ent->origin, 64.0f, m_bytenormals[i], 16.0f, forward, p->org );
	}
}

/*
===============
R_ParticleExplosion

===============
*/
void GAME_EXPORT R_ParticleExplosion( const vec3_t org )
{
	particle_t	*p;
	int		i, j;

	for( i = 0; i < 1024; i++ )
	{
		p = R_AllocParticle( NULL );
		if( !p ) return;

		p->die = cl.time + 5.0f;
		p->ramp = COM_RandomLong( 0, 3 );
		p->color = ramp1[0];

		for( j = 0; j < 3; j++ )
		{
			p->org[j] = org[j] + COM_RandomFloat( -16.0f, 16.0f );
			p->vel[j] = COM_RandomFloat( -256.0f, 256.0f );
		}

		if( i & 1 ) p->type = pt_explode;
		else p->type = pt_explode2;
	}
}

/*
===============
R_ParticleExplosion2

===============
*/
void GAME_EXPORT R_ParticleExplosion2( const vec3_t org, int colorStart, int colorLength )
{
	int		i, j;
	int		colorMod = 0, packedColor;
	particle_t	*p;

	if( FBitSet( host.features, ENGINE_QUAKE_COMPATIBLE ))
		packedColor = 255; // use old code for blob particles
	else packedColor = 0;

	for( i = 0; i < 512; i++ )
	{
		p = R_AllocParticle( NULL );
		if( !p ) return;

		p->die = cl.time + 0.3f;
		p->color = colorStart + ( colorMod % colorLength );
		p->packedColor = packedColor;
		colorMod++;

		p->type = pt_blob;

		for( j = 0; j < 3; j++ )
		{
			p->org[j] = org[j] + COM_RandomFloat( -16.0f, 16.0f );
			p->vel[j] = COM_RandomFloat( -256.0f, 256.0f );
		}
	}
}

/*
===============
R_BlobExplosion

===============
*/
void GAME_EXPORT R_BlobExplosion( const vec3_t org )
{
	particle_t	*p;
	int		i, j, packedColor;

	if( FBitSet( host.features, ENGINE_QUAKE_COMPATIBLE ))
		packedColor = 255; // use old code for blob particles
	else packedColor = 0;

	for( i = 0; i < 1024; i++ )
	{
		p = R_AllocParticle( NULL );
		if( !p ) return;

		p->die = cl.time + COM_RandomFloat( 1.0f, 1.4f );
		p->packedColor = packedColor;

		if( i & 1 )
		{
			p->type = pt_blob;
			p->color = COM_RandomLong( 66, 71 );
		}
		else
		{
			p->type = pt_blob2;
			p->color = COM_RandomLong( 150, 155 );
		}

		for( j = 0; j < 3; j++ )
		{
			p->org[j] = org[j] + COM_RandomFloat( -16.0f, 16.0f );
			p->vel[j] = COM_RandomFloat( -256.0f, 256.0f );
		}
	}
}

/*
===============
ParticleEffect

PARTICLE_EFFECT on server
===============
*/
void GAME_EXPORT R_RunParticleEffect( const vec3_t org, const vec3_t dir, int color, int count )
{
	particle_t	*p;
	int		i;

	if( count == 1024 )
	{
		// rocket explosion
		R_ParticleExplosion( org );
		return;
	}

	for( i = 0; i < count; i++ )
	{
		p = R_AllocParticle( NULL );
		if( !p ) return;

		p->color = (color & ~7) + COM_RandomLong( 0, 7 );
		p->die = cl.time + COM_RandomFloat( 0.1f, 0.4f );
		p->type = pt_slowgrav;

		VectorAddScalar( org, COM_RandomFloat( -8.0f, 8.0f ), p->org );
		VectorScale( dir, 15.0f, p->vel );
	}
}

/*
===============
R_Blood

particle spray
===============
*/
void GAME_EXPORT R_Blood( const vec3_t org, const vec3_t ndir, int pcolor, int speed )
{
	vec3_t		pos, dir, vec;
	float		pspeed = speed * 3.0f;
	int		i, j;
	particle_t	*p;

	VectorNormalize2( ndir, dir );

	for( i = 0; i < (speed / 2); i++ )
	{
		VectorAddScalar( org, COM_RandomFloat( -3.0f, 3.0f ), pos );
		VectorAddScalar( dir, COM_RandomFloat( -0.06f, 0.06f ), vec );

		for( j = 0; j < 7; j++ )
		{
			p = R_AllocParticle( NULL );
			if( !p ) return;

			p->die = cl.time + 1.5f;
			p->color = pcolor + COM_RandomLong( 0, 9 );
			p->type = pt_vox_grav;

			VectorAddScalar( pos, COM_RandomFloat( -1.0f, 1.0f ), p->org );
			VectorScale( vec, pspeed, p->vel );
		}
	}
}

/*
===============
R_BloodStream

particle spray 2
===============
*/
void GAME_EXPORT R_BloodStream( const vec3_t org, const vec3_t dir, int pcolor, int speed )
{
	particle_t	*p;
	int		i, j;
	float		arc;
	int		accel = speed; // must be integer due to bug in GoldSrc

	for( arc = 0.05f, i = 0; i < 100; i++ )
	{
		p = R_AllocParticle( NULL );
		if( !p ) return;

		p->die = cl.time + 2.0f;
		p->type = pt_vox_grav;
		p->color = pcolor + COM_RandomLong( 0, 9 );

		VectorCopy( org, p->org );
		VectorCopy( dir, p->vel );

		p->vel[2] -= arc;
		arc -= 0.005f;
		VectorScale( p->vel, accel, p->vel );
		accel -= 0.00001f; // so last few will drip
	}

	for( arc = 0.075f, i = 0; i < ( speed / 5 ); i++ )
	{
		float	num;

		p = R_AllocParticle( NULL );
		if( !p ) return;

		p->die = cl.time + 3.0f;
		p->color = pcolor + COM_RandomLong( 0, 9 );
		p->type = pt_vox_slowgrav;

		VectorCopy( org, p->org );
		VectorCopy( dir, p->vel );

		p->vel[2] -= arc;
		arc -= 0.005f;

		num = COM_RandomFloat( 0.0f, 1.0f );
		accel = speed * num;
		num *= 1.7f;

		VectorScale( p->vel, num, p->vel );
		VectorScale( p->vel, accel, p->vel );

		for( j = 0; j < 2; j++ )
		{
			p = R_AllocParticle( NULL );
			if( !p ) return;

			p->die = cl.time + 3.0f;
			p->color = pcolor + COM_RandomLong( 0, 9 );
			p->type = pt_vox_slowgrav;

			p->org[0] = org[0] + COM_RandomFloat( -1.0f, 1.0f );
			p->org[1] = org[1] + COM_RandomFloat( -1.0f, 1.0f );
			p->org[2] = org[2] + COM_RandomFloat( -1.0f, 1.0f );

			VectorCopy( dir, p->vel );
			p->vel[2] -= arc;

			VectorScale( p->vel, num, p->vel );
			VectorScale( p->vel, accel, p->vel );
		}
	}
}

/*
===============
R_LavaSplash

===============
*/
void GAME_EXPORT R_LavaSplash( const vec3_t org )
{
	particle_t	*p;
	float		vel;
	vec3_t		dir;
	int		i, j, k;

	for( i = -16; i < 16; i++ )
	{
		for( j = -16; j <16; j++ )
		{
			for( k = 0; k < 1; k++ )
			{
				p = R_AllocParticle( NULL );
				if( !p ) return;

				p->die = cl.time + COM_RandomFloat( 2.0f, 2.62f );
				p->color = COM_RandomLong( 224, 231 );
				p->type = pt_slowgrav;

				dir[0] = j * 8.0f + COM_RandomFloat( 0.0f, 7.0f );
				dir[1] = i * 8.0f + COM_RandomFloat( 0.0f, 7.0f );
				dir[2] = 256.0f;

				p->org[0] = org[0] + dir[0];
				p->org[1] = org[1] + dir[1];
				p->org[2] = org[2] + COM_RandomFloat( 0.0f, 63.0f );

				VectorNormalize( dir );
				vel = COM_RandomFloat( 50.0f, 113.0f );
				VectorScale( dir, vel, p->vel );
			}
		}
	}
}

/*
===============
R_ParticleBurst

===============
*/
void GAME_EXPORT R_ParticleBurst( const vec3_t org, int size, int color, float life )
{
	particle_t	*p;
	vec3_t		dir, dest;
	int		i, j;
	float		dist;

	for( i = 0; i < 32; i++ )
	{
		for( j = 0; j < 32; j++ )
		{
			p = R_AllocParticle( NULL );
			if( !p ) return;

			p->die = cl.time + life + COM_RandomFloat( -0.5f, 0.5f );
			p->color = color + COM_RandomLong( 0, 10 );
			p->ramp = 1.0f;

			VectorCopy( org, p->org );
			VectorAddScalar( org, COM_RandomFloat( -size, size ), dest );
			VectorSubtract( dest, p->org, dir );
			dist = VectorNormalizeLength( dir );
			VectorScale( dir, ( dist / life ), p->vel );
		}
	}
}

/*
===============
R_LargeFunnel

===============
*/
void GAME_EXPORT R_LargeFunnel( const vec3_t org, int reverse )
{
	particle_t	*p;
	float		vel, dist;
	vec3_t		dir, dest;
	int		i, j;

	for( i = -8; i < 8; i++ )
	{
		for( j = -8; j < 8; j++ )
		{
			p = R_AllocParticle( NULL );
			if( !p ) return;

			dest[0] = (i * 32.0f) + org[0];
			dest[1] = (j * 32.0f) + org[1];
			dest[2] = org[2] + COM_RandomFloat( 100.0f, 800.0f );

			if( reverse )
			{
				VectorCopy( org, p->org );
				VectorSubtract( dest, p->org, dir );
			}
			else
			{
				VectorCopy( dest, p->org );
				VectorSubtract( org, p->org, dir );
			}

			vel = dest[2] / 8.0f;
			if( vel < 64.0f ) vel = 64.0f;

			dist = VectorNormalizeLength( dir );
			vel += COM_RandomFloat( 64.0f, 128.0f );
			VectorScale( dir, vel, p->vel );
			p->die = cl.time + (dist / vel );
			p->color = 244; // green color
		}
	}
}

/*
===============
R_TeleportSplash

===============
*/
void GAME_EXPORT R_TeleportSplash( const vec3_t org )
{
	particle_t	*p;
	vec3_t		dir;
	float		vel;
	int		i, j, k;

	for( i = -16; i < 16; i += 4 )
	{
		for( j = -16; j < 16; j += 4 )
		{
			for( k = -24; k < 32; k += 4 )
			{
				p = R_AllocParticle( NULL );
				if( !p ) return;

				p->die = cl.time + COM_RandomFloat( 0.2f, 0.34f );
				p->color = COM_RandomLong( 7, 14 );
				p->type = pt_slowgrav;

				dir[0] = j * 8.0f;
				dir[1] = i * 8.0f;
				dir[2] = k * 8.0f;

				p->org[0] = org[0] + i + COM_RandomFloat( 0.0f, 3.0f );
				p->org[1] = org[1] + j + COM_RandomFloat( 0.0f, 3.0f );
				p->org[2] = org[2] + k + COM_RandomFloat( 0.0f, 3.0f );

				VectorNormalize( dir );
				vel = COM_RandomFloat( 50.0f, 113.0f );
				VectorScale( dir, vel, p->vel );
			}
		}
	}
}

/*
===============
R_RocketTrail

===============
*/
void GAME_EXPORT R_RocketTrail( vec3_t start, vec3_t end, int type )
{
	vec3_t		vec, right, up;
	static int	tracercount;
	float		s, c, x, y;
	float		len, dec;
	particle_t	*p;

	VectorSubtract( end, start, vec );
	len = VectorNormalizeLength( vec );

	if( type == 7 )
	{
		VectorVectors( vec, right, up );
	}

	if( type < 128 )
	{
		dec = 3.0f;
	}
	else
	{
		dec = 1.0f;
		type -= 128;
	}

	VectorScale( vec, dec, vec );

	while( len > 0 )
	{
		len -= dec;

		p = R_AllocParticle( NULL );
		if( !p ) return;

		p->die = cl.time + 2.0f;

		switch( type )
		{
		case 0:	// rocket trail
			p->ramp = COM_RandomLong( 0, 3 );
			p->color = ramp3[(int)p->ramp];
			p->type = pt_fire;
			VectorAddScalar( start, COM_RandomFloat( -3.0f, 3.0f ), p->org );
			break;
		case 1:	// smoke smoke
			p->ramp = COM_RandomLong( 2, 5 );
			p->color = ramp3[(int)p->ramp];
			p->type = pt_fire;
			VectorAddScalar( start, COM_RandomFloat( -3.0f, 3.0f ), p->org );
			break;
		case 2:	// blood
			p->type = pt_grav;
			p->color = COM_RandomLong( 67, 74 );
			VectorAddScalar( start, COM_RandomFloat( -3.0f, 3.0f ), p->org );
			break;
		case 3:
		case 5:	// tracer
			p->die = cl.time + 0.5f;

			if( type == 3 ) p->color = 52 + (( tracercount & 4 )<<1 );
			else p->color = 230 + (( tracercount & 4 )<<1 );

			VectorCopy( start, p->org );
			tracercount++;

			if( FBitSet( tracercount, 1 ))
			{
				p->vel[0] = 30.0f *  vec[1];
				p->vel[1] = 30.0f * -vec[0];
			}
			else
			{
				p->vel[0] = 30.0f * -vec[1];
				p->vel[1] = 30.0f *  vec[0];
			}
			break;
		case 4:	// slight blood
			p->type = pt_grav;
			p->color = COM_RandomLong( 67, 70 );
			VectorAddScalar( start, COM_RandomFloat( -3.0f, 3.0f ), p->org );
			len -= 3.0f;
			break;
		case 6:	// voor trail
			p->color = COM_RandomLong( 152, 155 );
			p->die += 0.3f;
			VectorAddScalar( start, COM_RandomFloat( -8.0f, 8.0f ), p->org );
			break;
		case 7:	// explosion tracer
			x = COM_RandomLong( 0, 65535 );
			y = COM_RandomLong( 8, 16 );
			SinCos( x, &s, &c );
			s *= y;
			c *= y;

			VectorMAMAM( 1.0f, start, s, right, c, up, p->org );
			VectorSubtract( start, p->org, p->vel );
			VectorScale( p->vel, 2.0f, p->vel );
			VectorMA( p->vel, COM_RandomFloat( 96.0f, 111.0f ), vec, p->vel );
			p->ramp = COM_RandomLong( 0, 3 );
			p->color = ramp3[(int)p->ramp];
			p->type = pt_explode2;
			break;
		default:
			// just build line to show error
			VectorCopy( start, p->org );
			break;
		}

		VectorAdd( start, vec, start );
	}
}

/*
================
R_ParticleLine

================
*/
void GAME_EXPORT R_ParticleLine( const vec3_t start, const vec3_t end, byte r, byte g, byte b, float life )
{
	int	pcolor;

	pcolor = R_LookupColor( r, g, b );
	PM_ParticleLine( start, end, pcolor, life, 0 );
}

/*
================
R_ParticleBox

================
*/
void GAME_EXPORT R_ParticleBox( const vec3_t absmin, const vec3_t absmax, byte r, byte g, byte b, float life )
{
	vec3_t	mins, maxs;
	vec3_t	origin;
	int	pcolor;

	pcolor = R_LookupColor( r, g, b );

	VectorAverage( absmax, absmin, origin );
	VectorSubtract( absmax, origin, maxs );
	VectorSubtract( absmin, origin, mins );

	PM_DrawBBox( mins, maxs, origin, pcolor, life );
}

/*
================
R_ShowLine

================
*/
void GAME_EXPORT R_ShowLine( const vec3_t start, const vec3_t end )
{
	vec3_t		dir, org;
	float		len;
	particle_t	*p;

	VectorSubtract( end, start, dir );
	len = VectorNormalizeLength( dir );
	VectorScale( dir, 5.0f, dir );
	VectorCopy( start, org );

	while( len > 0 )
	{
		len -= 5.0f;

		p = R_AllocParticle( NULL );
		if( !p ) return;

		p->die = cl.time + 30;
		p->color = 75;

		VectorCopy( org, p->org );
		VectorAdd( org, dir, org );
	}
}

/*
===============
R_BulletImpactParticles

===============
*/
void GAME_EXPORT R_BulletImpactParticles( const vec3_t pos )
{
	int		i, quantity;
	int		color;
	float		dist;
	vec3_t		dir;
	particle_t	*p;

	VectorSubtract( pos, refState.vieworg, dir );
	dist = VectorLength( dir );
	if( dist > 1000.0f ) dist = 1000.0f;

	quantity = (1000.0f - dist) / 100.0f;
	if( quantity == 0 ) quantity = 1;

	color = 3 - ((30 * quantity) / 100 );
	R_SparkStreaks( pos, 2, -200, 200 );

	for( i = 0; i < quantity * 4; i++ )
	{
		p = R_AllocParticle( NULL );
		if( !p ) return;

		VectorCopy( pos, p->org);

		p->vel[0] = COM_RandomFloat( -1.0f, 1.0f );
		p->vel[1] = COM_RandomFloat( -1.0f, 1.0f );
		p->vel[2] = COM_RandomFloat( -1.0f, 1.0f );
		VectorScale( p->vel, COM_RandomFloat( 50.0f, 100.0f ), p->vel );

		p->die = cl.time + 0.5;
		p->color = 3 - color;
		p->type = pt_grav;
	}
}

/*
===============
R_FlickerParticles

===============
*/
void GAME_EXPORT R_FlickerParticles( const vec3_t org )
{
	particle_t	*p;
	int		i;

	for( i = 0; i < 15; i++ )
	{
		p = R_AllocParticle( NULL );
		if( !p ) return;

		VectorCopy( org, p->org );
		p->vel[0] = COM_RandomFloat( -32.0f, 32.0f );
		p->vel[1] = COM_RandomFloat( -32.0f, 32.0f );
		p->vel[2] = COM_RandomFloat( 80.0f, 143.0f );

		p->die = cl.time + 2.0f;
		p->type = pt_blob2;
		p->color = 254;
	}
}

/*
===============
R_StreakSplash

create a splash of streaks
===============
*/
void GAME_EXPORT R_StreakSplash( const vec3_t pos, const vec3_t dir, int color, int count, float speed, int velocityMin, int velocityMax )
{
	vec3_t		vel, vel2;
	particle_t	*p;
	int		i;

	VectorScale( dir, speed, vel );

	for( i = 0; i < count; i++ )
	{
		VectorAddScalar( vel, COM_RandomFloat( velocityMin, velocityMax ), vel2 );
		p = R_AllocTracer( pos, vel2, COM_RandomFloat( 0.1f, 0.5f ));
		if( !p ) return;

		p->type = pt_grav;
		p->color = color;
		p->ramp = 1.0f;
	}
}

/*
===============
R_DebugParticle

just for debug purposes
===============
*/
void R_DebugParticle( const vec3_t pos, byte r, byte g, byte b )
{
	particle_t	*p;

	p = R_AllocParticle( NULL );
	if( !p ) return;

	VectorCopy( pos, p->org );
	p->color = R_LookupColor( r, g, b );
	p->die = cl.time + 0.01f;
}

/*
===============
CL_Particle

pmove debugging particle
===============
*/
void CL_Particle( const vec3_t org, int color, float life, int zpos, int zvel )
{
	particle_t	*p;

	p = R_AllocParticle( NULL );
	if( !p ) return;

	if( org ) VectorCopy( org, p->org );
	p->die = cl.time + life;
	p->vel[2] += zvel;	// ???
	p->color = color;
}

/*
===============
R_TracerEffect

===============
*/
void GAME_EXPORT R_TracerEffect( const vec3_t start, const vec3_t end )
{
	vec3_t	pos, vel, dir;
	float	len, speed;
	float	offset;

	speed = Q_max( tracerspeed->value, 3.0f );

	VectorSubtract( end, start, dir );
	len = VectorLength( dir );
	if( len == 0.0f ) return;

	VectorScale( dir, 1.0f / len, dir ); // normalize
	offset = COM_RandomFloat( -10.0f, 9.0f ) + traceroffset->value;
	VectorScale( dir, offset, vel );
	VectorAdd( start, vel, pos );
	VectorScale( dir, speed, vel );

	R_AllocTracer( pos, vel, len / speed );
}

/*
===============
R_UserTracerParticle

===============
*/
void GAME_EXPORT R_UserTracerParticle( float *org, float *vel, float life, int colorIndex, float length, byte deathcontext, void (*deathfunc)( particle_t *p ))
{
	particle_t	*p;

	if( colorIndex < 0 )
		return;

	if(( p = R_AllocTracer( org, vel, life )) != NULL )
	{
		p->context = deathcontext;
		p->deathfunc = deathfunc;
		p->color = colorIndex;
		p->ramp = length;
	}
}

/*
===============
R_TracerParticles

allow more customization
===============
*/
particle_t *R_TracerParticles( float *org, float *vel, float life )
{
	return R_AllocTracer( org, vel, life );
}

/*
===============
R_SparkStreaks

create a streak tracers
===============
*/
void GAME_EXPORT R_SparkStreaks( const vec3_t pos, int count, int velocityMin, int velocityMax )
{
	particle_t	*p;
	vec3_t		vel;
	int		i;

	for( i = 0; i<count; i++ )
	{
		vel[0] = COM_RandomFloat( velocityMin, velocityMax );
		vel[1] = COM_RandomFloat( velocityMin, velocityMax );
		vel[2] = COM_RandomFloat( velocityMin, velocityMax );

		p = R_AllocTracer( pos, vel, COM_RandomFloat( 0.1f, 0.5f ));
		if( !p ) return;

		p->color = 5;
		p->type = pt_grav;
		p->ramp = 0.5f;
	}
}

/*
===============
R_Implosion

make implosion tracers
===============
*/
void GAME_EXPORT R_Implosion( const vec3_t end, float radius, int count, float life )
{
	float		dist = ( radius / 100.0f );
	vec3_t		start, temp, vel;
	float		factor;
	particle_t	*p;
	int		i;

	if( life <= 0.0f ) life = 0.1f; // to avoid divide by zero
	factor = -1.0 / life;

	for ( i = 0; i < count; i++ )
	{
		temp[0] = dist * COM_RandomFloat( -100.0f, 100.0f );
		temp[1] = dist * COM_RandomFloat( -100.0f, 100.0f );
		temp[2] = dist * COM_RandomFloat( 0.0f, 100.0f );
		VectorScale( temp, factor, vel );
		VectorAdd( temp, end, start );

		if(( p = R_AllocTracer( start, vel, life )) == NULL )
			return;

		p->type = pt_explode;
	}
}


/*
==============
R_FreeDeadParticles

Free particles that time has expired
==============
*/
void R_FreeDeadParticles( particle_t **ppparticles )
{
	particle_t	*p, *kill;

	// kill all the ones hanging direcly off the base pointer
	while( 1 )
	{
		kill = *ppparticles;
		if( kill && kill->die < cl.time )
		{
			if( kill->deathfunc )
				kill->deathfunc( kill );
			kill->deathfunc = NULL;
			*ppparticles = kill->next;
			kill->next = cl_free_particles;
			cl_free_particles = kill;
			continue;
		}
		break;
	}

	// kill off all the others
	for( p = *ppparticles; p; p = p->next )
	{
		while( 1 )
		{
			kill = p->next;
			if( kill && kill->die < cl.time )
			{
				if( kill->deathfunc )
					kill->deathfunc( kill );
				kill->deathfunc = NULL;
				p->next = kill->next;
				kill->next = cl_free_particles;
				cl_free_particles = kill;
				continue;
			}
			break;
		}
	}
}

/*
===============
CL_ReadPointFile_f

===============
*/
void CL_ReadPointFile_f( void )
{
	byte *afile;
	char *pfile;
	vec3_t		org;
	int		count;
	particle_t	*p;
	char		filename[64];
	string		token;

	Q_snprintf( filename, sizeof( filename ), "maps/%s.pts", clgame.mapname );
	afile = FS_LoadFile( filename, NULL, false );

	if( !afile )
	{
		Con_Printf( S_ERROR "couldn't open %s\n", filename );
		return;
	}

	Con_Printf( "Reading %s...\n", filename );

	count = 0;
	pfile = (char *)afile;

	while( 1 )
	{
		pfile = COM_ParseFile( pfile, token, sizeof( token ));
		if( !pfile ) break;
		org[0] = Q_atof( token );

		pfile = COM_ParseFile( pfile, token, sizeof( token ));
		if( !pfile ) break;
		org[1] = Q_atof( token );

		pfile = COM_ParseFile( pfile, token, sizeof( token ));
		if( !pfile ) break;
		org[2] = Q_atof( token );

		count++;

		if( !cl_free_particles )
		{
			Con_Printf( S_ERROR "not enough free particles!\n" );
			break;
		}

		// NOTE: can't use R_AllocParticle because this command
		// may be executed from the console, while frametime is 0
		p = cl_free_particles;
		cl_free_particles = p->next;
		p->next = cl_active_particles;
		cl_active_particles = p;

		p->ramp = 0;
		p->type = pt_static;
		p->die = cl.time + 99999;
		p->color = (-count) & 15;
		VectorCopy( org, p->org );
		VectorClear( p->vel );
	}

	Mem_Free( afile );

	if( count ) Con_Printf( "%i points read\n", count );
	else Con_Printf( "map %s has no leaks!\n", clgame.mapname );
}

void CL_FreeDeadBeams( void )
{
	BEAM *pBeam, *pNext, *pPrev = NULL;
	// draw temporary entity beams
	for( pBeam = cl_active_beams; pBeam; pBeam = pNext )
	{
		// need to store the next one since we may delete this one
		pNext = pBeam->next;

		// retire old beams
		if( CL_BeamAttemptToDie( pBeam ))
		{
			// reset links
			if( pPrev ) pPrev->next = pNext;
			else cl_active_beams = pNext;

			// free the beam
			R_BeamFree( pBeam );

			pBeam = NULL;
			continue;
		}

		pPrev = pBeam;
	}
}

void CL_DrawEFX( float time, qboolean fTrans )
{
	CL_FreeDeadBeams();
	if( CVAR_TO_BOOL( cl_draw_beams ))
		ref.dllFuncs.CL_DrawBeams( fTrans, cl_active_beams );

	if( fTrans )
	{
		R_FreeDeadParticles( &cl_active_particles );
		if( CVAR_TO_BOOL( cl_draw_particles ))
			ref.dllFuncs.CL_DrawParticles( time, cl_active_particles, PART_SIZE );
		R_FreeDeadParticles( &cl_active_tracers );
		if( CVAR_TO_BOOL( cl_draw_tracers ))
			ref.dllFuncs.CL_DrawTracers( time, cl_active_tracers );
	}
}

void CL_ThinkParticle( double frametime, particle_t *p )
{
	float		time3 = 15.0f * frametime;
	float		time2 = 10.0f * frametime;
	float		time1 = 5.0f * frametime;
	float		dvel = 4.0f * frametime;
	float		grav = frametime * clgame.movevars.gravity * 0.05f;


	if( p->type != pt_clientcustom )
	{
		// update position.
		VectorMA( p->org, frametime, p->vel, p->org );
	}

	switch( p->type )
	{
	case pt_static:
		break;
	case pt_fire:
		p->ramp += time1;
		if( p->ramp >= 6.0f ) p->die = -1.0f;
		else p->color = ramp3[(int)p->ramp];
		p->vel[2] += grav;
		break;
	case pt_explode:
		p->ramp += time2;
		if( p->ramp >= 8.0f ) p->die = -1.0f;
		else p->color = ramp1[(int)p->ramp];
		VectorMA( p->vel, dvel, p->vel, p->vel );
		p->vel[2] -= grav;
		break;
	case pt_explode2:
		p->ramp += time3;
		if( p->ramp >= 8.0f ) p->die = -1.0f;
		else p->color = ramp2[(int)p->ramp];
		VectorMA( p->vel,-frametime, p->vel, p->vel );
		p->vel[2] -= grav;
		break;
	case pt_blob:
		if( p->packedColor == 255 )
		{
			// normal blob explosion
			VectorMA( p->vel, dvel, p->vel, p->vel );
			p->vel[2] -= grav;
			break;
		}
		// intentionally fallthrough
	case pt_blob2:
		if( p->packedColor == 255 )
		{
			// normal blob explosion
			p->vel[0] -= p->vel[0] * dvel;
			p->vel[1] -= p->vel[1] * dvel;
			p->vel[2] -= grav;
		}
		else
		{
			p->ramp += time2;
			if( p->ramp >= 9.0f ) p->ramp = 0.0f;
			p->color = gSparkRamp[(int)p->ramp];
			VectorMA( p->vel, -frametime * 0.5f, p->vel, p->vel );
			p->type = COM_RandomLong( 0, 3 ) ? pt_blob : pt_blob2;
			p->vel[2] -= grav * 5.0f;
		}
		break;
	case pt_grav:
		p->vel[2] -= grav * 20.0f;
		break;
	case pt_slowgrav:
		p->vel[2] -= grav;
		break;
	case pt_vox_grav:
		p->vel[2] -= grav * 8.0f;
		break;
	case pt_vox_slowgrav:
		p->vel[2] -= grav * 4.0f;
		break;
	case pt_clientcustom:
		if( p->callback )
			p->callback( p, frametime );
		break;
	}
}