mirror of
https://github.com/UberGames/rpgxEF.git
synced 2024-11-14 17:01:21 +00:00
a39565b783
... not quite content with where the project files lie but it is ok for now. ... compiling works fine so far (only tested mingw32 right now)
1318 lines
31 KiB
C
1318 lines
31 KiB
C
// Copyright (C) 1999-2000 Id Software, Inc.
|
|
//
|
|
|
|
// cg_localents.c -- every frame, generate renderer commands for locally
|
|
// processed entities, like smoke puffs, gibs, shells, etc.
|
|
|
|
#include "cg_local.h"
|
|
|
|
#define MAX_LOCAL_ENTITIES 512
|
|
localEntity_t cg_localEntities[MAX_LOCAL_ENTITIES];
|
|
localEntity_t cg_activeLocalEntities; // double linked list
|
|
localEntity_t *cg_freeLocalEntities; // single linked list
|
|
|
|
/*
|
|
===================
|
|
CG_InitLocalEntities
|
|
|
|
This is called at startup and for tournement restarts
|
|
===================
|
|
*/
|
|
void CG_InitLocalEntities( void ) {
|
|
int i;
|
|
|
|
memset( cg_localEntities, 0, sizeof( cg_localEntities ) );
|
|
cg_activeLocalEntities.next = &cg_activeLocalEntities;
|
|
cg_activeLocalEntities.prev = &cg_activeLocalEntities;
|
|
cg_freeLocalEntities = cg_localEntities;
|
|
for ( i = 0 ; i < MAX_LOCAL_ENTITIES - 1 ; i++ ) {
|
|
cg_localEntities[i].next = &cg_localEntities[i+1];
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
CG_FreeLocalEntity
|
|
==================
|
|
*/
|
|
void CG_FreeLocalEntity( localEntity_t *le ) {
|
|
if ( !le->prev ) {
|
|
CG_Error( "CG_FreeLocalEntity: not active" );
|
|
return;
|
|
}
|
|
|
|
// remove from the doubly linked active list
|
|
le->prev->next = le->next;
|
|
le->next->prev = le->prev;
|
|
|
|
// the free list is only singly linked
|
|
le->next = cg_freeLocalEntities;
|
|
cg_freeLocalEntities = le;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
CG_AllocLocalEntity
|
|
|
|
Will 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;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
CG_GetActiveList
|
|
Accessor fn
|
|
==================
|
|
*/
|
|
localEntity_t CG_GetActiveList( void )
|
|
{
|
|
return cg_activeLocalEntities;
|
|
}
|
|
|
|
/*
|
|
====================================================================================
|
|
|
|
FRAGMENT PROCESSING
|
|
|
|
A fragment localentity interacts with the environment in some way (hitting walls),
|
|
or generates more localentities along a trail.
|
|
|
|
====================================================================================
|
|
*/
|
|
|
|
|
|
/*
|
|
================
|
|
CG_ReflectVelocity
|
|
================
|
|
*/
|
|
void CG_ReflectVelocity( localEntity_t *le, trace_t *trace ) {
|
|
vec3_t velocity;
|
|
float dot;
|
|
int hitTime;
|
|
|
|
// reflect the velocity on the trace plane
|
|
hitTime = cg.time - cg.frametime + cg.frametime * trace->fraction;
|
|
BG_EvaluateTrajectoryDelta( &le->pos, hitTime, velocity );
|
|
dot = DotProduct( velocity, trace->plane.normal );
|
|
VectorMA( velocity, -2*dot, trace->plane.normal, le->pos.trDelta );
|
|
|
|
VectorScale( le->pos.trDelta, le->bounceFactor, le->pos.trDelta );
|
|
|
|
VectorCopy( trace->endpos, le->pos.trBase );
|
|
le->pos.trTime = cg.time;
|
|
|
|
|
|
// check for stop, making sure that even on low FPS systems it doesn't bobble
|
|
if ( trace->allsolid ||
|
|
( trace->plane.normal[2] > 0 &&
|
|
( le->pos.trDelta[2] < 40 || le->pos.trDelta[2] < -cg.frametime * le->pos.trDelta[2] ) ) ) {
|
|
le->pos.trType = TR_STATIONARY;
|
|
} else {
|
|
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================================================================
|
|
|
|
TRIVIAL LOCAL ENTITIES
|
|
|
|
These only do simple scaling or modulation before passing to the renderer
|
|
=====================================================================
|
|
*/
|
|
|
|
/*
|
|
====================
|
|
CG_AddFadeRGB
|
|
====================
|
|
*/
|
|
void CG_AddFadeRGB( localEntity_t *le ) {
|
|
refEntity_t *re;
|
|
float c;
|
|
|
|
re = &le->refEntity;
|
|
|
|
c = ( le->endTime - cg.time ) * le->lifeRate;
|
|
c *= 0xff;
|
|
|
|
re->shaderRGBA[0] = le->color[0] * c;
|
|
re->shaderRGBA[1] = le->color[1] * c;
|
|
re->shaderRGBA[2] = le->color[2] * c;
|
|
re->shaderRGBA[3] = le->color[3] * c;
|
|
|
|
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_AddScaleFade
|
|
|
|
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.
|
|
===================
|
|
*/
|
|
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->data.sprite.radius = le->data.sprite.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->data.sprite.radius ) {
|
|
CG_FreeLocalEntity( le );
|
|
return;
|
|
}
|
|
|
|
trap_R_AddRefEntityToScene( re );
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
CG_AddFallScaleFade
|
|
|
|
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.
|
|
=================
|
|
*/
|
|
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->data.sprite.radius = le->data.sprite.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->data.sprite.radius ) {
|
|
CG_FreeLocalEntity( le );
|
|
return;
|
|
}
|
|
|
|
trap_R_AddRefEntityToScene( re );
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
================
|
|
CG_AddExplosion
|
|
================
|
|
*/
|
|
void CG_AddExplosion( localEntity_t *ex )
|
|
{
|
|
refEntity_t *ent;
|
|
|
|
ent = &ex->refEntity;
|
|
|
|
// calculate model frame
|
|
if ( ex->lifeRate > 0 ) {
|
|
float frac = (cg.time - ex->startTime) * ex->lifeRate;
|
|
int f = floor(frac);
|
|
if ( f < 0 ) {
|
|
f = 0;
|
|
}
|
|
|
|
ent->frame = f + 1;
|
|
ent->oldframe = f;
|
|
ent->backlerp = 1.0 - ( frac - f );
|
|
ent->renderfx |= RF_CAP_FRAMES;
|
|
}
|
|
// Explosions with zero shaders (using model default shader) don't fade, so
|
|
// allow fading when this flag is set.
|
|
if ( ex->leFlags & LEF_FADE_RGB )
|
|
{
|
|
float frac = (float)( cg.time - ex->startTime )/(float)( ex->endTime - ex->startTime );
|
|
|
|
ent->shaderRGBA[0] =
|
|
ent->shaderRGBA[1] =
|
|
ent->shaderRGBA[2] = frac * 255;
|
|
ent->shaderRGBA[3] = 255;
|
|
}
|
|
|
|
// add the entity
|
|
trap_R_AddRefEntityToScene(ent);
|
|
|
|
// add the dlight
|
|
if ( ex->light ) {
|
|
float light;
|
|
|
|
light = (float)( cg.time - ex->startTime ) / ( ex->endTime - ex->startTime );
|
|
if ( light < 0.5 ) {
|
|
light = 1.0;
|
|
} else {
|
|
light = 1.0 - ( light - 0.5 ) * 2;
|
|
}
|
|
light = ex->light * light;
|
|
trap_R_AddLightToScene(ent->origin, light, ex->lightColor[0], ex->lightColor[1], ex->lightColor[2] );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
CG_AddSpriteExplosion
|
|
================
|
|
*/
|
|
void CG_AddSpriteExplosion( localEntity_t *le )
|
|
{
|
|
refEntity_t re;
|
|
float c;
|
|
|
|
re = le->refEntity;
|
|
|
|
c = ( le->endTime - cg.time ) / ( float ) ( le->endTime - le->startTime );
|
|
if ( c > 1 ) {
|
|
c = 1.0; // can happen during connection problems
|
|
}
|
|
|
|
re.shaderRGBA[0] = 0xff;
|
|
re.shaderRGBA[1] = 0xff;
|
|
re.shaderRGBA[2] = 0xff;
|
|
re.shaderRGBA[3] = 0xff * c * 0.33;
|
|
|
|
re.reType = RT_SPRITE;
|
|
re.data.sprite.radius = 42 * ( 1.0 - c ) + 30;
|
|
|
|
trap_R_AddRefEntityToScene( &re );
|
|
|
|
// add the dlight
|
|
if ( le->light ) {
|
|
float light;
|
|
|
|
light = (float)( cg.time - le->startTime ) / ( le->endTime - le->startTime );
|
|
if ( light < 0.5 ) {
|
|
light = 1.0;
|
|
} else {
|
|
light = 1.0 - ( light - 0.5 ) * 2;
|
|
}
|
|
light = le->light * light;
|
|
trap_R_AddLightToScene(re.origin, light, le->lightColor[0], le->lightColor[1], le->lightColor[2] );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
===================
|
|
CG_AddScaleFadeSprite
|
|
|
|
For 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_AddQuad
|
|
|
|
Of 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 );
|
|
}
|
|
|
|
|
|
/*
|
|
===================
|
|
CG_AddLine
|
|
|
|
For trek, for beams and the like.
|
|
===================
|
|
*/
|
|
void CG_AddLine( 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.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->reType = RT_LINE;
|
|
|
|
trap_R_AddRefEntityToScene( re );
|
|
}
|
|
|
|
|
|
/*
|
|
===================
|
|
CG_AddOLine
|
|
|
|
For trek, for rectangles.
|
|
===================
|
|
*/
|
|
void 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.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.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->reType = RT_ORIENTEDLINE;
|
|
|
|
trap_R_AddRefEntityToScene( re );
|
|
}
|
|
|
|
/*
|
|
===================
|
|
CG_AddLine2
|
|
|
|
For 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 );
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
===================
|
|
CG_AddTrail
|
|
|
|
For trek, for sparks and the like.
|
|
===================
|
|
*/
|
|
void CG_AddTrail( localEntity_t *le )
|
|
{
|
|
refEntity_t *re;
|
|
float frac, length, alpha;
|
|
vec3_t dir;
|
|
trace_t trace;
|
|
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.trail.width + (le->data.trail.dwidth * frac);
|
|
if (re->data.line.width <= 0)
|
|
{
|
|
CG_FreeLocalEntity( le );
|
|
return;
|
|
}
|
|
|
|
if (!(le->leFlags & LEF_MOVE))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
|
|
// Set the length based on the velocity of the bit.
|
|
length = le->data.trail.length + (le->data.trail.dlength * frac);
|
|
if (length <= 0)
|
|
{
|
|
CG_FreeLocalEntity( le );
|
|
return;
|
|
}
|
|
|
|
VectorMA(re->origin, length, dir, re->oldorigin);
|
|
|
|
// We will assume here that we want additive transparency effects.
|
|
alpha = le->alpha + (le->dalpha * frac);
|
|
VectorMA(le->data.trail.startRGB, frac, le->data.trail.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; // Yes, we could apply c to this too, but fading the color is better for lines.
|
|
|
|
re->reType = RT_LINE;
|
|
|
|
trap_R_AddRefEntityToScene( re );
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
===================
|
|
CG_AddViewSprite
|
|
|
|
For trek, view sprites like smoke and the like.
|
|
===================
|
|
*/
|
|
void CG_AddViewSprite( localEntity_t *le )
|
|
{
|
|
refEntity_t *re;
|
|
float frac, alpha;
|
|
vec3_t delta;
|
|
float len;
|
|
trace_t trace;
|
|
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 (le->leFlags & LEF_MOVE)
|
|
{
|
|
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 );
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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_SPRITE;
|
|
|
|
trap_R_AddRefEntityToScene( re );
|
|
}
|
|
|
|
|
|
/*
|
|
===================
|
|
CG_AddBezier
|
|
|
|
For 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_AddCylinder
|
|
|
|
For 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_AddElectricity
|
|
|
|
For trek, electricity primitive.
|
|
===================
|
|
*/
|
|
|
|
#define DEFAULT_DEVIATION 0.5
|
|
|
|
void CG_AddElectricity( 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;
|
|
|
|
re->data.electricity.width = le->data.electricity.width + (le->data.electricity.dwidth*frac);
|
|
|
|
// 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_ELECTRICITY;
|
|
|
|
trap_R_AddRefEntityToScene( re );
|
|
}
|
|
|
|
/*
|
|
===================
|
|
CG_AddParticle
|
|
|
|
For trek, special explosion stuff sometimes wants these
|
|
===================
|
|
*/
|
|
static void CG_AddParticle( localEntity_t *le )
|
|
{
|
|
refEntity_t *re;
|
|
float frac, alpha;
|
|
vec3_t delta, dir;
|
|
float len;
|
|
trace_t trace;
|
|
|
|
re = &le->refEntity;
|
|
|
|
//safety check - since this renders over all, make sure we can't see this thru a wall
|
|
if ( re->renderfx & RF_DEPTHHACK ) {
|
|
CG_Trace( &trace, re->origin, NULL, NULL, cg.refdef.vieworg, cg.predictedPlayerState.clientNum, MASK_SOLID );
|
|
|
|
if ( trace.fraction != 1.0 )
|
|
return;
|
|
|
|
}
|
|
|
|
frac = ( cg.time - le->startTime ) / ( float ) ( le->endTime - le->startTime );
|
|
if ( le->leFlags & LEF_SINE_SCALE ) {
|
|
//frac = 1.0-(0.5f * sin( 4.0f * frac + 0.75f ) + 0.5f); //TiM: Sine calc //+ 1.5f
|
|
frac = 1.0-(0.65 * sin( 3.0 * frac +0.75 ) + 0.35);
|
|
}
|
|
|
|
if ( frac > 1 )
|
|
frac = 1.0; // can happen during connection problems
|
|
else if (frac < 0)
|
|
frac = 0.0;
|
|
|
|
//CG_Printf( "%f\n", frac );
|
|
|
|
// Use the liferate to set the scale over time.
|
|
if ( !(le->leFlags & LEF_REVERSE_SCALE) )
|
|
re->data.sprite.radius = le->data.particle.radius + (le->data.particle.dradius*frac);
|
|
else
|
|
re->data.sprite.radius = le->data.particle.radius - (le->data.particle.dradius*frac);
|
|
if (re->data.sprite.radius <= 0)
|
|
{
|
|
CG_FreeLocalEntity( le );
|
|
return;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
// 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.particle.radius ) {
|
|
CG_FreeLocalEntity( le );
|
|
return;
|
|
}
|
|
|
|
// kef -- here's where I, in my infinite wisdom, have decided to emulate the singleplayer
|
|
//particle think function
|
|
VectorNegate(dir, le->data.particle.dir);
|
|
if (le->data.particle.thinkFn)
|
|
{
|
|
le->data.particle.thinkFn(le);
|
|
}
|
|
|
|
// 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_SPRITE;
|
|
|
|
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_AddFragment
|
|
================
|
|
*/
|
|
void CG_AddFragment( localEntity_t *le ) {
|
|
vec3_t newOrigin;
|
|
trace_t trace;
|
|
int k;
|
|
|
|
if ( le->pos.trType == TR_STATIONARY ) {
|
|
// sink into the ground if near the removal time
|
|
int t;
|
|
float oldZ;
|
|
|
|
t = le->endTime - cg.time;
|
|
if ( t < SINK_TIME ) {
|
|
// we must use an explicit lighting origin, otherwise the
|
|
// lighting would be lost as soon as the origin went
|
|
// into the ground
|
|
VectorCopy( le->refEntity.origin, le->refEntity.lightingOrigin );
|
|
le->refEntity.renderfx |= RF_LIGHTING_ORIGIN;
|
|
oldZ = le->refEntity.origin[2];
|
|
le->refEntity.origin[2] -= 16 * ( 1.0 - (float)t / SINK_TIME );
|
|
trap_R_AddRefEntityToScene( &le->refEntity );
|
|
le->refEntity.origin[2] = oldZ;
|
|
} else {
|
|
trap_R_AddRefEntityToScene( &le->refEntity );
|
|
}
|
|
|
|
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, 0 /*le->ownerGentNum*/, 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 );
|
|
for(k = 0; k < 3; k++)
|
|
{
|
|
VectorScale(le->refEntity.axis[k], le->data.fragment.radius, le->refEntity.axis[k]);
|
|
}
|
|
|
|
}
|
|
|
|
trap_R_AddRefEntityToScene( &le->refEntity );
|
|
|
|
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;
|
|
}
|
|
|
|
// reflect the velocity on the trace plane
|
|
CG_ReflectVelocity( le, &trace );
|
|
//FIXME: if LEF_TUMBLE, change avelocity too?
|
|
|
|
trap_R_AddRefEntityToScene( &le->refEntity );
|
|
}
|
|
|
|
|
|
//==============================================================================
|
|
|
|
/*
|
|
===================
|
|
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;
|
|
}
|
|
|
|
if (le->leFlags & LEF_ONE_FRAME)
|
|
{ // If this flag is set, only render one single frame, no more.
|
|
if (le->leFlags & LEF_ONE_FRAME_DONE)
|
|
{
|
|
CG_FreeLocalEntity( le );
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
le->leFlags |= LEF_ONE_FRAME_DONE;
|
|
}
|
|
}
|
|
|
|
switch ( le->leType ) {
|
|
default:
|
|
CG_Error( "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_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_SCALE_FADE_SPRITE: // Trek type for oriented poly sprites.
|
|
CG_AddScaleFadeSprite( le );
|
|
break;
|
|
|
|
case LE_LINE: // Trek type for beams.
|
|
CG_AddLine( le );
|
|
break;
|
|
|
|
case LE_LINE2: // Trek type for beams, with taper support.
|
|
CG_AddLine2( le );
|
|
break;
|
|
|
|
case LE_OLINE: // Trek type for rectangles
|
|
CG_AddOLine( le );
|
|
break;
|
|
|
|
case LE_TRAIL: // Trek type for sparks.
|
|
CG_AddTrail( le );
|
|
break;
|
|
|
|
case LE_VIEWSPRITE: // Trek primitive for camera-facing sprites.
|
|
CG_AddViewSprite( le );
|
|
break;
|
|
|
|
case LE_BEZIER:
|
|
CG_AddBezier( le );
|
|
break;
|
|
|
|
case LE_QUAD:
|
|
CG_AddQuad( le );
|
|
break;
|
|
|
|
case LE_CYLINDER:
|
|
CG_AddCylinder(le);
|
|
break;
|
|
|
|
case LE_ELECTRICITY:
|
|
CG_AddElectricity(le);
|
|
break;
|
|
|
|
case LE_PARTICLE:
|
|
CG_AddParticle(le);
|
|
break;
|
|
|
|
case LE_SPAWNER:
|
|
CG_AddSpawner(le);
|
|
break;
|
|
|
|
case LE_FRAGMENT:
|
|
CG_AddFragment(le);
|
|
break;
|
|
|
|
case LE_STASISDOOR:
|
|
if(le->refEntity.data.cylinder.wrap) {
|
|
le->refEntity.shaderRGBA[3] = (1 - (le->endTime - cg.time)/1000) * 255;
|
|
} else {
|
|
le->refEntity.shaderRGBA[3] = ((le->endTime - cg.time)/1000) * 255;
|
|
}
|
|
trap_R_AddRefEntityToScene(&le->refEntity);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|