//This file contains environmental effects for the designers

#include "cg_local.h"
#include "fx_public.h"

extern void G_RadiusDamage ( vec3_t origin, gentity_t *attacker, float damage, float radius,
					 gentity_t *ignore, int mod);
/*
======================
CG_Spark

Creates a spark effect
======================
*/

void CG_Spark( vec3_t origin, vec3_t normal )
{
	FXTrail	*particle;
	vec3_t	dir, direction, start, end;
	vec3_t	velocity, accel;
	float	scale;
	int		numSparks;

	AngleVectors( normal, normal, NULL, NULL );

	for ( int j = 0; j < 3; j ++ )
		normal[j] = normal[j] + (0.15f * crandom());

	VectorNormalize( normal );

	//cgi_S_StartSound( origin, ENTITYNUM_WORLD, CHAN_AUTO, cgi_S_RegisterSound( va( "sound/world/ric%d.wav", (rand() & 2)+1) ) );

	numSparks = 8 + (random() * 4.0f);
	
	scale = 0.2f + (random() *0.4);
	VectorMA( origin, 24.0f + (crandom() * 4.0f), normal, end );

	//One long spark
	FX_AddLine( origin,
				end,
				1.0f,
				scale,
				0.0f,
				1.0f,
				0.25f,
				125.0f,
				cgs.media.sparkShader );
	
	for ( int i = 0; i < numSparks; i++ )
	{	
		scale = 0.2f + (random() *0.4);

		for ( j = 0; j < 3; j ++ )
			dir[j] = normal[j] + (0.25f * crandom());
		
		VectorNormalize(dir);

		VectorMA( origin, 0.0f + ( random() * 2.0f ), dir, start );
		VectorMA( start, 2.0f + ( random() * 16.0f ), dir, end );

		FX_AddLine( start,
					end,
					1.0f,
					scale,
					0.0f,
					1.0f,
					0.25f,
					125.0f,
					cgs.media.sparkShader );
	}

	if ( rand() & 1 )
	{
		numSparks = 1 + (random() * 2.0f);
		for ( i = 0; i < numSparks; i++ )
		{	
			scale = 0.5f + (random() * 0.5f);

			VectorScale( normal, 250, velocity );
			VectorSet( accel, 0, 0, -512 );

			particle = FX_AddTrail( start,
									velocity,
									accel,
									8.0f,
									-32.0f,
									scale,
									-scale,
									1.0f,
									0.5f,
									0.25f,
									700.0f,
									cgs.media.sparkShader,
									FXF_BOUNCE );

		}
	}

	VectorMA( origin, 1, normal, direction );

	scale = 6.0f + (random() * 8.0f);
	float alpha = 0.1 + (random() * 0.4f);

	VectorSet( velocity, 0, 0, 8 );

	FX_AddSprite(	direction, 
					velocity, 
					NULL, 
					scale,
					scale,
					alpha,
					0.0f,
					random()*45.0f,
					0.0f,
					1000.0f,
					cgs.media.steamShader );
}

//------------------------------------------------------------------------------
void SteamThink( vec3_t position, vec3_t dest, vec3_t dir, vec3_t puff_scale )
{
	float	speed = 200;
	vec3_t	direction, facing, color = { 1.0f, 1.0f, 1.0f };
	vec3_t	velocity		= { 0, 0, 128 };
	vec3_t	acceleration	= { 0, 0, 256 };
	float	scale, dscale, len, detail;

	detail = FX_DetailLevel( position, 16, 1024 );

	if (detail == 0)
		return;

	VectorSubtract( dest, position, facing );
	len = VectorNormalize( facing );

	VectorCopy( dir, direction );

	if ( puff_scale[1] )
	{
		VectorSet( color, 0.9f + random() * 0.1f, 0.8f + random() * 0.2f, 0.4f + random() * 0.3f );
	}

	direction[0] += (2.0f + (crandom() * 2.0f));
	direction[1] += (2.0f + (crandom() * 2.0f));
	direction[2] += (2.0f + (crandom() * 2.0f));

	AngleVectors( direction, direction, NULL, NULL );

	VectorScale( direction, speed, velocity );
	VectorScale( velocity, -1.0f, acceleration );

	scale = 8.0f + (random() * 4.0f) * (puff_scale[0] / 10.0f);
	dscale = scale * 8.0 * (puff_scale[0] / 10.0f);

	FX_AddSprite(	position,
					velocity, 
					acceleration, 
					scale, 
					dscale, 
					1.0f, 
					0.0f,
					color,
					color,
					random() * 360,
					0.25f,
					(len / speed) * 1000, 
					cgs.media.steamShader );
}

//void SteamJetThink( vec3_t position, vec3_t dest, vec3_t dir, vec3_t user )
//{
//	FX_AddSpawner( position, dest, dir, NULL, 50, 0, 200 + ( random() * 500 ), (void *) SteamThink );
//}

/*
======================
CG_Steam

Creates a steam effect
======================
*/

void CG_Steam( vec3_t position, vec3_t dest, vec3_t dir, float scale, int flags )
{
	vec3_t user;

	// stuff some extra info into the user field
	user[0] = scale;
	user[1] = (flags & 4);

	if ( (flags & 2) )
	{
		FX_AddSpawner( position, dest, dir, user, 50, 0, 200 + ( random() * 500 ), (void *) SteamThink );
	}
	else
	{
		SteamThink( position, dest, dir, user );
	}
}

/*
======================
CG_CookingSteam

Creates a basic cooking steam effect
======================
*/
void CG_CookingSteam( vec3_t origin, float radius )
{
	vec3_t dir;

	VectorSet( dir, crandom()*2, crandom()*2, crandom() + radius); // always move mostly up
	VectorScale( dir, random() * 5 + 2, dir );

	FX_AddSprite( origin, dir, NULL, radius, radius * 2, 0.4F, 0.0, 0, 0, 1000, cgs.media.steamShader );
}

/*
======================
CG_Bolt

Creates a electricity bolt effect
======================
*/
#define DATA_EFFECTS	0
#define DATA_CHAOS		1
#define DATA_RADIUS		2

void BoltFireback( vec3_t start, vec3_t end, vec3_t velocity, vec3_t user )
{
	FX_AddElectricity( start, end, 1.0, user[DATA_RADIUS], 5.0, 1.0, 0.0, 200, cgs.media.bolt2Shader, 
						(int)user[DATA_EFFECTS], user[DATA_CHAOS] );

	if ( rand() & 1 )
		FX_AddElectricity( end, start, 1.0, user[DATA_RADIUS] * 2, 5.0, 1.0, 0.0, 200, cgs.media.bolt2Shader,
							(int)user[DATA_EFFECTS], user[DATA_CHAOS] );
}

//-----------------------------
void BorgBoltFireback( vec3_t start, vec3_t end, vec3_t velocity, vec3_t user )
{
	FX_AddElectricity( start, end, 1.0, user[DATA_RADIUS], 5.0, 1.0, 0.0, 100, cgs.media.borgLightningShaders[2],
						(int)user[DATA_EFFECTS], user[DATA_CHAOS]  );

	if ( rand() & 1 )
		FX_AddElectricity( end, start, 1.0, user[DATA_RADIUS] * 2, 5.0, 1.0, 0.0, 100, cgs.media.borgLightningShaders[3], 
							(int)user[DATA_EFFECTS], user[DATA_CHAOS] );
}

//-----------------------------
void BlackAndWhiteBoltFireback( vec3_t start, vec3_t end, vec3_t velocity, vec3_t user )
{
	FX_AddElectricity( start, end, 1.0, user[DATA_RADIUS], 5.0, 1.0, 0.0, 100, cgs.media.whiteLaserShader,
						(int)user[DATA_EFFECTS], user[DATA_CHAOS]  );

	if ( rand() & 1 )
		FX_AddElectricity( end, start, 1.0, user[DATA_RADIUS] * 2, 5.0, 1.0, 0.0, 100, cgs.media.whiteLaserShader, 
							(int)user[DATA_EFFECTS], user[DATA_CHAOS] );
}

//-----------------------------
// This looks a bit cheesy
void BoltSparkSpew( vec3_t origin, vec3_t dir, qhandle_t shader )
{
	FXTrail	*particle;

	// Create the sparks
	for ( int i = 0; i < 6; i++ )
	{	
		particle = FX_AddTrail( origin, NULL, NULL, 2.0f + random() * 3, -5.0f,
								0.5, -2.0, 0.3f, 0.0f, 0.25f, 500.0f, shader );
 
		if ( particle == NULL )
			return;

		FXE_Spray( dir, 25, 25, 0.6f, 300 + (rand() & 100), (FXPrimitive *) particle );
	}
}

//-----------------------------
void CG_Bolt( centity_t *cent )
{
	qboolean	borg, bw; // bw = black and white
	int			effects;
	float		chaos, radius;
	
	// Set up all of the parms
	borg = (cent->gent->spawnflags & 8);
	bw = (cent->gent->spawnflags & 64);
	effects = (cent->gent->spawnflags & 16) ? FXF_TAPER : 0;
	effects = (cent->gent->spawnflags & 32) ? (FXF_WRAP | effects) : effects;
	chaos = cent->gent->random;
	radius = cent->gent->radius;

	// Delayed bolt that should "work" a while
	if ( cent->gent->spawnflags & 2 )
	{
		vec3_t data;

		// This sucks, but the spawn function needs some extra bits of info
		data[DATA_EFFECTS] = effects;
		data[DATA_CHAOS] = chaos;
		data[DATA_RADIUS] = radius;

		if ( bw )
		{
			FX_AddSpawner( cent->lerpOrigin, cent->currentState.origin2, NULL, data, 70, random() * 25, 450, 
					(void *) BlackAndWhiteBoltFireback, NULL, 768 );
		}
		else if ( borg )
			FX_AddSpawner( cent->lerpOrigin, cent->currentState.origin2, NULL, data, 70, random() * 25, 450, (void *) BorgBoltFireback, NULL, 768 );
		else
			FX_AddSpawner( cent->lerpOrigin, cent->currentState.origin2, NULL, data, 70, random() * 25, 450, (void *) BoltFireback, NULL, 768 );
	}
	else
	{
		// Continuous bolts
		if ( bw )
		{
			FX_AddElectricity( cent->lerpOrigin, cent->currentState.origin2, 1.0, radius, 5.0, 1.0, 0.0, 200, cgs.media.whiteLaserShader, 
							effects, chaos );

			if ( rand() & 1 )
				FX_AddElectricity( cent->currentState.origin2, cent->lerpOrigin, 1.0, radius * 2, 5.0, 1.0, 0.0, 200, cgs.media.whiteLaserShader,
								effects, chaos );
		}
		else if ( borg )
		{
			FX_AddElectricity( cent->lerpOrigin, cent->currentState.origin2, 1.0, radius, 5.0, 1.0, 0.0, 200, cgs.media.borgLightningShaders[2], 
							effects, chaos );

			if ( rand() & 1 )
				FX_AddElectricity( cent->currentState.origin2, cent->lerpOrigin, 1.0, radius * 2, 5.0, 1.0, 0.0, 200, cgs.media.borgLightningShaders[3], 
								effects, chaos );
		}
		else
		{
			FX_AddElectricity( cent->lerpOrigin, cent->currentState.origin2, 1.0, radius, 5.0, 1.0, 0.0, 200, cgs.media.bolt2Shader, 
							effects, chaos );

			if ( rand() & 1 )
				FX_AddElectricity( cent->currentState.origin2, cent->lerpOrigin, 1.0, radius * 2, 5.0, 1.0, 0.0, 200, cgs.media.bolt2Shader, 
							effects, chaos );
		}
	}

	// Bolt that generates sparks at the impact point
	if ( cent->gent->spawnflags & 4 )
	{
		vec3_t	dir;

		VectorSubtract( cent->lerpOrigin, cent->currentState.origin2, dir );
		VectorNormalize( dir );

		if ( bw )
		{
			BoltSparkSpew( cent->currentState.origin2, dir, cgs.media.waterDropShader );
		}
		else if ( borg )
			BoltSparkSpew( cent->currentState.origin2, dir, cgs.media.borgFlareShader );
		else
			BoltSparkSpew( cent->currentState.origin2, dir, cgs.media.spark2Shader );
	}
}

/*
======================
CG_ForgeBolt

Creates an orange electricity bolt effect with a pulse that travels down the beam
======================
*/

void ForgeBoltFireback( vec3_t start, vec3_t end, vec3_t velocity, vec3_t user )
{
	FX_AddElectricity( start, end, 1.0, user[DATA_RADIUS], 5.0, 1.0, 0.0, 200, cgs.media.pjBoltShader, 
						(int)user[DATA_EFFECTS], user[DATA_CHAOS] );
}

//---------------------------------------------------
bool ForgeBoltPulse( FXPrimitive *fx, centity_t *ent )
{
	vec3_t			origin, new_org;
	trace_t			trace;
	qboolean		remove = qfalse;

	VectorCopy( fx->m_origin, origin );
	fx->UpdateOrigin();
	VectorCopy( fx->m_origin, new_org );

	CG_Trace( &trace, origin, NULL, NULL, new_org, -1, CONTENTS_SOLID );

	if ( trace.fraction < 1.0f && !trace.startsolid && !trace.allsolid )
	{
		// The effect hit something, presumably a barrier, so kill it
		remove = qtrue;
		return false;
	}

	vec3_t		normal, rgb1 ={ 1.0F, 0.5F, 0.4F}, rgb2 ={ 1.0F, 1.0F, 0.3F};//, org;
	FXCylinder	*fxc;

	// Convert the direction of travel in to a normal;
	VectorCopy( fx->m_velocity, normal );
	VectorNormalize( normal );
	VectorScale( normal, -1, normal );

	fxc = FX_AddCylinder( new_org, normal, 16, 0, 16 - random() * 8, 0, 32 + random() * 24, 0, 0.2F, 0.2F, rgb1, rgb1, 1, cgs.media.psychicShader, 0.6F );

	if ( fxc == NULL )
		return false;

	fxc->SetFlags( FXF_WRAP );
	fxc->SetSTScale( Q_irand(1,3) );

	fxc = FX_AddCylinder( new_org, normal, 8, 0, 12 - random() * 8, 0, 24 + random() * 24, 0, 0.2F, 0.2F, rgb2, rgb2, 1, cgs.media.psychicShader, 0.6F );

	if ( fxc == NULL )
		return false;

	fxc->SetFlags( FXF_WRAP );
	fxc->SetSTScale( Q_irand(1,2) );

	return true;
}

//-----------------------------
void CG_ForgeBolt( centity_t *cent )
{
	qboolean	pulse;
	int			effects;
	float		chaos, radius;
	
	// Set up all of the parms
	pulse = (cent->gent->spawnflags & 8) ? qtrue : qfalse;
	effects = (cent->gent->spawnflags & 16) ? FXF_TAPER : 0;
	effects = (cent->gent->spawnflags & 32) ? (FXF_WRAP | effects) : effects;
	chaos = cent->gent->random;
	radius = cent->gent->radius;

	// Delayed bolt that should "work" a while
	if ( cent->gent->spawnflags & 2 )
	{
		vec3_t data;

		// This sucks, but the spawn function needs some extra bits of info
		data[DATA_EFFECTS] = effects;
		data[DATA_CHAOS] = chaos;
		data[DATA_RADIUS] = radius;

		FX_AddSpawner( cent->lerpOrigin, cent->currentState.origin2, NULL, data, 70, random() * 25, 450, (void *) ForgeBoltFireback );
	}
	else
	{
		FX_AddElectricity( cent->lerpOrigin, cent->currentState.origin2, 1.0, radius, 5.0, 1.0, 0.0, 200, cgs.media.pjBoltShader, 
						effects, chaos );

		if ( rand() & 1 )
			FX_AddElectricity( cent->currentState.origin2, cent->lerpOrigin, 1.0, radius * 2, 5.0, 1.0, 0.0, 200, cgs.media.pjBoltShader, 
						effects, chaos );

		if ( cg.time > cent->gent->delay && pulse )
		{
			vec3_t	dir;
			float	amt;

			VectorSubtract( cent->currentState.origin2, cent->lerpOrigin, dir );
			VectorNormalize( dir );
			amt = 200 + random() * 100;
			VectorScale( dir, amt, dir );

			FX_AddParticle( cent, cent->lerpOrigin, dir, NULL, 16, 0.0, 1.0, 1.0,
						0.0, 0.0, 6000, cgs.media.ltblueParticleShader, FXF_NODRAW, ForgeBoltPulse );

			cent->gent->delay = cg.time + 500;
		}
	}

	// Bolt that generates sparks at the impact point
	if ( cent->gent->spawnflags & 4 )
	{
		vec3_t	dir;

		VectorSubtract( cent->lerpOrigin, cent->currentState.origin2, dir );
		VectorNormalize( dir );

		BoltSparkSpew( cent->currentState.origin2, dir, cgs.media.dkorangeParticleShader );
	}
}

/*
======================
CG_PsychoJism

Creates a psycho jism bolt effect
======================
*/

void CG_PsychoJism( vec3_t start, vec3_t end, qboolean open )
{
	vec3_t	dir, rev_dir, angles, pos1, pos2, ofdir, ofang;
	float	len, detail;
	int		i;

	detail = FX_DetailLevel( start, 16, 1024 );	//Technically this needs to find the average or closer...

	// don't draw if we are too far away
	if (detail == 0 || cg_freezeFX.integer)
	{
		return;
	}

	VectorSubtract( end, start, dir );
	len = VectorNormalize( dir );
	VectorScale( dir, -1, rev_dir );
	vectoangles( rev_dir, angles );

	if(open)
	{
		// Calculate a new start 
		VectorCopy( dir, ofdir );
		vectoangles( ofdir, ofang );
		
		ofang[2] = crandom() * 360;

		AngleVectors( ofang, NULL, ofdir, NULL );
		VectorMA( start, len * 0.06f, ofdir, pos1 );

		// Calculate a new end
		VectorMA( end, len * 0.08f, rev_dir, pos2 );
		for ( i=0; i < 3; i++ )
		{
			pos2[i] += crandom() * 2.0f;
		}
	}
	else
	{
		VectorCopy( start, pos1 );
		VectorCopy( end, pos2 );
	}

	FX_AddElectricity( pos1, pos2, 1.0f, 2.0f, 2.0f, 1.0f, 0.0f, 150.0f, cgs.media.pjBoltShader );

	if(!open)
	{
		VectorMA( start, -4, dir, pos1 );
		VectorMA( end, 4, dir, pos2 );
		FX_AddLine( pos2, pos1, 1.0, 2.0, 32.0 * random() + 24.0 , 0.5f, 0.0f, 100.0f, cgs.media.spark3Shader );

		CG_Spark(end, angles);
	}
}

/*
===========================
Plasma

Create directed and scaled plasma jet
===========================
*/

void CG_Plasma( vec3_t start, vec3_t end, vec4_t startRGBA, vec4_t endRGBA )
{
	vec3_t	v, sp, sRGB, eRGB;
	float	detail, len, salpha, ealpha;

	detail = FX_DetailLevel( start, 16, 1200 );
	if ( detail == 0 )
		return;

	salpha = Vector4to3( startRGBA, sRGB );
	ealpha = Vector4to3( endRGBA, eRGB );

	// Orient the plasma
	VectorSubtract( end, start, v );
	len = VectorNormalize( v );
	VectorMA( start, 0.5f, v, sp );

	// Stash a quad at the base to make the effect look a bit more solid
	FX_AddQuad( sp, v, NULL, NULL, len * 0.36f, 0.0f, salpha, salpha, sRGB, sRGB, 0.0f, 45.0f, 0.0f, 200, cgs.media.prifleImpactShader );
	
	// Add a subtle, random flutter to the cone direction
	v[0] += crandom() * 0.04;
	v[1] += crandom() * 0.04;
	v[2] += crandom() * 0.04;
	
	// Wanted the effect to be scalable based on the length of the jet. 
	FX_AddCylinder( start, v, len * 0.05, len * 2.0f, len * 0.16f, len * 0.32f, len * 0.40f, len * 0.64f, 
					salpha, ealpha, sRGB, eRGB, 200, cgs.media.plasmaShader, 0.3f );
	FX_AddCylinder( start, v, len * 0.05, len * 4.0f, len * 0.16f, len * 0.32f, len * 0.28f, len * 0.64f, 
					salpha, ealpha, sRGB, eRGB, 200, cgs.media.plasmaShader, 0.2f );
	FX_AddCylinder( start, v, len * 0.25, len * 8.0f, len * 0.20f, len * 0.32f, len * 0.02f, len * 0.32f, 
					salpha, ealpha, sRGB, eRGB, 200, cgs.media.plasmaShader, 0.1f );
}

/*
===========================
Drip

Create timed drip effect
===========================
*/

bool DripCallback( FXPrimitive *fx, centity_t *ent )
{
	vec3_t	org, dir = {0,0,-1};

	fx->UpdateOrigin();
	fx->UpdateAlpha();
	fx->UpdateRGB();

	VectorMA( fx->m_origin, -1.4, dir, org );
	FX_AddLine( fx->m_origin, org, 1.0, fx->m_scale * 0.75, -(fx->m_scale * 4), fx->m_alpha, 0.0, fx->m_RGB, fx->m_RGB, 
				25, fx->m_shader );

	return true;
}

//------------------------------------------------------------------------------
void DripSplash( vec3_t origin, vec3_t normal, vec3_t work, vec3_t user )
{
	FXTrail		*particle;
	float		detail;

	detail = FX_DetailLevel( origin, 16, 400 );
	if (detail == 0)
		return;

	for ( int i = 0; i < 5; i++ )
	{	
		particle = FX_AddTrail( origin, NULL, NULL, 1.5f, -2.0f, work[0], -work[0],
								work[1], 0, user, user, 0.25f, 350.0f, work[2], rand() & FXF_BOUNCE );

		if ( particle == NULL )
			return;

		FXE_Spray( normal, 60, 50, 0.4f, 512, (FXPrimitive *) particle );
	}
	
	switch( rand() & 3 )
	{
	case 1:
		cgi_S_StartSound( origin, ENTITYNUM_WORLD, CHAN_AMBIENT, cgi_S_RegisterSound( "sound/ambience/waterdrop1.wav") );
		break;
	case 2:
		cgi_S_StartSound( origin, ENTITYNUM_WORLD, CHAN_AMBIENT, cgi_S_RegisterSound( "sound/ambience/waterdrop2.wav") );
		break;
	default:
		cgi_S_StartSound( origin, ENTITYNUM_WORLD, CHAN_AMBIENT, cgi_S_RegisterSound( "sound/ambience/waterdrop3.wav") );
		break;
	}
}

#define DRIP_ACCEL	370.0f

//------------------------------------------------------------------------------
void CG_Drip( vec3_t origin, vec4_t RGBA, float diameter, int thinktime, qhandle_t shader )
{
	FXSpawner	*spawner;
	trace_t		trace;
	vec3_t		vel, accel, end, RGB, work;
	float		grow, alpha, time, dis;

	alpha = Vector4to3( RGBA, RGB );

	// Calc how fast it should grow to reach drop size in the given amount of time
	grow = diameter / (float)((thinktime - cg.time) * 0.001);

	// Growing drop -- never moves
	FX_AddSprite( origin, NULL, NULL, 0.0, grow, alpha, alpha, RGB, RGB, 0.0, 0.0, thinktime - cg.time + cg.frametime, shader, 0 );

	// Ideally, zero should be used for vel...so just use something sufficiently close
	VectorSet( vel, 0, 0, -0.00001f );
	VectorSet( accel, 0, 0, -DRIP_ACCEL );

	// Find out where it will hit
	VectorMA( origin, 4, accel, end );
	gi.trace( &trace, origin, NULL, NULL, end, -1, MASK_SHOT );//ignore

	if ( trace.fraction < 1.0 )
	{
		VectorSubtract( trace.endpos, origin, end );
		dis = VectorNormalize( end );

		time = sqrt( 2  / DRIP_ACCEL * dis ) * 1000;	// Calculate how long the thing will take to travel that distance

		// Falling drop
		FX_AddParticle( NULL, origin, vel, accel, diameter, 0.0, alpha, alpha, RGB, RGB, 0.0, 0.0, time, 
						shader, 0, DripCallback );

		// Ok, so this is a little bit harsh, but all of this info needs to get to the spawner
		VectorSet( work, diameter, alpha, shader );

		spawner = FX_AddSpawner( trace.endpos, trace.plane.normal, work, RGB, time, 0, time + 100, 
									FXF_DELAY_SPAWN | FXF_SPAWN_ONCE, DripSplash, NULL );
	}
	else
	// Falling a long way so just send one that will fall for 2 secs, but don't spawn a splash
	{
		FX_AddSprite( origin, vel, accel, diameter, 0.0, alpha, alpha, RGB, RGB, 0, 0, 2000, shader );
	}
}

/*
======================
CG_ElectricFire

Creates an electric fire effect
======================
*/

void CG_ElectricFire( vec3_t origin, vec3_t normal )
{
	FXTrail	*particle;
	vec3_t	dir, direction, start, end;
	vec3_t	velocity, accel;
	float	scale, alpha;
	int		numSparks;

	AngleVectors( normal, normal, NULL, NULL);

	numSparks = 4 + (random() * 8.0f);
	
	for ( int i = 0; i < numSparks; i++ )
	{	
		scale = 0.3f + (random() *0.4);

		for ( int j = 0; j < 3; j ++ )
			dir[j] = normal[j] + (0.4f * crandom());
		
		VectorNormalize(dir);

		VectorMA( origin, -1.0f + ( random() * 2.0f ), dir, start );
		VectorMA( start, 2.0f + ( random() * 12.0f ), dir, end );

		FX_AddLine( start,
					end,
					1.0f,
					scale,
					0.0f,
					1.0f,
					0.0f,
					75.0f,
					cgs.media.sparkShader );
	}
 
	scale = 0.5f + (random() * 0.5f);

	VectorScale( normal, 300, velocity );
	VectorSet( accel, 0, 0, -600 );

	particle = FX_AddTrail( start,
							velocity,
							accel,
							6.0f,
							-24.0f,
							scale,
							-scale,
							1.0f,
							0.5f,
							0.0f,
							200.0f,
							cgs.media.sparkShader,
							FXF_BOUNCE );

	if ( particle == NULL )
		return;

	FXE_Spray( dir, 200, 200, 0.2f, 300, (FXPrimitive *) particle );

	VectorMA( origin, 1, normal, direction );
	VectorSet( velocity, 0, 0, 8 );

	for ( i = 0; i < 3; i++)
	{
		scale = 6.0f + (random() * 8.0f);
		alpha = 0.1 + (random() * 0.4f);

		FX_AddSprite( direction, 
					velocity, 
					NULL, 
					scale,
					scale,
					alpha,
					0.0,
					random()*45.0f,
					0.0f,
					1000.0f,
					cgs.media.steamShader );

		VectorMA( velocity, 9.0, normal, velocity);
	}
}

/*
======================
CG_Teleporter

persistent teleporter fx for STASIS level
======================
*/

bool teleporter_think( FXPrimitive *fx, centity_t *ent )
{
	vec3_t	angvect;

	// Can generically update these . . even if the entity gets yanked.
	fx->UpdateAlpha();
	fx->UpdateScale();
	fx->UpdateRGB();

	// If the ent was somehow removed, it would be meaningless to continue any further.
	if ( !ent )
		return false;

	// Update the angle of the particle (position on the ellipsoid).
	VectorMA( fx->m_velocity, cg.frametime * 0.001, fx->m_acceleration, fx->m_velocity );

	// Update the actual position of the particle.
	AngleVectors( fx->m_velocity, angvect, NULL, NULL );
	fx->m_origin[0] = (4 * cos(cg.time * 0.004) + 20) * angvect[0] + ent->lerpOrigin[0];
	fx->m_origin[1] = (4 * sin(cg.time * 0.005) + 20) * angvect[1] + ent->lerpOrigin[1];
	fx->m_origin[2] = (4 * sin(cg.time * 0.006) + 30) * angvect[2] + ent->lerpOrigin[2];

	return true;
}

//------------------------------------------------------------------------------
void CG_Teleporter( centity_t *cent )
{
	vec3_t	vel, accel, angvect, org;

	// Velocity is actually the position on the sphere
	vel[ROLL]	= 0;
	vel[YAW]	= random() * 360.0;
	vel[PITCH]	= random() * 360.0;

	// Accel is actually the velocity around the sphere
	accel[ROLL] = 0;
	accel[YAW]	= crandom() * 180;
	accel[PITCH] = crandom() * 45;

	AngleVectors(vel, angvect, NULL, NULL);

	// Set the particle position
	org[0] = (4 * cos(cg.time * 0.004) + 20) * angvect[0] + cent->lerpOrigin[0];
	org[1] = (4 * sin(cg.time * 0.005) + 20) * angvect[1] + cent->lerpOrigin[1];
	org[2] = (4 * sin(cg.time * 0.006) + 30) * angvect[2] + cent->lerpOrigin[2];

	// Use a couple of different kinds to break up the monotony
	if ( rand() & 1 )
	{
		FX_AddParticle( cent, org, vel, accel, 1.0, 0.6f, 1.0, 0.3f,
						0.0, 0.0, 6000, cgs.media.ltblueParticleShader, 0, teleporter_think );
	}
	else
	{
		FX_AddParticle( cent, org, vel, accel, 1.0, 0.6f, 0.7f, 0.3f, 
						0.0, 0.0, 6000, cgs.media.purpleParticleShader, 0, teleporter_think );
	}
}

/*
======================
CG_ParticleStream

particle stream fx for STASIS level
======================
*/

bool particle_stream_think( FXPrimitive *fx, centity_t *ent )
{
	vec3_t old_org;

	// Make it flicker. . .always safe to do this
	fx->m_scale = random() * 12 + 2;
	fx->m_alpha = random() * 0.4 + 0.6;

	// If the ent was somehow removed, we don't want to continue any further.
	if ( !ent )
		return false;

	// Stash the old position so that we can draw a trailer line
	VectorCopy( fx->m_origin, old_org );

	// Update the position of the particle.
	fx->m_origin[0]  = cos(cg.time * 0.01 + fx->m_velocity[0]) * fx->m_velocity[1] + ent->lerpOrigin[0];
	fx->m_origin[1]  = sin(cg.time * 0.01 + fx->m_velocity[0]) * fx->m_velocity[1] + ent->lerpOrigin[1];
	fx->m_origin[2] += (fx->m_velocity[2] * cg.frametime * 0.001);

	FX_AddLine( fx->m_origin, old_org, 1.0f, 2.0f, -4.0f, 0.6f, 0.0, 500, cgs.media.IMOD2Shader );

	return true;
}

//------------------------------------------------------------------------------
void CG_ParticleStream( centity_t *cent )
{
	vec3_t	vel, org, dir;
	float	len, time;

	// This effect will currently only travel directly up or down--never sideways
	VectorSubtract( cent->currentState.origin2, cent->lerpOrigin, dir );
	len = VectorNormalize( dir );

	// since the movement direction is limited, use the velocity var a bit more efficiently
	vel[0] = random() * 360;						// random position around the cylinder
	vel[1] = random() > 0.9  ? 20 : 6;				// random radius
	vel[2] = dir[2] * 120 + dir[2] * random() * 50;	// random velocity (up or down)

	// Set the particle position
	org[0] = cos(cg.time * 0.01 + vel[0]) * vel[1] + cent->lerpOrigin[0];
	org[1] = sin(cg.time * 0.01 + vel[0]) * vel[1] + cent->lerpOrigin[1];
	org[2] = cent->lerpOrigin[2];

	// Calculate how long the thing should live based on it's velocity and the distance it has to travel
	time = len / vel[2] * 1000;

	// Use a couple of different kinds to break up the monotony
	if ( rand() & 1 )
	{
		FX_AddParticle( cent, org, vel, NULL, 16, 0.0, 1.0, 1.0,
						0.0, 0.0, time, cgs.media.ltblueParticleShader, 0, particle_stream_think );
	}
	else
	{
		FX_AddParticle( cent, org, vel, NULL, 16, 0.0, 1.0, 1.0,
						0.0, 0.0, time, cgs.media.purpleParticleShader, 0, particle_stream_think );
	}
}

/*
======================
CG_ElectricalExplosion

Electrical Explosion
======================
*/

void smoke_puffs( vec3_t position, vec3_t dest, vec3_t dir, vec3_t user )
{
	vec3_t direc;

	direc[0] = crandom() * 7;
	direc[1] = crandom() * 7;
	direc[2] = random() * 6 + 8;

	FX_AddSprite( position, direc, NULL, 6.0f, 10.0f, 0.3f, 0.0f, 0.0f, 0.0f, 2200, cgs.media.steamShader );
}

//------------------------------------------------------------------------------
void electric_spark( vec3_t pos, vec3_t normal, vec3_t dir, vec3_t user )
{
	CG_Spark( pos, normal );
}

//------------------------------------------------------------------------------
void CG_ElectricalExplosion( vec3_t start, vec3_t dir, float radius )
{
	localEntity_t	*le;
	FXTrail			*particle;
	vec3_t			pos, temp, angles;
	int				i, numSparks;
	float			scale, dscale;

	// Spawn some delayed smoke
	FX_AddSpawner( start, dir, NULL, NULL, 150, 40, 9000, smoke_puffs );
	vectoangles( dir, angles );
	FX_AddSpawner( start, angles, NULL, NULL, 900, 800, 4000, FXF_DELAY_SPAWN, electric_spark );

	// Create the sparks for the explosion
	numSparks = 46 + (random() * 8.0f);
	 
	for ( i = 0; i < numSparks; i++ )
	{	
		scale = 0.2f + random();
		dscale = -scale*2;

		particle = FX_AddTrail( start,
								NULL,
								NULL,
								8.0f + random() * 6,
								-16.0f,
								scale,
								-scale,
								1.0f,
								0.0f,
								0.25f,
								700.0f,
								cgs.media.spark2Shader );
 
		if ( particle == NULL )
			return;

		FXE_Spray( dir, 200, 200, 0.3f, 500 + (rand() & 300), (FXPrimitive *) particle );
	}

	// Create some initial smoke puffs
	for (i = 0; i < 12; i++)
	{
		VectorCopy( dir, temp );
		temp[0] += crandom() * 0.5f;
		temp[1] += crandom() * 0.5f;
		temp[2] += crandom() * 0.5f;

		VectorMA( start, random() * 16 + 8, temp, pos );
		VectorScale( temp, random() * 4 + 5, temp );

		FX_AddSprite( pos, temp, NULL, 16.0, 3.0f, 1.0f, 0.0f, 0.0f, 0.0f, 2700 + random() * 600, cgs.media.steamShader );
	}

	// Now place a cool explosion model on top
	VectorSubtract( cg.refdef.vieworg, start, dir );
	VectorNormalize( dir );

	le = CG_MakeExplosion( start, dir, cgs.media.explosionModel, 6, cgs.media.electricalExplosionSlowShader, 500, qfalse, radius * 0.01f + ( crandom() * 0.3f)  );
	le->light = 150;
	
	le->refEntity.renderfx |= RF_NOSHADOW;

	VectorSet( le->lightColor, 0.8f, 0.8f, 1.0f );
}

/*
===========================
Laser

Create directed laser shot
===========================
*/

void CG_SmallSpark( vec3_t origin, vec3_t normal )
{
	vec3_t	dir, direction, start, end, velocity;
	float	scale;
	int		numSparks;

	AngleVectors( normal, normal, NULL, NULL );

	for ( int j = 0; j < 3; j ++ )
		normal[j] = normal[j] + (0.1f * crandom());

	VectorNormalize( normal );

	numSparks = 6 + (random() * 4.0f );
	
	for ( int i = 0; i < numSparks; i++ )
	{	
		scale = 0.1f + (random() *0.2f );

		for ( j = 0; j < 3; j ++ )
			dir[j] = normal[j] + (0.7f * crandom());

		VectorMA( origin, 0.0f + ( random() * 0.5f ), dir, start );
		VectorMA( start, 1.0f + ( random() * 1.5f ), dir, end );

		FX_AddLine( start,
					end,
					1.0f,
					scale,
					0.0f,
					1.0f,
					0.7f,
					4.0f,
					cgs.media.sparkShader );
	}

	VectorMA( origin, 1, normal, direction );

	scale = 2.0f + (random() * 3.0f );
	float alpha = 0.6f + (random() * 0.4f );

	VectorSet( velocity, crandom() * 2, crandom() * 2, 8 + random() * 4 );
	VectorMA( velocity, 5, normal, velocity );

	FX_AddSprite(	direction, 
					velocity, 
					NULL, 
					scale,
					scale,
					alpha,
					0.0f,
					random() * 45.0f,
					0.0f,
					1000.0f,
					cgs.media.steamShader );
}

//------------------------------------------------------------------------------
void CG_FireLaser( vec3_t start, vec3_t end, vec3_t normal, vec4_t laserRGB, qboolean hit_ent )
{
	vec3_t	dir, right, up, angles, work, pos,
			sRGB, lRGB;
	float	scale = 1.0f, alpha;
	int		life = 0;

	if ( !(FX_DetailLevel( start, 16, 1200 ) ))
		return;

	// Orient the laser spray
	VectorSubtract( end, start, dir );
	VectorNormalize( dir );
	alpha = Vector4to3( laserRGB, lRGB );

	VectorMA( end, 0.5f, normal, pos );
	MakeNormalVectors( normal, right, up );
	
	VectorSet( sRGB, 1.0f, 0.8f, 0.8f );	

	FX_AddSprite( start, NULL, NULL, 
					1.75f, 1.0f, 
					alpha, 0.0f, 
					lRGB, lRGB, 
					0.0f, 
					0.0f, 
					200, 
					cgs.media.waterDropShader );

	FX_AddLine( start, end, 
					1.0f, 
					3.0f, 5.0f, 
					alpha, 0.0f, 
					lRGB, lRGB, 
					125, 
					cgs.media.whiteLaserShader );

	FX_AddLine( start, end, 
					1.0f, 
					0.3f, 5.0f, 
					random() * 0.4 + 0.4, 0.1f,
					125,
					cgs.media.whiteLaserShader );

	// Doing all of this extra stuff would look weird if it hits a player ent.
	if ( !hit_ent )
	{
		FX_AddQuad( pos, normal, NULL, NULL, 
					3.5f, 1.0f, 
					alpha, 0.0f, 
					lRGB, lRGB, 
					0.0f, 0.0f, 
					0.0f, 
					200, 
					cgs.media.waterDropShader );

		for ( int t=0; t < 2; t ++ )
		{
			VectorMA( pos, crandom() * 0.5f, right, work );
			VectorMA( work, crandom() * 0.5f, up, work );

			scale = crandom() * 0.5f + 1.75f;
			life = crandom() * 300 + 2100;

			VectorSet( sRGB, 1.0f, 0.7f, 0.2f );
			FX_AddQuad( work, normal, NULL, NULL, 
					scale, -0.1f, 
					1.0f, 0.0f, 
					sRGB, sRGB, 
					0, 0, 
					0, 
					life, 
					cgs.media.waterDropShader );
		}

		FX_AddQuad( pos, normal, NULL, NULL, 
					scale * 2.5f, 0.0f, 
					1.0f, 0.0f, 
					0, 0, 
					0, 
					life * 2, 
					cgs.media.smokeShader );
	
		vectoangles( normal, angles );
		CG_SmallSpark( end, angles );
	}
	else
	{
		// However, do add a little smoke puff
		FX_AddSprite( pos, NULL, NULL, 
						2.0f, 1.0f, 
						alpha, 0.0f, 
						lRGB, lRGB, 
						0.0f, 
						0.0f, 
						200, 
						cgs.media.waterDropShader );

		VectorMA( end, 1, normal, dir );
		scale = 1.0f + (random() * 3.0f);

		CG_Smoke( dir, normal, scale, 12.0f, cgs.media.steamShader );
	}
}

//------------------------------------------------------------------------------
void CG_AimLaser( vec3_t start, vec3_t end, vec3_t normal )
{
	vec3_t		lRGB = {1.0,0.0,0.0};

	// Beam
	FX_AddLine( start, end, 
					1.0f, 
					5.5f, 5.0f, 
					random() * 0.2 + 0.2, 0.1f,
					lRGB, lRGB,
					150,
					cgs.media.whiteLaserShader );

	FX_AddLine( start, end, 
					1.0f, 
					0.3f, 5.0f, 
					random() * 0.4 + 0.4, 0.1f,
					125,
					cgs.media.whiteLaserShader );

	// Flare at the start point
	FX_AddSprite( start, NULL, NULL, 
					1.5 + random() * 4, 0.0,
					0.1f,0.0, 
					0.0,
					0.0,
					100,
					cgs.media.borgEyeFlareShader );

	// endpoint flare
	FX_AddSprite( end, NULL, NULL, 
					2.5 + random() * 4, 0.0,
					0.1f,0.0, 
					0.0,
					0.0,
					100,
					cgs.media.borgEyeFlareShader );

	// oriented impact flare
	FX_AddQuad( end, normal, NULL, NULL, 
					1.5 + random() * 2, 0.0, 
					1.0, 0.0, 
					0.0, 0.0, 
					0.0, 
					120, 
					cgs.media.borgEyeFlareShader );
}
	
/*
======================
CG_TransporterStream

particle stream fx for forge level
The particles will accelerate up to the half-way point of the cylinder, then deccelerate til they hit their target
======================
*/

void CG_TransporterStream( centity_t *cent )
{
	vec3_t	vel, accel, dir, pos, right, up;
	float	len, time, acceleration, scale, dis, vf;

	VectorSubtract( cent->currentState.origin2, cent->lerpOrigin, dir );
	len = VectorNormalize( dir );
	MakeNormalVectors( dir, right, up );

	for ( int t=0; t < 3; t++ )
	{
		// Create start offset within a circular radius
		VectorMA( cent->lerpOrigin, 8 * crandom(), right, pos );
		VectorMA( pos, 8 * crandom(), up, pos );

		acceleration = 80 + random() * 50;
		VectorScale( dir, acceleration, accel ); // acceleration vector
		VectorScale( dir, 0.0001, vel );		// Ideally, vel would be zero, so just make it really small

		dis = ( len * 0.8f );					// the two segs will be overlapping to cover up the middle

		// This is derived from dis = (vi)(t)  +  (1/2)(a)(t)^2 where the inital velocity (vi) = zero
		time = sqrt( 2  / acceleration * dis );	// Calculate how long the thing will take to travel that distance
		
		scale = 1.5f + random() * 4;

		// These will spawn at the base and accelerate towards the middle
		if ( rand() & 1 )
		{
			FX_AddSprite( pos, vel, accel, 
						scale, 0.0f, 
						1.0f, 0.0f, 
						0.0f, 
						0.0f, 
						time * 1000, 
						cgs.media.orangeParticleShader );
		}
		else
		{
			FX_AddSprite( pos, vel, accel, 
						scale, 0.0f, 
						1.0f, 0.0f, 
						0.0f, 
						0.0f, 
						time * 1000, 
						cgs.media.dkorangeParticleShader );
		}

		// These will be spawned somewhere in the middle and deccelerate till they reach the end of their target
		VectorMA( pos, len - dis, dir, pos );
		VectorScale( accel, -1, accel );

		vf = sqrt( 2 * dis * acceleration ); // calculate the how fast it would be moving at the end of its path
		VectorScale( dir, vf, vel );		//	this will be the _initial_ velocity for those starting in the middle

		if ( rand() & 1 )
		{
			FX_AddSprite( pos, vel, accel, 
						scale, 0.0f, 
						0.0f, 1.0f, 
						0.0f, 
						0.0f, 
						time * 1000, 
						cgs.media.orangeParticleShader );
		}
		else
		{
			FX_AddSprite( pos, vel, accel, 
						scale, 0.0f, 
						0.0f, 1.0f, 
						0.0f, 
						0.0f, 
						time * 1000, 
						cgs.media.dkorangeParticleShader );
		}
	}
}

/*
-------------------------
CG_Smoke
-------------------------
*/

void CG_Smoke( vec3_t origin, vec3_t dir, float radius, float speed, qhandle_t shader, int flags)
{
	vec3_t	velocity, accel;

	for ( int i = 0; i < 3; i++ )
	{
		velocity[i] = dir[i] + ( 0.2f * crandom());
	}

	VectorScale( velocity, speed, velocity );
	VectorScale( velocity, -0.25f, accel );
	accel[2] = random() * 12.0f + 6.0f;

	FX_AddSprite(	origin,
					velocity, 
					accel, 
					radius + (crandom() * radius * 0.5f ),  
					radius + (crandom() * radius), 
					0.9f + crandom(), 
					0.0f,
					16.0f + random() * 45.0f,
					0.5f,
					2000, 
					shader,
					flags );
}

/*
-------------------------
CG_ExplosionTrail
-------------------------
*/

bool explosionTrailThink( FXPrimitive *fx, centity_t *ent )
{
	localEntity_t	*le=0;
	vec3_t			direction, origin, new_org, angles, dir;
	trace_t			trace;
	float			scale;
	int				i;
	qboolean		remove = qfalse;

	VectorCopy( fx->m_origin, origin );
	fx->UpdateOrigin();
	VectorCopy( fx->m_origin, new_org );

	CG_Trace( &trace, origin, NULL, NULL, new_org, -1, CONTENTS_SOLID );

	if ( trace.fraction < 1.0f && !trace.startsolid && !trace.allsolid )
	{
		// The effect hit something, presumably a barrier, so kill it
		// When the effect gets killed like this, it dies quickly and looks a bit thin.
		// Maybe something else should be done as well...
		remove = qtrue;
		//FIXME: FX_RemoveEffect( fx );
		return false;
	}

	scale = 80 * 0.03f;

	VectorSubtract( new_org, origin, dir );
	VectorNormalize( dir );
	vectoangles( dir, angles );
		
	//Orient the explosions to face the camera
	VectorSubtract( cg.refdef.vieworg, origin, direction );
	VectorNormalize( direction );

	for ( i = 0; i < 3 + (int)remove * 6; i++)
	{
		angles[2] = crandom() * 360;

		AngleVectors( angles, NULL, dir, NULL );
		VectorMA( origin, random() * 50.0f, dir, new_org );

		le = CG_MakeExplosion( new_org, direction, cgs.media.explosionModel, 6, cgs.media.surfaceExplosionShader, 400 + (int)remove * 800, qfalse, random() * 1.0 + 0.8 );//random() * 1.0 + 1.0 );
	}

	le->light = 150;
	VectorSet( le->lightColor, 64, 192, 255 );

	//Shake the camera and damage everything in an area
	CG_ExplosionEffects( origin, 3.0f, 600 );
	G_RadiusDamage( origin, ent->gent, 150, 80, NULL, MOD_UNKNOWN );

	return true;
}

//------------------------------------------------------------------------------
void CG_ExplosionTrail( centity_t *cent )
{
	vec3_t			dir;
	float			len;

	VectorSubtract( cent->currentState.origin2, cent->lerpOrigin, dir );
	len = VectorNormalize( dir );
	VectorScale( dir, 325, dir );

	FX_AddParticle( cent, cent->lerpOrigin, dir, NULL, 16, 0.0, 1.0, 1.0,
						0.0, 0.0, 6000, cgs.media.ltblueParticleShader, FXF_NODRAW, explosionTrailThink );
}

/*
----------------------
CG_BorgEnergyBeam

A scanning type beam
----------------------
*/

void CG_BorgEnergyBeam( centity_t *cent )
{
	vec3_t		normal, angles, base, dir, dir2, rgb;
	float		len, alpha;

	VectorSubtract( cent->currentState.origin2, cent->lerpOrigin, normal );
	len = VectorNormalize( normal );
	vectoangles( normal, angles );
	alpha = Vector4to3( cent->gent->startRGBA, rgb );

/*	// Code to make the thing "snap" when it's doing the beam slices
	if ( abs( cent->gent->pos2[0] ) >= cent->gent->radius )
	{
		// Snap back to start and move to the next slice
		cent->gent->pos2[0] = cent->gent->radius;
		cent->gent->pos2[1] -= ( cg.frametime * 0.0003 * cent->gent->speed );
	}

	// The slice has moved past the end so snap back to the first slice position
	if ( abs( cent->gent->pos2[1] ) >= cent->gent->radius )
	{
		cent->gent->pos2[1] = cent->gent->radius;
	}

	// Always move across the slice
	cent->gent->pos2[0] -= ( cg.frametime * 0.001 * cent->gent->speed );
*/

	if ( cent->gent->spawnflags & 2 )
	{
		// Trace a cone
		angles[2] = cent->gent->angle;
	}

	AngleVectors( angles, NULL, dir, dir2 );

	if ( cent->gent->spawnflags & 2 )
	{
		// Cone
		VectorMA( cent->currentState.origin2, cent->gent->radius, dir, base );
	}
	else
	{
		// Swinging pendulum
		VectorMA( cent->currentState.origin2, cent->gent->radius * ( sin( cent->gent->angle * 0.03f )), dir, base );
		VectorMA( base, cent->gent->radius * ( cos( cent->gent->angle * 0.003f )), dir2, base );
		// Do "snapping" beam slices
//		VectorMA( cent->currentState.origin2, cent->gent->pos2[0], dir, base );
//		VectorMA( base, cent->gent->pos2[1], dir2, base );
	}

	// Main trace laser
	FX_AddLine( cent->lerpOrigin, base, 64, 0.8f, 5.0f, alpha, 0.0, rgb, rgb, 120, cgs.media.whiteLaserShader );
	// Faint trail at base.  Is this really adding anything useful?
	FX_AddLine( cent->gent->pos1, base, 1, 1.0, 2.0, alpha * 0.2, 0.0, rgb, rgb, 1000, cgs.media.whiteLaserShader );
	// Faint trace cone, adds a bit of meat to the effect
	FX_AddTri( cent->lerpOrigin, cent->gent->pos1, base, alpha * 0.2, 0.0, rgb, rgb, 800, cgs.media.solidWhiteShader );
	// Laser impact point
	FX_AddSprite( base, NULL, NULL, random() * 2, 0.0, alpha, 0.0, rgb, rgb, 0.0, 0.0, 100, cgs.media.waterDropShader );

	VectorCopy( base, cent->gent->pos1 );
	cent->gent->angle += cent->gent->speed * 0.08f;
}

/*
----------------------
CG_ShimmeryThing

Creates column or cone of shimmering lines
Kind of looks like a teleporter effect
----------------------
*/

void CG_ShimmeryThing( vec3_t start, vec3_t end, float radius, qboolean taper )
{
	vec3_t	normal, angles, base, top, dir;
	float	len;

	VectorSubtract( end, start, normal );
	len = VectorNormalize( normal );
	vectoangles( normal, angles );

	for ( int i=0; i < 2; i++)
	{
		// Spawn the shards of light around a cylinder
		angles[2] = crandom() * 360;
		AngleVectors( angles, NULL, dir, NULL );

		// See if the effect should be tapered at the top
		if ( taper )
		{
			VectorMA( start, radius * 0.25f, dir, top );
		}
		else
		{
			VectorMA( start, radius, dir, top );
		}

		VectorMA( end, radius, dir, base );

		// Use a couple of different kinds to break up the monotony..
		if ( rand() & 1 )
		{
			FX_AddLine( top, base, 1.0f, len * 0.008f, len * 0.19f, 0.3f, 0.0f, random() * 200 + 600, cgs.media.ltblueParticleShader );
		}
		else
		{
			FX_AddLine( top, base, 1.0f, len * 0.008f, len * 0.19f, 0.2f, 0.0f, random() * 200 + 600, cgs.media.spark2Shader );
		}
	}
}

/*
-------------------------
CG_ShimmeryThing_Spawner
-------------------------
*/

void CG_Shimmer( vec3_t position, vec3_t dest, vec3_t dir, vec3_t other )
{
	CG_ShimmeryThing( position, dest, other[0], (qboolean) other[1] );
}

void CG_ShimmeryThing_Spawner( vec3_t start, vec3_t end, float radius, qboolean taper, int duration )
{
	vec3_t	packed = { radius, (float) taper, 0 };

	FX_AddSpawner( start, end, NULL, packed, 100, 0, duration, (void *) CG_Shimmer, NULL, 512 );
}

/*
----------------------
CG_Borg_Bolt

Yellow bolts that spark when the endpoints get close together
----------------------
*/
void CG_Borg_Bolt( centity_t *cent )
{
	vec3_t	diff, neworg, start, end;
	float	len;

	if (!cent->gent->enemy){
		return;//we lost him
	}
	VectorCopy( cent->gent->enemy->currentOrigin, end );
	
	if ( cent->gent->target2 )
	{
		VectorCopy( cent->gent->chain->currentOrigin, start );
	}
	else
	{
		VectorCopy( cent->lerpOrigin, start );
	}

	// Get the midpoint of the seg
	VectorSubtract( end, start, diff );
	len = VectorNormalize( diff );
	VectorMA( start, len * 0.5, diff, neworg );

	// If the length is pretty short, then spawn a glow spark
	if ( len > 0 && len < 12 )
	{
		int		ct;
		vec3_t	angles, dir;
		FXTrail	*particle;

		FX_AddSprite( neworg, NULL, NULL, random() * (128 / len) + 12, 16.0, 0.6f, 0.0, 0.0, 0.0, 300, 
					cgs.media.yellowParticleShader );

		vectoangles( dir, angles );

		ct = 12 - len;

		// fun sparks
		for ( int t=0; t < ct; t++ )
		{
			angles[1] = random() * 360;
			AngleVectors( angles, dir, NULL, NULL );
			dir[2] = random() * 0.3f;

			particle = FX_AddTrail( neworg, NULL, NULL, 8.0f + random() * 6, -16.0f, 1, -1,
							1.0f, 0.0f, 0.25f, 700.0f, cgs.media.yellowParticleShader );

			if ( particle == NULL )
				return;

			FXE_Spray( dir, 100, 150, 0.5f, 300 + (rand() & 300), (FXPrimitive *) particle );
		}

		// If it's really short, spark and make a noise.  Tried this without the if (len>0... and it was way
		//	too obnoxious
		if ( len <= 5 )
		{
			cgi_S_StartSound( neworg, 0, 0, cgi_S_RegisterSound( "sound/enemies/borg/borgtaser.wav") );
		}
	}

	// Use this to scale down the width of the bolts.  Otherwise, they will look pretty fairly nasty when they
	//	get too short.
	len = len / 32;

	FX_AddElectricity( start, end, 1.0, len, 5.0, 1.0, 0.0, 200, cgs.media.yellowBoltShader );

	if ( rand() & 1 )
	{
		FX_AddElectricity( end, start, 1.0, len, 5.0, 1.0, 0.0, 200, cgs.media.yellowBoltShader );
	}
}


/*
----------------------
CG_StasisTeleporter

New stasis teleporter effect
----------------------
*/
void CG_StasisTeleporter( vec3_t origin, float radius, qboolean exit )
{
	vec3_t		up = { 0,0,1 }, sRGB, eRGB, org;
	float		alpha = sin( cg.time * 0.005 ) * 0.2 + 0.3;
	FXCylinder	*fx;

	if ( exit )
	{
		// these are the exit colors
		VectorSet( sRGB, 0.0f, 0.8f, 1.0f ); // light-blue
		VectorSet( eRGB, 0.0f, 0.0f, 1.0f ); // blue
	}
	else
	{
		// these are the colors for the active type teleporters
		VectorSet( sRGB, 0.5f, 0.2f, 1.0f ); // bluish-purple
		VectorSet( eRGB, 1.0f, 0.0f, 0.4f ); // redish-purple
	}

	// Designers wanted the effects shifted down a bit, but still have the fx entity such that it gets placed so that it sits perfectly
	//	on top of the jump pads for ease of placement.
	VectorCopy( origin, org );
	org[2] -= 16;

	fx = FX_AddCylinder( org, up, 42.0f, 256.0f, 36.0f, 16.0f, 52.0f, 32.0f, alpha, 0.0f, sRGB, eRGB, 100, cgs.media.psychicShader, 0.25f );

	if ( fx == NULL )
		return;
	
	fx->SetSTScale( 1.0f );
	fx->SetFlags( FXF_WRAP );

	if ( exit )
	{
		// We are an exit type teleporter, so skip all of the proximity stuff
		return;
	}

	if ( radius < 256 )
	{
		vec3_t end, mid, vel, accel;
		float scale = ( 256 - radius ) * ( random() * 0.5f + 0.5f );

		VectorMA( origin, 80, up, end );

		FX_AddLine( org, end, 1, 1, scale * 4, 1.0, 0.0, 120, cgs.media.blueParticleShader );

		// take the average of the two points to get the midpoint
		VectorAdd( org, end, mid );
		VectorScale( mid, 0.5f, mid );

		for ( int i = 0; i < 2; i++ )
		{
			VectorSet( vel, crandom(), crandom(), crandom() * 2 );
			VectorScale( vel, random() * 24 + scale * 0.25f, vel );
			VectorScale( vel, -0.2f, accel );

			if ( rand() & 1 )
			{
				FX_AddSprite( mid, vel, accel, scale * 0.1f, scale * -0.2f, 0.3f, 0.0f, 0.0, 0.0, 500, cgs.media.ltblueParticleShader );
			}
			else
			{
				FX_AddSprite( mid, vel, accel, scale * 0.1f, scale * -0.2f, 0.3f, 0.0f, 0.0, 0.0, 500, cgs.media.purpleParticleShader );
			}
		}
	}
}

/*
----------------------
CG_StasisMushrooms

Ambient effect for when 
the stasis mushrooms get used.
----------------------
*/
bool MushroomThink( FXPrimitive *fx, centity_t *ent )
{
	fx->UpdateOrigin();
	fx->UpdateAlpha();
	fx->UpdateRGB();
	fx->UpdateScale();

	for ( int i = 0; i < 3; i++ )
	{
		fx->m_velocity[i] += crandom() * 300.0f * cg.frametime * 0.001f;
	}

	return true;
}

void CG_StasisMushrooms( vec3_t origin, int count )
{
	vec3_t	up, org;
	float	scale, alpha;

	for ( int i = 0; i < count; i++ )
	{
		// Make the thing move mostly up
		VectorSet( up, crandom() * 12.0f, crandom() * 12.0f, random() * 12.0f + 8.0f );
		VectorSet( org, origin[0] + crandom() * 4.0f, origin[1] + crandom() * 4.0f, origin[2] - 4.0f );

		scale = random() + 1.0f;
		alpha = random() * 0.4f + 0.3f;

		// Use a couple of different kinds to break up the monotony
		if ( rand() & 1 )
		{
			FX_AddParticle( NULL, org, up, NULL, scale, -1.0f, alpha, 0.1f, 0.0f, 0.0f, 600 + random() * 600, 
				cgs.media.ltblueParticleShader, 0, MushroomThink );
		}
		else
		{
			FX_AddParticle( NULL, org, up, NULL, scale, -1.0f, alpha, 0.1f, 0.0f, 0.0f, 600 + random() * 600, 
				cgs.media.blueParticleShader, 0, MushroomThink );
		}
	}
}

/*
----------------------
CG_DreadnoughtBeamGlow

Focusing beam effect
----------------------
*/
void CG_DreadnoughtBeamGlow( vec3_t origin, vec3_t normal, float radius )
{
	FX_AddQuad( origin, normal, NULL, NULL, radius + random() * 10, crandom() * 20, 1.0f, 0.1f, random() * 360, crandom() * 20, 0, 300, 
					cgs.media.bigBoomShader );
}

/*
----------------------
CG_MagicSmoke

Smoke effect for reaver
popping out of vats
----------------------
*/

void CG_MagicSmoke( vec3_t origin )
{
	int		i;
	float	v;
	vec3_t	org, vel, accel;

	for ( i = 0; i < 48; i++ )
	{
		org[0] = origin[0] + crandom() * 16;
		org[1] = origin[1] + crandom() * 16;
		org[2] = origin[2] + crandom() * 40;

		VectorSet( vel, crandom(), crandom(), crandom() );
		v = random() * 32 + 32;
		VectorScale( vel, v, vel );

		VectorScale( vel, -3, accel );

		FX_AddSprite( org, vel, accel, random() * 32 + 32, -(random() * 32 + 8), 1.0f, 0.0f, crandom() * 360, 0, random() * 600 + 400, cgs.media.steamShader );
	}
}

void CG_FountainSpurt( vec3_t org )
{
	int			i, t;
	vec3_t		org1, org2, cpt1, cpt2;
	vec3_t		dir, dir2;
	vec3_t		rgb = { 0.4f, 0.7f, 0.8f };
	FXBezier	*fxb;

	// offset table, could have used sin/cos, I suppose
	const float m[][2] = { 
						1, 0,
						0, 1,
						-1, 0,
						0, -1 };

	// The origin shouldn't be in solid, otherwise the ent won't think.  So, place the spawner above
	//	the solid object, then move the spout spawn points down to where they should be.
	org[2] -= 56; // magic number stuff

	// Create four spouts
	for ( i = 0; i < 4; i++ )
	{
		// Move the spout out from the exact center
		VectorCopy( org, org1 );
		org1[0] += 35 * m[i][0];
		org1[1] += 35 * m[i][1];

		// Create our Bezier path control points
		VectorSet( cpt1, 50 * m[i][0], 50 * m[i][1], 0 );
		VectorAdd( org1, cpt1, cpt1 );

		VectorSet( cpt2, 60 * m[i][0], 60 * m[i][1], -78 );
		VectorAdd( org1, cpt2, cpt2 );

		// Create the second endpoint--for now just try and use the last control point 
		VectorCopy( cpt2, org2 );

		// Add the main spout
		fxb = FX_AddBezier( org1, org2, cpt1, cpt2, NULL, NULL, NULL, NULL, 4, 15, 0.5f, 0.3f, 90, 
			cgs.media.fountainShader, FXF_WRAP );

		if ( fxb )
			fxb->SetSTScale( 0.7f );

		// Add a hazy faint spout
		fxb = FX_AddBezier( org1, org2, cpt1, cpt2, NULL, NULL, NULL, NULL, 10, 15, 0.1f, 0.0f, 200, 
			cgs.media.fountainShader, FXF_WRAP );

		if ( fxb )
			fxb->SetSTScale( 0.7f );

		// Create misty bits at the impact point
		VectorSet( dir, crandom(), crandom(), crandom() + 4 ); // always move mostly up
		VectorScale( dir, random() * 3 + 2, dir );
		FX_AddSprite( org2, dir, NULL, 20, -8, 0.3f, 0.0, 0, 0, 600, cgs.media.steamShader );

		// ripple shader
		VectorSet( dir, 0, 0, 1 ); // normal
		VectorSet( dir2, crandom() * 8, crandom() * 8, 0 ); // random drift
		FX_AddQuad( org2, dir, dir2, dir2, 14.0f, 6.0f + random() * 16.0f, 0.2f, 0.0f, 
					crandom() * 50, 0, 0, 800, cgs.media.rippleShader );

		// Spray from nozzle
		for ( t = 0; t < 2; t++ )
		{
			VectorSet( dir, 45 * m[i][0] + crandom() * 12, 45 * m[i][1] + crandom() * 12, crandom() * 16 );
			VectorSet( dir2, -5 * m[i][0], -5 * m[i][1], -95 );
			FX_AddSprite( org1, dir, dir2, 0.9f, 0.0f, 0.7f, 0.1f, rgb, rgb, 0.0f, 0.0f, 400.0f, cgs.media.waterDropShader );
		}

		// Impact splashes
		for ( t = 0; t < 3; t++ )
		{
			VectorCopy( org2, org1 );
			org1[0] += crandom() * 2;
			org1[1] += crandom() * 2;
			VectorSet( dir, m[i][0] * 14 + crandom() * 16, m[i][1] * 14 + crandom() * 16, 50 + random() * 50 );
			VectorSet( dir2, 0, 0, -250 );
			FX_AddSprite( org1, dir, dir2, 1.1f, -0.4f, 0.7f, 0.1f, rgb, rgb, 0.0f, 0.0f, 400.0f, cgs.media.waterDropShader );
		}
	}
}