// cg_effects.c -- these functions generate localentities

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

/*
====================
CG_MakeExplosion
====================
*/
localEntity_t *CG_MakeExplosion( vec3_t origin, vec3_t dir, 
								qhandle_t hModel, int numFrames, qhandle_t shader,
								int msec, qboolean isSprite, float scale, int flags )
{
	float			ang = 0;
	localEntity_t	*ex;
	int				offset;
	vec3_t			tmpVec, newOrigin;

	if ( msec <= 0 ) {
		CG_Error( "CG_MakeExplosion: msec = %i", msec );
	}

	// skew the time a bit so they aren't all in sync
	offset = rand() & 63;

	ex = CG_AllocLocalEntity();
	if ( isSprite ) {
		ex->leType = LE_SPRITE_EXPLOSION; 
		ex->refEntity.rotation = rand() % 360;
		ex->radius = scale;
		VectorScale( dir, 16, tmpVec );
		VectorAdd( tmpVec, origin, newOrigin );
	} else {
		ex->leType = LE_EXPLOSION;
		VectorCopy( origin, newOrigin );

		// set axis with random rotate when necessary
		if ( !dir )
		{
			AxisClear( ex->refEntity.axis );
		}
		else
		{
			if ( !(flags & LEF_NO_RANDOM_ROTATE) )
				ang = rand() % 360;
			VectorCopy( dir, ex->refEntity.axis[0] );
			RotateAroundDirection( ex->refEntity.axis, ang );
		}
	}

	ex->startTime = cg.time - offset;
	ex->endTime = ex->startTime + msec;
	
	// bias the time so all shader effects start correctly
	ex->refEntity.shaderTime = ex->startTime / 1000.0f;

	ex->refEntity.hModel = hModel;
	ex->refEntity.customShader = shader;
	ex->lifeRate = (float)numFrames / msec;
	ex->leFlags = flags;

	//Scale the explosion
	if (scale != 1) {
		ex->refEntity.nonNormalizedAxes = qtrue;

		VectorScale( ex->refEntity.axis[0], scale, ex->refEntity.axis[0] );
		VectorScale( ex->refEntity.axis[1], scale, ex->refEntity.axis[1] );
		VectorScale( ex->refEntity.axis[2], scale, ex->refEntity.axis[2] );
	}
	// set origin
	VectorCopy ( newOrigin, ex->refEntity.origin);
	VectorCopy ( newOrigin, ex->refEntity.oldorigin );

	ex->color[0] = ex->color[1] = ex->color[2] = 1.0;

	return ex;
}

// When calling this version, just pass in a zero for the flags
localEntity_t *CG_MakeExplosion( vec3_t origin, vec3_t dir, 
								qhandle_t hModel, int numFrames, qhandle_t shader,
								int msec, qboolean isSprite, float scale ) {
	return CG_MakeExplosion( origin, dir, hModel, numFrames, shader, msec, isSprite, scale, 0 );
}

/*
====================
CG_AddTempLight
====================
*/
localEntity_t *CG_AddTempLight( vec3_t origin, float scale, vec3_t color, int msec )
{
	localEntity_t	*ex;

	if ( msec <= 0 ) {
		CG_Error( "CG_AddTempLight: msec = %i", msec );
	}

	ex = CG_AllocLocalEntity();

	ex->leType = LE_LIGHT; 

	ex->startTime = cg.time;
	ex->endTime = ex->startTime + msec;
	
	// set origin
	VectorCopy ( origin, ex->refEntity.origin);
	VectorCopy ( origin, ex->refEntity.oldorigin );

	VectorCopy( color, ex->lightColor );
	ex->light = scale;	

	return ex;
}

/*
-------------------------
CG_ExplosionEffects

Used to find the player and shake the camera if close enough
intensity ranges from 1 (minor tremble) to 16 (major quake)
-------------------------
*/

void CG_ExplosionEffects( vec3_t origin, int intensity, int radius)
{
	//FIXME: When exactly is the vieworg calculated in relation to the rest of the frame?s

	vec3_t	dir;
	float	dist, intensityScale;
	float	realIntensity;

	VectorSubtract( cg.refdef.vieworg, origin, dir );
	dist = VectorNormalize( dir );

	//Use the dir to add kick to the explosion

	if ( dist > radius )
		return;

	intensityScale = 1 - ( dist / (float) radius );
	realIntensity = intensity * intensityScale;

	CGCam_Shake( realIntensity, 750 ); // 500 seemed a bit too quick
}


/*
-------------------------
CG_SmokeSpawn
-------------------------
*/

void CG_SmokeSpawn( vec3_t origin, vec3_t normal, vec3_t vel, vec3_t user )
{
	// This function will create directable smoke.
	CG_Smoke( origin, normal, 24.0f, 24.0f, cgs.media.smokeShader, FXF_USE_ALPHA_CHAN );
}

/*
-------------------------
CG_SurfaceExplosion

Adds an explosion to a surface
-------------------------
*/

#define NUM_SPARKS		12
#define NUM_PUFFS		1
#define NUM_EXPLOSIONS	4

void CG_SurfaceExplosion( vec3_t origin, vec3_t normal, float radius, float shake_speed, qboolean smoke )
{
	localEntity_t	*le;
	FXTrail			*particle;
	vec3_t			direction, new_org;
	vec3_t			velocity		= { 0, 0, 0 };
	vec3_t			temp_org, temp_vel;
	float			scale, dscale;
	int				i, numSparks;

	//Sparks
	numSparks = 16 + (random() * 16.0f);
	
	for ( i = 0; i < numSparks; i++ )
	{	
		scale = 0.25f + (random() * 2.0f);
		dscale = -scale*0.5;

		particle = FX_AddTrail( origin,
								NULL,
								NULL,
								32.0f,
								-64.0f,
								scale,
								-scale,
								1.0f,
								0.0f,
								0.25f,
								4000.0f,
								cgs.media.sparkShader,
								rand() & FXF_BOUNCE);

		if ( particle == NULL )
			return;

		FXE_Spray( normal, 500, 150, 1.0f, 768 + (rand() & 255), (FXPrimitive *) particle );
	}

	//Smoke
	//Move this out a little from the impact surface
	VectorMA( origin, 4, normal, new_org );
	VectorSet( velocity, 0.0f, 0.0f, 16.0f );

	for ( i = 0; i < 4; i++ )
	{
		VectorSet( temp_org, new_org[0] + (crandom() * 16.0f), new_org[1] + (crandom() * 16.0f), new_org[2] + (random() * 4.0f) );
		VectorSet( temp_vel, velocity[0] + (crandom() * 8.0f), velocity[1] + (crandom() * 8.0f), velocity[2] + (crandom() * 8.0f) );

		FX_AddSprite(	temp_org,
						temp_vel, 
						NULL, 
						64.0f + (random() * 32.0f), 
						16.0f, 
						1.0f, 
						0.0f,
						20.0f + (crandom() * 90.0f),
						0.5f,
						1500.0f, 
						cgs.media.smokeShader, FXF_USE_ALPHA_CHAN );
	}

	//Core of the explosion

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

	//Tag the last one with a light
	le = CG_MakeExplosion( origin, direction, cgs.media.explosionModel, 6, cgs.media.surfaceExplosionShader, 500, qfalse, radius * 0.02f + (random() * 0.3f) );
	le->light = 150;
	VectorSet( le->lightColor, 0.9f, 0.8f, 0.5f );

	for ( i = 0; i < NUM_EXPLOSIONS-1; i ++)
	{
		VectorSet( new_org, (origin[0] + (16 + (crandom() * 8))*crandom()), (origin[1] + (16 + (crandom() * 8))*crandom()), (origin[2] + (16 + (crandom() * 8))*crandom()) );
		le = CG_MakeExplosion( new_org, direction, cgs.media.explosionModel, 6, cgs.media.surfaceExplosionShader, 300 + (rand() & 99), qfalse, radius * 0.05f + (crandom() *0.3f) );
	}

	//Shake the camera
	CG_ExplosionEffects( origin, shake_speed, 350 );

	// The level designers wanted to be able to turn the smoke spawners off.  The rationale is that they
	//	want to blow up catwalks and such that fall down...when that happens, it shouldn't really leave a mark
	//	and a smoke spewer at the explosion point...
	if ( smoke )
	{
		VectorMA( origin, -8, normal, temp_org );
		FX_AddSpawner( temp_org, normal, NULL, NULL, 100, random()*25.0f, 5000.0f, (void *) CG_SmokeSpawn );

		//Impact mark
		//FIXME: Replace mark
		//CG_ImpactMark( cgs.media.burnMarkShader, origin, normal, random()*360, 1,1,1,1, qfalse, 8, qfalse );
	}
}

/*
-------------------------
CG_MiscModelExplosion

Adds an explosion to a misc model breakables
-------------------------
*/

void CG_MiscModelExplosion( vec3_t origin, vec3_t normal )
{
	localEntity_t	*le;
	FXTrail			*particle;
	vec3_t			direction, new_org;
	vec3_t			velocity		= { 0, 0, 0 };
	vec3_t			temp_org, temp_vel;
	float			scale, dscale;
	int				i, numSparks;

	//Sparks
	numSparks = 8 + (random() * 8.0f);
	
	for ( i = 0; i < numSparks; i++ )
	{	
		scale = 0.25f + (random() * 2.0f);
		dscale = -scale*0.5;

		particle = FX_AddTrail( origin,
								NULL,
								NULL,
								32.0f,
								-64.0f,
								scale,
								-scale,
								1.0f,
								0.0f,
								0.25f,
								4000.0f,
								cgs.media.sparkShader,
								rand() & FXF_BOUNCE);

		if ( particle == NULL )
			return;

		FXE_Spray( normal, 500, 150, 1.0f, 768 + (rand() & 255), (FXPrimitive *) particle );
	}

	//Smoke
	//Move this out a little from the impact surface
	VectorMA( origin, 4, normal, new_org );
	VectorScale( normal, -16, velocity );

	for ( i = 0; i < 3; i++ )
	{
		VectorSet( temp_org, new_org[0] + (crandom() * 8.0f), new_org[1] + (crandom() * 8.0f), new_org[2] + (random() * 8.0f) );
		VectorSet( temp_vel, velocity[0] + (crandom() * 16.0f), velocity[1] + (crandom() * 16.0f), velocity[2] + (crandom() * 16.0f) );

		FX_AddSprite(	temp_org,
						temp_vel, 
						NULL, 
						16.0f + (random() * 16.0f), 
						8.0f, 
						1.0f, 
						0.0f,
						20.0f + (crandom() * 90.0f),
						0.5f,
						1000.0f + random() * 1000.0f, 
						cgs.media.smokeShader, FXF_USE_ALPHA_CHAN );
	}

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

	//Tag the last one with a light
	le = CG_MakeExplosion( origin, direction, cgs.media.explosionModel, 6, cgs.media.surfaceExplosionShader, 500, qfalse, 0.7 + crandom() * 0.3f );
	le->light = 150;
	VectorSet( le->lightColor, 0.9f, 0.8f, 0.5f );

//	for ( i = 0; i < 2; i ++)
	{
		VectorSet( new_org, origin[0] + crandom() * 16, origin[1] + crandom() * 16, origin[2] + crandom() * 16 );
		le = CG_MakeExplosion( new_org, direction, cgs.media.explosionModel, 6, cgs.media.surfaceExplosionShader, 300 + (rand() & 99), qfalse, 0.7 + crandom() *0.3f );
	}
}

/*
-------------------------
CG_Chunks

Fun chunk spewer
-------------------------
*/

void CG_Chunks( int owner, vec3_t origin, const vec3_t normal, float speed, int numChunks, material_t chunkType, int customChunk, float baseScale )
{
	localEntity_t	*le;
	refEntity_t		*re;
	vec3_t			dir;
	int				i, j, k;
	int				chunkModel=0, chunkSound;
	qboolean		chunk = qfalse;

	switch(chunkType)
	{
	case MAT_METAL:
	case MAT_BORG:
		// FIXME: Precache sounds?
		chunkSound = cgs.media.borgChunkSound;
		break;
	case MAT_GLASS:
		chunkSound = cgs.media.glassChunkSound;
		break;
	case MAT_GLASS_METAL:
		chunkSound = cgs.media.chunkSound;
		break;
	case MAT_ELECTRICAL:// (sparks)
		cgi_S_StartSound (NULL, owner, CHAN_BODY, cgi_S_RegisterSound (va("sound/ambience/spark%d.wav", Q_irand(1, 6))) );
		vectoangles(normal, dir);
		CG_Spark( origin, dir );
		return;
		break;
	case MAT_ORGANIC:// (not implemented)
	case MAT_STASIS:
		chunkSound = cgs.media.stasisChunkSound;
		break;
	default:
		//Invalid material?  Assume MAT_METAL?
		CG_Error( "CG_Chunks: Invalid chunk type" );
		return;
		break;
	}

	if(baseScale <= 0)
	{
		baseScale = 1;
	}

	//FIXME: LOD
	//Chunks
	for ( i = 0; i < numChunks; i++ )
	{
		if ( customChunk > 0 )
		{
			// Try to use a custom chunk.
			if ( cgs.model_draw[customChunk] )
			{
				chunk = qtrue;
				chunkModel = cgs.model_draw[customChunk];
			}
		}

		if ( !chunk )
		{
			// No custom chunk.  Pick a random chunk type at run-time so we don't get the same chunks
			switch( chunkType )
			{
			case MAT_GLASS:
				chunkModel = cgs.media.glassChunkModels[0][Q_irand(0, 5)];
				break;
			case MAT_ORGANIC:
				// FIXME: These are actually metal chunks.
				chunkModel = cgs.media.chunkModels[0][Q_irand(0, 5)];
				break;
			case MAT_BORG:
				chunkModel = cgs.media.borgChunkModels[0][Q_irand(0, 2)];
				break;
			case MAT_STASIS:
				chunkModel = cgs.media.stasisChunkModels[0][Q_irand(0, 3)];
				break;
			case MAT_GLASS_METAL:
				// Do some random chunk types
				if ( rand() & 1 )
				{
					chunkModel = cgs.media.glassChunkModels[0][Q_irand(0, 5)];
				}
				else
				{
					chunkModel = cgs.media.chunkModels[0][Q_irand(0, 5)];
				}
				break;
			default:
				// Metal chunks, etc..
				chunkModel = cgs.media.chunkModels[0][Q_irand(0, 5)];
				break;
			}
		}

		le = CG_AllocLocalEntity();
		re = &le->refEntity;

		le->leType = LE_FRAGMENT;
		le->endTime = cg.time + 2000;

		VectorCopy( origin, re->origin );

		for ( j = 0; j < 3; j++ )
		{
			re->origin[j] += crandom() * 12;
		}
		VectorCopy( re->origin, le->pos.trBase );

		//Velocity
		for ( j = 0; j < 3; j ++ )
		{
			dir[j] = normal[j] + Q_flrand(-0.8f, 0.8f);
		}

//		VectorNormalize(dir);
		VectorScale( dir, Q_flrand( speed * 0.25f, speed * 1.75f ), le->pos.trDelta );

		//Angular Velocity
		VectorSet( le->angles.trBase, Q_flrand(0, 360), Q_flrand(0, 360), Q_flrand(0, 360) );
		for ( j = 0; j < 3; j ++ )
		{
			le->angles.trDelta[j] = Q_flrand(-24.0f, 24.0f);
		}

		VectorNormalize(le->angles.trDelta);
		VectorScale( le->angles.trDelta, Q_flrand(200.0f, 800.0f), le->angles.trDelta );

		AxisCopy( axisDefault, re->axis );

		le->radius = Q_flrand(baseScale * 0.7f, baseScale * 1.3f );

		re->nonNormalizedAxes = qtrue;
		re->hModel = chunkModel;
		
		le->pos.trType = TR_GRAVITY;
		le->pos.trTime = cg.time;
		le->angles.trType = TR_INTERPOLATE;
		le->angles.trTime = cg.time;
		le->bounceFactor = 0.2f + random() * 0.2f;
		le->leFlags |= LEF_TUMBLE;
		le->ownerGentNum = owner;

		// Make sure that we have the desired start size set
		for( k = 0; k < 3; k++)
		{
			VectorScale(le->refEntity.axis[k], le->radius, le->refEntity.axis[k]);
		}
	}

	//Sound
	cgi_S_StartSound( origin, ENTITYNUM_WORLD, CHAN_AUTO, chunkSound );
}

void CG_EnergyGibs( int owner, vec3_t origin )
{
	localEntity_t	*le;
	refEntity_t		*re;
	vec3_t			dir;
	int				i, j, k;
	int				chunkModel=0;
	float			baseScale = 0.7f;
	int				numChunks = Q_irand( 13, 20 );//FIXME: LOD

	for ( i = 0; i < numChunks; i++ )
	{
		if ( rand() & 1 )
		{
			chunkModel = cgs.media.glassChunkModels[0][Q_irand(0, 5)];
		}
		else
		{
			chunkModel = cgs.media.chunkModels[0][Q_irand(0, 5)];
		}

		le = CG_AllocLocalEntity();
		re = &le->refEntity;

		le->leType = LE_FRAGMENT;
		le->endTime = cg.time + 2000;

		VectorCopy( origin, re->origin );

		for ( j = 0; j < 3; j++ )
		{
			re->origin[j] += crandom() * 12;
		}
		VectorCopy( re->origin, le->pos.trBase );

		//Velocity
		VectorSet( dir, crandom(), crandom(), crandom() );
		VectorScale( dir, Q_flrand( 300, 500 ), le->pos.trDelta );

		//Angular Velocity
		VectorSet( le->angles.trBase, crandom() * 360, crandom() * 360, crandom() * 360 );
		VectorSet( le->angles.trDelta, crandom() * 90, crandom() * 90, crandom() * 90 );

		AxisCopy( axisDefault, re->axis );

		le->radius = Q_flrand(baseScale * 0.7f, baseScale * 1.3f );

		re->nonNormalizedAxes = qtrue;
		re->hModel = chunkModel;
		re->customShader = cgs.media.quantumDisruptorShader;
		re->shaderTime = cg.time/1000.0f;
		
		le->pos.trType = TR_GRAVITY;
		le->pos.trTime = cg.time;
		le->angles.trType = TR_INTERPOLATE;
		le->angles.trTime = cg.time;
		le->bounceFactor = 0.3f + random() * 0.3f;
		le->leFlags |= LEF_TUMBLE;
		le->ownerGentNum = owner;

		re->shaderRGBA[0] = re->shaderRGBA[1] = re->shaderRGBA[2] = re->shaderRGBA[3] = 255;

		// Make sure that we have the desired start size set
		for( k = 0; k < 3; k++)
		{
			VectorScale(le->refEntity.axis[k], le->radius, le->refEntity.axis[k]);
		}
	}
}