codemp/cgame/cg_ents.c

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
// cg_ents.c -- present snapshot entities, happens every single frame

#include "cg_local.h"
/*
Ghoul2 Insert Start
*/
#include "..\game\q_shared.h"
#include "..\ghoul2\g2.h"
/*
Ghoul2 Insert end
*/

extern qboolean CG_InFighter( void );
static void CG_Missile( centity_t *cent );

/*
======================
CG_PositionEntityOnTag

Modifies the entities position and axis by the given
tag location
======================
*/
void CG_PositionEntityOnTag( refEntity_t *entity, const refEntity_t *parent, 
                                                        qhandle_t parentModel, char *tagName ) {
        int                             i;
        orientation_t   lerped;
        
        // lerp the tag
        trap_R_LerpTag( &lerped, parentModel, parent->oldframe, parent->frame,
                1.0 - parent->backlerp, tagName );

        // FIXME: allow origin offsets along tag?
        VectorCopy( parent->origin, entity->origin );
        for ( i = 0 ; i < 3 ; i++ ) {
                VectorMA( entity->origin, lerped.origin[i], parent->axis[i], entity->origin );
        }

        // had to cast away the const to avoid compiler problems...
        MatrixMultiply( lerped.axis, ((refEntity_t *)parent)->axis, entity->axis );
        entity->backlerp = parent->backlerp;
}


/*
======================
CG_PositionRotatedEntityOnTag

Modifies the entities position and axis by the given
tag location
======================
*/
void CG_PositionRotatedEntityOnTag( refEntity_t *entity, const refEntity_t *parent, 
                                                        qhandle_t parentModel, char *tagName ) {
        int                             i;
        orientation_t   lerped;
        vec3_t                  tempAxis[3];

//AxisClear( entity->axis );
        // lerp the tag
        trap_R_LerpTag( &lerped, parentModel, parent->oldframe, parent->frame,
                1.0 - parent->backlerp, tagName );

        // FIXME: allow origin offsets along tag?
        VectorCopy( parent->origin, entity->origin );
        for ( i = 0 ; i < 3 ; i++ ) {
                VectorMA( entity->origin, lerped.origin[i], parent->axis[i], entity->origin );
        }

        // had to cast away the const to avoid compiler problems...
        MatrixMultiply( entity->axis, lerped.axis, tempAxis );
        MatrixMultiply( tempAxis, ((refEntity_t *)parent)->axis, entity->axis );
}



/*
==========================================================================

FUNCTIONS CALLED EACH FRAME

==========================================================================
*/

//only need to use the CG_S_ system when you want a looping sound that isn't going to add itself
//via trap each frame. Such as ones generated by events.
/*
======================
CG_SetEntitySoundPosition

Also called by event processing code
======================
*/
void CG_SetEntitySoundPosition( centity_t *cent ) {
        if ( cent->currentState.solid == SOLID_BMODEL )
        {
                vec3_t  origin;
                float   *v;

                v = cgs.inlineModelMidpoints[ cent->currentState.modelindex ];
                VectorAdd( cent->lerpOrigin, v, origin );
                trap_S_UpdateEntityPosition( cent->currentState.number, origin );
        }
        else
        {
                trap_S_UpdateEntityPosition( cent->currentState.number, cent->lerpOrigin );
        }
}

/*
==================
CG_S_AddLoopingSound

Set the current looping sounds on the entity.
==================
*/
void CG_S_AddLoopingSound(int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx)
{
        centity_t *cent = &cg_entities[entityNum];
        cgLoopSound_t *cSound = NULL;
        int i = 0;
        qboolean alreadyPlaying = qfalse;

        //first see if we're already looping this sound handle.
        while (i < cent->numLoopingSounds)
        {
                cSound = &cent->loopingSound[i];

                if (cSound->sfx == sfx)
                {
                        alreadyPlaying = qtrue;
                        break;
                }
        }
        
        if (alreadyPlaying && cSound)
        { //if this is the case, just update the properties of the looping sound and return.
                VectorCopy(origin, cSound->origin);
                VectorCopy(velocity, cSound->velocity);
        }
        else if (cent->numLoopingSounds >= MAX_CG_LOOPSOUNDS)
        { //Just don't add it then I suppose.
#ifdef _XBOX    // We decreased this number, so I'd like to know if it gets overflowed
                Com_Printf( S_COLOR_YELLOW "Warning: MAX_CG_LOOPSOUNDS exceeded!!\n" );
#endif
                return;
        }

        //Add a new looping sound.
        cSound = &cent->loopingSound[cent->numLoopingSounds];

        cSound->entityNum = entityNum;
        VectorCopy(origin, cSound->origin);
        VectorCopy(velocity, cSound->velocity);
        cSound->sfx = sfx;

        cent->numLoopingSounds++;
}

/*
==================
CG_S_AddLoopingSound

For now just redirect, might eventually do something different.
==================
*/
void CG_S_AddRealLoopingSound(int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx)
{
        CG_S_AddLoopingSound(entityNum, origin, velocity, sfx);
}

/*
==================
CG_S_AddLoopingSound

Clear looping sounds.
==================
*/
void CG_S_StopLoopingSound(int entityNum, sfxHandle_t sfx)
{
        centity_t *cent = &cg_entities[entityNum];
        cgLoopSound_t *cSound;

        if (sfx == -1)
        { //clear all the looping sounds on the entity
                cent->numLoopingSounds = 0;
        }
        else
        { //otherwise, clear only the specified looping sound
                int i = 0;

                while (i < cent->numLoopingSounds)
                {
                        cSound = &cent->loopingSound[i];

                        if (cSound->sfx == sfx)
                        { //remove it then
                                int x = i+1;

                                while (x < cent->numLoopingSounds)
                                {
                                        memcpy(&cent->loopingSound[x-1], &cent->loopingSound[x], sizeof(cent->loopingSound[x]));
                                        x++;
                                }
                                cent->numLoopingSounds--;
                        }

                        i++;
                }
        }
        //trap_S_StopLoopingSound(entityNum);
}

/*
==================
CG_S_UpdateLoopingSounds

Update any existing looping sounds on the entity.
==================
*/
void CG_S_UpdateLoopingSounds(int entityNum)
{
        centity_t *cent = &cg_entities[entityNum];
        cgLoopSound_t *cSound;
        vec3_t lerpOrg;
        float *v;
        int i = 0;

        if (!cent->numLoopingSounds)
        {
                return;
        }

        if (cent->currentState.eType == ET_MOVER)
        {
                v = cgs.inlineModelMidpoints[ cent->currentState.modelindex ];
                VectorAdd( cent->lerpOrigin, v, lerpOrg );
        }
        else
        {
                VectorCopy(cent->lerpOrigin, lerpOrg);
        }

        while (i < cent->numLoopingSounds)
        {
                cSound = &cent->loopingSound[i];

                //trap_S_AddLoopingSound(entityNum, cSound->origin, cSound->velocity, cSound->sfx);
                //I guess just keep using lerpOrigin for now,
                trap_S_AddLoopingSound(entityNum, lerpOrg, cSound->velocity, cSound->sfx);
                i++;
        }
}

/*
==================
CG_EntityEffects

Add continuous entity effects, like local entity emission and lighting
==================
*/
static void CG_EntityEffects( centity_t *cent ) {

        // update sound origins
        CG_SetEntitySoundPosition( cent );

        // add loop sound
        if ( cent->currentState.loopSound || (cent->currentState.loopIsSoundset && cent->currentState.number >= MAX_CLIENTS) ) {
                sfxHandle_t realSoundIndex = -1;
                        
                if (cent->currentState.loopIsSoundset && cent->currentState.number >= MAX_CLIENTS)
                { //If this is so, then first get our soundset from the index, and loopSound actually contains which part of the set to
                  //use rather than a sound index (BMS_START [0], BMS_MID [1], or BMS_END [2]). Typically loop sounds will be BMS_MID.
                        const char *soundSet;
                        
                        soundSet = CG_ConfigString( CS_AMBIENT_SET + cent->currentState.soundSetIndex );

                        if (soundSet && soundSet[0])
                        {
                                realSoundIndex = trap_AS_GetBModelSound(soundSet, cent->currentState.loopSound);
                        }
                }
                else
                {
                        realSoundIndex = cgs.gameSounds[ cent->currentState.loopSound ];
                }

                //rww - doors and things with looping sounds have a crazy origin (being brush models and all)
                if (realSoundIndex != -1)
                {
                        if ( cent->currentState.solid == SOLID_BMODEL )
                        {
                                vec3_t  origin;
                                float   *v;

                                v = cgs.inlineModelMidpoints[ cent->currentState.modelindex ];
                                VectorAdd( cent->lerpOrigin, v, origin );
                                trap_S_AddLoopingSound( cent->currentState.number, origin, vec3_origin, 
                                        realSoundIndex );
                        }
                        else if (cent->currentState.eType != ET_SPEAKER) {
                                trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, 
                                        realSoundIndex );
                        } else {
                                trap_S_AddRealLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, 
                                        realSoundIndex );
                        }
                }
        }


        // constant light glow
        if ( cent->currentState.constantLight ) {
                int             cl;
                int             i, r, g, b;

                cl = cent->currentState.constantLight;
                r = cl & 255;
                g = ( cl >> 8 ) & 255;
                b = ( cl >> 16 ) & 255;
                i = ( ( cl >> 24 ) & 255 ) * 4;
                trap_R_AddLightToScene( cent->lerpOrigin, i, r, g, b );
        }

}

localEntity_t *FX_AddOrientedLine(vec3_t start, vec3_t end, vec3_t normal, float stScale, float scale,
                                                                  float dscale, float startalpha, float endalpha, float killTime, qhandle_t shader)
{
        localEntity_t   *le;
        
#ifdef _DEBUG
        if (!shader)
        {
                Com_Printf("FX_AddLine: NULL shader\n");
        }
#endif

        le = CG_AllocLocalEntity();
        le->leType = LE_OLINE;

        le->startTime = cg.time;
        le->endTime = le->startTime + killTime;
        le->data.line.width = scale;
        le->data.line.dwidth = dscale;

        le->alpha = startalpha;
        le->dalpha = endalpha - startalpha;

        le->refEntity.data.line.stscale = stScale;
        le->refEntity.data.line.width = scale;

        le->refEntity.customShader = shader;

        // set origin
        VectorCopy ( start, le->refEntity.origin);
        VectorCopy ( end, le->refEntity.oldorigin );

        AxisClear(le->refEntity.axis);
        VectorCopy( normal, le->refEntity.axis[0] );
        RotateAroundDirection( le->refEntity.axis, 0); // le->refEntity.data.sprite.rotation ); This is roll in quad land

        le->refEntity.shaderRGBA[0] = 0xff;
        le->refEntity.shaderRGBA[1] = 0xff;
        le->refEntity.shaderRGBA[2] = 0xff;
        le->refEntity.shaderRGBA[3] = 0xff;

        le->color[0] = 1.0;
        le->color[1] = 1.0;
        le->color[2] = 1.0;
        le->color[3] = 1.0;
        le->lifeRate = 1.0 / ( le->endTime - le->startTime );

        return(le);
}

void FX_DrawPortableShield(centity_t *cent)
{
        //rww - this code differs a bit from the draw code in EF, I don't know why I had to do
        //it this way yet it worked in EF the other way.

        int                             xaxis, height, posWidth, negWidth, team;
        vec3_t                  start, end, normal;
        localEntity_t   *le;
        qhandle_t               shader;
        char                    buf[1024];

        trap_Cvar_VariableStringBuffer("cl_paused", buf, sizeof(buf));

        if (atoi(buf))
        { //rww - fix to keep from rendering repeatedly while HUD menu is up
                return;
        }

        if (cent->currentState.eFlags & EF_NODRAW)
        {
                return;
        }

        // decode the data stored in time2
        xaxis = ((cent->currentState.time2 >> 24) & 1);
        height = ((cent->currentState.time2 >> 16) & 255);
        posWidth = ((cent->currentState.time2 >> 8) & 255);
        negWidth = (cent->currentState.time2 & 255);

        team = (cent->currentState.otherEntityNum2);

        VectorClear(normal);

        VectorCopy(cent->lerpOrigin, start);
        VectorCopy(cent->lerpOrigin, end);

        if (xaxis) // drawing along x-axis
        {
                start[0] -= negWidth;
                end[0] += posWidth;
        }
        else
        {
                start[1] -= negWidth;
                end[1] += posWidth;
        }

        normal[0] = 1;
        normal[1] = 1;

        start[2] += height/2;
        end[2] += height/2;

        if (team == TEAM_RED)
        {
                if (cent->currentState.trickedentindex)
                {
                        shader = trap_R_RegisterShader( "gfx/misc/red_dmgshield" );
                }
                else
                {
                        shader = trap_R_RegisterShader( "gfx/misc/red_portashield" );
                }
        }
        else
        {
                if (cent->currentState.trickedentindex)
                {
                        shader = trap_R_RegisterShader( "gfx/misc/blue_dmgshield" );
                }
                else
                {
                        shader = trap_R_RegisterShader( "gfx/misc/blue_portashield" );
                }
        }

        le = FX_AddOrientedLine(start, end, normal, 1.0f, height, 0.0f, 1.0f, 1.0f, 50.0, shader);
}

/*
==================
CG_Special
==================
*/
void CG_Special( centity_t *cent ) {
        entityState_t           *s1;

        s1 = &cent->currentState;

        if (!s1)
        {
                return;
        }

        // if set to invisible, skip
        if (!s1->modelindex) {
                return;
        }

        if (s1->modelindex == HI_SHIELD) 
        {       // The portable shield should go through a different rendering function.
                FX_DrawPortableShield(cent);
                return;
        }
}

/*
Ghoul2 Insert Start
*/

// Copy the ghoul2 data into the ref ent correctly
void CG_SetGhoul2Info( refEntity_t *ent, centity_t *cent)
{

        ent->ghoul2 = cent->ghoul2;
        VectorCopy( cent->modelScale, ent->modelScale);
        ent->radius = cent->radius;
        VectorCopy (cent->lerpAngles, ent->angles);
}



// create 8 new points on screen around a model so we can see it's bounding box
void CG_CreateBBRefEnts(entityState_t *s1, vec3_t origin )
{
/* 
//g2r
#if _DEBUG
        refEntity_t             point[8];
        int                             i;
        vec3_t                  angles = {0,0,0};

        for (i=0; i<8; i++)
        {
                memset (&point[i], 0, sizeof(refEntity_t));
                point[i].reType = RT_SPRITE;
                point[i].radius = 1;
                point[i].customShader = trap_R_RegisterShader("textures/tests/circle");
                point[i].shaderRGBA[0] = 255;
                point[i].shaderRGBA[1] = 255;
                point[i].shaderRGBA[2] = 255;
                point[i].shaderRGBA[3] = 255;

                AnglesToAxis( angles, point[i].axis );

                // now, we need to put the correct origins into each origin from the mins and max's
                switch(i)
                {
                case 0:
                        VectorCopy(s1->mins, point[i].origin);
                        break;
                case 1:
                        VectorCopy(s1->mins, point[i].origin);
                        point[i].origin[0] = s1->maxs[0];
                        break;
                case 2:
                        VectorCopy(s1->mins, point[i].origin);
                        point[i].origin[1] = s1->maxs[1];
                        break;
                case 3:
                        VectorCopy(s1->mins, point[i].origin);
                        point[i].origin[0] = s1->maxs[0];
                        point[i].origin[1] = s1->maxs[1];
                        break;
                case 4:
                        VectorCopy(s1->maxs, point[i].origin);
                        break;
                case 5:
                        VectorCopy(s1->maxs, point[i].origin);
                        point[i].origin[0] = s1->mins[0];
                        break;
                case 6:
                        VectorCopy(s1->maxs, point[i].origin);
                        point[i].origin[1] = s1->mins[1];
                        break;
                case 7:
                        VectorCopy(s1->maxs, point[i].origin);
                        point[i].origin[0] = s1->mins[0];
                        point[i].origin[1] = s1->mins[1];
                        break;
                }

                // add the original origin to each point and then stuff them out there
                VectorAdd(point[i].origin, origin, point[i].origin);

                trap_R_AddRefEntityToScene (&point[i]);
        }
#endif
        */
}

// write in the axis and stuff
void G2_BoltToGhoul2Model(centity_t *cent, refEntity_t *ent)
{
                // extract the wraith ID from the bolt info
        int modelNum = cent->boltInfo >> MODEL_SHIFT;
        int boltNum     = cent->boltInfo >> BOLT_SHIFT;
        int     entNum = cent->boltInfo >> ENTITY_SHIFT;
        mdxaBone_t              boltMatrix;
        
        modelNum &= MODEL_AND;
        boltNum &= BOLT_AND;
        entNum &= ENTITY_AND;


        //NOTENOTE I put this here because the cgs.gamemodels array no longer gets initialized.
        assert(0);              


        // go away and get me the bolt position for this frame please
        trap_G2API_GetBoltMatrix(cent->ghoul2, modelNum, boltNum, &boltMatrix, cg_entities[entNum].currentState.angles, cg_entities[entNum].currentState.origin, cg.time, cgs.gameModels, cent->modelScale);

        // set up the axis and origin we need for the actual effect spawning
        ent->origin[0] = boltMatrix.matrix[0][3];
        ent->origin[1] = boltMatrix.matrix[1][3];
        ent->origin[2] = boltMatrix.matrix[2][3];

        ent->axis[0][0] = boltMatrix.matrix[0][0];
        ent->axis[0][1] = boltMatrix.matrix[1][0];
        ent->axis[0][2] = boltMatrix.matrix[2][0];

        ent->axis[1][0] = boltMatrix.matrix[0][1];
        ent->axis[1][1] = boltMatrix.matrix[1][1];
        ent->axis[1][2] = boltMatrix.matrix[2][1];

        ent->axis[2][0] = boltMatrix.matrix[0][2];
        ent->axis[2][1] = boltMatrix.matrix[1][2];
        ent->axis[2][2] = boltMatrix.matrix[2][2];
}

void ScaleModelAxis(refEntity_t *ent)

{               // scale the model should we need to
                if (ent->modelScale[0] && ent->modelScale[0] != 1.0f)
                {
                        VectorScale( ent->axis[0], ent->modelScale[0] , ent->axis[0] );
                        ent->nonNormalizedAxes = qtrue;
                }
                if (ent->modelScale[1] && ent->modelScale[1] != 1.0f)
                {
                        VectorScale( ent->axis[1], ent->modelScale[1] , ent->axis[1] );
                        ent->nonNormalizedAxes = qtrue;
                }
                if (ent->modelScale[2] && ent->modelScale[2] != 1.0f)
                {
                        VectorScale( ent->axis[2], ent->modelScale[2] , ent->axis[2] );
                        ent->nonNormalizedAxes = qtrue;
                }
}
/*
Ghoul2 Insert End
*/

char *forceHolocronModels[] = {
        "models/map_objects/mp/lt_heal.md3",            //FP_HEAL,
        "models/map_objects/mp/force_jump.md3",         //FP_LEVITATION,
        "models/map_objects/mp/force_speed.md3",        //FP_SPEED,
        "models/map_objects/mp/force_push.md3",         //FP_PUSH,
        "models/map_objects/mp/force_pull.md3",         //FP_PULL,
        "models/map_objects/mp/lt_telepathy.md3",       //FP_TELEPATHY,
        "models/map_objects/mp/dk_grip.md3",            //FP_GRIP,
        "models/map_objects/mp/dk_lightning.md3",       //FP_LIGHTNING,
        "models/map_objects/mp/dk_rage.md3",            //FP_RAGE,
        "models/map_objects/mp/lt_protect.md3",         //FP_PROTECT,
        "models/map_objects/mp/lt_absorb.md3",          //FP_ABSORB,
        "models/map_objects/mp/lt_healother.md3",       //FP_TEAM_HEAL,
        "models/map_objects/mp/dk_powerother.md3",      //FP_TEAM_FORCE,
        "models/map_objects/mp/dk_drain.md3",           //FP_DRAIN,
        "models/map_objects/mp/force_sight.md3",        //FP_SEE,
        "models/map_objects/mp/saber_attack.md3",       //FP_SABER_OFFENSE,
        "models/map_objects/mp/saber_defend.md3",       //FP_SABER_DEFENSE,
        "models/map_objects/mp/saber_throw.md3"         //FP_SABERTHROW
};

void CG_Disintegration(centity_t *cent, refEntity_t *ent)
{
        vec3_t tempAng, hitLoc;
        float tempLength;

        VectorCopy(cent->currentState.origin2, hitLoc);

        VectorSubtract( hitLoc, ent->origin, ent->oldorigin );
        
        tempLength = VectorNormalize( ent->oldorigin );
        vectoangles( ent->oldorigin, tempAng );
        tempAng[YAW] -= cent->lerpAngles[YAW];
        AngleVectors( tempAng, ent->oldorigin, NULL, NULL );
        VectorScale( ent->oldorigin, tempLength, ent->oldorigin );

        ent->endTime = cent->dustTrailTime;

        ent->renderfx |= RF_DISINTEGRATE2;
        ent->customShader = cgs.media.disruptorShader;
        trap_R_AddRefEntityToScene( ent );

        ent->renderfx &= ~(RF_DISINTEGRATE2);
        ent->renderfx |= (RF_DISINTEGRATE1);
        ent->customShader = 0;
        trap_R_AddRefEntityToScene( ent );

        if ( cg.time - ent->endTime < 1000 && (cg_timescale.value * cg_timescale.value * random()) > 0.05f )
        {
                vec3_t fxOrg, fxDir;
                mdxaBone_t      boltMatrix;
                int torsoBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "lower_lumbar");

                VectorSet(fxDir, 0, 1, 0);

                trap_G2API_GetBoltMatrix( cent->ghoul2, 0, torsoBolt, &boltMatrix, cent->lerpAngles, cent->lerpOrigin, cg.time, 
                                cgs.gameModels, cent->modelScale);
                                BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, fxOrg );

                VectorMA( fxOrg, -18, cg.refdef.viewaxis[0], fxOrg );
                fxOrg[2] += crandom() * 20;
                trap_FX_PlayEffectID( cgs.effects.mDisruptorDeathSmoke, fxOrg, fxDir, -1, -1 );

                if ( random() > 0.5f )
                {
                        trap_FX_PlayEffectID( cgs.effects.mDisruptorDeathSmoke, fxOrg, fxDir, -1, -1 );
                }
        }
}

extern int cgSiegeEntityRender;
static qboolean CG_RenderTimeEntBolt(centity_t *cent)
{
        int clientNum = cent->currentState.boltToPlayer-1;
        centity_t *cl;
        mdxaBone_t matrix;
        vec3_t boltOrg, boltAng;
        int getBolt = -1;

        if (clientNum >= MAX_CLIENTS || clientNum < 0)
        {
                assert(0);
                return qfalse;
        }

        cl = &cg_entities[clientNum];

        if (!cl->ghoul2)
        {
                assert(0);
                return qfalse;
        }

        if (clientNum == cg.predictedPlayerState.clientNum &&
                !cg.renderingThirdPerson)
        { //If in first person and you have it then render the thing spinning around on your hud.
                cgSiegeEntityRender = cent->currentState.number; //set it to render at the end of the frame.
                return qfalse;
        }

        getBolt = trap_G2API_AddBolt(cl->ghoul2, 0, "lhand");

        trap_G2API_GetBoltMatrix(cl->ghoul2, 0, getBolt, &matrix, cl->turAngles, cl->lerpOrigin, cg.time, cgs.gameModels, cl->modelScale);

        BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, boltOrg);
        BG_GiveMeVectorFromMatrix(&matrix, NEGATIVE_Y, boltAng);
        vectoangles(boltAng, boltAng);
        boltAng[PITCH] = boltAng[ROLL] = 0;

        VectorCopy(boltOrg, cent->lerpOrigin);
        VectorCopy(boltAng, cent->lerpAngles);

        return qtrue;
}

/*
static void CG_SiegeEntRenderAboveHead(centity_t *cent)
{
        int clientNum = cent->currentState.boltToPlayer-1;
        centity_t *cl;
        refEntity_t ent;
        vec3_t renderAngles;

        if (clientNum >= MAX_CLIENTS || clientNum < 0)
        {
                assert(0);
                return;
        }

        cl = &cg_entities[clientNum];

        memset(&ent, 0, sizeof(ent));

        //Set the angles to the global auto rotating ones, and the origin to slightly above the client
        VectorCopy(cg.autoAngles, renderAngles);
        AnglesToAxis( renderAngles, ent.axis );
        VectorCopy(cl->lerpOrigin, ent.origin);
        ent.origin[2] += 50;

        //Set the model (ghoul2 or md3/other)
        if (cent->ghoul2)
        {
                ent.ghoul2 = cent->ghoul2;
                ent.hModel = 0;
        }
        else
        {
                ent.ghoul2 = NULL;
                ent.hModel = cgs.gameModels[cent->currentState.modelindex];
        }

        //Scale it up
        ent.modelScale[0] = 1.5f;
        ent.modelScale[1] = 1.5f;
        ent.modelScale[2] = 1.5f;
        ScaleModelAxis(&ent);

        //Make it transparent
        ent.renderfx = RF_FORCE_ENT_ALPHA;
        ent.shaderRGBA[0] = ent.shaderRGBA[1] = ent.shaderRGBA[2] = 255;
        ent.shaderRGBA[3] = 100;

        //And finally add it
        trap_R_AddRefEntityToScene(&ent);
}
*/

void CG_AddRadarEnt(centity_t *cent) 
{
        if (cg.radarEntityCount == sizeof(cg.radarEntities)/sizeof(cg.radarEntities[0]))
        {       
#ifdef _DEBUG
                Com_Printf("^3Warning: CG_AddRadarEnt full. (%d max)\n", sizeof(cg.radarEntities)/sizeof(cg.radarEntities[0]));
#endif
                return;
        }
        cg.radarEntities[cg.radarEntityCount++] = cent->currentState.number;
}

void CG_AddBracketedEnt(centity_t *cent) 
{
        if (cg.bracketedEntityCount == sizeof(cg.bracketedEntities)/sizeof(cg.bracketedEntities[0]))
        {       
#ifdef _DEBUG
                Com_Printf("^3Warning: CG_AddBracketedEnt full. (%d max)\n", sizeof(cg.radarEntities)/sizeof(cg.bracketedEntities[0]));
#endif
                return;
        }
        cg.bracketedEntities[cg.bracketedEntityCount++] = cent->currentState.number;
}
/*
==================
CG_General
==================
*/
void CG_G2ServerBoneAngles(centity_t *cent);

#include "../namespace_begin.h"
extern qboolean BG_GetRootSurfNameWithVariant( void *ghoul2, const char *rootSurfName, char *returnSurfName, int returnSize );
#include "../namespace_end.h"

static void CG_General( centity_t *cent ) {
        refEntity_t                     ent;
        entityState_t           *s1;
        float                           val;
        int                                     beamID;
        vec3_t                          beamOrg;
        mdxaBone_t                      matrix;
        qboolean                        doNotSetModel = qfalse;

        if (cent->currentState.modelGhoul2 == 127)
        { //not ready to be drawn or initialized..
                return;
        }

        if (cent->ghoul2 && !cent->currentState.modelGhoul2 && cent->currentState.eType != ET_BODY &&
                cent->currentState.number >= MAX_CLIENTS)
        { //this is a bad thing
                if (trap_G2_HaveWeGhoul2Models(cent->ghoul2))
                {
                        trap_G2API_CleanGhoul2Models(&(cent->ghoul2));
                }
        }
        
        if (cent->currentState.eFlags & EF_RADAROBJECT)
        {
                CG_AddRadarEnt(cent);
        }
        if (cent->currentState.eFlags2 & EF2_BRACKET_ENTITY)
        {
                if ( CG_InFighter() )
                {//only bracken when in a fighter
                        CG_AddBracketedEnt(cent);
                }
        }
        
        if (cent->currentState.boltToPlayer)
        { //Shove it into the player's left hand then.
                centity_t *pl = &cg_entities[cent->currentState.boltToPlayer-1];
                if (CG_IsMindTricked(pl->currentState.trickedentindex,
                        pl->currentState.trickedentindex2,
                        pl->currentState.trickedentindex3,
                        pl->currentState.trickedentindex4,
                        cg.predictedPlayerState.clientNum))
                { //don't show if this guy is mindtricking
            return;
                }
                if (!CG_RenderTimeEntBolt(cent))
                { //If this function returns qfalse we shouldn't render this ent at all.
                        if (cent->currentState.boltToPlayer > 0 &&
                                cent->currentState.boltToPlayer <= MAX_CLIENTS)
                        {
                                VectorCopy(pl->lerpOrigin, cent->lerpOrigin);

                                if (cent->currentState.eFlags & EF_CLIENTSMOOTH)
                                { //if it's set to smooth keep the smoothed lerp origin updated, as we don't want to smooth while bolted.
                                        VectorCopy(cent->lerpOrigin, cent->turAngles);
                                }
                        }
                        return;
                }

                if (cent->currentState.eFlags & EF_CLIENTSMOOTH)
                { //if it's set to smooth keep the smoothed lerp origin updated, as we don't want to smooth while bolted.
                        VectorCopy(cent->lerpOrigin, cent->turAngles);
                }

/* disabled for now
                if (pl->currentState.number != cg.predictedPlayerState.clientNum)
                { //don't render thing above head to self
                        CG_SiegeEntRenderAboveHead(cent);
                }
*/
        }
        else if (cent->currentState.eFlags & EF_CLIENTSMOOTH)
        {
                if (cent->currentState.groundEntityNum >= ENTITYNUM_WORLD)
                {
                        float smoothFactor = 0.5f*cg_timescale.value;
                        int k = 0;
                        vec3_t posDif;

                        //Use origin smoothing since dismembered limbs use ExPhys
                        if (DistanceSquared(cent->turAngles,cent->lerpOrigin)>18000.0f)
                        {
                                VectorCopy(cent->lerpOrigin, cent->turAngles);
                        }

                        VectorSubtract(cent->lerpOrigin, cent->turAngles, posDif);
                        
                        for (k=0;k<3;k++)
                        {
                                cent->turAngles[k]=(cent->turAngles[k]+posDif[k]*smoothFactor);
                                cent->lerpOrigin[k]=cent->turAngles[k];
                        }
                }
                else
                { //if we're sitting on an entity like a moving plat then we don't want to smooth either
                        VectorCopy(cent->lerpOrigin, cent->turAngles);
                }
        }

        //rww - now do ragdoll stuff
        if (cent->ghoul2 &&
                (cent->currentState.eType == ET_BODY || (cent->currentState.eFlags & EF_RAG)))
        {
                if (!(cent->currentState.eFlags & EF_NODRAW) &&
                        !(cent->currentState.eFlags & EF_DISINTEGRATION) &&
                        cent->bodyFadeTime <= cg.time)
                {
                        vec3_t forcedAngles;

                        VectorClear(forcedAngles);
                        forcedAngles[YAW] = cent->lerpAngles[YAW];

                        CG_RagDoll(cent, forcedAngles);
                }
        }
        else if (cent->isRagging)
        {
                cent->isRagging = qfalse;

                if (cent->ghoul2 && trap_G2_HaveWeGhoul2Models(cent->ghoul2))
                { //May not be valid, in the case of a ragged entity being removed and a non-g2 ent filling its slot.
                        trap_G2API_SetRagDoll(cent->ghoul2, NULL); //calling with null parms resets to no ragdoll.
                }
        }

        if (cent->currentState.boneOrient && cent->ghoul2)
        { //server sent us some bone angles to use
                CG_G2ServerBoneAngles(cent);
        }

        if ((cent->currentState.eFlags & EF_G2ANIMATING) && cent->ghoul2)
        { //mini-animation routine for general objects that want to play quick ghoul2 anims
                //obviously lacks much of the functionality contained in player/npc animation.
                //we actually use torsoAnim as the start frame and legsAnim as the end frame and
                //always play the anim on the root bone.
                if (cent->currentState.torsoAnim != cent->pe.torso.animationNumber ||
                        cent->currentState.legsAnim != cent->pe.legs.animationNumber ||
                        cent->currentState.torsoFlip != cent->pe.torso.lastFlip)
                {
                        trap_G2API_SetBoneAnim(cent->ghoul2, 0, "model_root", cent->currentState.torsoAnim,
                                cent->currentState.legsAnim, (BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND), 1.0f, cg.time, -1, 100);

                        cent->pe.torso.animationNumber = cent->currentState.torsoAnim;
                        cent->pe.legs.animationNumber = cent->currentState.legsAnim;
                        cent->pe.torso.lastFlip = cent->currentState.torsoFlip;
                }
        }

        memset (&ent, 0, sizeof(ent));

        ent.shaderRGBA[0] = cent->currentState.customRGBA[0];
        ent.shaderRGBA[1] = cent->currentState.customRGBA[1];
        ent.shaderRGBA[2] = cent->currentState.customRGBA[2];
        ent.shaderRGBA[3] = cent->currentState.customRGBA[3];

        if (cent->currentState.modelGhoul2 >= G2_MODELPART_HEAD &&
                cent->currentState.modelGhoul2 <= G2_MODELPART_RLEG &&
                /*cent->currentState.modelindex < MAX_CLIENTS &&*/
                cent->currentState.weapon == G2_MODEL_PART)
        { //special case for client limbs
                centity_t *clEnt;
                int dismember_settings = cg_dismember.integer;
                float smoothFactor = 0.5f*cg_timescale.value;
                int k = 0;
                vec3_t posDif;
                
                doNotSetModel = qtrue;

                if (cent->currentState.modelindex >= 0)
                {
                        clEnt = &cg_entities[cent->currentState.modelindex];
                }
                else
                {
                        clEnt = &cg_entities[cent->currentState.otherEntityNum2];
                }

                if (!dismember_settings)
                { //This client does not wish to see dismemberment.
                        return;
                }

                if (dismember_settings < 2 && (cent->currentState.modelGhoul2 == G2_MODELPART_HEAD || cent->currentState.modelGhoul2 == G2_MODELPART_WAIST))
                { //dismember settings are not high enough to display decaps and torso slashes
                        return;
                }

                if (!cent->ghoul2)
                {
                        const char *limbBone;
                        const char *rotateBone;
                        char    limbName[MAX_QPATH];
                        char    stubName[MAX_QPATH];
                        char    limbCapName[MAX_QPATH];
                        char    stubCapName[MAX_QPATH];
                        char *limbTagName;
                        char *stubTagName;
                        int limb_anim;
                        int newBolt;
                        int limbBit = (1 << (cent->currentState.modelGhoul2-10));

                        if (clEnt && (clEnt->torsoBolt & limbBit))
                        { //already have this limb missing!
                                return;
                        }


                        if (clEnt && !(clEnt->currentState.eFlags & EF_DEAD))
                        { //death flag hasn't made it through yet for the limb owner, we cannot create the limb until he's flagged as dead
                                return;
                        }

                        if (clEnt && (!BG_InDeathAnim(clEnt->currentState.torsoAnim) || !BG_InDeathAnim(clEnt->pe.torso.animationNumber)))
                        { //don't make it unless we're in an actual death anim already
                                if (clEnt->currentState.torsoAnim != BOTH_RIGHTHANDCHOPPEDOFF)
                                { //exception
                                        return;
                                }
                        }

                        cent->bolt4 = -1;
                        cent->trailTime = 0;

                        if (cent->currentState.modelGhoul2 == G2_MODELPART_HEAD)
                        {
                                limbBone = "cervical";
                                rotateBone = "cranium";
                                Q_strncpyz( limbName , "head", sizeof( limbName  ) );
                                Q_strncpyz( limbCapName, "head_cap_torso", sizeof( limbCapName ) );
                                Q_strncpyz( stubCapName, "torso_cap_head", sizeof( stubCapName ) );
                                limbTagName = "*head_cap_torso";
                                stubTagName = "*torso_cap_head";
                                limb_anim = BOTH_DISMEMBER_HEAD1;
                        }
                        else if (cent->currentState.modelGhoul2 == G2_MODELPART_WAIST)
                        {
                                limbBone = "pelvis";

                                if (clEnt->localAnimIndex <= 1)
                                { //humanoid/rtrooper
                                        rotateBone = "thoracic";
                                }
                                else
                                {
                                        rotateBone = "pelvis";
                                }
                                Q_strncpyz( limbName, "torso", sizeof( limbName ) );
                                Q_strncpyz( limbCapName, "torso_cap_hips", sizeof( limbCapName ) );
                                Q_strncpyz( stubCapName, "hips_cap_torso", sizeof( stubCapName ) );
                                limbTagName = "*torso_cap_hips";
                                stubTagName = "*hips_cap_torso";
                                limb_anim = BOTH_DISMEMBER_TORSO1;
                        }
                        else if (cent->currentState.modelGhoul2 == G2_MODELPART_LARM)
                        {
                                limbBone = "lhumerus";
                                rotateBone = "lradius";
                                BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "l_arm", limbName, sizeof(limbName) );
                                BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "torso", stubName, sizeof(stubName) );
                                Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_torso", limbName );
                                Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_l_arm", stubName );
                                limbTagName = "*l_arm_cap_torso";
                                stubTagName = "*torso_cap_l_arm";
                                limb_anim = BOTH_DISMEMBER_LARM;
                        }
                        else if (cent->currentState.modelGhoul2 == G2_MODELPART_RARM)
                        {
                                limbBone = "rhumerus";
                                rotateBone = "rradius";
                                BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "r_arm", limbName, sizeof(limbName) );
                                BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "torso", stubName, sizeof(stubName) );
                                Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_torso", limbName );
                                Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_arm", stubName );
                                limbTagName = "*r_arm_cap_torso";
                                stubTagName = "*torso_cap_r_arm";
                                limb_anim = BOTH_DISMEMBER_RARM;
                        }
                        else if (cent->currentState.modelGhoul2 == G2_MODELPART_RHAND)
                        {
                                limbBone = "rradiusX";
                                rotateBone = "rhand";
                                BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "r_hand", limbName, sizeof(limbName) );
                                BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "r_arm", stubName, sizeof(stubName) );
                                Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_r_arm", limbName );
                                Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_hand", stubName );
                                limbTagName = "*r_hand_cap_r_arm";
                                stubTagName = "*r_arm_cap_r_hand";
                                limb_anim = BOTH_DISMEMBER_RARM;
                        }
                        else if (cent->currentState.modelGhoul2 == G2_MODELPART_LLEG)
                        {
                                limbBone = "lfemurYZ";
                                rotateBone = "ltibia";
                                BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "l_leg", limbName, sizeof(limbName) );
                                BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "hips", stubName, sizeof(stubName) );
                                Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_hips", limbName );
                                Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_l_leg", stubName );
                                limbTagName = "*l_leg_cap_hips";
                                stubTagName = "*hips_cap_l_leg";
                                limb_anim = BOTH_DISMEMBER_LLEG;
                        }
                        else if (cent->currentState.modelGhoul2 == G2_MODELPART_RLEG)
                        {
                                limbBone = "rfemurYZ";
                                rotateBone = "rtibia";
                                BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "r_leg", limbName, sizeof(limbName) );
                                BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "hips", stubName, sizeof(stubName) );
                                Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_hips", limbName );
                                Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_leg", stubName );
                                limbTagName = "*r_leg_cap_hips";
                                stubTagName = "*hips_cap_r_leg";
                                limb_anim = BOTH_DISMEMBER_RLEG;
                        }
                        else
                        {//umm... just default to the right leg, I guess (same as on server)
                                limbBone = "rfemurYZ";
                                rotateBone = "rtibia";
                                BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "r_leg", limbName, sizeof(limbName) );
                                BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "hips", stubName, sizeof(stubName) );
                                Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_hips", limbName );
                                Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_leg", stubName );
                                limbTagName = "*r_leg_cap_hips";
                                stubTagName = "*hips_cap_r_leg";
                                limb_anim = BOTH_DISMEMBER_RLEG;
                        }

                        if (clEnt && clEnt->ghoul2)
                        {
                                if (trap_G2API_HasGhoul2ModelOnIndex(&(clEnt->ghoul2), 2))
                                { //don't want to bother dealing with a second saber on limbs and stuff, just remove the thing
                                        trap_G2API_RemoveGhoul2Model(&(clEnt->ghoul2), 2);
                                }

                                if (trap_G2API_HasGhoul2ModelOnIndex(&(clEnt->ghoul2), 3))
                                { //turn off jetpack also I suppose
                                        trap_G2API_RemoveGhoul2Model(&(clEnt->ghoul2), 3);
                                }

                                if (clEnt->localAnimIndex <= 0)
                                { //humanoid
                                        trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "model_root", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
                                        trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "pelvis", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 0, cg.time); 
                                        trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "thoracic", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 0, cg.time); 
                                        trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
                                        trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
                                        trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "cranium", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, POSITIVE_X, cgs.gameModels, 100, cg.time);
                                }
                                else
                                {
                                        trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "model_root", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
                                        trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "pelvis", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 0, cg.time); 
                                        trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
                                        trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
                                }

                                trap_G2API_DuplicateGhoul2Instance(clEnt->ghoul2, &cent->ghoul2);
                        }

                        if (!cent->ghoul2)
                        {
                                return;
                        }

                        newBolt = trap_G2API_AddBolt( cent->ghoul2, 0, limbTagName );
                        if ( newBolt != -1 )
                        {
                                vec3_t boltOrg, boltAng;

                                trap_G2API_GetBoltMatrix(cent->ghoul2, 0, newBolt, &matrix, cent->lerpAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);

                                BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, bol