/*
* CG_AllocModel
*/
static lentity_t *CG_AllocModel( letype_t type, const vec3_t origin, const vec3_t angles, int frames,
float r, float g, float b, float a, float light, float lr, float lg, float lb, struct model_s *model, struct shader_s *shader )
{
lentity_t *le;
le = CG_AllocLocalEntity( type, r, g, b, a );
le->frames = frames;
le->light = light;
le->lightcolor[0] = lr;
le->lightcolor[1] = lg;
le->lightcolor[2] = lb;
le->ent.rtype = RT_MODEL;
le->ent.renderfx = RF_NOSHADOW;
le->ent.model = model;
le->ent.customShader = shader;
le->ent.shaderTime = cg.time;
le->ent.scale = 1.0f;
VectorCopy( angles, le->angles );
AnglesToAxis( angles, le->ent.axis );
VectorCopy( origin, le->ent.origin );
return le;
}
/*
====================
CG_MakeExplosion
====================
*/
localEntity_t *CG_MakeExplosion( vec3_t origin, vec3_t dir,
qhandle_t hModel, qhandle_t shader,
int offset, int duration, bool isSprite )
{
float ang;
localEntity_t *ex;
vec3_t tmpVec, newOrigin;
if ( duration <= 0 ) {
Com_Error( ERR_DROP, "CG_MakeExplosion: duration = %i", duration );
}
// 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;
// randomly rotate sprite orientation
ex->refEntity.rotation = rand() % 360;
VectorScale( dir, 16, tmpVec );
VectorAdd( tmpVec, origin, newOrigin );
}
else
{
ex->leType = LE_EXPLOSION;
VectorCopy( origin, newOrigin );
// set axis with random rotate
if ( !dir )
{
AxisClear( ex->refEntity.axis );
} else
{
ang = rand() % 360;
VectorCopy( dir, ex->refEntity.axis[0] );
RotateAroundDirection( ex->refEntity.axis, ang );
}
}
// calc the timings
ex->startTime = cg.time + offset;
ex->endTime = ex->startTime + duration;
// bias the time so all shader effects start correctly
ex->refEntity.shaderTime = ex->startTime / 1000.0f;
ex->refEntity.hModel = hModel;
ex->refEntity.customShader = shader;
// set origin
VectorCopy( newOrigin, ex->refEntity.origin );
VectorCopy( newOrigin, ex->refEntity.oldorigin );
ex->color[0] = ex->color[1] = ex->color[2] = 1;
return ex;
}
/*
==================
CG_NukeEffect
==================
*/
void CG_NukeEffect( centity_t * cent, entityState_t * es ) {
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
le->leFlags = 0;
le->leType = LE_NUKE;
le->startTime = cg.time;
le->endTime = cg.time + NUKE_CLOUD_ENDTIME;// 3000;//2250;
le->lifeRate = 1.0 / ( le->endTime - le->startTime );
le->color[0] = le->color[1] = le->color[2] = le->color[3] = 1.0;
VectorClear(le->angles.trBase);
re = &le->refEntity;
re->radius = availableWeapons[es->weaponIndex].damageRadius;
re->reType = RT_MODEL;
re->shaderTime = cg.time / 1000.0f;
re->hModel = cgs.media.nukeEffectModel;
VectorCopy( cent->lerpOrigin, re->origin );
//CG_NukeCloud(cent, es);
}
/*
==================
CG_LaunchGib
==================
*/
void CG_LaunchGib( vec3_t origin, vec3_t velocity, qhandle_t hModel ) {
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
re = &le->refEntity;
le->leType = LE_FRAGMENT;
le->startTime = cg.time;
le->endTime = le->startTime + 5000 + random() * 3000;
VectorCopy( origin, re->origin );
AxisCopy( axisDefault, re->axis );
re->hModel = hModel;
le->pos.trType = TR_GRAVITY;
VectorCopy( origin, le->pos.trBase );
VectorCopy( velocity, le->pos.trDelta );
le->pos.trTime = cg.time;
le->bounceFactor = 0.6f;
le->leBounceSoundType = LEBS_BLOOD;
le->leMarkType = LEMT_BLOOD;
if ( cg_leiSuperGoreyAwesome.integer ) {
CG_SpurtBlood( origin, velocity, 7); // LEILEI toss some extra juice
CG_SpurtBlood( origin, velocity, 22);
CG_SpurtBlood( origin, velocity, 11);
}
}
/*
==================
CG_SpawnEffect
Player teleporting in or out
==================
*/
void CG_SpawnEffect( bvec3_t org ) {
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
le->leFlags = 0;
le->leType = LE_FADE_RGB;
le->startTime = cg.time;
le->endTime = cg.time + 500;
le->lifeRate = FIXED_INT32RATIO_G(1,( le->endTime - le->startTime ));
le->color[0] = le->color[1] = le->color[2] = le->color[3] = GFIXED_1;
re = &le->refEntity;
re->reType = RT_MODEL;
re->shaderTime = MSECTIME_G(cg.time);
#ifndef MISSIONPACK
re->customShader = cgs.media.teleportEffectShader;
#endif
re->hModel = cgs.media.teleportEffectModel;
AxisClear( re->axis );
VectorCopy( org, re->origin );
#ifdef MISSIONPACK
re->origin[2] += BFIXED(16,0);
#else
re->origin[2] -= BFIXED(24,0);
#endif
}
/*
==================
CG_InvulnerabilityJuiced
==================
*/
void CG_InvulnerabilityJuiced( vec3_t org ) {
localEntity_t *le;
refEntity_t *re;
vec3_t angles;
le = CG_AllocLocalEntity();
le->leFlags = 0;
le->leType = LE_INVULJUICED;
le->startTime = cg.time;
le->endTime = cg.time + 10000;
le->lifeRate = 1.0 / ( le->endTime - le->startTime );
le->color[0] = le->color[1] = le->color[2] = le->color[3] = 1.0;
re = &le->refEntity;
re->reType = RT_MODEL;
re->shaderTime = cg.time / 1000.0f;
re->hModel = cgs.media.invulnerabilityJuicedModel;
VectorCopy( org, re->origin );
VectorClear(angles);
AnglesToAxis( angles, re->axis );
trap_S_StartSound (org, ENTITYNUM_NONE, CHAN_BODY, cgs.media.invulnerabilityJuicedSound );
}
/*
==================
CG_SpawnEffect
Player teleporting in or out
RPG-X: RedTechie Added refEntity_t *ent_legs, refEntity_t *ent_torso, refEntity_t *ent_head
==================
*/
void CG_SpawnEffect( vec3_t org, refEntity_t *ent_legs, refEntity_t *ent_torso, refEntity_t *ent_head ) {
localEntity_t *le;
refEntity_t *re;
FX_Transporter(org);
le = CG_AllocLocalEntity();
le->leFlags = 0;
le->leType = LE_FADE_RGB;
le->startTime = cg.time;
le->endTime = cg.time + 500;
le->lifeRate = 1.0 / ( le->endTime - le->startTime );
le->color[0] = le->color[1] = le->color[2] = le->color[3] = 1.0;
re = &le->refEntity;
//RPG-X: RedTechie - Playing with transporter crap
re->shaderTime = cg.time * 0.001f;
re = &le->refEntity;
re->reType = RT_MODEL;
re->shaderTime = cg.time * 0.001f;
re->customShader = cgs.media.teleportEffectShader;
re->hModel = cgs.media.teleportEffectModel;
AxisClear( re->axis );
VectorCopy( org, re->origin );
re->origin[2] -= 24;
}
/*
==================
CG_LaunchRocketSpark
==================
*/
void CG_LaunchRocketSpark( vec3_t origin, vec3_t velocity ) {
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
re = &le->refEntity;
le->leType = LE_FRAGMENT;
le->startTime = cg.time;
le->endTime = le->startTime + 4000;
VectorCopy( origin, re->origin );
AxisCopy( axisDefault, re->axis );
re->hModel = cgs.media.nullModel;
// re->reType = RT_SPRITE;
le->pos.trType = TR_GRAVITY;
VectorCopy( origin, le->pos.trBase );
VectorCopy( velocity, le->pos.trDelta );
le->pos.trTime = cg.time;
le->bounceFactor = 0.5;
// re->radius = 16;
// le->radius = 1;
le->leBounceSoundType = LEBS_SPARK;
// le->leMarkType = LEMT_BLOOD;
}
/*
==================
CG_ThrowChunk
==================
*/
void CG_ThrowChunk( vec3_t origin, vec3_t velocity, qhandle_t hModel, int optionalSound, int startalpha ) {
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
re = &le->refEntity;
le->leType = LE_FRAGMENT;
le->startTime = cg.time;
le->endTime = le->startTime + 5000 + random() * 3000;
VectorCopy( origin, re->origin );
AxisCopy( axisDefault, re->axis );
re->hModel = hModel;
le->pos.trType = TR_GRAVITY;
le->angles.trType = TR_GRAVITY;
VectorCopy( origin, le->pos.trBase );
VectorCopy( velocity, le->pos.trDelta );
VectorSet(le->angles.trBase, 20, 20, 20);
VectorCopy( velocity, le->angles.trDelta );
le->pos.trTime = cg.time;
le->angles.trTime = cg.time;
le->leFlags = LEF_TUMBLE;
le->angles.trBase[YAW] = 180;
le->bounceFactor = 0.3f;
le->bounceSound = optionalSound;
le->forceAlpha = startalpha;
}
/*
==================
CG_Bubble
Bullets shot underwater
==================
*/
void CG_Bubble( vec3_t start, vec3_t velocity, int time, float radius, float alpha ) {
localEntity_t *le;
refEntity_t *re;
// advance a random amount first
le = CG_AllocLocalEntity();
le->leFlags = LEF_PUFF_DONT_SCALE;
le->leType = LE_MOVE_SCALE_FADE;
le->startTime = cg.time;
le->endTime = cg.time + time + random() * 250;
le->lifeRate = 1.0 / ( le->endTime - le->startTime );
re = &le->refEntity;
re->shaderTime = cg.time / 1000.0f;
re->reType = RT_SPRITE;
re->rotation = 0;
re->radius = radius;
re->customShader = cgs.media.waterBubbleShader;
re->shaderRGBA[0] = 0xff;
re->shaderRGBA[1] = 0xff;
re->shaderRGBA[2] = 0xff;
re->shaderRGBA[3] = 0xff;
le->color[3] = alpha;
le->pos.trType = TR_LINEAR;
le->pos.trTime = cg.time;
VectorCopy( start, le->pos.trBase );
VectorScale( velocity, 150 + test_h.value, le->pos.trDelta );
}
/*
==================
CG_SpawnEffect
Player teleporting in or out
==================
*/
void CG_SpawnEffect(vec3_t org)
{
localEntity_t *le;
refEntity_t *re;
return; // (SA) don't play spawn in effect right now
le = CG_AllocLocalEntity();
le->leFlags = 0;
le->leType = LE_FADE_RGB;
le->startTime = cg.time;
le->endTime = cg.time + 500;
le->lifeRate = 1.0 / (le->endTime - le->startTime);
le->color[0] = le->color[1] = le->color[2] = le->color[3] = 1.0;
re = &le->refEntity;
re->reType = RT_MODEL;
re->shaderTime = cg.time / 1000.0f;
re->customShader = cgs.media.teleportEffectShader;
re->hModel = cgs.media.teleportEffectModel;
AxisClear(re->axis);
VectorCopy(org, re->origin);
re->origin[2] -= 24;
}
/*
==============
CG_SparklerSparks
==============
*/
void CG_SparklerSparks( vec3_t origin, int count ) {
// these effect the look of the, umm, effect
int FUSE_SPARK_LIFE = 100;
int FUSE_SPARK_LENGTH = 30;
// these are calculated from the above
int FUSE_SPARK_SPEED = ( FUSE_SPARK_LENGTH * 1000 / FUSE_SPARK_LIFE );
int i;
localEntity_t *le;
refEntity_t *re;
for ( i = 0; i < count; i++ ) {
// spawn the spark
le = CG_AllocLocalEntity();
re = &le->refEntity;
le->leType = LE_FUSE_SPARK;
le->startTime = cg.time;
le->endTime = cg.time + FUSE_SPARK_LIFE;
le->lastTrailTime = cg.time;
VectorCopy( origin, re->origin );
le->pos.trType = TR_GRAVITY;
VectorCopy( origin, le->pos.trBase );
VectorSet( le->pos.trDelta, crandom(), crandom(), crandom() );
VectorNormalize( le->pos.trDelta );
VectorScale( le->pos.trDelta, FUSE_SPARK_SPEED, le->pos.trDelta );
le->pos.trTime = cg.time;
}
}
/*
==================
CG_LaunchGib
==================
*/
void CG_LaunchExplode( vec3_t origin, vec3_t velocity, qhandle_t hModel ) {
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
re = &le->refEntity;
le->leType = LE_FRAGMENT;
le->startTime = cg.time;
le->endTime = le->startTime + 10000 + random() * 6000;
VectorCopy( origin, re->origin );
AxisCopy( axisDefault, re->axis );
re->hModel = hModel;
le->pos.trType = TR_GRAVITY;
VectorCopy( origin, le->pos.trBase );
VectorCopy( velocity, le->pos.trDelta );
le->pos.trTime = cg.time;
le->bounceFactor = 0.1f;
le->leBounceSoundType = LEBS_BRASS;
le->leMarkType = LEMT_NONE;
}
/*
==================
CG_LaunchGib
==================
*/
void CG_LaunchGib( vector3 *origin, vector3 *velocity, qhandle_t hModel ) {
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
re = &le->refEntity;
le->leType = LE_FRAGMENT;
le->startTime = cg.time;
le->endTime = le->startTime + 5000 + random() * 3000;
VectorCopy( origin, &re->origin );
AxisCopy( axisDefault, re->axis );
re->hModel = hModel;
le->pos.trType = TR_GRAVITY;
VectorCopy( origin, &le->pos.trBase );
VectorCopy( velocity, &le->pos.trDelta );
le->pos.trTime = cg.time;
le->bounceFactor = 0.6f;
le->leBounceSoundType = LEBS_BLOOD;
le->leMarkType = LEMT_BLOOD;
}
/*
==================
CG_InvulnerabilityImpact
==================
*/
void CG_InvulnerabilityImpact( vec3_t org, vec3_t angles ) {
localEntity_t *le;
refEntity_t *re;
int r;
sfxHandle_t sfx;
le = CG_AllocLocalEntity();
le->leFlags = 0;
le->leType = LE_INVULIMPACT;
le->startTime = cg.time;
le->endTime = cg.time + 1000;
le->lifeRate = 1.0 / ( le->endTime - le->startTime );
le->color[0] = le->color[1] = le->color[2] = le->color[3] = 1.0;
re = &le->refEntity;
re->reType = RT_MODEL;
re->shaderTime = cg.time / 1000.0f;
re->hModel = cgs.media.invulnerabilityImpactModel;
VectorCopy( org, re->origin );
AnglesToAxis( angles, re->axis );
r = rand() & 3;
if ( r < 2 ) {
sfx = cgs.media.invulnerabilityImpactSound1;
} else if ( r == 2 ) {
sfx = cgs.media.invulnerabilityImpactSound2;
} else {
sfx = cgs.media.invulnerabilityImpactSound3;
}
trap_S_StartSound (org, ENTITYNUM_NONE, CHAN_BODY, sfx );
}
/*
=================
CG_AddBloodTrails
=================
*/
void CG_AddBloodTrails(vec3_t origin, vec3_t dir, int speed, int duration, int count, float randScale)
{
localEntity_t *le;
refEntity_t *re;
vec3_t velocity;
int i;
for (i = 0; i < count; i++)
{
le = CG_AllocLocalEntity();
re = &le->refEntity;
VectorSet(velocity, dir[0] + crandom() * randScale, dir[1] + crandom() * randScale, dir[2] + crandom() * randScale);
VectorScale(velocity, (float)speed, velocity);
le->leType = LE_BLOOD;
le->startTime = cg.time;
le->endTime = le->startTime + duration; // DHM - Nerve :: (removed) - (int)(0.5 * random() * duration);
le->lastTrailTime = cg.time;
VectorCopy(origin, re->origin);
AxisCopy(axisDefault, re->axis);
le->pos.trType = TR_GRAVITY_LOW;
VectorCopy(origin, le->pos.trBase);
VectorMA(le->pos.trBase, 2 + random() * 4, dir, le->pos.trBase);
VectorCopy(velocity, le->pos.trDelta);
le->pos.trTime = cg.time;
le->bounceFactor = 0.9;
}
}
/*
==================
CG_KamikazeEffect
==================
*/
void CG_KamikazeEffect( vec3_t org ) {
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
le->leFlags = 0;
le->leType = LE_KAMIKAZE;
le->startTime = cg.time;
le->endTime = cg.time + 3000;//2250;
le->lifeRate = 1.0 / ( le->endTime - le->startTime );
le->color[0] = le->color[1] = le->color[2] = le->color[3] = 1.0;
VectorClear(le->angles.trBase);
re = &le->refEntity;
re->reType = RT_MODEL;
re->shaderTime = cg.time / 1000.0f;
re->hModel = cgs.media.kamikazeEffectModel;
VectorCopy( org, re->origin );
}
/*
==================
CG_SpawnEffect
Player teleporting in or out
==================
*/
void CG_SpawnEffect( vec3_t org ) {
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
le->leFlags = 0;
le->leType = LE_FADE_RGB;
le->startTime = cg.time;
le->endTime = cg.time + 500;
le->lifeRate = 1.0 / ( le->endTime - le->startTime );
le->color[0] = le->color[1] = le->color[2] = le->color[3] = 1.0;
re = &le->refEntity;
re->reType = RT_MODEL;
re->shaderTime = cg.time / 1000.0f;
#ifndef MISSIONPACK
re->customShader = cgs.media.teleportEffectShader;
#endif
re->hModel = cgs.media.teleportEffectModel;
AxisClear( re->axis );
VectorCopy( org, re->origin );
#ifdef MISSIONPACK
re->origin[2] += 16;
#else
re->origin[2] -= 24;
#endif
}
/*
==================
CG_LaunchGib
==================
*/
void CG_LaunchGib( centity_t *cent, vec3_t origin, vec3_t angles, vec3_t velocity, qhandle_t hModel, float sizeScale, int breakCount ) {
localEntity_t *le;
refEntity_t *re;
int i;
if ( !cg_blood.integer ) {
return;
}
le = CG_AllocLocalEntity();
re = &le->refEntity;
le->leType = LE_FRAGMENT;
le->startTime = cg.time;
// le->endTime = le->startTime + 60000 + random() * 60000;
le->endTime = le->startTime + 20000 + (crandom() * 5000);
le->breakCount = breakCount;
le->sizeScale = sizeScale;
VectorCopy( angles, le->angles.trBase );
VectorCopy( origin, re->origin );
AnglesToAxis( angles, re->axis );
if (sizeScale != 1.0) {
for (i=0;i<3;i++) VectorScale( re->axis[i], sizeScale, re->axis[i] );
}
re->hModel = hModel;
// re->fadeStartTime = le->endTime - 3000;
re->fadeStartTime = le->endTime - 1000;
re->fadeEndTime = le->endTime;
le->leBounceSoundType = LEBS_BLOOD;
le->leMarkType = LEMT_BLOOD;
le->pos.trType = TR_GRAVITY;
le->angles.trDelta[0] = (10 + (rand()&50)) - 30;
// le->angles.trDelta[0] = (100 + (rand()&500)) - 300; // pitch
le->angles.trDelta[1] = (100 + (rand()&500)) - 300; // (SA) this is the safe one right now (yaw) turn the others up when I have tumbling things landing properly
le->angles.trDelta[2] = (10 + (rand()&50)) - 30;
// le->angles.trDelta[2] = (100 + (rand()&500)) - 300; // roll
le->bounceFactor = 0.3;
VectorCopy( origin, le->pos.trBase );
VectorCopy( velocity, le->pos.trDelta );
le->pos.trTime = cg.time;
le->angles.trType = TR_LINEAR;
le->angles.trTime = cg.time;
le->ownerNum = cent->currentState.number;
// Ridah, if the player is on fire, then spawn some flaming gibs
if (cent && CG_EntOnFire(cent)) {
le->onFireStart = cent->currentState.onFireStart;
le->onFireEnd = re->fadeEndTime+1000;
}
}
/*
==================
CG_LaunchGib
==================
*/
void CG_LaunchGib( bvec3_t origin, bvec3_t velocity, qhandle_t hModel ) {
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
re = &le->refEntity;
le->leType = LE_FRAGMENT;
le->startTime = cg.time;
le->endTime = le->startTime + 5000 + FIXED_TO_INT(random() * GFIXED(3000,0));
VectorCopy( origin, re->origin );
AxisCopy( aaxisDefault, re->axis );
re->hModel = hModel;
le->pos.trType = TR_GRAVITY;
VectorCopy( origin, le->pos.trBase );
VectorCopy( velocity, le->pos.trDelta );
le->pos.trTime = cg.time;
le->bounceFactor = BFIXED(0,6);
le->leBounceSoundType = LEBS_BLOOD;
le->leMarkType = LEMT_BLOOD;
}
/*
=================
CG_Bleed
This is the spurt of blood when a character gets hit
=================
*/
void CG_Bleed( vec3_t origin, int entityNum ) {
localEntity_t *ex;
if ( !cg_blood.integer ) {
return;
}
ex = CG_AllocLocalEntity();
ex->leType = LE_EXPLOSION;
ex->startTime = cg.time;
ex->endTime = ex->startTime + 500;
VectorCopy ( origin, ex->refEntity.origin);
ex->refEntity.reType = RT_SPRITE;
ex->refEntity.rotation = rand() % 360;
ex->refEntity.radius = 24;
ex->refEntity.customShader = 0; //cgs.media.bloodExplosionShader;
// don't show player's own blood in view
if ( entityNum == cg.snap->ps.clientNum ) {
ex->refEntity.renderfx |= RF_THIRD_PERSON;
}
}
/*
=====================
CG_SmokePuff
Adds a smoke puff or blood trail localEntity.
it would be nice to have an acceleration vector for this as well.
big velocity vector with a negative acceleration for deceleration, etc.
(breath could then come out of a guys mouth at the rate he's walking/running and it
would slow down once it's created)
=====================
*/
localEntity_t *CG_SmokePuff(const vec3_t p, const vec3_t vel,
float radius,
float r, float g, float b, float a,
float duration,
int startTime,
int fadeInTime,
int leFlags,
qhandle_t hShader)
{
static int seed = 0x92;
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
le->leFlags = leFlags;
le->radius = radius;
re = &le->refEntity;
re->rotation = Q_random(&seed) * 360;
re->radius = radius;
re->shaderTime = startTime / 1000.0f;
le->leType = LE_MOVE_SCALE_FADE;
le->startTime = startTime;
le->endTime = startTime + duration;
le->fadeInTime = fadeInTime;
if (fadeInTime > startTime)
{
le->lifeRate = 1.0 / (le->endTime - le->fadeInTime);
}
else
{
le->lifeRate = 1.0 / (le->endTime - le->startTime);
}
le->color[0] = r;
le->color[1] = g;
le->color[2] = b;
le->color[3] = a;
le->pos.trType = TR_LINEAR;
le->pos.trTime = startTime;
VectorCopy(vel, le->pos.trDelta);
VectorCopy(p, le->pos.trBase);
VectorCopy(p, re->origin);
re->customShader = hShader;
re->shaderRGBA[0] = le->color[0] * 0xff;
re->shaderRGBA[1] = le->color[1] * 0xff;
re->shaderRGBA[2] = le->color[2] * 0xff;
re->shaderRGBA[3] = 0xff;
re->reType = RT_SPRITE;
re->radius = le->radius;
return le;
}
/*
=====================
CG_SmokePuff
Adds a smoke puff or blood trail localEntity.
=====================
*/
localEntity_t *CG_SmokePuff( const vec3_t p, const vec3_t vel,
float radius,
float r, float g, float b, float a,
float duration,
int startTime,
int leFlags,
qhandle_t hShader ) {
static int seed = 0x92;
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
le->leFlags = leFlags;
le->data.sprite.radius = radius;
re = &le->refEntity;
re->data.sprite.rotation = Q_random( &seed ) * 360;
re->data.sprite.radius = radius;
re->shaderTime = startTime * 0.001f;
le->leType = LE_MOVE_SCALE_FADE;
le->startTime = startTime;
le->endTime = startTime + duration;
le->lifeRate = 1.0 / ( le->endTime - le->startTime );
le->color[0] = r;
le->color[1] = g;
le->color[2] = b;
le->color[3] = a;
le->pos.trType = TR_LINEAR;
le->pos.trTime = startTime;
VectorCopy( vel, le->pos.trDelta );
VectorCopy( p, le->pos.trBase );
VectorCopy( p, re->origin );
re->customShader = hShader;
// rage pro can't alpha fade, so use a different shader
if ( cgs.glconfig.hardwareType == GLHW_RAGEPRO ) {
re->customShader = cgs.media.smokePuffRageProShader;
re->shaderRGBA[0] = 0xff;
re->shaderRGBA[1] = 0xff;
re->shaderRGBA[2] = 0xff;
re->shaderRGBA[3] = 0xff;
} else {
re->shaderRGBA[0] = le->color[0] * 0xff;
re->shaderRGBA[1] = le->color[1] * 0xff;
re->shaderRGBA[2] = le->color[2] * 0xff;
re->shaderRGBA[3] = 0xff;
}
re->reType = RT_SPRITE;
re->data.sprite.radius = le->data.sprite.radius;
return le;
}
/*
==================
CG_BubbleTrail
Bullets shot underwater
==================
*/
void CG_BubbleTrail( vector3 *start, vector3 *end, float spacing ) {
vector3 move;
vector3 vec;
float len;
int i;
#if 0
if ( cg_noProjectileTrail.integer ) {
return;
}
#endif
VectorCopy (start, &move);
VectorSubtract (end, start, &vec);
len = VectorNormalize (&vec);
// advance a random amount first
i = rand() % (int)spacing;
VectorMA( &move, i, &vec, &move );
VectorScale (&vec, spacing, &vec);
for ( ; i < len; i += spacing ) {
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
le->leFlags = LEF_PUFF_DONT_SCALE;
le->leType = LE_MOVE_SCALE_FADE;
le->startTime = cg.time;
le->endTime = cg.time + 1000 + random() * 250;
le->lifeRate = 1.0 / ( le->endTime - le->startTime );
re = &le->refEntity;
re->shaderTime = cg.time / 1000.0f;
re->reType = RT_SPRITE;
re->rotation = 0;
re->radius = 3;
re->customShader = 0;//cgs.media.waterBubbleShader;
re->shaderRGBA[0] = 0xff;
re->shaderRGBA[1] = 0xff;
re->shaderRGBA[2] = 0xff;
re->shaderRGBA[3] = 0xff;
le->color[3] = 1.0;
le->pos.trType = TR_LINEAR;
le->pos.trTime = cg.time;
VectorCopy( &move, &le->pos.trBase );
le->pos.trDelta.x = crandom()*5;
le->pos.trDelta.y = crandom()*5;
le->pos.trDelta.z = crandom()*5 + 6;
VectorAdd (&move, &vec, &move);
}
}
/*
==================
CG_RealBloodTrail
Bullets shot underwater
==================
*/
void CG_RealBloodTrail( vec3_t start, vec3_t end, float spacing ) {
vec3_t move;
vec3_t vec;
float len;
int i;
int type = 5;
VectorCopy( start, move );
VectorSubtract( end, start, vec );
len = VectorNormalize( vec );
while ( type > 4 )
type = (int)random() * 5;
// advance a random amount first
i = rand() % (int)spacing;
VectorMA( move, i, vec, move );
VectorScale( vec, spacing, vec );
for ( ; i < len; i += spacing ) {
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
le->leFlags = LEF_PUFF_DONT_SCALE;
le->leType = LE_MOVE_SCALE_FADE; //LE_MOVE_SCALE_FADE;
le->startTime = cg.time;
le->endTime = cg.time + 2000 + random() * 250;
le->lifeRate = 1.0 / ( le->endTime - le->startTime );
re = &le->refEntity;
re->shaderTime = cg.time / 1000.0f;
re->reType = RT_SPRITE;
re->rotation = rand() % 360;
re->radius = 1 + random() * 2;
re->customShader = cgs.media.bloodparticleShaders[type];
re->shaderRGBA[0] = 0xff;
re->shaderRGBA[1] = 0xff;
re->shaderRGBA[2] = 0xff;
re->shaderRGBA[3] = 0xff;
le->color[3] = 1.0;
le->pos.trType = TR_LINEAR;
le->pos.trTime = cg.time;
VectorCopy( move, le->pos.trBase );
// le->pos.trDelta[0] = crandom()*10;
// le->pos.trDelta[1] = crandom()*10;
le->pos.trDelta[2] = ( 10 + crandom() * 10 ) * -1;
VectorAdd( move, vec, move );
}
}
/*
==================
CG_BubbleTrail
Bullets shot underwater
==================
*/
void CG_BubbleTrail(vec3_t start, vec3_t end, float size, float spacing)
{
vec3_t move;
vec3_t vec;
float len;
int i;
VectorCopy(start, move);
VectorSubtract(end, start, vec);
len = VectorNormalize(vec);
// advance a random amount first
i = rand() % (int)spacing;
VectorMA(move, i, vec, move);
VectorScale(vec, spacing, vec);
for ( ; i < len; i += spacing)
{
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
le->leFlags = LEF_PUFF_DONT_SCALE;
le->leType = LE_MOVE_SCALE_FADE;
le->startTime = cg.time;
le->endTime = cg.time + 1000 + random() * 250;
le->lifeRate = 1.0 / (le->endTime - le->startTime);
re = &le->refEntity;
re->shaderTime = cg.time / 1000.0f;
re->reType = RT_SPRITE;
re->rotation = 0;
// re->radius = 3;
re->radius = size; // (SA)
re->customShader = cgs.media.waterBubbleShader;
re->shaderRGBA[0] = 0xff;
re->shaderRGBA[1] = 0xff;
re->shaderRGBA[2] = 0xff;
re->shaderRGBA[3] = 0xff;
le->color[3] = 1.0;
le->pos.trType = TR_LINEAR;
le->pos.trTime = cg.time;
VectorCopy(move, le->pos.trBase);
le->pos.trDelta[0] = crandom() * 3;
le->pos.trDelta[1] = crandom() * 3;
// le->pos.trDelta[2] = crandom()*5 + 6;
le->pos.trDelta[2] = crandom() * 5 + 20; // (SA)
VectorAdd(move, vec, move);
}
}
/*
==================
CG_BubbleTrail
Bullets shot underwater
==================
*/
void CG_BubbleTrail( bvec3_t start, bvec3_t end, bfixed spacing ) {
bvec3_t move;
bvec3_t vec;
bfixed len;
int i;
if ( cg_noProjectileTrail.integer ) {
return;
}
VectorCopy (start, move);
VectorSubtract (end, start, vec);
len = VectorNormalize (vec);
// advance a random amount first
i = rand() % FIXED_TO_INT(spacing);
FIXED_VEC3MA( move, MAKE_BFIXED(i), vec, move );
FIXED_VEC3SCALE (vec, spacing, vec);
for ( ; MAKE_BFIXED(i) < len; i += FIXED_TO_INT(spacing) ) {
localEntity_t *le;
refEntity_t *re;
le = CG_AllocLocalEntity();
le->leFlags = LEF_PUFF_DONT_SCALE;
le->leType = LE_MOVE_SCALE_FADE;
le->startTime = cg.time;
le->endTime = cg.time + 1000 + FIXED_TO_INT(random() * GFIXED(250,0));
le->lifeRate = FIXED_INT32RATIO_G(1,( le->endTime - le->startTime ));
re = &le->refEntity;
re->shaderTime = MSECTIME_G(cg.time);
re->reType = RT_SPRITE;
re->rotation = AFIXED_0;
re->radius = BFIXED(3,0);
re->customShader = cgs.media.waterBubbleShader;
re->shaderRGBA[0] = 0xff;
re->shaderRGBA[1] = 0xff;
re->shaderRGBA[2] = 0xff;
re->shaderRGBA[3] = 0xff;
le->color[3] = GFIXED_1;
le->pos.trType = TR_LINEAR;
le->pos.trTime = cg.time;
VectorCopy( move, le->pos.trBase );
le->pos.trDelta[0] = crandom_b()*BFIXED(5,0);
le->pos.trDelta[1] = crandom_b()*BFIXED(5,0);
le->pos.trDelta[2] = crandom_b()*BFIXED(5,0) + BFIXED(6,0);
VectorAdd (move, vec, move);
}
}
/*
====================
CG_MakeExplosion
====================
*/
localEntity_t *CG_MakeExplosion( bvec3_t origin, avec3_t dir,
qhandle_t hModel, qhandle_t shader,
int msec, qboolean isSprite ) {
afixed ang;
localEntity_t *ex;
int offset;
bvec3_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;
// randomly rotate sprite orientation
ex->refEntity.rotation =MAKE_AFIXED(rand() % 360);
FIXED_VEC3SCALE_R( dir, BFIXED(16,0), tmpVec );
VectorAdd( tmpVec, origin, newOrigin );
} else {
ex->leType = LE_EXPLOSION;
VectorCopy( origin, newOrigin );
// set axis with random rotate
if ( !dir ) {
AxisClear( ex->refEntity.axis );
} else {
ang = MAKE_AFIXED(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 = MSECTIME_G(ex->startTime);
ex->refEntity.hModel = hModel;
ex->refEntity.customShader = shader;
// set origin
VectorCopy( newOrigin, ex->refEntity.origin );
VectorCopy( newOrigin, ex->refEntity.oldorigin );
ex->color[0] = ex->color[1] = ex->color[2] = GFIXED_1;
return ex;
}
/*
* CG_AllocLaser
*/
static lentity_t *CG_AllocLaser( vec3_t start, vec3_t end, float radius, int frames,
float r, float g, float b, float a, struct shader_s *shader )
{
lentity_t *le;
le = CG_AllocLocalEntity( LE_LASER, 1, 1, 1, 1 );
le->frames = frames;
le->ent.radius = radius;
le->ent.customShader = shader;
Vector4Set( le->ent.shaderRGBA, r * 255, g * 255, b * 255, a * 255 );
VectorCopy( start, le->ent.origin );
VectorCopy( end, le->ent.origin2 );
return le;
}
/*
===============
CG_LightningBoltBeam
===============
*/
void CG_LightningBoltBeam( vec3_t start, vec3_t end ) {
localEntity_t *le;
refEntity_t *beam;
le = CG_AllocLocalEntity();
le->leFlags = 0;
le->leType = LE_SHOWREFENTITY;
le->startTime = cg.time;
le->endTime = cg.time + 50;
beam = &le->refEntity;
VectorCopy( start, beam->origin );
// this is the end point
VectorCopy( end, beam->oldorigin );
beam->reType = RT_LIGHTNING;
beam->customShader = cgs.media.lightningShader;
}
