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

/*================CG_AddFireEffect================*/static void CG_AddFireEffect( localEntity_t *le ) {	refEntity_t			*re;	trace_t				trace;	re = &le->refEntity;	if ( le->pos.trType == TR_STATIONARY ) {		if ( le->leFlags & LEF_LESSOVERDRAW ) {			// avoid too much overdraw			if ( CG_NearbyDrawnLeCount( le, re->origin, le->leType, 52 + !!cg_lowDetailEffects.integer * 24 ) > 0 ) return;		}		// add to refresh list		trap_R_AddRefEntityToScene( re );		return;	}	// calculate position	BG_EvaluateTrajectory( &le->pos, cg.time, re->origin );	// check for water	if ( trap_CM_PointContents( re->origin, 0 ) & CONTENTS_WATER ) {		// do a trace to get water surface normals		CG_Trace( &trace, re->oldorigin, NULL, NULL, re->origin, le->owner, MASK_WATER );		CG_FreeLocalEntity( le );		CG_MakeExplosion( trace.endpos, trace.plane.normal, 			cgs.media.ringFlashModel, cgs.media.vaporShader,			500, qfalse, qtrue );		return;	}	// do a trace sometimes	if ( le->ti.trailTime++ > 5 ) {		le->ti.trailTime = 0;		CG_Trace( &trace, re->oldorigin, NULL, NULL, re->origin, le->owner, MASK_SHOT );		VectorCopy( trace.endpos, re->origin );		VectorCopy( trace.endpos, re->oldorigin );		// hit something		if ( trace.fraction < 1.0 ) {			// free le if another one is nearby, otherwise make it stationary			if ( CG_CheckDistance( re->origin, le->leType, TR_STATIONARY, re->customShader, 200, 32 ) ) { 				CG_FreeLocalEntity( le );				return;			} else {				le->pos.trType = TR_STATIONARY;			}		}	}	if ( le->leFlags & LEF_LESSOVERDRAW ) {		// avoid too much overdraw		if ( CG_NearbyDrawnLeCount( le, re->origin, le->leType, 52 + !!cg_lowDetailEffects.integer * 24 ) > 0 ) return;	}	// add to refresh list	trap_R_AddRefEntityToScene( re );}

void CG_AddGore( localEntity_t *le ) {	vec3_t	newOrigin;	trace_t	trace;	if ( le->pos.trType == TR_STATIONARY ) {		// sink into the ground if near the removal time		//int		t;		//float	oldZ;				CG_FreeLocalEntity( le ); // kill it		return;	}	// calculate new position	BG_EvaluateTrajectory( &le->pos, cg.time, newOrigin );	// trace a line from previous position to new position	CG_Trace( &trace, le->refEntity.origin, NULL, NULL, newOrigin, -1, CONTENTS_SOLID );	if ( trace.fraction == 1.0 ) {		// still in free fall		VectorCopy( newOrigin, le->refEntity.origin );		if ( le->leFlags & LEF_TUMBLE ) {			vec3_t angles;			BG_EvaluateTrajectory( &le->angles, cg.time, angles );			AnglesToAxis( angles, le->refEntity.axis );		}		trap_R_AddRefEntityToScene( &le->refEntity );		CG_SmallBloodTrail( le );			return;	}	// if it is in a nodrop zone, remove it	// this keeps gibs from waiting at the bottom of pits of death	// and floating levels	if ( trap_CM_PointContents( trace.endpos, 0 ) & CONTENTS_NODROP ) {		CG_FreeLocalEntity( le );		return;	}	// leave a mark	CG_GoreMark( le, &trace );	// do a juicy sound	CG_SplatSound( le, &trace );	CG_JustSplat( le, &trace );	trap_R_AddRefEntityToScene( &le->refEntity );}

/*===================CG_AddRefEntity===================*/void CG_AddRefEntity( localEntity_t *le ) {	if (le->endTime < cg.time) {		CG_FreeLocalEntity( le );		return;	}	CG_AddRefEntityWithMinLight( &le->refEntity );}

/*==================CG_AddPuff==================*/static void CG_AddPuff( localEntity_t *le ) {	refEntity_t	*re;	float		c;	vec3_t		delta;	float		len;	re = &le->refEntity;	// fade / grow time	c = ( le->endTime - cg.time ) / (float)( le->endTime - le->startTime );	re->shaderRGBA[0] = le->color[0] * c;	re->shaderRGBA[1] = le->color[1] * c;	re->shaderRGBA[2] = le->color[2] * c;	if ( !( le->leFlags & LEF_PUFF_DONT_SCALE ) ) {		re->radius = le->radius * ( 1.0 - c ) + 8;	}	BG_EvaluateTrajectory( &le->pos, cg.time, re->origin );	// if the view would be "inside" the sprite, kill the sprite	// so it doesn't add too much overdraw	VectorSubtract( re->origin, cg.refdef.vieworg, delta );	len = VectorLength( delta );	if ( len < le->radius ) {		CG_FreeLocalEntity( le );		return;	}	trap->R_AddRefEntityToScene( re );}

/*================CG_ResetMissileEntity================*/void CG_ResetMissileEntity( centity_t *cent ) {		// link trajectory	cent->ti.trPos = &cent->currentState.pos;	cent->ti.weapon = cent->currentState.weapon;	// check for predicted missiles if necessary	if ( cg.predictWeapons && cent->currentState.clientNum == cg.snap->ps.clientNum ) {		localEntity_t	*le;		le = cg_activeLocalEntities.prev;		for ( ; le != &cg_activeLocalEntities ; le = le->prev ) {			// the first (and oldest) missile le is the one represented by the new one			if ( le->leType == LE_MISSILE && weLi[le->ti.weapon].prediction != PR_FLAME ) {				// set the correct trailTime				cent->ti.trailTime = le->ti.trailTime;				VectorCopy( le->ti.lastPos, cent->ti.lastPos );				// free the local entity				CG_FreeLocalEntity( le );				return;			}		}		}	// there isn't a predicted missile, use normal trailTime reset	cent->ti.trailTime = cent->currentState.pos.trTime + TRAIL_DELAY;	BG_EvaluateTrajectory( cent->ti.trPos, cent->ti.trailTime, cent->ti.lastPos );}

/*=================CG_AddFallScaleFadeThis is just an optimized CG_AddMoveScaleFadeFor blood mists that drift down, fade out, and areremoved if the view passes through them.There are often 100+ of these, so it needs to be simple.=================*/static void CG_AddFallScaleFade( localEntity_t *le ) {	refEntity_t	*re;	gfixed		c;	bvec3_t		delta;	bfixed		len;	re = &le->refEntity;	// fade time	c = MAKE_GFIXED( le->endTime - cg.time ) * le->lifeRate;	re->shaderRGBA[3] = FIXED_TO_INT(GFIXED(255,0) * c * le->color[3]);	re->origin[2] = le->pos.trBase[2] - MAKE_BFIXED( GFIXED_1 - c ) * le->pos.trDelta[2];	re->radius = le->radius * MAKE_BFIXED( GFIXED_1 - c ) + BFIXED(16,0);	// if the view would be "inside" the sprite, kill the sprite	// so it doesn't add too much overdraw	VectorSubtract( re->origin, cg.refdef.vieworg, delta );	len = FIXED_VEC3LEN( delta );	if ( len < le->radius ) {		CG_FreeLocalEntity( le );		return;	}	_CG_trap_R_AddRefEntityToScene( re );}

/*===================CG_AllocLocalEntityWill allways succeed, even if it requires freeing an old active entity===================*/localEntity_t	*CG_AllocLocalEntity( void ) {	localEntity_t	*le;	if ( !cg_freeLocalEntities ) {		// no free entities, so free the one at the end of the chain		// remove the oldest active entity		CG_FreeLocalEntity( cg_activeLocalEntities.prev );	}	// Ridah, debugging	localEntCount++;//	trap_Print( va("AllocLocalEntity: locelEntCount = %d/n", localEntCount) );	// done.	le = cg_freeLocalEntities;	cg_freeLocalEntities = cg_freeLocalEntities->next;	memset( le, 0, sizeof( *le ) );	// link into the active list	le->next = cg_activeLocalEntities.next;	le->prev = &cg_activeLocalEntities;	cg_activeLocalEntities.next->prev = le;	cg_activeLocalEntities.next = le;	return le;}

/*=================CG_AddFallScaleFadeThis is just an optimized CG_AddMoveScaleFadeFor blood mists that drift down, fade out, and areremoved if the view passes through them.There are often 100+ of these, so it needs to be simple.=================*/static void CG_AddFallScaleFade( localEntity_t *le ) {	refEntity_t	*re;	float		c;	vec3_t		delta;	float		len;	re = &le->refEntity;	// fade time	c = ( le->endTime - cg.time ) * le->lifeRate;	re->shaderRGBA[3] = 0xff * c * le->color[3];	re->origin[2] = le->pos.trBase[2] - ( 1.0 - c ) * le->pos.trDelta[2];	re->radius = le->radius * ( 1.0 - c ) + 16;	// if the view would be "inside" the sprite, kill the sprite	// so it doesn't add too much overdraw	VectorSubtract( re->origin, cg.refdef.vieworg, delta );	len = VectorLength( delta );	if ( len < le->radius ) {		CG_FreeLocalEntity( le );		return;	}	trap->R_AddRefEntityToScene( re );}

void CG_AddRefEntity( localEntity_t *le ) {	if ( le->endTime < cg.time ) {		CG_FreeLocalEntity( le );		return;	}	SE_R_AddRefEntityToScene( &le->refEntity, MAX_CLIENTS );}

// For forcefields/other rectangular thingsvoid CG_AddOLine( localEntity_t *le ) {	refEntity_t	*re;	float		frac, alpha;	re = &le->refEntity;	frac = (cg.time - le->startTime) / (float)(le->endTime - le->startTime);	if ( frac > 1 )		frac = 1.0f;	// can happen during connection problems	else if ( frac < 0 )		frac = 0.0f;	// Use the liferate to set the scale over time.	re->data.line.width = le->data.line.width + (le->data.line.dwidth * frac);	if ( re->data.line.width <= 0 ) {		CG_FreeLocalEntity( le );		return;	}	// We will assume here that we want additive transparency effects.	alpha = le->alpha + (le->dalpha * frac);	re->shaderRGBA[0] = 0xff * alpha;	re->shaderRGBA[1] = 0xff * alpha;	re->shaderRGBA[2] = 0xff * alpha;	re->shaderRGBA[3] = 0xff * alpha;	// Yes, we could apply c to this too, but fading the color is better for lines.	re->shaderTexCoord.x = 1;	re->shaderTexCoord.y = 1;	re->rotation = 90;	re->reType = RT_ORIENTEDLINE;	SE_R_AddRefEntityToScene( re, MAX_CLIENTS );}

/*===================CG_AddRefEntity===================*/void CG_AddRefEntity( localEntity_t *le ) {	if (le->endTime < cg.time) {		CG_FreeLocalEntity( le );		return;	}	trap->R_AddRefEntityToScene( &le->refEntity );}

// For rocket smokes that hang in place, fade out, and are removed if the view passes through them.//	There are often many of these, so it needs to be simple.static void CG_AddScaleFade( localEntity_t *le ) {	refEntity_t	*re;	float		c;	vector3		delta;	float		len;	refdef_t *refdef = CG_GetRefdef();	re = &le->refEntity;	// fade / grow time	c = (le->endTime - cg.time) * le->lifeRate;	re->shaderRGBA[3] = 0xff * c * le->color[3];	re->radius = le->radius * (1.0f - c) + 8;	// if the view would be "inside" the sprite, kill the sprite	// so it doesn't add too much overdraw	VectorSubtract( &re->origin, &refdef->vieworg, &delta );	len = VectorLength( &delta );	if ( len < le->radius ) {		CG_FreeLocalEntity( le );		return;	}	SE_R_AddRefEntityToScene( re, MAX_CLIENTS );}

/*===================CG_AddScaleFadeFor rocket smokes that hang in place, fade out, and areremoved if the view passes through them.There are often many of these, so it needs to be simple.===================*/static void CG_AddScaleFade( localEntity_t *le ) {	refEntity_t	*re;	float		c;	vec3_t		delta;	float		len;	re = &le->refEntity;	// fade / grow time	c = ( le->endTime - cg.time ) * le->lifeRate;	re->shaderRGBA[3] = 0xff * c * le->color[3];	re->radius = le->radius * ( 1.0 - c ) + 8;	// if the view would be "inside" the sprite, kill the sprite	// so it doesn't add too much overdraw	VectorSubtract( re->origin, cg.refdef.vieworg, delta );	len = VectorLength( delta );	if ( len < le->radius ) {		CG_FreeLocalEntity( le );		return;	}	CG_AddRefEntityWithMinLight( re );}

/*===================CG_AddLine2For trek, for beams and the like.===================*/void CG_AddLine2( localEntity_t *le ){	refEntity_t	*re;	float		frac, alpha;	vec3_t		curRGB;	re = &le->refEntity;	frac = (cg.time - le->startTime) / ( float ) ( le->endTime - le->startTime );	if ( frac > 1 ) 		frac = 1.0;	// can happen during connection problems	else if (frac < 0)		frac = 0.0;	// Use the liferate to set the scale over time.	re->data.line.width = le->data.line2.width + (le->data.line2.dwidth * frac);	re->data.line.width2 = le->data.line2.width2 + (le->data.line2.dwidth2 * frac);	if (re->data.line.width <= 0)	{		CG_FreeLocalEntity( le );		return;	}	// We will assume here that we want additive transparency effects.	alpha = le->alpha + (le->dalpha * frac);	VectorMA(le->data.line2.startRGB, frac, le->data.line2.dRGB, curRGB);	re->shaderRGBA[0] = 0xff * alpha * curRGB[0];	re->shaderRGBA[1] = 0xff * alpha * curRGB[1];	re->shaderRGBA[2] = 0xff * alpha * curRGB[2];	re->shaderRGBA[3] = 0xff * alpha;	// Yes, we could apply c to this too, but fading the color is better for lines.	re->reType = RT_LINE2;	trap_R_AddRefEntityToScene( re );}

// This is just an optimized CG_AddMoveScaleFade for blood mists that drift down, fade out, and are removed if the view passes through them.//	There are often 100+ of these, so it needs to be simple.static void CG_AddFallScaleFade( localEntity_t *le ) {	refEntity_t	*re;	float		c;	vector3		delta;	float		len;	re = &le->refEntity;	// fade time	c = ( le->endTime - cg.time ) * le->lifeRate;	re->shaderRGBA[3] = (byte)(255 * c * le->color.a);	re->origin.z = le->pos.trBase.z - ( 1.0f - c ) * le->pos.trDelta.z;	re->radius = le->radius * ( 1.0f - c ) + 16;	// if the view would be "inside" the sprite, kill the sprite so it doesn't add too much overdraw	VectorSubtract( &re->origin, &cg.refdef.vieworg, &delta );	len = VectorLength( &delta );	if ( len < le->radius ) {		CG_FreeLocalEntity( le );		return;	}	trap->R_AddRefEntityToScene( re );}

/*==================CG_AddMoveScaleFade==================*/void CG_AddMoveScaleFade( localEntity_t *le ){	refEntity_t	*re;	float		c;	vec3_t		delta;	float		len;	re = &le->refEntity;	// fade / grow time	c = ( le->endTime - cg.time ) * le->lifeRate;	re->shaderRGBA[3] = 0xff * c * le->color[3];	if ( !( le->leFlags & LEF_PUFF_DONT_SCALE ) ) {		re->data.sprite.radius = le->data.sprite.radius * ( 1.0 - c ) + 8;	}	BG_EvaluateTrajectory( &le->pos, cg.time, re->origin );	// if the view would be "inside" the sprite, kill the sprite	// so it doesn't add too much overdraw	VectorSubtract( re->origin, cg.refdef.vieworg, delta );	len = VectorLength( delta );	if ( len < le->data.sprite.radius ) {		CG_FreeLocalEntity( le );		return;	}	trap_R_AddRefEntityToScene( re );}

/*===================CG_AddQuadOf Trek, by Trek, and for Trek===================*/void CG_AddQuad( localEntity_t *le ){	refEntity_t	*re;	float		frac, alpha;	vec3_t		delta;	float		len;	vec3_t		curRGB;	re = &le->refEntity;	frac = ( cg.time - le->startTime ) / ( float ) ( le->endTime - le->startTime );	if ( frac > 1 )		frac = 1.0;	// can happen during connection problems	else if (frac < 0)		frac = 0.0;	// Use the liferate to set the scale over time.	re->data.sprite.radius = le->data.sprite.radius + (le->data.sprite.dradius*frac);	if (re->data.sprite.radius <= 0)	{		CG_FreeLocalEntity( le );		return;	}	// if the view would be "inside" the sprite, kill the sprite	// so it doesn't add too much overdraw	VectorSubtract( re->origin, cg.refdef.vieworg, delta );	len = VectorLength( delta );	if ( len < le->data.sprite.radius ) {		CG_FreeLocalEntity( le );		return;	}	// Calculate the current alpha.	alpha = le->alpha + (le->dalpha * frac);	VectorMA(le->data.sprite.startRGB, frac, le->data.sprite.dRGB, curRGB);	re->shaderRGBA[0] = 0xff * alpha * curRGB[0];	re->shaderRGBA[1] = 0xff * alpha * curRGB[1];	re->shaderRGBA[2] = 0xff * alpha * curRGB[2];	re->shaderRGBA[3] = 0xff;		re->reType = RT_ORIENTEDSPRITE;	trap_R_AddRefEntityToScene( re );}

static void CG_AddSpawner( localEntity_t *le ) {	refEntity_t	*re;	vec3_t		dir;	trace_t		trace;	re = &le->refEntity;	if (le->leFlags & LEF_MOVE)	{		// kef -- do these two lines _before_ copying origin into oldorigin		VectorSubtract(re->oldorigin, re->origin, dir);		VectorNormalize(dir);		VectorCopy(re->origin, re->oldorigin);		BG_EvaluateTrajectory( &le->pos, cg.time, re->origin );		if (le->leFlags & LEF_USE_COLLISION)		{			// trace a line from previous position to new position			CG_Trace( &trace, re->oldorigin, NULL, NULL, re->origin, -1, CONTENTS_SOLID );			if ( trace.fraction != 1.0 ) 			{	// Hit something.				// if it is in a nodrop zone, remove it				// this keeps gibs from waiting at the bottom of pits of death				// and floating levels				if ( trap_CM_PointContents( trace.endpos, 0 ) & CONTENTS_NODROP ) {					CG_FreeLocalEntity( le );					return;				}				// reflect the velocity on the trace plane				CG_ReflectVelocity( le, &trace );			}			VectorSubtract(re->oldorigin, re->origin, dir);			VectorNormalize(dir);		}	}	// kef -- here's where I, in my infinite wisdom, have decided to emulate the singleplayer	//particle think function	if (cg.time < le->data.spawner.nextthink)	{		return;	}	le->data.spawner.nextthink = cg.time + (le->data.spawner.delay + 		(le->data.spawner.delay*flrandom(-le->data.spawner.variance,le->data.spawner.variance)));	if (le->data.spawner.thinkFn)	{		le->data.spawner.thinkFn(le);	}	if (le->data.spawner.dontDie)	{		le->endTime = le->endTime + 10000;	}}

/*===================CG_AddCylinderFor trek, cylinder primitive.===================*/void CG_AddCylinder( localEntity_t *le ){	refEntity_t	*re;	float		frac, alpha;	re = &le->refEntity;	frac = ( cg.time - le->startTime ) / ( float ) ( le->endTime - le->startTime );	if ( frac > 1 )		frac = 1.0;	// can happen during connection problems	else if (frac < 0)		frac = 0.0;	// Use the liferate to set the scale over time.	re->data.cylinder.height = le->data.cylinder.height + (le->data.cylinder.dheight*frac);	if (re->data.cylinder.height <= 0)	{		CG_FreeLocalEntity( le );		return;	}	re->data.cylinder.width = le->data.cylinder.width + (le->data.cylinder.dwidth*frac);	if (re->data.cylinder.width <= 0)	{		CG_FreeLocalEntity( le );		return;	}	re->data.cylinder.width2 = le->data.cylinder.width2 + (le->data.cylinder.dwidth2*frac);	if (re->data.cylinder.width2 <= 0)	{		CG_FreeLocalEntity( le );		return;	}	// Calculate the current alpha.	alpha = le->alpha + (le->dalpha * frac);	re->shaderRGBA[0] = 0xff * alpha;	re->shaderRGBA[1] = 0xff * alpha;	re->shaderRGBA[2] = 0xff * alpha;	re->shaderRGBA[3] = 0xff;		re->reType = RT_CYLINDER;	trap_R_AddRefEntityToScene( re );}

/*===================CG_AddScaleFadeSpriteFor trek, oriented sprites like blast rings and the like.===================*/void CG_AddScaleFadeSprite( localEntity_t *le ){	refEntity_t	*re;	float		c;	vec3_t		delta;	float		len;	re = &le->refEntity;	c = ( le->endTime - cg.time ) / ( float ) ( le->endTime - le->startTime );	if ( c > 1 ) {		c = 1.0;	// can happen during connection problems	}	// Use the liferate to set the scale over time.	re->data.sprite.radius = le->data.sprite.radius + (le->lifeRate * (cg.time - le->startTime));	if (re->data.sprite.radius <= 0)	{		CG_FreeLocalEntity( le );		return;	}	// if the view would be "inside" the sprite, kill the sprite	// so it doesn't add too much overdraw	VectorSubtract( re->origin, cg.refdef.vieworg, delta );	len = VectorLength( delta );	if ( len < le->data.sprite.radius ) {		CG_FreeLocalEntity( le );		return;	}	// We will assume here that we want additive transparency effects.	re->shaderRGBA[0] = 0xff * c;	re->shaderRGBA[1] = 0xff * c;	re->shaderRGBA[2] = 0xff * c;	re->shaderRGBA[3] = 0xff * le->color[3];	re->reType = RT_ORIENTEDSPRITE;	trap_R_AddRefEntityToScene( re );}

/*===================CG_AddBezierFor trek, for the imod and the...uh...imod.===================*/void CG_AddBezier( localEntity_t *le ){	refEntity_t	*re;	float		frac, alpha;	float		t = (cg.time - le->startTime)*0.001; // time elapsed since beginning of effect	vec3_t		vTempPos;	re = &le->refEntity;	frac = (cg.time - le->startTime) / ( float ) ( le->endTime - le->startTime );	if ( frac > 1 ) 		frac = 1.0;	// can happen during connection problems	else if (frac < 0)		frac = 0.0;	// Use the liferate to set the scale over time.	re->data.bezier.width = le->data.line.width + (le->data.line.dwidth * frac);	if (re->data.bezier.width <= 0)	{		CG_FreeLocalEntity( le );		return;	}	// We will assume here that we want additive transparency effects.	alpha = le->alpha + (le->dalpha * frac);	re->shaderRGBA[0] = 0xff * alpha;	re->shaderRGBA[1] = 0xff * alpha;	re->shaderRGBA[2] = 0xff * alpha;	re->shaderRGBA[3] = 0xff;	// Yes, we could apply c to this too, but fading the color is better for lines.	re->reType = RT_BEZIER;	// the refEntity only stores the two control points, so we need to update them here with 	//the control_velocity and control_acceleration, then store the results in refEntity. 	//use (cg.time - le->startTime) as a value for elapsed time t, plug it into the position formula:	//	// x = x0 + (v0 * t) + (0.5 * a * t * t)	//	//...where x is the position at time t, x0 is initial control point position, v0 is control point velocity,	//and a is control point acceleration	//	// update control point 1	VectorMA(le->data.line.control1, t, le->data.line.control1_velocity, vTempPos);	VectorMA(vTempPos, (0.5*t*t), le->data.line.control1_acceleration, re->data.bezier.control1);	// update control point 2	VectorMA(le->data.line.control2, t, le->data.line.control2_velocity, vTempPos);	VectorMA(vTempPos, (0.5*t*t), le->data.line.control2_acceleration, re->data.bezier.control2);	trap_R_AddRefEntityToScene( re );}

/** CG_FreeLocalEntities*/void CG_FreeLocalEntities( void ){	lentity_t *le, *next, *hnode;	hnode = &cg_localents_headnode;	for( le = hnode->next; le != hnode; le = next )	{		next = le->next;		le->type = LE_FREE;		CG_FreeLocalEntity( le );	}	CG_ClearLocalEntities();}

/*=======================================================================================================================================CG_BubbleThink=======================================================================================================================================*/void CG_BubbleThink(localEntity_t *le) {	int contents;	vec3_t newOrigin;	trace_t trace;	// calculate new position	BG_EvaluateTrajectory(&le->pos, cg.time, newOrigin);	// trace a line from previous position to new position	CG_Trace(&trace, le->refEntity.origin, NULL, NULL, newOrigin, -1, CONTENTS_SOLID);	contents = CG_PointContents(trace.endpos, -1);	if (!(contents & (CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA))) {		// bubble isn't in liquid anymore, remove it		CG_FreeLocalEntity(le);		return;	}	CG_AddMoveScaleFade(le);}

/*===================CG_AllocLocalEntityWill allways succeed, even if it requires freeing an old active entity===================*/localEntity_t	*CG_AllocLocalEntity( void ) {	localEntity_t	*le;	if ( !cg_freeLocalEntities ) {		// no free entities, so free the one at the end of the chain		// remove the oldest active entity		CG_FreeLocalEntity( cg_activeLocalEntities.prev );	}	le = cg_freeLocalEntities;	cg_freeLocalEntities = cg_freeLocalEntities->next;	memset( le, 0, sizeof( *le ) );	// link into the active list	le->next = cg_activeLocalEntities.next;	le->prev = &cg_activeLocalEntities;	cg_activeLocalEntities.next->prev = le;	cg_activeLocalEntities.next = le;	return le;}

//---------------------------------------------------static void CG_AddFadeModel( localEntity_t *le ){	refEntity_t	*ent = &le->refEntity;	if ( cg.time < le->startTime )	{		CG_FreeLocalEntity( le );		return;	}	float frac = 1.0f - ((float)( cg.time - le->startTime )/(float)( le->endTime - le->startTime ));	ent->shaderRGBA[0] = le->color[0] * frac;	ent->shaderRGBA[1] = le->color[1] * frac;	ent->shaderRGBA[2] = le->color[2] * frac;	ent->shaderRGBA[3] = le->color[3] * frac;	EvaluateTrajectory( &le->pos, cg.time, ent->origin );	// add the entity	cgi_R_AddRefEntityToScene( ent );}

static void CG_AddMoveScaleFade( localEntity_t *le ) {	refEntity_t	*re;	float		c;	vector3		delta;	float		len;	refdef_t *refdef = CG_GetRefdef();	re = &le->refEntity;	if ( le->fadeInTime > le->startTime && cg.time < le->fadeInTime ) {		// fade / grow time		c = 1.0f - (float)(le->fadeInTime - cg.time) / (le->fadeInTime - le->startTime);	}	else {		// fade / grow time		c = (le->endTime - cg.time) * le->lifeRate;	}	re->shaderRGBA[3] = 0xff * c * le->color[3];	if ( !(le->leFlags & LEF_PUFF_DONT_SCALE) ) {		re->radius = le->radius * (1.0f - c) + 8;	}	BG_EvaluateTrajectory( &le->pos, cg.time, &re->origin );	// if the view would be "inside" the sprite, kill the sprite	// so it doesn't add too much overdraw	VectorSubtract( &re->origin, &refdef->vieworg, &delta );	len = VectorLength( &delta );	if ( len < le->radius ) {		CG_FreeLocalEntity( le );		return;	}	SE_R_AddRefEntityToScene( re, MAX_CLIENTS );}

void CG_AddPressureEntity(localEntity_t * le){	vec3_t velocity;//	vec3_t origin;	float alpha;	// Kill it if LCA.	if (cg.lca)		CG_FreeLocalEntity(le);	alpha = -(cg.time - le->startTime) + (le->endTime - le->startTime);	alpha /= (le->endTime - le->startTime);	//steamSound!!!	// steam:	if ( le->leFlags != LEF_AIR && le->leFlags != LEF_WATER ) {		VectorScale(le->pos.trDelta, le->size + rand() % 30, velocity);		velocity[0] += rand() % 40 - 20;		velocity[1] += rand() % 40 - 20;	} else		VectorScale(le->pos.trDelta, le->size, velocity);//	VectorCopy(le->pos.trBase, origin);	if (le->leFlags == LEF_AIR)		CG_ParticleAir(le->pos.trBase, velocity, le->life + rand() % 120, alpha, 2, 1);	else if (le->leFlags == LEF_FLAME)		CG_ParticleSteam(le->pos.trBase, velocity, le->life + rand() % 120, alpha, 2, 1,				cgs.media.flamePressureShader);	else if (le->leFlags == LEF_WATER)		CG_ParticleWater(le->pos.trBase, velocity, le->life + rand() % 120, alpha, 1, 2);	else		CG_ParticleSteam(le->pos.trBase, velocity, le->life + rand() % 120, alpha, 2, 1, 				cgs.media.smokePuffShader);}

/*==================CG_AddMoveScaleFade==================*/static void CG_AddMoveScaleFade( localEntity_t *le ) {	refEntity_t	*re;	gfixed		c;	bvec3_t		delta;	bfixed		len;	re = &le->refEntity;	if ( le->fadeInTime > le->startTime && cg.time < le->fadeInTime ) {		// fade / grow time		c = GFIXED_1 - MAKE_GFIXED( le->fadeInTime - cg.time ) / MAKE_GFIXED( le->fadeInTime - le->startTime );	}	else {		// fade / grow time		c = MAKE_GFIXED( le->endTime - cg.time ) * le->lifeRate;	}	re->shaderRGBA[3] = FIXED_TO_INT( GFIXED(255,0) * c * le->color[3] );	if ( !( le->leFlags & LEF_PUFF_DONT_SCALE ) ) {		re->radius = (le->radius * ( GFIXED_1 - c )) + BFIXED(8,0);	}	BG_EvaluateTrajectory( &le->pos, cg.time, re->origin );	// if the view would be "inside" the sprite, kill the sprite	// so it doesn't add too much overdraw	VectorSubtract( re->origin, cg.refdef.vieworg, delta );	len = FIXED_VEC3LEN( delta );	if ( len < le->radius ) {		CG_FreeLocalEntity( le );		return;	}	_CG_trap_R_AddRefEntityToScene( re );}

/*===================CG_AddLocalEntities===================*/void CG_AddLocalEntities( void ) {	localEntity_t	*le, *next;	// walk the list backwards, so any new local entities generated	// (trails, marks, etc) will be present this frame	le = cg_activeLocalEntities.prev;	for ( ; le != &cg_activeLocalEntities ; le = next ) {		// grab next now, so if the local entity is freed we		// still have it		next = le->prev;		if ( cg.time >= le->endTime ) {			CG_FreeLocalEntity( le );			continue;		}		switch ( le->leType ) {		default:			trap->Error( ERR_DROP, "Bad leType: %i", le->leType );			break;		case LE_MARK:			break;		case LE_SPRITE_EXPLOSION:			CG_AddSpriteExplosion( le );			break;		case LE_EXPLOSION:			CG_AddExplosion( le );			break;		case LE_FADE_SCALE_MODEL:			CG_AddFadeScaleModel( le );			break;		case LE_FRAGMENT:			// gibs and brass			CG_AddFragment( le );			break;		case LE_PUFF:			CG_AddPuff( le );			break;		case LE_MOVE_SCALE_FADE:		// water bubbles			CG_AddMoveScaleFade( le );			break;		case LE_FADE_RGB:				// teleporters, railtrails			CG_AddFadeRGB( le );			break;		case LE_FALL_SCALE_FADE: // gib blood trails			CG_AddFallScaleFade( le );			break;		case LE_SCALE_FADE:		// rocket trails			CG_AddScaleFade( le );			break;		case LE_SCOREPLUM:			CG_AddScorePlum( le );			break;		case LE_OLINE:			CG_AddOLine( le );			break;		case LE_SHOWREFENTITY:			CG_AddRefEntity( le );			break;		case LE_LINE:					// oriented lines for FX			CG_AddLine( le );			break;		}	}}

void CG_AddScorePlum( localEntity_t *le ) {	refEntity_t	*re;	vec3_t		origin, delta, dir, vec, up = {0, 0, 1};	float		c, len;	int			i, score, digits[10], numdigits, negative;	re = &le->refEntity;	c = ( le->endTime - cg.time ) * le->lifeRate;	score = le->radius;	if (score < 0) {		re->shaderRGBA[0] = 0xff;		re->shaderRGBA[1] = 0x11;		re->shaderRGBA[2] = 0x11;	}	else {		re->shaderRGBA[0] = 0xff;		re->shaderRGBA[1] = 0xff;		re->shaderRGBA[2] = 0xff;		if (score >= 50) {			re->shaderRGBA[1] = 0;		} else if (score >= 20) {			re->shaderRGBA[0] = re->shaderRGBA[1] = 0;		} else if (score >= 10) {			re->shaderRGBA[2] = 0;		} else if (score >= 2) {			re->shaderRGBA[0] = re->shaderRGBA[2] = 0;		}	}	if (c < 0.25)		re->shaderRGBA[3] = 0xff * 4 * c;	else		re->shaderRGBA[3] = 0xff;	re->radius = NUMBER_SIZE / 2;	VectorCopy(le->pos.trBase, origin);	origin[2] += 110 - c * 100;	VectorSubtract(cg.refdef.vieworg, origin, dir);	CrossProduct(dir, up, vec);	VectorNormalize(vec);	VectorMA(origin, -10 + 20 * sin(c * 2 * M_PI), vec, origin);	// if the view would be "inside" the sprite, kill the sprite	// so it doesn't add too much overdraw	VectorSubtract( origin, cg.refdef.vieworg, delta );	len = VectorLength( delta );	if ( len < 20 ) {		CG_FreeLocalEntity( le );		return;	}	negative = qfalse;	if (score < 0) {		negative = qtrue;		score = -score;	}	for (numdigits = 0; !(numdigits && !score); numdigits++) {		digits[numdigits] = score % 10;		score = score / 10;	}	if (negative) {		digits[numdigits] = 10;		numdigits++;	}	for (i = 0; i < numdigits; i++) {		VectorMA(origin, (float) (((float) numdigits / 2) - i) * NUMBER_SIZE, vec, re->origin);		re->customShader = cgs.media.numberShaders[digits[numdigits-1-i]];		trap->R_AddRefEntityToScene( re );	}}