自学教程：C++ CG_AllocLocalEntity函数代码示例

/** 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_SpawnEffectPlayer 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_SpawnEffectPlayer teleporting in or outRPG-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_BubbleBullets 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_SpawnEffectPlayer 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_SpawnEffectPlayer 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_BleedThis 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_SmokePuffAdds 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_SmokePuffAdds 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_BubbleTrailBullets 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_RealBloodTrailBullets 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_BubbleTrailBullets 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_BubbleTrailBullets 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;}