codemp/cgame/cg_view.c

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
// cg_view.c -- setup all the parameters (position, angle, etc)
// for a 3D rendering
#include "cg_local.h"

#include "bg_saga.h"

#if !defined(CL_LIGHT_H_INC)
        #include "cg_lights.h"
#endif

#define MASK_CAMERACLIP (MASK_SOLID|CONTENTS_PLAYERCLIP)
#define CAMERA_SIZE     4


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

  MODEL TESTING

The viewthing and gun positioning tools from Q2 have been integrated and
enhanced into a single model testing facility.

Model viewing can begin with either "testmodel <modelname>" or "testgun <modelname>".

The names must be the full pathname after the basedir, like 
"models/weapons/v_launch/tris.md3" or "players/male/tris.md3"

Testmodel will create a fake entity 100 units in front of the current view
position, directly facing the viewer.  It will remain immobile, so you can
move around it to view it from different angles.

Testgun will cause the model to follow the player around and supress the real
view weapon model.  The default frame 0 of most guns is completely off screen,
so you will probably have to cycle a couple frames to see it.

"nextframe", "prevframe", "nextskin", and "prevskin" commands will change the
frame or skin of the testmodel.  These are bound to F5, F6, F7, and F8 in
q3default.cfg.

If a gun is being tested, the "gun_x", "gun_y", and "gun_z" variables will let
you adjust the positioning.

Note that none of the model testing features update while the game is paused, so
it may be convenient to test with deathmatch set to 1 so that bringing down the
console doesn't pause the game.

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

/*
=================
CG_TestModel_f

Creates an entity in front of the current position, which
can then be moved around
=================
*/
void CG_TestModel_f (void) {
        vec3_t          angles;

        memset( &cg.testModelEntity, 0, sizeof(cg.testModelEntity) );
        if ( trap_Argc() < 2 ) {
                return;
        }

        Q_strncpyz (cg.testModelName, CG_Argv( 1 ), MAX_QPATH );
        cg.testModelEntity.hModel = trap_R_RegisterModel( cg.testModelName );

        if ( trap_Argc() == 3 ) {
                cg.testModelEntity.backlerp = atof( CG_Argv( 2 ) );
                cg.testModelEntity.frame = 1;
                cg.testModelEntity.oldframe = 0;
        }
        if (! cg.testModelEntity.hModel ) {
                CG_Printf( "Can't register model\n" );
                return;
        }

        VectorMA( cg.refdef.vieworg, 100, cg.refdef.viewaxis[0], cg.testModelEntity.origin );

        angles[PITCH] = 0;
        angles[YAW] = 180 + cg.refdef.viewangles[1];
        angles[ROLL] = 0;

        AnglesToAxis( angles, cg.testModelEntity.axis );
        cg.testGun = qfalse;
}

/*
=================
CG_TestGun_f

Replaces the current view weapon with the given model
=================
*/
void CG_TestGun_f (void) {
        CG_TestModel_f();
        cg.testGun = qtrue;
        //cg.testModelEntity.renderfx = RF_MINLIGHT | RF_DEPTHHACK | RF_FIRST_PERSON;

        // rww - 9-13-01 [1-26-01-sof2]
        cg.testModelEntity.renderfx = RF_DEPTHHACK | RF_FIRST_PERSON;
}


void CG_TestModelNextFrame_f (void) {
        cg.testModelEntity.frame++;
        CG_Printf( "frame %i\n", cg.testModelEntity.frame );
}

void CG_TestModelPrevFrame_f (void) {
        cg.testModelEntity.frame--;
        if ( cg.testModelEntity.frame < 0 ) {
                cg.testModelEntity.frame = 0;
        }
        CG_Printf( "frame %i\n", cg.testModelEntity.frame );
}

void CG_TestModelNextSkin_f (void) {
        cg.testModelEntity.skinNum++;
        CG_Printf( "skin %i\n", cg.testModelEntity.skinNum );
}

void CG_TestModelPrevSkin_f (void) {
        cg.testModelEntity.skinNum--;
        if ( cg.testModelEntity.skinNum < 0 ) {
                cg.testModelEntity.skinNum = 0;
        }
        CG_Printf( "skin %i\n", cg.testModelEntity.skinNum );
}

static void CG_AddTestModel (void) {
        int             i;

        // re-register the model, because the level may have changed
        cg.testModelEntity.hModel = trap_R_RegisterModel( cg.testModelName );
        if (! cg.testModelEntity.hModel ) {
                CG_Printf ("Can't register model\n");
                return;
        }

        // if testing a gun, set the origin reletive to the view origin
        if ( cg.testGun ) {
                VectorCopy( cg.refdef.vieworg, cg.testModelEntity.origin );
                VectorCopy( cg.refdef.viewaxis[0], cg.testModelEntity.axis[0] );
                VectorCopy( cg.refdef.viewaxis[1], cg.testModelEntity.axis[1] );
                VectorCopy( cg.refdef.viewaxis[2], cg.testModelEntity.axis[2] );

                // allow the position to be adjusted
                for (i=0 ; i<3 ; i++) {
                        cg.testModelEntity.origin[i] += cg.refdef.viewaxis[0][i] * cg_gun_x.value;
                        cg.testModelEntity.origin[i] += cg.refdef.viewaxis[1][i] * cg_gun_y.value;
                        cg.testModelEntity.origin[i] += cg.refdef.viewaxis[2][i] * cg_gun_z.value;
                }
        }

        trap_R_AddRefEntityToScene( &cg.testModelEntity );
}



//============================================================================


/*
=================
CG_CalcVrect

Sets the coordinates of the rendered window
=================
*/
static void CG_CalcVrect (void) {
        int             size;

        // the intermission should allways be full screen
        if ( cg.snap->ps.pm_type == PM_INTERMISSION ) {
                size = 100;
        } else {
                // bound normal viewsize
                if (cg_viewsize.integer < 30) {
                        trap_Cvar_Set ("cg_viewsize","30");
                        size = 30;
                } else if (cg_viewsize.integer > 100) {
                        trap_Cvar_Set ("cg_viewsize","100");
                        size = 100;
                } else {
                        size = cg_viewsize.integer;
                }

        }
        cg.refdef.width = cgs.glconfig.vidWidth*size/100;
        cg.refdef.width &= ~1;

        cg.refdef.height = cgs.glconfig.vidHeight*size/100;
        cg.refdef.height &= ~1;

        cg.refdef.x = (cgs.glconfig.vidWidth - cg.refdef.width)/2;
        cg.refdef.y = (cgs.glconfig.vidHeight - cg.refdef.height)/2;
}

//==============================================================================

//==============================================================================
//==============================================================================
// this causes a compiler bug on mac MrC compiler
static void CG_StepOffset( void ) {
        int             timeDelta;
        
        // smooth out stair climbing
        timeDelta = cg.time - cg.stepTime;
        if ( timeDelta < STEP_TIME ) {
                cg.refdef.vieworg[2] -= cg.stepChange 
                        * (STEP_TIME - timeDelta) / STEP_TIME;
        }
}

#define CAMERA_DAMP_INTERVAL    50

static vec3_t   cameramins = { -CAMERA_SIZE, -CAMERA_SIZE, -CAMERA_SIZE };
static vec3_t   cameramaxs = { CAMERA_SIZE, CAMERA_SIZE, CAMERA_SIZE };
vec3_t  camerafwd, cameraup;

vec3_t  cameraFocusAngles,                      cameraFocusLoc;
vec3_t  cameraIdealTarget,                      cameraIdealLoc;
vec3_t  cameraCurTarget={0,0,0},        cameraCurLoc={0,0,0};
vec3_t  cameraOldLoc={0,0,0},           cameraNewLoc={0,0,0};
int             cameraLastFrame=0;

float   cameraLastYaw=0;
float   cameraStiffFactor=0.0f;

/*
===============
Notes on the camera viewpoint in and out...

cg.refdef.vieworg
--at the start of the function holds the player actor's origin (center of player model).
--it is set to the final view location of the camera at the end of the camera code.
cg.refdef.viewangles
--at the start holds the client's view angles
--it is set to the final view angle of the camera at the end of the camera code.

===============
*/
  
extern qboolean gCGHasFallVector;
extern vec3_t gCGFallVector;

/*
===============
CG_CalcTargetThirdPersonViewLocation

===============
*/
static void CG_CalcIdealThirdPersonViewTarget(void)
{
        // Initialize IdealTarget
        if (gCGHasFallVector)
        {
                VectorCopy(gCGFallVector, cameraFocusLoc);
        }
        else
        {
                VectorCopy(cg.refdef.vieworg, cameraFocusLoc);
        }

        // Add in the new viewheight
        cameraFocusLoc[2] += cg.snap->ps.viewheight;

        // Add in a vertical offset from the viewpoint, which puts the actual target above the head, regardless of angle.
//      VectorMA(cameraFocusLoc, thirdPersonVertOffset, cameraup, cameraIdealTarget);
        
        // Add in a vertical offset from the viewpoint, which puts the actual target above the head, regardless of angle.
        VectorCopy( cameraFocusLoc, cameraIdealTarget );
        
        {
                float vertOffset = cg_thirdPersonVertOffset.value;

                if (cg.snap && cg.snap->ps.m_iVehicleNum)
                {
                        centity_t *veh = &cg_entities[cg.snap->ps.m_iVehicleNum];
                        if (veh->m_pVehicle &&
                                veh->m_pVehicle->m_pVehicleInfo->cameraOverride)
                        { //override the range with what the vehicle wants it to be
                                if ( veh->m_pVehicle->m_pVehicleInfo->cameraPitchDependantVertOffset )
                                {
                                        if ( cg.snap->ps.viewangles[PITCH] > 0 )
                                        {
                                                vertOffset = 130+cg.predictedPlayerState.viewangles[PITCH]*-10;
                                                if ( vertOffset < -170 )
                                                {
                                                        vertOffset = -170;
                                                }
                                        }
                                        else if ( cg.snap->ps.viewangles[PITCH] < 0 )
                                        {
                                                vertOffset = 130+cg.predictedPlayerState.viewangles[PITCH]*-5;
                                                if ( vertOffset > 130 )
                                                {
                                                        vertOffset = 130;
                                                }
                                        }
                                        else
                                        {
                                                vertOffset = 30;
                                        }
                                }
                                else 
                                {
                                        vertOffset = veh->m_pVehicle->m_pVehicleInfo->cameraVertOffset;
                                }
                        }
                        else if ( veh->m_pVehicle
                                && veh->m_pVehicle->m_pVehicleInfo
                                && veh->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL )
                        {
                                vertOffset = 0;
                        }
                }
                cameraIdealTarget[2] += vertOffset;
        }
        //VectorMA(cameraFocusLoc, cg_thirdPersonVertOffset.value, cameraup, cameraIdealTarget);
}

        

/*
===============
CG_CalcTargetThirdPersonViewLocation

===============
*/
static void CG_CalcIdealThirdPersonViewLocation(void)
{
        float thirdPersonRange = cg_thirdPersonRange.value;

        if (cg.snap && cg.snap->ps.m_iVehicleNum)
        {
                centity_t *veh = &cg_entities[cg.snap->ps.m_iVehicleNum];
                if (veh->m_pVehicle &&
                        veh->m_pVehicle->m_pVehicleInfo->cameraOverride)
                { //override the range with what the vehicle wants it to be
                        thirdPersonRange = veh->m_pVehicle->m_pVehicleInfo->cameraRange;
                        if ( veh->playerState->hackingTime )
                        {
                                thirdPersonRange += fabs(((float)veh->playerState->hackingTime)/MAX_STRAFE_TIME) * 100.0f;
                        }
                }
        }

        if ( cg.snap
                && (cg.snap->ps.eFlags2&EF2_HELD_BY_MONSTER) 
                && cg.snap->ps.hasLookTarget
                && cg_entities[cg.snap->ps.lookTarget].currentState.NPC_class == CLASS_RANCOR )//only possibility for now, may add Wampa and sand creature later
        {//stay back
                //thirdPersonRange = 180.0f;
                thirdPersonRange = 120.0f;
        }

        VectorMA(cameraIdealTarget, -(thirdPersonRange), camerafwd, cameraIdealLoc);
}



static void CG_ResetThirdPersonViewDamp(void)
{
        trace_t trace;

        // Cap the pitch within reasonable limits
        if (cameraFocusAngles[PITCH] > 89.0)
        {
                cameraFocusAngles[PITCH] = 89.0;
        }
        else if (cameraFocusAngles[PITCH] < -89.0)
        {
                cameraFocusAngles[PITCH] = -89.0;
        }

        AngleVectors(cameraFocusAngles, camerafwd, NULL, cameraup);

        // Set the cameraIdealTarget
        CG_CalcIdealThirdPersonViewTarget();

        // Set the cameraIdealLoc
        CG_CalcIdealThirdPersonViewLocation();

        // Now, we just set everything to the new positions.
        VectorCopy(cameraIdealLoc, cameraCurLoc);
        VectorCopy(cameraIdealTarget, cameraCurTarget);

        // First thing we do is trace from the first person viewpoint out to the new target location.
        CG_Trace(&trace, cameraFocusLoc, cameramins, cameramaxs, cameraCurTarget, cg.snap->ps.clientNum, MASK_CAMERACLIP);
        if (trace.fraction <= 1.0)
        {
                VectorCopy(trace.endpos, cameraCurTarget);
        }

        // Now we trace from the new target location to the new view location, to make sure there is nothing in the way.
        CG_Trace(&trace, cameraCurTarget, cameramins, cameramaxs, cameraCurLoc, cg.snap->ps.clientNum, MASK_CAMERACLIP);
        if (trace.fraction <= 1.0)
        {
                VectorCopy(trace.endpos, cameraCurLoc);
        }

        cameraLastFrame = cg.time;
        cameraLastYaw = cameraFocusAngles[YAW];
        cameraStiffFactor = 0.0f;
}

// This is called every frame.
static void CG_UpdateThirdPersonTargetDamp(void)
{
        trace_t trace;
        vec3_t  targetdiff;
        float   dampfactor, dtime, ratio;

        // Set the cameraIdealTarget
        // Automatically get the ideal target, to avoid jittering.
        CG_CalcIdealThirdPersonViewTarget();

        if ( cg.predictedVehicleState.hyperSpaceTime
                && (cg.time-cg.predictedVehicleState.hyperSpaceTime) < HYPERSPACE_TIME )
        {//hyperspacing, no damp
                VectorCopy(cameraIdealTarget, cameraCurTarget);
        }
        else if (cg_thirdPersonTargetDamp.value>=1.0||cg.thisFrameTeleport||cg.predictedPlayerState.m_iVehicleNum)
        {       // No damping.
                VectorCopy(cameraIdealTarget, cameraCurTarget);
        }
        else if (cg_thirdPersonTargetDamp.value>=0.0)
        {       
                // Calculate the difference from the current position to the new one.
                VectorSubtract(cameraIdealTarget, cameraCurTarget, targetdiff);

                // Now we calculate how much of the difference we cover in the time allotted.
                // The equation is (Damp)^(time)
                dampfactor = 1.0-cg_thirdPersonTargetDamp.value;        // We must exponent the amount LEFT rather than the amount bled off
                dtime = (float)(cg.time-cameraLastFrame) * (1.0/(float)CAMERA_DAMP_INTERVAL);   // Our dampfactor is geared towards a time interval equal to "1".

                // Note that since there are a finite number of "practical" delta millisecond values possible, 
                // the ratio should be initialized into a chart ultimately.
                ratio = powf(dampfactor, dtime);
                
                // This value is how much distance is "left" from the ideal.
                VectorMA(cameraIdealTarget, -ratio, targetdiff, cameraCurTarget);
        }

        // Now we trace to see if the new location is cool or not.

        // First thing we do is trace from the first person viewpoint out to the new target location.
        CG_Trace(&trace, cameraFocusLoc, cameramins, cameramaxs, cameraCurTarget, cg.snap->ps.clientNum, MASK_CAMERACLIP);
        if (trace.fraction < 1.0)
        {
                VectorCopy(trace.endpos, cameraCurTarget);
        }

        // Note that previously there was an upper limit to the number of physics traces that are done through the world
        // for the sake of camera collision, since it wasn't calced per frame.  Now it is calculated every frame.
        // This has the benefit that the camera is a lot smoother now (before it lerped between tested points),
        // however two full volume traces each frame is a bit scary to think about.
}

// This can be called every interval, at the user's discretion.
extern void CG_CalcEntityLerpPositions( centity_t *cent ); //cg_ents.c
static void CG_UpdateThirdPersonCameraDamp(void)
{
        trace_t trace;
        vec3_t  locdiff;
        float dampfactor, dtime, ratio;

        // Set the cameraIdealLoc
        CG_CalcIdealThirdPersonViewLocation();
        
        
        // First thing we do is calculate the appropriate damping factor for the camera.
        dampfactor=0.0;
        if ( cg.predictedVehicleState.hyperSpaceTime
                && (cg.time-cg.predictedVehicleState.hyperSpaceTime) < HYPERSPACE_TIME )
        {//hyperspacing - don't damp camera
                dampfactor = 1.0f;
        }
        else if (cg_thirdPersonCameraDamp.value != 0.0)
        {
                float pitch;
                float dFactor;

                if (!cg.predictedPlayerState.m_iVehicleNum)
                {
                        dFactor = cg_thirdPersonCameraDamp.value;
                }
                else
                {
                        dFactor = 1.0f;
                }

                // Note that the camera pitch has already been capped off to 89.
                pitch = Q_fabs(cameraFocusAngles[PITCH]);

                // The higher the pitch, the larger the factor, so as you look up, it damps a lot less.
                pitch /= 115.0; 
                dampfactor = (1.0-dFactor)*(pitch*pitch);

                dampfactor += dFactor;

                // Now we also multiply in the stiff factor, so that faster yaw changes are stiffer.
                if (cameraStiffFactor > 0.0f)
                {       // The cameraStiffFactor is how much of the remaining damp below 1 should be shaved off, i.e. approach 1 as stiffening increases.
                        dampfactor += (1.0-dampfactor)*cameraStiffFactor;
                }
        }

        if (dampfactor>=1.0||cg.thisFrameTeleport)
        {       // No damping.
                VectorCopy(cameraIdealLoc, cameraCurLoc);
        }
        else if (dampfactor>=0.0)
        {       
                // Calculate the difference from the current position to the new one.
                VectorSubtract(cameraIdealLoc, cameraCurLoc, locdiff);

                // Now we calculate how much of the difference we cover in the time allotted.
                // The equation is (Damp)^(time)
                dampfactor = 1.0-dampfactor;    // We must exponent the amount LEFT rather than the amount bled off
                dtime = (float)(cg.time-cameraLastFrame) * (1.0/(float)CAMERA_DAMP_INTERVAL);   // Our dampfactor is geared towards a time interval equal to "1".

                // Note that since there are a finite number of "practical" delta millisecond values possible, 
                // the ratio should be initialized into a chart ultimately.
                ratio = powf(dampfactor, dtime);
                
                // This value is how much distance is "left" from the ideal.
                VectorMA(cameraIdealLoc, -ratio, locdiff, cameraCurLoc);
        }

        // Now we trace from the new target location to the new view location, to make sure there is nothing in the way.
        CG_Trace(&trace, cameraCurTarget, cameramins, cameramaxs, cameraCurLoc, cg.snap->ps.clientNum, MASK_CAMERACLIP);

        if (trace.fraction < 1.0)
        {
                if (trace.entityNum < ENTITYNUM_WORLD &&
                        cg_entities[trace.entityNum].currentState.solid == SOLID_BMODEL &&
                        cg_entities[trace.entityNum].currentState.eType == ET_MOVER)
                { //get a different position for movers -rww
                        centity_t *mover = &cg_entities[trace.entityNum];

                        //this is absolutely hackiful, since we calc view values before we add packet ents and lerp,
                        //if we hit a mover we want to update its lerp pos and force it when we do the trace against
                        //it.
                        if (mover->currentState.pos.trType != TR_STATIONARY &&
                                mover->currentState.pos.trType != TR_LINEAR)
                        {
                                int curTr = mover->currentState.pos.trType;
                                vec3_t curTrB;

                                VectorCopy(mover->currentState.pos.trBase, curTrB);

                                //calc lerporigin for this client frame
                                CG_CalcEntityLerpPositions(mover);

                                //force the calc'd lerp to be the base and say we are stationary so we don't try to extrapolate
                                //out further.
                                mover->currentState.pos.trType = TR_STATIONARY;
                                VectorCopy(mover->lerpOrigin, mover->currentState.pos.trBase);
                                
                                //retrace
                                CG_Trace(&trace, cameraCurTarget, cameramins, cameramaxs, cameraCurLoc, cg.snap->ps.clientNum, MASK_CAMERACLIP);

                                //copy old data back in
                                mover->currentState.pos.trType = (trType_t) curTr;
                                VectorCopy(curTrB, mover->currentState.pos.trBase);
                        }
                        if (trace.fraction < 1.0f)
                        { //still hit it, so take the proper trace endpos and use that.
                                VectorCopy(trace.endpos, cameraCurLoc);
                        }
                }
                else
                {
                        VectorCopy( trace.endpos, cameraCurLoc );
                }
        }

        // Note that previously there was an upper limit to the number of physics traces that are done through the world
        // for the sake of camera collision, since it wasn't calced per frame.  Now it is calculated every frame.
        // This has the benefit that the camera is a lot smoother now (before it lerped between tested points),
        // however two full volume traces each frame is a bit scary to think about.
}




/*
===============`
CG_OffsetThirdPersonView

===============
*/
extern vmCvar_t cg_thirdPersonHorzOffset;
extern qboolean BG_UnrestrainedPitchRoll( playerState_t *ps, Vehicle_t *pVeh );
static void CG_OffsetThirdPersonView( void ) 
{
        vec3_t diff;
        float thirdPersonHorzOffset = cg_thirdPersonHorzOffset.value;
        float deltayaw;

        if (cg.snap && cg.snap->ps.m_iVehicleNum)
        {
                centity_t *veh = &cg_entities[cg.snap->ps.m_iVehicleNum];
                if (veh->m_pVehicle &&
                        veh->m_pVehicle->m_pVehicleInfo->cameraOverride)
                { //override the range with what the vehicle wants it to be
                        thirdPersonHorzOffset = veh->m_pVehicle->m_pVehicleInfo->cameraHorzOffset;
                        if ( veh->playerState->hackingTime )
                        {
                                thirdPersonHorzOffset += (((float)veh->playerState->hackingTime)/MAX_STRAFE_TIME) * -80.0f;
                        }
                }
        }

        cameraStiffFactor = 0.0;

        // Set camera viewing direction.
        VectorCopy( cg.refdef.viewangles, cameraFocusAngles );

        // if dead, look at killer
        if ( cg.snap
                && (cg.snap->ps.eFlags2&EF2_HELD_BY_MONSTER) 
                && cg.snap->ps.hasLookTarget
                && cg_entities[cg.snap->ps.lookTarget].currentState.NPC_class == CLASS_RANCOR )//only possibility for now, may add Wampa and sand creature later
        {//being held
                //vec3_t monsterPos, dir2Me;
                centity_t       *monster = &cg_entities[cg.snap->ps.lookTarget];
                VectorSet( cameraFocusAngles, 0, AngleNormalize180(monster->lerpAngles[YAW]+180), 0 );
                //make the look angle the vector from his mouth to me
                /*
                VectorCopy( monster->lerpOrigin, monsterPos );
                monsterPos[2] = cg.snap->ps.origin[2];
                VectorSubtract( monsterPos, cg.snap->ps.origin, dir2Me );
                vectoangles( dir2Me, cameraFocusAngles );
                */
        }
        else if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 ) 
        {
                cameraFocusAngles[YAW] = cg.snap->ps.stats[STAT_DEAD_YAW];
        }
        else
        {       // Add in the third Person Angle.
                cameraFocusAngles[YAW] += cg_thirdPersonAngle.value;
                {
                        float pitchOffset = cg_thirdPersonPitchOffset.value;
                        if (cg.snap && cg.snap->ps.m_iVehicleNum)
                        {
                                centity_t *veh = &cg_entities[cg.snap->ps.m_iVehicleNum];
                                if (veh->m_pVehicle &&
                                        veh->m_pVehicle->m_pVehicleInfo->cameraOverride)
                                { //override the range with what the vehicle wants it to be
                                        if ( veh->m_pVehicle->m_pVehicleInfo->cameraPitchDependantVertOffset )
                                        {
                                                if ( cg.snap->ps.viewangles[PITCH] > 0 )
                                                {
                                                        pitchOffset = cg.predictedPlayerState.viewangles[PITCH]*-0.75;
                                                }
                                                else if ( cg.snap->ps.viewangles[PITCH] < 0 )
                                                {
                                                        pitchOffset = cg.predictedPlayerState.viewangles[PITCH]*-0.75;
                                                }
                                                else
                                                {
                                                        pitchOffset = 0;
                                                }
                                        }
                                        else
                                        {
                                                pitchOffset = veh->m_pVehicle->m_pVehicleInfo->cameraPitchOffset;
                                        }
                                }
                        }
                        if ( 0 && cg.predictedPlayerState.m_iVehicleNum //in a vehicle
                                && BG_UnrestrainedPitchRoll( &cg.predictedPlayerState, cg_entities[cg.predictedPlayerState.m_iVehicleNum].m_pVehicle ) )//can roll/pitch without restriction
                        {
                                float pitchPerc = ((90.0f-fabs(cameraFocusAngles[ROLL]))/90.0f);
                                cameraFocusAngles[PITCH] += pitchOffset*pitchPerc;
                                if ( cameraFocusAngles[ROLL] > 0 )
                                {
                                        cameraFocusAngles[YAW] -= pitchOffset-(pitchOffset*pitchPerc);
                                }
                                else
                                {
                                        cameraFocusAngles[YAW] += pitchOffset-(pitchOffset*pitchPerc);
                                }
                        }
                        else
                        {
                                cameraFocusAngles[PITCH] += pitchOffset;
                        }
                }
        }

        // The next thing to do is to see if we need to calculate a new camera target location.

        // If we went back in time for some reason, or if we just started, reset the sample.
        if (cameraLastFrame == 0 || cameraLastFrame > cg.time)
        {
                CG_ResetThirdPersonViewDamp();
        }
        else
        {
                // Cap the pitch within reasonable limits
                if ( cg.predictedPlayerState.m_iVehicleNum //in a vehicle
                        && BG_UnrestrainedPitchRoll( &cg.predictedPlayerState, cg_entities[cg.predictedPlayerState.m_iVehicleNum].m_pVehicle ) )//can roll/pitch without restriction
                {//no clamp on pitch
                        //FIXME: when pitch >= 90 or <= -90, camera rotates oddly... need to CrossProduct not just vectoangles
                }
                else
                {
                        if (cameraFocusAngles[PITCH] > 80.0)
                        {
                                cameraFocusAngles[PITCH] = 80.0;
                        }
                        else if (cameraFocusAngles[PITCH] < -80.0)
                        {
                                cameraFocusAngles[PITCH] = -80.0;
                        }
                }

                AngleVectors(cameraFocusAngles, camerafwd, NULL, cameraup);

                deltayaw = fabs(cameraFocusAngles[YAW] - cameraLastYaw);
                if (deltayaw > 180.0f)
                { // Normalize this angle so that it is between 0 and 180.
                        deltayaw = fabs(deltayaw - 360.0f);
                }
                cameraStiffFactor = deltayaw / (float)(cg.time-cameraLastFrame);
                if (cameraStiffFactor < 1.0)
                {
                        cameraStiffFactor = 0.0;
                }
                else if (cameraStiffFactor > 2.5)
                {
                        cameraStiffFactor = 0.75;
                }
                else
                {       // 1 to 2 scales from 0.0 to 0.5
                        cameraStiffFactor = (cameraStiffFactor-1.0f)*0.5f;
                }
                cameraLastYaw = cameraFocusAngles[YAW];

                // Move the target to the new location.
                CG_UpdateThirdPersonTargetDamp();
                CG_UpdateThirdPersonCameraDamp();
        }

        // Now interestingly, the Quake method is to calculate a target focus point above the player, and point the camera at it.
        // We won't do that for now.

        // We must now take the angle taken from the camera target and location.
        /*VectorSubtract(cameraCurTarget, cameraCurLoc, diff);
        VectorNormalize(diff);
        vectoangles(diff, cg.refdef.viewangles);*/
        VectorSubtract(cameraCurTarget, cameraCurLoc, diff);
        {
                float dist = VectorNormalize(diff);
                //under normal circumstances, should never be 0.00000 and so on.
                if ( !dist || (diff[0] == 0 || diff[1] == 0) )
                {//must be hitting something, need some value to calc angles, so use cam forward
                        VectorCopy( camerafwd, diff );
                }
        }
        if ( 0 && cg.predictedPlayerState.m_iVehicleNum //in a vehicle
                && BG_UnrestrainedPitchRoll( &cg.predictedPlayerState, cg_entities[cg.predictedPlayerState.m_iVehicleNum].m_pVehicle ) )//can roll/pitch without restriction
        {//FIXME: this causes camera jerkiness, need to blend the roll?
                float sav_Roll = cg.refdef.viewangles[ROLL];
                vectoangles(diff, cg.refdef.viewangles);
                cg.refdef.viewangles[ROLL] = sav_Roll;
        }
        else
        {
                vectoangles(diff, cg.refdef.viewangles);
        }

        // Temp: just move the camera to the side a bit
        if ( thirdPersonHorzOffset != 0.0f )
        {
                AnglesToAxis( cg.refdef.viewangles, cg.refdef.viewaxis );
                VectorMA( cameraCurLoc, thirdPersonHorzOffset, cg.refdef.viewaxis[1], cameraCurLoc );
        }

        // ...and of course we should copy the new view location to the proper spot too.
        VectorCopy(cameraCurLoc, cg.refdef.vieworg);

        cameraLastFrame=cg.time;
}

void CG_GetVehicleCamPos( vec3_t camPos )
{
        VectorCopy( cg.refdef.vieworg, camPos );
}

/*
===============
CG_OffsetThirdPersonView

===============
*//*
#define FOCUS_DISTANCE  512
static void CG_OffsetThirdPersonView( void ) {
        vec3_t          forward, right, up;
        vec3_t          view;
        vec3_t          focusAngles;
        trace_t         trace;
        static vec3_t   mins = { -4, -4, -4 };
        static vec3_t   maxs = { 4, 4, 4 };
        vec3_t          focusPoint;
        float           focusDist;
        float           forwardScale, sideScale;

        cg.refdef.vieworg[2] += cg.predictedPlayerState.viewheight;

        VectorCopy( cg.refdef.viewangles, focusAngles );

        // if dead, look at killer
        if ( cg.predictedPlayerState.stats[STAT_HEALTH] <= 0 ) {
                focusAngles[YAW] = cg.predictedPlayerState.stats[STAT_DEAD_YAW];
                cg.refdef.viewangles[YAW] = cg.predictedPlayerState.stats[STAT_DEAD_YAW];
        }

        if ( focusAngles[PITCH] > 45 ) {
                focusAngles[PITCH] = 45;                // don't go too far overhead
        }
        AngleVectors( focusAngles, forward, NULL, NULL );

        VectorMA( cg.refdef.vieworg, FOCUS_DISTANCE, forward, focusPoint );

        VectorCopy( cg.refdef.vieworg, view );

        view[2] += 8;

        cg.refdef.viewangles[PITCH] *= 0.5;

        AngleVectors( cg.refdef.viewangles, forward, right, up );

        forwardScale = cos( cg_thirdPersonAngle.value / 180 * M_PI );
        sideScale = sin( cg_thirdPersonAngle.value / 180 * M_PI );
        VectorMA( view, -cg_thirdPersonRange.value * forwardScale, forward, view );
        VectorMA( view, -cg_thirdPersonRange.value * sideScale, right, view );

        // trace a ray from the origin to the viewpoint to make sure the view isn't
        // in a solid block.  Use an 8 by 8 block to prevent the view from near clipping anything

        if (!cg_cameraMode.integer) {
                CG_Trace( &trace, cg.refdef.vieworg, mins, maxs, view, cg.predictedPlayerState.clientNum, MASK_CAMERACLIP);

                if ( trace.fraction != 1.0 ) {
                        VectorCopy( trace.endpos, view );
                        view[2] += (1.0 - trace.fraction) * 32;
                        // try another trace to this position, because a tunnel may have the ceiling
                        // close enogh that this is poking out

                        CG_Trace( &trace, cg.refdef.vieworg, mins, maxs, view, cg.predictedPlayerState.clientNum, MASK_CAMERACLIP);
                        VectorCopy( trace.endpos, view );
                }
        }


        VectorCopy( view, cg.refdef.vieworg );

        // select pitch to look at focus point from vieword
        VectorSubtract( focusPoint, cg.refdef.vieworg, focusPoint );
        focusDist = sqrt( focusPoint[0] * focusPoint[0] + focusPoint[1] * focusPoint[1] );
        if ( focusDist < 1 ) {
                focusDist = 1;  // should never happen
        }
        cg.refdef.viewangles[PITCH] = -180 / M_PI * atan2( focusPoint[2], focusDist );
        cg.refdef.viewangles[YAW] -= cg_thirdPersonAngle.value;
}


// this causes a compiler bug on mac MrC compiler
static void CG_StepOffset( void ) {
        int             timeDelta;
        
        // smooth out stair climbing
        timeDelta = cg.time - cg.stepTime;
        if ( timeDelta < STEP_TIME ) {
                cg.refdef.vieworg[2] -= cg.stepChange 
                        * (STEP_TIME - timeDelta) / STEP_TIME;
        }
}*/

/*
===============
CG_OffsetFirstPersonView

===============
*/
static void CG_OffsetFirstPersonView( void ) {
        float                   *origin;
        float                   *angles;
        float                   bob;
        float                   ratio;
        float                   delta;
        float                   speed;
        float                   f;
        vec3_t                  predictedVelocity;
        int                             timeDelta;
        int                             kickTime;
        
        if ( cg.snap->ps.pm_type == PM_INTERMISSION ) {
                return;
        }

        origin = cg.refdef.vieworg;
        angles = cg.refdef.viewangles;

        // if dead, fix the angle and don't add any kick
        if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 ) {
                angles[ROLL] = 40;
                angles[PITCH] = -15;
                angles[YAW] = cg.snap->ps.stats[STAT_DEAD_YAW];
                origin[2] += cg.predictedPlayerState.viewheight;
                return;
        }

        // add angles based on weapon kick
        kickTime = (cg.time - cg.kick_time);
        if ( kickTime < 800 )
        {//kicks are always 1 second long.  Deal with it.
                float kickPerc = 0.0f;
                if ( kickTime <= 200 )
                {//winding up
                        kickPerc = kickTime/200.0f;
                }
                else
                {//returning to normal
                        kickTime = 800 - kickTime;
                        kickPerc = kickTime/600.0f;
                }
                VectorMA( angles, kickPerc, cg.kick_angles, angles );
        }
        // add angles based on damage kick
        if ( cg.damageTime ) {
                ratio = cg.time - cg.damageTime;
                if ( ratio < DAMAGE_DEFLECT_TIME ) {
                        ratio /= DAMAGE_DEFLECT_TIME;
                        angles[PITCH] += ratio * cg.v_dmg_pitch;
                        angles[ROLL] += ratio * cg.v_dmg_roll;
                } else {
                        ratio = 1.0 - ( ratio - DAMAGE_DEFLECT_TIME ) / DAMAGE_RETURN_TIME;
                        if ( ratio > 0 ) {
                                angles[PITCH] += ratio * cg.v_dmg_pitch;
                                angles[ROLL] += ratio * cg.v_dmg_roll;
                        }
                }
        }

        // add pitch based on fall kick
#if 0
        ratio = ( cg.time - cg.landTime) / FALL_TIME;
        if (ratio < 0)
                ratio = 0;
        angles[PITCH] += ratio * cg.fall_value;
#endif

        // add angles based on velocity
        VectorCopy( cg.predictedPlayerState.velocity, predictedVelocity );

        delta = DotProduct ( predictedVelocity, cg.refdef.viewaxis[0]);
        angles[PITCH] += delta * cg_runpitch.value;
        
        delta = DotProduct ( predictedVelocity, cg.refdef.viewaxis[1]);
        angles[ROLL] -= delta * cg_runroll.value;

        // add angles based on bob

        // make sure the bob is visible even at low speeds
        speed = cg.xyspeed > 200 ? cg.xyspeed : 200;

        delta = cg.bobfracsin * cg_bobpitch.value * speed;
        if (cg.predictedPlayerState.pm_flags & PMF_DUCKED)
                delta *= 3;             // crouching
        angles[PITCH] += delta;
        delta = cg.bobfracsin * cg_bobroll.value * speed;
        if (cg.predictedPlayerState.pm_flags & PMF_DUCKED)
                delta *= 3;             // crouching accentuates roll
        if (cg.bobcycle & 1)
                delta = -delta;
        angles[ROLL] += delta;

//===================================

        // add view height
        origin[2] += cg.predictedPlayerState.viewheight;

        // smooth out duck height changes
        timeDelta = cg.time - cg.duckTime;
        if ( timeDelta < DUCK_TIME) {
                cg.refdef.vieworg[2] -= cg.duckChange 
                        * (DUCK_TIME - timeDelta) / DUCK_TIME;
        }

        // add bob height
        bob = cg.bobfracsin * cg.xyspeed * cg_bobup.value;
        if (bob > 6) {
                bob = 6;
        }

        origin[2] += bob;


        // add fall height
        delta = cg.time - cg.landTime;
        if ( delta < LAND_DEFLECT_TIME ) {
                f = delta / LAND_DEFLECT_TIME;
                cg.refdef.vieworg[2] += cg.landChange * f;
        } else if ( delta < LAND_DEFLECT_TIME + LAND_RETURN_TIME ) {
                delta -= LAND_DEFLECT_TIME;
                f = 1.0 - ( delta / LAND_RETURN_TIME );
                cg.refdef.vieworg[2] += cg.landChange * f;
        }

        // add step offset
        CG_StepOffset();

        // add kick offset

        VectorAdd (origin, cg.kick_origin, origin);

        // pivot the eye based on a neck length
#if 0
        {
#define NECK_LENGTH             8
        vec3_t                  forward, up;
 
        cg.refdef.vieworg[2] -= NECK_LENGTH;
        AngleVectors( cg.refdef.viewangles, forward, NULL, up );
        VectorMA( cg.refdef.vieworg, 3, forward, cg.refdef.vieworg );
        VectorMA( cg.refdef.vieworg, NECK_LENGTH, up, cg.refdef.vieworg );
        }
#endif
}

static void CG_OffsetFighterView( void )
{
        vec3_t vehFwd, vehRight, vehUp, backDir;
        vec3_t  camOrg, camBackOrg;
        float horzOffset = cg_thirdPersonHorzOffset.value;
        float vertOffset = cg_thirdPersonVertOffset.value;
        float pitchOffset = cg_thirdPersonPitchOffset.value;
        float yawOffset = cg_thirdPersonAngle.value;
        float range = cg_thirdPersonRange.value;
        trace_t trace;
        centity_t *veh = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];

        AngleVectors( cg.refdef.viewangles, vehFwd, vehRight, vehUp );

        if ( veh->m_pVehicle &&
                veh->m_pVehicle->m_pVehicleInfo->cameraOverride )
        { //override the horizontal offset with what the vehicle wants it to be
                horzOffset = veh->m_pVehicle->m_pVehicleInfo->cameraHorzOffset;
                vertOffset = veh->m_pVehicle->m_pVehicleInfo->cameraVertOffset;
                //NOTE: no yaw offset?
                pitchOffset = veh->m_pVehicle->m_pVehicleInfo->cameraPitchOffset;
                range = veh->m_pVehicle->m_pVehicleInfo->cameraRange;
                if ( veh->playerState->hackingTime )
                {
                        horzOffset += (((float)veh->playerState->hackingTime)/MAX_STRAFE_TIME) * -80.0f;
                        range += fabs(((float)veh->playerState->hackingTime)/MAX_STRAFE_TIME) * 100.0f;
                }
        }

        //Set camera viewing position
        VectorMA( cg.refdef.vieworg, horzOffset, vehRight, camOrg );
        VectorMA( camOrg, vertOffset, vehUp, camOrg );

        //trace to that pos
        CG_Trace(&trace, cg.refdef.vieworg, cameramins, cameramaxs, camOrg, cg.snap->ps.clientNum, MASK_CAMERACLIP);
        if ( trace.fraction < 1.0 )
        {
                VectorCopy( trace.endpos, camOrg );
        }

        // Set camera viewing direction.
        cg.refdef.viewangles[YAW] += yawOffset;
        cg.refdef.viewangles[PITCH] += pitchOffset;

        //Now bring the cam back from that pos and angles at range
        AngleVectors( cg.refdef.viewangles, backDir, NULL, NULL );
        VectorScale( backDir, -1, backDir );

        VectorMA( camOrg, range, backDir, camBackOrg );

        //trace to that pos
        CG_Trace(&trace, camOrg, cameramins, cameramaxs, camBackOrg, cg.snap->ps.clientNum, MASK_CAMERACLIP);
        VectorCopy( trace.endpos, camOrg );

        //FIXME: do we need to smooth the org?
        // ...and of course we should copy the new view location to the proper spot too.
        VectorCopy(camOrg, cg.refdef.vieworg);
}
//======================================================================

void CG_ZoomDown_f( void ) { 
        if ( cg.zoomed ) {
                return;
        }
        cg.zoomed = qtrue;
        cg.zoomTime = cg.time;
}

void CG_ZoomUp_f( void ) { 
        if ( !cg.zoomed ) {
                return;
        }
        cg.zoomed = qfalse;
        cg.zoomTime = cg.time;
}



/*
====================
CG_CalcFovFromX

Calcs Y FOV from given X FOV
====================
*/
qboolean CG_CalcFOVFromX( float fov_x ) 
{
        float   x;
//      float   phase;
//      float   v;
//      int             contents;
        float   fov_y;
        qboolean        inwater;

        x = cg.refdef.width / tan( fov_x / 360 * M_PI );
        fov_y = atan2( cg.refdef.height, x );
        fov_y = fov_y * 360 / M_PI;

        // there's a problem with this, it only takes the leafbrushes into account, not the entity brushes,
        //      so if you give slime/water etc properties to a func_door area brush in order to move the whole water 
        //      level up/down this doesn't take into account the door position, so warps the view the whole time
        //      whether the water is up or not. Fortunately there's only one slime area in Trek that you can be under,
        //      so lose it...
#if 0
/*
        // warp if underwater
        contents = CG_PointContents( cg.refdef.vieworg, -1 );
        if ( contents & ( CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA ) ){
                phase = cg.time / 1000.0 * WAVE_FREQUENCY * M_PI * 2;
                v = WAVE_AMPLITUDE * sin( phase );
                fov_x += v;
                fov_y -= v;
                inwater = qtrue;
        }
        else {
                inwater = qfalse;
        }
*/
#else
        inwater = qfalse;
#endif


        // set it
        cg.refdef.fov_x = fov_x;
        cg.refdef.fov_y = fov_y;

#ifdef _XBOX
        if(cg.widescreen)
                cg.refdef.fov_x *= 1.125f;