cg_weapons.c

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
//
// cg_weapons.c -- events and effects dealing with weapons
#include "cg_local.h"

/*
==========================
CG_MachineGunEjectBrass
==========================
*/
static void CG_MachineGunEjectBrass( centity_t *cent ) {
    localEntity_t   *le;
    refEntity_t     *re;
    vec3_t          velocity, xvelocity;
    vec3_t          offset, xoffset;
    float           waterScale = 1.0f;
    vec3_t          v[3];

    if ( cg_brassTime.integer <= 0 ) {
        return;
    }

    le = CG_AllocLocalEntity();
    re = &le->refEntity;

    velocity[0] = 0;
    velocity[1] = -50 + 40 * crandom();
    velocity[2] = 100 + 50 * crandom();

    le->leType = LE_FRAGMENT;
    le->startTime = cg.time;
    le->endTime = le->startTime + cg_brassTime.integer + ( cg_brassTime.integer / 4 ) * random();

    le->pos.trType = TR_GRAVITY;
    le->pos.trTime = cg.time - (rand()&15);

    AnglesToAxis( cent->lerpAngles, v );

    offset[0] = 8;
    offset[1] = -4;
    offset[2] = 24;

    xoffset[0] = offset[0] * v[0][0] + offset[1] * v[1][0] + offset[2] * v[2][0];
    xoffset[1] = offset[0] * v[0][1] + offset[1] * v[1][1] + offset[2] * v[2][1];
    xoffset[2] = offset[0] * v[0][2] + offset[1] * v[1][2] + offset[2] * v[2][2];
    VectorAdd( cent->lerpOrigin, xoffset, re->origin );

    VectorCopy( re->origin, le->pos.trBase );

    if ( CG_PointContents( re->origin, -1 ) & CONTENTS_WATER ) {
        waterScale = 0.10f;
    }

    xvelocity[0] = velocity[0] * v[0][0] + velocity[1] * v[1][0] + velocity[2] * v[2][0];
    xvelocity[1] = velocity[0] * v[0][1] + velocity[1] * v[1][1] + velocity[2] * v[2][1];
    xvelocity[2] = velocity[0] * v[0][2] + velocity[1] * v[1][2] + velocity[2] * v[2][2];
    VectorScale( xvelocity, waterScale, le->pos.trDelta );

    AxisCopy( axisDefault, re->axis );
    re->hModel = cgs.media.machinegunBrassModel;

    le->bounceFactor = 0.4 * waterScale;

    le->angles.trType = TR_LINEAR;
    le->angles.trTime = cg.time;
    le->angles.trBase[0] = rand()&31;
    le->angles.trBase[1] = rand()&31;
    le->angles.trBase[2] = rand()&31;
    le->angles.trDelta[0] = 2;
    le->angles.trDelta[1] = 1;
    le->angles.trDelta[2] = 0;

    le->leFlags = LEF_TUMBLE;
    le->leBounceSoundType = LEBS_BRASS;
    le->leMarkType = LEMT_NONE;
}

/*
==========================
CG_ShotgunEjectBrass
==========================
*/
static void CG_ShotgunEjectBrass( centity_t *cent ) {
    localEntity_t   *le;
    refEntity_t     *re;
    vec3_t          velocity, xvelocity;
    vec3_t          offset, xoffset;
    vec3_t          v[3];
    int             i;

    if ( cg_brassTime.integer <= 0 ) {
        return;
    }

    for ( i = 0; i < 2; i++ ) {
        float   waterScale = 1.0f;

        le = CG_AllocLocalEntity();
        re = &le->refEntity;

        velocity[0] = 60 + 60 * crandom();
        if ( i == 0 ) {
            velocity[1] = 40 + 10 * crandom();
        } else {
            velocity[1] = -40 + 10 * crandom();
        }
        velocity[2] = 100 + 50 * crandom();

        le->leType = LE_FRAGMENT;
        le->startTime = cg.time;
        le->endTime = le->startTime + cg_brassTime.integer*3 + cg_brassTime.integer * random();

        le->pos.trType = TR_GRAVITY;
        le->pos.trTime = cg.time;

        AnglesToAxis( cent->lerpAngles, v );

        offset[0] = 8;
        offset[1] = 0;
        offset[2] = 24;

        xoffset[0] = offset[0] * v[0][0] + offset[1] * v[1][0] + offset[2] * v[2][0];
        xoffset[1] = offset[0] * v[0][1] + offset[1] * v[1][1] + offset[2] * v[2][1];
        xoffset[2] = offset[0] * v[0][2] + offset[1] * v[1][2] + offset[2] * v[2][2];
        VectorAdd( cent->lerpOrigin, xoffset, re->origin );
        VectorCopy( re->origin, le->pos.trBase );
        if ( CG_PointContents( re->origin, -1 ) & CONTENTS_WATER ) {
            waterScale = 0.10f;
        }

        xvelocity[0] = velocity[0] * v[0][0] + velocity[1] * v[1][0] + velocity[2] * v[2][0];
        xvelocity[1] = velocity[0] * v[0][1] + velocity[1] * v[1][1] + velocity[2] * v[2][1];
        xvelocity[2] = velocity[0] * v[0][2] + velocity[1] * v[1][2] + velocity[2] * v[2][2];
        VectorScale( xvelocity, waterScale, le->pos.trDelta );

        AxisCopy( axisDefault, re->axis );
        re->hModel = cgs.media.shotgunBrassModel;
        le->bounceFactor = 0.3f;

        le->angles.trType = TR_LINEAR;
        le->angles.trTime = cg.time;
        le->angles.trBase[0] = rand()&31;
        le->angles.trBase[1] = rand()&31;
        le->angles.trBase[2] = rand()&31;
        le->angles.trDelta[0] = 1;
        le->angles.trDelta[1] = 0.5;
        le->angles.trDelta[2] = 0;

        le->leFlags = LEF_TUMBLE;
        le->leBounceSoundType = LEBS_BRASS;
        le->leMarkType = LEMT_NONE;
    }
}


#ifdef MISSIONPACK
/*
==========================
CG_NailgunEjectBrass
==========================
*/
static void CG_NailgunEjectBrass( centity_t *cent ) {
    localEntity_t   *smoke;
    vec3_t          origin;
    vec3_t          v[3];
    vec3_t          offset;
    vec3_t          xoffset;
    vec3_t          up;

    AnglesToAxis( cent->lerpAngles, v );

    offset[0] = 0;
    offset[1] = -12;
    offset[2] = 24;

    xoffset[0] = offset[0] * v[0][0] + offset[1] * v[1][0] + offset[2] * v[2][0];
    xoffset[1] = offset[0] * v[0][1] + offset[1] * v[1][1] + offset[2] * v[2][1];
    xoffset[2] = offset[0] * v[0][2] + offset[1] * v[1][2] + offset[2] * v[2][2];
    VectorAdd( cent->lerpOrigin, xoffset, origin );

    VectorSet( up, 0, 0, 64 );

    smoke = CG_SmokePuff( origin, up, 32, 1, 1, 1, 0.33f, 700, cg.time, 0, 0, cgs.media.smokePuffShader );
    // use the optimized local entity add
    smoke->leType = LE_SCALE_FADE;
}
#endif


/*
==========================
CG_RailTrail
==========================
*/
void CG_RailTrail (clientInfo_t *ci, vec3_t start, vec3_t end) {
    vec3_t axis[36], move, move2, next_move, vec, temp;
    float  len;
    int    i, j, skip;
 
    localEntity_t *le;
    refEntity_t   *re;
 
#define RADIUS   4
#define ROTATION 1
#define SPACING  5
 
    start[2] -= 4;
    VectorCopy (start, move);
    VectorSubtract (end, start, vec);
    len = VectorNormalize (vec);
    PerpendicularVector(temp, vec);
    for (i = 0 ; i < 36; i++) {
        RotatePointAroundVector(axis[i], vec, temp, i * 10);//banshee 2.4 was 10
    }
 
    le = CG_AllocLocalEntity();
    re = &le->refEntity;
 
    le->leType = LE_FADE_RGB;
    le->startTime = cg.time;
    le->endTime = cg.time + cg_railTrailTime.value;
    le->lifeRate = 1.0 / (le->endTime - le->startTime);
 
    re->shaderTime = cg.time / 1000.0f;
    re->reType = RT_RAIL_CORE;
    re->customShader = cgs.media.railCoreShader;
 
    VectorCopy(start, re->origin);
    VectorCopy(end, re->oldorigin);
 
    re->shaderRGBA[0] = ci->color1[0] * 255;
    re->shaderRGBA[1] = ci->color1[1] * 255;
    re->shaderRGBA[2] = ci->color1[2] * 255;
    re->shaderRGBA[3] = 255;

    le->color[0] = ci->color1[0] * 0.75;
    le->color[1] = ci->color1[1] * 0.75;
    le->color[2] = ci->color1[2] * 0.75;
    le->color[3] = 1.0f;

    AxisClear( re->axis );
 
    VectorMA(move, 20, vec, move);
    VectorCopy(move, next_move);
    VectorScale (vec, SPACING, vec);

    if (cg_oldRail.integer != 0) {
        // nudge down a bit so it isn't exactly in center
        re->origin[2] -= 8;
        re->oldorigin[2] -= 8;
        return;
    }
    skip = -1;
 
    j = 18;
    for (i = 0; i < len; i += SPACING) {
        if (i != skip) {
            skip = i + SPACING;
            le = CG_AllocLocalEntity();
            re = &le->refEntity;
            le->leFlags = LEF_PUFF_DONT_SCALE;
            le->leType = LE_MOVE_SCALE_FADE;
            le->startTime = cg.time;
            le->endTime = cg.time + (i>>1) + 600;
            le->lifeRate = 1.0 / (le->endTime - le->startTime);

            re->shaderTime = cg.time / 1000.0f;
            re->reType = RT_SPRITE;
            re->radius = 1.1f;
            re->customShader = cgs.media.railRingsShader;

            re->shaderRGBA[0] = ci->color2[0] * 255;
            re->shaderRGBA[1] = ci->color2[1] * 255;
            re->shaderRGBA[2] = ci->color2[2] * 255;
            re->shaderRGBA[3] = 255;

            le->color[0] = ci->color2[0] * 0.75;
            le->color[1] = ci->color2[1] * 0.75;
            le->color[2] = ci->color2[2] * 0.75;
            le->color[3] = 1.0f;

            le->pos.trType = TR_LINEAR;
            le->pos.trTime = cg.time;

            VectorCopy( move, move2);
            VectorMA(move2, RADIUS , axis[j], move2);
            VectorCopy(move2, le->pos.trBase);

            le->pos.trDelta[0] = axis[j][0]*6;
            le->pos.trDelta[1] = axis[j][1]*6;
            le->pos.trDelta[2] = axis[j][2]*6;
        }

        VectorAdd (move, vec, move);

        j = j + ROTATION < 36 ? j + ROTATION : (j + ROTATION) % 36;
    }
}

/*
==========================
CG_RocketTrail
==========================
*/
static void CG_RocketTrail( centity_t *ent, const weaponInfo_t *wi ) {
    int     step;
    vec3_t  origin, lastPos;
    int     t;
    int     startTime, contents;
    int     lastContents;
    entityState_t   *es;
    vec3_t  up;
    localEntity_t   *smoke;

    if ( cg_noProjectileTrail.integer ) {
        return;
    }

    up[0] = 0;
    up[1] = 0;
    up[2] = 0;

    step = 50;

    es = &ent->currentState;
    startTime = ent->trailTime;
    t = step * ( (startTime + step) / step );

    BG_EvaluateTrajectory( &es->pos, cg.time, origin );
    contents = CG_PointContents( origin, -1 );

    // if object (e.g. grenade) is stationary, don't toss up smoke
    if ( es->pos.trType == TR_STATIONARY ) {
        ent->trailTime = cg.time;
        return;
    }

    BG_EvaluateTrajectory( &es->pos, ent->trailTime, lastPos );
    lastContents = CG_PointContents( lastPos, -1 );

    ent->trailTime = cg.time;

    if ( contents & ( CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA ) ) {
        if ( contents & lastContents & CONTENTS_WATER ) {
            CG_BubbleTrail( lastPos, origin, 8 );
        }
        return;
    }

    for ( ; t <= ent->trailTime ; t += step ) {
        BG_EvaluateTrajectory( &es->pos, t, lastPos );

        smoke = CG_SmokePuff( lastPos, up, 
                      wi->trailRadius, 
                      1, 1, 1, 0.33f,
                      wi->wiTrailTime, 
                      t,
                      0,
                      0, 
                      cgs.media.smokePuffShader );
        // use the optimized local entity add
        smoke->leType = LE_SCALE_FADE;
    }

}

#ifdef MISSIONPACK
/*
==========================
CG_NailTrail
==========================
*/
static void CG_NailTrail( centity_t *ent, const weaponInfo_t *wi ) {
    int     step;
    vec3_t  origin, lastPos;
    int     t;
    int     startTime, contents;
    int     lastContents;
    entityState_t   *es;
    vec3_t  up;
    localEntity_t   *smoke;

    if ( cg_noProjectileTrail.integer ) {
        return;
    }

    up[0] = 0;
    up[1] = 0;
    up[2] = 0;

    step = 50;

    es = &ent->currentState;
    startTime = ent->trailTime;
    t = step * ( (startTime + step) / step );

    BG_EvaluateTrajectory( &es->pos, cg.time, origin );
    contents = CG_PointContents( origin, -1 );

    // if object (e.g. grenade) is stationary, don't toss up smoke
    if ( es->pos.trType == TR_STATIONARY ) {
        ent->trailTime = cg.time;
        return;
    }

    BG_EvaluateTrajectory( &es->pos, ent->trailTime, lastPos );
    lastContents = CG_PointContents( lastPos, -1 );

    ent->trailTime = cg.time;

    if ( contents & ( CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA ) ) {
        if ( contents & lastContents & CONTENTS_WATER ) {
            CG_BubbleTrail( lastPos, origin, 8 );
        }
        return;
    }

    for ( ; t <= ent->trailTime ; t += step ) {
        BG_EvaluateTrajectory( &es->pos, t, lastPos );

        smoke = CG_SmokePuff( lastPos, up, 
                      wi->trailRadius, 
                      1, 1, 1, 0.33f,
                      wi->wiTrailTime, 
                      t,
                      0,
                      0, 
                      cgs.media.nailPuffShader );
        // use the optimized local entity add
        smoke->leType = LE_SCALE_FADE;
    }

}
#endif

/*
==========================
CG_NailTrail
==========================
*/
static void CG_PlasmaTrail( centity_t *cent, const weaponInfo_t *wi ) {
    localEntity_t   *le;
    refEntity_t     *re;
    entityState_t   *es;
    vec3_t          velocity, xvelocity, origin;
    vec3_t          offset, xoffset;
    vec3_t          v[3];
    int             t, startTime, step;

    float   waterScale = 1.0f;

    if ( cg_noProjectileTrail.integer || cg_oldPlasma.integer ) {
        return;
    }

    step = 50;

    es = &cent->currentState;
    startTime = cent->trailTime;
    t = step * ( (startTime + step) / step );

    BG_EvaluateTrajectory( &es->pos, cg.time, origin );

    le = CG_AllocLocalEntity();
    re = &le->refEntity;

    velocity[0] = 60 - 120 * crandom();
    velocity[1] = 40 - 80 * crandom();
    velocity[2] = 100 - 200 * crandom();

    le->leType = LE_MOVE_SCALE_FADE;
    le->leFlags = LEF_TUMBLE;
    le->leBounceSoundType = LEBS_NONE;
    le->leMarkType = LEMT_NONE;

    le->startTime = cg.time;
    le->endTime = le->startTime + 600;

    le->pos.trType = TR_GRAVITY;
    le->pos.trTime = cg.time;

    AnglesToAxis( cent->lerpAngles, v );

    offset[0] = 2;
    offset[1] = 2;
    offset[2] = 2;

    xoffset[0] = offset[0] * v[0][0] + offset[1] * v[1][0] + offset[2] * v[2][0];
    xoffset[1] = offset[0] * v[0][1] + offset[1] * v[1][1] + offset[2] * v[2][1];
    xoffset[2] = offset[0] * v[0][2] + offset[1] * v[1][2] + offset[2] * v[2][2];

    VectorAdd( origin, xoffset, re->origin );
    VectorCopy( re->origin, le->pos.trBase );

    if ( CG_PointContents( re->origin, -1 ) & CONTENTS_WATER ) {
        waterScale = 0.10f;
    }

    xvelocity[0] = velocity[0] * v[0][0] + velocity[1] * v[1][0] + velocity[2] * v[2][0];
    xvelocity[1] = velocity[0] * v[0][1] + velocity[1] * v[1][1] + velocity[2] * v[2][1];
    xvelocity[2] = velocity[0] * v[0][2] + velocity[1] * v[1][2] + velocity[2] * v[2][2];
    VectorScale( xvelocity, waterScale, le->pos.trDelta );

    AxisCopy( axisDefault, re->axis );
    re->shaderTime = cg.time / 1000.0f;
    re->reType = RT_SPRITE;
    re->radius = 0.25f;
    re->customShader = cgs.media.railRingsShader;
    le->bounceFactor = 0.3f;

    re->shaderRGBA[0] = wi->flashDlightColor[0] * 63;
    re->shaderRGBA[1] = wi->flashDlightColor[1] * 63;
    re->shaderRGBA[2] = wi->flashDlightColor[2] * 63;
    re->shaderRGBA[3] = 63;

    le->color[0] = wi->flashDlightColor[0] * 0.2;
    le->color[1] = wi->flashDlightColor[1] * 0.2;
    le->color[2] = wi->flashDlightColor[2] * 0.2;
    le->color[3] = 0.25f;

    le->angles.trType = TR_LINEAR;
    le->angles.trTime = cg.time;
    le->angles.trBase[0] = rand()&31;
    le->angles.trBase[1] = rand()&31;
    le->angles.trBase[2] = rand()&31;
    le->angles.trDelta[0] = 1;
    le->angles.trDelta[1] = 0.5;
    le->angles.trDelta[2] = 0;

}
/*
==========================
CG_GrappleTrail
==========================
*/
void CG_GrappleTrail( centity_t *ent, const weaponInfo_t *wi ) {
    vec3_t  origin;
    entityState_t   *es;
    vec3_t          forward, up;
    refEntity_t     beam;

    es = &ent->currentState;

    BG_EvaluateTrajectory( &es->pos, cg.time, origin );
    ent->trailTime = cg.time;

    memset( &beam, 0, sizeof( beam ) );
    //FIXME adjust for muzzle position
    VectorCopy ( cg_entities[ ent->currentState.otherEntityNum ].lerpOrigin, beam.origin );
    beam.origin[2] += 26;
    AngleVectors( cg_entities[ ent->currentState.otherEntityNum ].lerpAngles, forward, NULL, up );
    VectorMA( beam.origin, -6, up, beam.origin );
    VectorCopy( origin, beam.oldorigin );

    if (Distance( beam.origin, beam.oldorigin ) < 64 )
        return; // Don't draw if close

    beam.reType = RT_LIGHTNING;
    beam.customShader = cgs.media.lightningShader;

    AxisClear( beam.axis );
    beam.shaderRGBA[0] = 0xff;
    beam.shaderRGBA[1] = 0xff;
    beam.shaderRGBA[2] = 0xff;
    beam.shaderRGBA[3] = 0xff;
    trap_R_AddRefEntityToScene( &beam );
}

/*
==========================
CG_GrenadeTrail
==========================
*/
static void CG_GrenadeTrail( centity_t *ent, const weaponInfo_t *wi ) {
    CG_RocketTrail( ent, wi );
}


/*
=================
CG_RegisterWeapon

The server says this item is used on this level
=================
*/
void CG_RegisterWeapon( int weaponNum ) {
    weaponInfo_t    *weaponInfo;
    gitem_t         *item, *ammo;
    char            path[MAX_QPATH];
    vec3_t          mins, maxs;
    int             i;

    weaponInfo = &cg_weapons[weaponNum];

    if ( weaponNum == 0 ) {
        return;
    }

    if ( weaponInfo->registered ) {
        return;
    }

    memset( weaponInfo, 0, sizeof( *weaponInfo ) );
    weaponInfo->registered = qtrue;

    for ( item = bg_itemlist + 1 ; item->classname ; item++ ) {
        if ( item->giType == IT_WEAPON && item->giTag == weaponNum ) {
            weaponInfo->item = item;
            break;
        }
    }
    if ( !item->classname ) {
        CG_Error( "Couldn't find weapon %i", weaponNum );
    }
    CG_RegisterItemVisuals( item - bg_itemlist );

    // load cmodel before model so filecache works
    weaponInfo->weaponModel = trap_R_RegisterModel( item->world_model[0] );

    // calc midpoint for rotation
    trap_R_ModelBounds( weaponInfo->weaponModel, mins, maxs );
    for ( i = 0 ; i < 3 ; i++ ) {
        weaponInfo->weaponMidpoint[i] = mins[i] + 0.5 * ( maxs[i] - mins[i] );
    }

    weaponInfo->weaponIcon = trap_R_RegisterShader( item->icon );
    weaponInfo->ammoIcon = trap_R_RegisterShader( item->icon );

    for ( ammo = bg_itemlist + 1 ; ammo->classname ; ammo++ ) {
        if ( ammo->giType == IT_AMMO && ammo->giTag == weaponNum ) {
            break;
        }
    }
    if ( ammo->classname && ammo->world_model[0] ) {
        weaponInfo->ammoModel = trap_R_RegisterModel( ammo->world_model[0] );
    }

    strcpy( path, item->world_model[0] );
    COM_StripExtension( path, path );
    strcat( path, "_flash.md3" );
    weaponInfo->flashModel = trap_R_RegisterModel( path );

    strcpy( path, item->world_model[0] );
    COM_StripExtension( path, path );
    strcat( path, "_barrel.md3" );
    weaponInfo->barrelModel = trap_R_RegisterModel( path );

    strcpy( path, item->world_model[0] );
    COM_StripExtension( path, path );
    strcat( path, "_hand.md3" );
    weaponInfo->handsModel = trap_R_RegisterModel( path );

    if ( !weaponInfo->handsModel ) {
        weaponInfo->handsModel = trap_R_RegisterModel( "models/weapons2/shotgun/shotgun_hand.md3" );
    }

    weaponInfo->loopFireSound = qfalse;

    switch ( weaponNum ) {
    case WP_GAUNTLET:
        MAKERGB( weaponInfo->flashDlightColor, 0.6f, 0.6f, 1.0f );
        weaponInfo->firingSound = trap_S_RegisterSound( "sound/weapons/melee/fstrun.wav", qfalse );
        weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/melee/fstatck.wav", qfalse );
        break;

    case WP_LIGHTNING:
        MAKERGB( weaponInfo->flashDlightColor, 0.6f, 0.6f, 1.0f );
        weaponInfo->readySound = trap_S_RegisterSound( "sound/weapons/melee/fsthum.wav", qfalse );
        weaponInfo->firingSound = trap_S_RegisterSound( "sound/weapons/lightning/lg_hum.wav", qfalse );

        weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/lightning/lg_fire.wav", qfalse );
        cgs.media.lightningShader = trap_R_RegisterShader( "lightningBoltNew");
        cgs.media.lightningExplosionModel = trap_R_RegisterModel( "models/weaphits/crackle.md3" );
        cgs.media.sfx_lghit1 = trap_S_RegisterSound( "sound/weapons/lightning/lg_hit.wav", qfalse );
        cgs.media.sfx_lghit2 = trap_S_RegisterSound( "sound/weapons/lightning/lg_hit2.wav", qfalse );
        cgs.media.sfx_lghit3 = trap_S_RegisterSound( "sound/weapons/lightning/lg_hit3.wav", qfalse );

        break;

    case WP_GRAPPLING_HOOK:
        MAKERGB( weaponInfo->flashDlightColor, 0.6f, 0.6f, 1.0f );
        weaponInfo->missileModel = trap_R_RegisterModel( "models/ammo/rocket/rocket.md3" );
        weaponInfo->missileTrailFunc = CG_GrappleTrail;
        weaponInfo->missileDlight = 200;
        weaponInfo->wiTrailTime = 2000;
        weaponInfo->trailRadius = 64;
        MAKERGB( weaponInfo->missileDlightColor, 1, 0.75f, 0 );
        weaponInfo->readySound = trap_S_RegisterSound( "sound/weapons/melee/fsthum.wav", qfalse );
        weaponInfo->firingSound = trap_S_RegisterSound( "sound/weapons/melee/fstrun.wav", qfalse );
        break;

#ifdef MISSIONPACK
    case WP_CHAINGUN:
        weaponInfo->firingSound = trap_S_RegisterSound( "sound/weapons/vulcan/wvulfire.wav", qfalse );
        weaponInfo->loopFireSound = qtrue;
        MAKERGB( weaponInfo->flashDlightColor, 1, 1, 0 );
        weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/vulcan/vulcanf1b.wav", qfalse );
        weaponInfo->flashSound[1] = trap_S_RegisterSound( "sound/weapons/vulcan/vulcanf2b.wav", qfalse );
        weaponInfo->flashSound[2] = trap_S_RegisterSound( "sound/weapons/vulcan/vulcanf3b.wav", qfalse );
        weaponInfo->flashSound[3] = trap_S_RegisterSound( "sound/weapons/vulcan/vulcanf4b.wav", qfalse );
        weaponInfo->ejectBrassFunc = CG_MachineGunEjectBrass;
        cgs.media.bulletExplosionShader = trap_R_RegisterShader( "bulletExplosion" );
        break;
#endif

    case WP_MACHINEGUN:
        MAKERGB( weaponInfo->flashDlightColor, 1, 1, 0 );
        weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/machinegun/machgf1b.wav", qfalse );
        weaponInfo->flashSound[1] = trap_S_RegisterSound( "sound/weapons/machinegun/machgf2b.wav", qfalse );
        weaponInfo->flashSound[2] = trap_S_RegisterSound( "sound/weapons/machinegun/machgf3b.wav", qfalse );
        weaponInfo->flashSound[3] = trap_S_RegisterSound( "sound/weapons/machinegun/machgf4b.wav", qfalse );
        weaponInfo->ejectBrassFunc = CG_MachineGunEjectBrass;
        cgs.media.bulletExplosionShader = trap_R_RegisterShader( "bulletExplosion" );
        break;

    case WP_SHOTGUN:
        MAKERGB( weaponInfo->flashDlightColor, 1, 1, 0 );
        weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/shotgun/sshotf1b.wav", qfalse );
        weaponInfo->ejectBrassFunc = CG_ShotgunEjectBrass;
        break;

    case WP_ROCKET_LAUNCHER:
        weaponInfo->missileModel = trap_R_RegisterModel( "models/ammo/rocket/rocket.md3" );
        weaponInfo->missileSound = trap_S_RegisterSound( "sound/weapons/rocket/rockfly.wav", qfalse );
        weaponInfo->missileTrailFunc = CG_RocketTrail;
        weaponInfo->missileDlight = 200;
        weaponInfo->wiTrailTime = 2000;
        weaponInfo->trailRadius = 64;
        
        MAKERGB( weaponInfo->missileDlightColor, 1, 0.75f, 0 );
        MAKERGB( weaponInfo->flashDlightColor, 1, 0.75f, 0 );

        weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/rocket/rocklf1a.wav", qfalse );
        cgs.media.rocketExplosionShader = trap_R_RegisterShader( "rocketExplosion" );
        break;

#ifdef MISSIONPACK
    case WP_PROX_LAUNCHER:
        weaponInfo->missileModel = trap_R_RegisterModel( "models/weaphits/proxmine.md3" );
        weaponInfo->missileTrailFunc = CG_GrenadeTrail;
        weaponInfo->wiTrailTime = 700;
        weaponInfo->trailRadius = 32;
        MAKERGB( weaponInfo->flashDlightColor, 1, 0.70f, 0 );
        weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/proxmine/wstbfire.wav", qfalse );
        cgs.media.grenadeExplosionShader = trap_R_RegisterShader( "grenadeExplosion" );
        break;
#endif

    case WP_GRENADE_LAUNCHER:
        weaponInfo->missileModel = trap_R_RegisterModel( "models/ammo/grenade1.md3" );
        weaponInfo->missileTrailFunc = CG_GrenadeTrail;
        weaponInfo->wiTrailTime = 700;
        weaponInfo->trailRadius = 32;
        MAKERGB( weaponInfo->flashDlightColor, 1, 0.70f, 0 );
        weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/grenade/grenlf1a.wav", qfalse );
        cgs.media.grenadeExplosionShader = trap_R_RegisterShader( "grenadeExplosion" );
        break;

#ifdef MISSIONPACK
    case WP_NAILGUN:
        weaponInfo->ejectBrassFunc = CG_NailgunEjectBrass;
        weaponInfo->missileTrailFunc = CG_NailTrail;
//      weaponInfo->missileSound = trap_S_RegisterSound( "sound/weapons/nailgun/wnalflit.wav", qfalse );
        weaponInfo->trailRadius = 16;
        weaponInfo->wiTrailTime = 250;
        weaponInfo->missileModel = trap_R_RegisterModel( "models/weaphits/nail.md3" );
        MAKERGB( weaponInfo->flashDlightColor, 1, 0.75f, 0 );
        weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/nailgun/wnalfire.wav", qfalse );
        break;
#endif

    case WP_PLASMAGUN:
//      weaponInfo->missileModel = cgs.media.invulnerabilityPowerupModel;
        weaponInfo->missileTrailFunc = CG_PlasmaTrail;
        weaponInfo->missileSound = trap_S_RegisterSound( "sound/weapons/plasma/lasfly.wav", qfalse );
        MAKERGB( weaponInfo->flashDlightColor, 0.6f, 0.6f, 1.0f );
        weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/plasma/hyprbf1a.wav", qfalse );
        cgs.media.plasmaExplosionShader = trap_R_RegisterShader( "plasmaExplosion" );
        cgs.media.railRingsShader = trap_R_RegisterShader( "railDisc" );
        break;

    case WP_RAILGUN:
        weaponInfo->readySound = trap_S_RegisterSound( "sound/weapons/railgun/rg_hum.wav", qfalse );
        MAKERGB( weaponInfo->flashDlightColor, 1, 0.5f, 0 );
        weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/railgun/railgf1a.wav", qfalse );
        cgs.media.railExplosionShader = trap_R_RegisterShader( "railExplosion" );
        cgs.media.railRingsShader = trap_R_RegisterShader( "railDisc" );
        cgs.media.railCoreShader = trap_R_RegisterShader( "railCore" );
        break;

    case WP_BFG:
        weaponInfo->readySound = trap_S_RegisterSound( "sound/weapons/bfg/bfg_hum.wav", qfalse );
        MAKERGB( weaponInfo->flashDlightColor, 1, 0.7f, 1 );
        weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/bfg/bfg_fire.wav", qfalse );
        cgs.media.bfgExplosionShader = trap_R_RegisterShader( "bfgExplosion" );
        weaponInfo->missileModel = trap_R_RegisterModel( "models/weaphits/bfg.md3" );
        weaponInfo->missileSound = trap_S_RegisterSound( "sound/weapons/rocket/rockfly.wav", qfalse );
        break;

     default:
        MAKERGB( weaponInfo->flashDlightColor, 1, 1, 1 );
        weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/rocket/rocklf1a.wav", qfalse );
        break;
    }
}

/*
=================
CG_RegisterItemVisuals

The server says this item is used on this level
=================
*/
void CG_RegisterItemVisuals( int itemNum ) {
    itemInfo_t      *itemInfo;
    gitem_t         *item;

    if ( itemNum < 0 || itemNum >= bg_numItems ) {
        CG_Error( "CG_RegisterItemVisuals: itemNum %d out of range [0-%d]", itemNum, bg_numItems-1 );
    }

    itemInfo = &cg_items[ itemNum ];
    if ( itemInfo->registered ) {
        return;
    }

    item = &bg_itemlist[ itemNum ];

    memset( itemInfo, 0, sizeof( &itemInfo ) );
    itemInfo->registered = qtrue;

    itemInfo->models[0] = trap_R_RegisterModel( item->world_model[0] );

    itemInfo->icon = trap_R_RegisterShader( item->icon );

    if ( item->giType == IT_WEAPON ) {
        CG_RegisterWeapon( item->giTag );
    }

    //
    // powerups have an accompanying ring or sphere
    //
    if ( item->giType == IT_POWERUP || item->giType == IT_HEALTH || 
        item->giType == IT_ARMOR || item->giType == IT_HOLDABLE ) {
        if ( item->world_model[1] ) {
            itemInfo->models[1] = trap_R_RegisterModel( item->world_model[1] );
        }
    }
}


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

VIEW WEAPON

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

/*
=================
CG_MapTorsoToWeaponFrame

=================
*/
static int CG_MapTorsoToWeaponFrame( clientInfo_t *ci, int frame ) {

    // change weapon
    if ( frame >= ci->animations[TORSO_DROP].firstFrame 
        && frame < ci->animations[TORSO_DROP].firstFrame + 9 ) {
        return frame - ci->animations[TORSO_DROP].firstFrame + 6;
    }

    // stand attack
    if ( frame >= ci->animations[TORSO_ATTACK].firstFrame 
        && frame < ci->animations[TORSO_ATTACK].firstFrame + 6 ) {
        return 1 + frame - ci->animations[TORSO_ATTACK].firstFrame;
    }

    // stand attack 2
    if ( frame >= ci->animations[TORSO_ATTACK2].firstFrame 
        && frame < ci->animations[TORSO_ATTACK2].firstFrame + 6 ) {
        return 1 + frame - ci->animations[TORSO_ATTACK2].firstFrame;
    }
    
    return 0;
}


/*
==============
CG_CalculateWeaponPosition
==============
*/
static void CG_CalculateWeaponPosition( vec3_t origin, vec3_t angles ) {
    float   scale;
    int     delta;
    float   fracsin;

    VectorCopy( cg.refdef.vieworg, origin );
    VectorCopy( cg.refdefViewAngles, angles );

    // on odd legs, invert some angles
    if ( cg.bobcycle & 1 ) {
        scale = -cg.xyspeed;
    } else {
        scale = cg.xyspeed;
    }

    // gun angles from bobbing
    angles[ROLL] += scale * cg.bobfracsin * 0.005;
    angles[YAW] += scale * cg.bobfracsin * 0.01;
    angles[PITCH] += cg.xyspeed * cg.bobfracsin * 0.005;

    // drop the weapon when landing
    delta = cg.time - cg.landTime;
    if ( delta < LAND_DEFLECT_TIME ) {
        origin[2] += cg.landChange*0.25 * delta / LAND_DEFLECT_TIME;
    } else if ( delta < LAND_DEFLECT_TIME + LAND_RETURN_TIME ) {
        origin[2] += cg.landChange*0.25 * 
            (LAND_DEFLECT_TIME + LAND_RETURN_TIME - delta) / LAND_RETURN_TIME;
    }

#if 0
    // drop the weapon when stair climbing
    delta = cg.time - cg.stepTime;
    if ( delta < STEP_TIME/2 ) {
        origin[2] -= cg.stepChange*0.25 * delta / (STEP_TIME/2);
    } else if ( delta < STEP_TIME ) {
        origin[2] -= cg.stepChange*0.25 * (STEP_TIME - delta) / (STEP_TIME/2);
    }
#endif

    // idle drift
    scale = cg.xyspeed + 40;
    fracsin = sin( cg.time * 0.001 );
    angles[ROLL] += scale * fracsin * 0.01;
    angles[YAW] += scale * fracsin * 0.01;
    angles[PITCH] += scale * fracsin * 0.01;
}


/*
===============
CG_LightningBolt

Origin will be the exact tag point, which is slightly
different than the muzzle point used for determining hits.
The cent should be the non-predicted cent if it is from the player,
so the endpoint will reflect the simulated strike (lagging the predicted
angle)
===============
*/
static void CG_LightningBolt( centity_t *cent, vec3_t origin ) {
    trace_t  trace;
    refEntity_t  beam;
    vec3_t   forward;
    vec3_t   muzzlePoint, endPoint;

    if (cent->currentState.weapon != WP_LIGHTNING) {
        return;
    }

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

    // CPMA  "true" lightning
    if ((cent->currentState.number == cg.predictedPlayerState.clientNum) && (cg_trueLightning.value != 0)) {
        vec3_t angle;
        int i;

        for (i = 0; i < 3; i++) {
            float a = cent->lerpAngles[i] - cg.refdefViewAngles[i];
            if (a > 180) {
                a -= 360;
            }
            if (a < -180) {
                a += 360;
            }

            angle[i] = cg.refdefViewAngles[i] + a * (1.0 - cg_trueLightning.value);
            if (angle[i] < 0) {
                angle[i] += 360;
            }
            if (angle[i] > 360) {
                angle[i] -= 360;
            }
        }

        AngleVectors(angle, forward, NULL, NULL );
        VectorCopy(cent->lerpOrigin, muzzlePoint );
//      VectorCopy(cg.refdef.vieworg, muzzlePoint );
    } else {
        // !CPMA
        AngleVectors( cent->lerpAngles, forward, NULL, NULL );
        VectorCopy(cent->lerpOrigin, muzzlePoint );
    }

    // FIXME: crouch
    muzzlePoint[2] += DEFAULT_VIEWHEIGHT;

    VectorMA( muzzlePoint, 14, forward, muzzlePoint );

    // project forward by the lightning range
    VectorMA( muzzlePoint, LIGHTNING_RANGE, forward, endPoint );

    // see if it hit a wall
    CG_Trace( &trace, muzzlePoint, vec3_origin, vec3_origin, endPoint, 
        cent->currentState.number, MASK_SHOT );

    // this is the endpoint
    VectorCopy( trace.endpos, beam.oldorigin );

    // use the provided origin, even though it may be slightly
    // different than the muzzle origin
    VectorCopy( origin, beam.origin );

    beam.reType = RT_LIGHTNING;
    beam.customShader = cgs.media.lightningShader;
    trap_R_AddRefEntityToScene( &beam );

    // add the impact flare if it hit something
    if ( trace.fraction < 1.0 ) {
        vec3_t  angles;
        vec3_t  dir;

        VectorSubtract( beam.oldorigin, beam.origin, dir );
        VectorNormalize( dir );

        memset( &beam, 0, sizeof( beam ) );
        beam.hModel = cgs.media.lightningExplosionModel;

        VectorMA( trace.endpos, -16, dir, beam.origin );

        // make a random orientation
        angles[0] = rand() % 360;
        angles[1] = rand() % 360;
        angles[2] = rand() % 360;
        AnglesToAxis( angles, beam.axis );
        trap_R_AddRefEntityToScene( &beam );
    }
}
/*

static void CG_LightningBolt( centity_t *cent, vec3_t origin ) {
    trace_t     trace;
    refEntity_t     beam;
    vec3_t          forward;
    vec3_t          muzzlePoint, endPoint;

    if ( cent->currentState.weapon != WP_LIGHTNING ) {
        return;
    }

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

    // find muzzle point for this frame
    VectorCopy( cent->lerpOrigin, muzzlePoint );
    AngleVectors( cent->lerpAngles, forward, NULL, NULL );

    // FIXME: crouch
    muzzlePoint[2] += DEFAULT_VIEWHEIGHT;

    VectorMA( muzzlePoint, 14, forward, muzzlePoint );

    // project forward by the lightning range
    VectorMA( muzzlePoint, LIGHTNING_RANGE, forward, endPoint );

    // see if it hit a wall
    CG_Trace( &trace, muzzlePoint, vec3_origin, vec3_origin, endPoint, 
        cent->currentState.number, MASK_SHOT );

    // this is the endpoint
    VectorCopy( trace.endpos, beam.oldorigin );

    // use the provided origin, even though it may be slightly
    // different than the muzzle origin
    VectorCopy( origin, beam.origin );

    beam.reType = RT_LIGHTNING;
    beam.customShader = cgs.media.lightningShader;
    trap_R_AddRefEntityToScene( &beam );

    // add the impact flare if it hit something
    if ( trace.fraction < 1.0 ) {
        vec3_t  angles;
        vec3_t  dir;

        VectorSubtract( beam.oldorigin, beam.origin, dir );
        VectorNormalize( dir );

        memset( &beam, 0, sizeof( beam ) );
        beam.hModel = cgs.media.lightningExplosionModel;

        VectorMA( trace.endpos, -16, dir, beam.origin );

        // make a random orientation
        angles[0] = rand() % 360;
        angles[1] = rand() % 360;
        angles[2] = rand() % 360;
        AnglesToAxis( angles, beam.axis );
        trap_R_AddRefEntityToScene( &beam );
    }
}
*/

/*
===============
CG_SpawnRailTrail

Origin will be the exact tag point, which is slightly
different than the muzzle point used for determining hits.
===============
*/
static void CG_SpawnRailTrail( centity_t *cent, vec3_t origin ) {
    clientInfo_t    *ci;

    if ( cent->currentState.weapon != WP_RAILGUN ) {
        return;
    }
    if ( !cent->pe.railgunFlash ) {
        return;
    }
    cent->pe.railgunFlash = qtrue;
    ci = &cgs.clientinfo[ cent->currentState.clientNum ];
    CG_RailTrail( ci, origin, cent->pe.railgunImpact );
}


/*
======================
CG_MachinegunSpinAngle
======================
*/
#define     SPIN_SPEED  0.9
#define     COAST_TIME  1000
static float    CG_MachinegunSpinAngle( centity_t *cent ) {
    int     delta;
    float   angle;
    float   speed;

    delta = cg.time - cent->pe.barrelTime;
    if ( cent->pe.barrelSpinning ) {
        angle = cent->pe.barrelAngle + delta * SPIN_SPEED;
    } else {
        if ( delta > COAST_TIME ) {
            delta = COAST_TIME;
        }

        speed = 0.5 * ( SPIN_SPEED + (float)( COAST_TIME - delta ) / COAST_TIME );
        angle = cent->pe.barrelAngle + delta * speed;
    }

    if ( cent->pe.barrelSpinning == !(cent->currentState.eFlags & EF_FIRING) ) {
        cent->pe.barrelTime = cg.time;
        cent->pe.barrelAngle = AngleMod( angle );
        cent->pe.barrelSpinning = !!(cent->currentState.eFlags & EF_FIRING);
#ifdef MISSIONPACK
        if ( cent->currentState.weapon == WP_CHAINGUN && !cent->pe.barrelSpinning ) {
            trap_S_StartSound( NULL, cent->currentState.number, CHAN_WEAPON, trap_S_RegisterSound( "sound/weapons/vulcan/wvulwind.wav", qfalse ) );
        }
#endif
    }

    return angle;
}


/*
========================
CG_AddWeaponWithPowerups
========================
*/
static void CG_AddWeaponWithPowerups( refEntity_t *gun, int powerups ) {
    // add powerup effects
    if ( powerups & ( 1 << PW_INVIS ) ) {
        gun->customShader = cgs.media.invisShader;
        trap_R_AddRefEntityToScene( gun );
    } else {
        trap_R_AddRefEntityToScene( gun );

        if ( powerups & ( 1 << PW_BATTLESUIT ) ) {
            gun->customShader = cgs.media.battleWeaponShader;
            trap_R_AddRefEntityToScene( gun );
        }
        if ( powerups & ( 1 << PW_QUAD ) ) {
            gun->customShader = cgs.media.quadWeaponShader;
            trap_R_AddRefEntityToScene( gun );
        }
    }
}


/*
=============
CG_AddPlayerWeapon

Used for both the view weapon (ps is valid) and the world modelother character models (ps is NULL)
The main player will have this called for BOTH cases, so effects like ligh