/*
===========================================================================
Copyright (C) 1999 - 2005, Id Software, Inc.
Copyright (C) 2000 - 2013, Raven Software, Inc.
Copyright (C) 2001 - 2013, Activision, Inc.
Copyright (C) 2013 - 2015, OpenJK contributors
This file is part of the OpenJK source code.
OpenJK is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 as
published by the Free Software Foundation.
This program 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 this program; if not, see .
===========================================================================
*/
// cg_view.c -- setup all the parameters (position, angle, etc)
// for a 3D rendering
#include "cg_local.h"
#include "cg_media.h"
#include "FxScheduler.h"
#include "../game/wp_saber.h"
#include "../game/anims.h"
#include "../game/g_functions.h"
#include "bg_local.h"
#include
#define MASK_CAMERACLIP (MASK_SOLID)
#define CAMERA_SIZE 4
float cg_zoomFov;
//#define CG_CAM_ABOVE 2
extern qboolean CG_OnMovingPlat( playerState_t *ps );
/*
=============================================================================
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 " or "testgun ".
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.
=============================================================================
*/
/*
Ghoul2 Insert Start
*/
/*
=================
CG_TestModel_f
Creates an entity in front of the current position, which
can then be moved around
=================
*/
void CG_TestG2Model_f (void) {
vec3_t angles;
CGhoul2Info_v *ghoul2;
memset( &cg.testModelEntity, 0, sizeof(cg.testModelEntity) );
ghoul2 = new CGhoul2Info_v;
cg.testModelEntity.ghoul2 = ghoul2;
if ( cgi_Argc() < 2 ) {
return;
}
Q_strncpyz (cg.testModelName, CG_Argv( 1 ), MAX_QPATH );
cg.testModelEntity.hModel = cgi_R_RegisterModel( cg.testModelName );
cg.testModel = gi.G2API_InitGhoul2Model( *((CGhoul2Info_v *)cg.testModelEntity.ghoul2), cg.testModelName, cg.testModelEntity.hModel, NULL_HANDLE, NULL_HANDLE, 0, 0 );
cg.testModelEntity.radius = 100.0f;
if ( cgi_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.refdefViewAngles[1];
angles[ROLL] = 0;
AnglesToAxis( angles, cg.testModelEntity.axis );
cg.testGun = qfalse;
}
void CG_ListModelSurfaces_f (void)
{
CGhoul2Info_v &ghoul2 = *((CGhoul2Info_v *)cg.testModelEntity.ghoul2);
gi.G2API_ListSurfaces(&ghoul2[cg.testModel]);
}
void CG_ListModelBones_f (void)
{
// test to see if we got enough args
if ( cgi_Argc() < 2 )
{
return;
}
CGhoul2Info_v &ghoul2 = *((CGhoul2Info_v *)cg.testModelEntity.ghoul2);
gi.G2API_ListBones(&ghoul2[cg.testModel], atoi(CG_Argv(1)));
}
void CG_TestModelSurfaceOnOff_f(void)
{
// test to see if we got enough args
if ( cgi_Argc() < 3 )
{
return;
}
CGhoul2Info_v &ghoul2 = *((CGhoul2Info_v *)cg.testModelEntity.ghoul2);
gi.G2API_SetSurfaceOnOff(&ghoul2[cg.testModel], CG_Argv(1), atoi(CG_Argv(2)));
}
void CG_TestModelSetAnglespre_f(void)
{
vec3_t angles;
if ( cgi_Argc() < 3 )
{
return;
}
CGhoul2Info_v &ghoul2 = *((CGhoul2Info_v *)cg.testModelEntity.ghoul2);
angles[0] = atof(CG_Argv(2));
angles[1] = atof(CG_Argv(3));
angles[2] = atof(CG_Argv(4));
gi.G2API_SetBoneAngles(&ghoul2[cg.testModel], CG_Argv(1), angles, BONE_ANGLES_PREMULT, POSITIVE_X, POSITIVE_Z, POSITIVE_Y, NULL, 0, 0);
}
void CG_TestModelSetAnglespost_f(void)
{
vec3_t angles;
if ( cgi_Argc() < 3 )
{
return;
}
CGhoul2Info_v &ghoul2 = *((CGhoul2Info_v *)cg.testModelEntity.ghoul2);
angles[0] = atof(CG_Argv(2));
angles[1] = atof(CG_Argv(3));
angles[2] = atof(CG_Argv(4));
gi.G2API_SetBoneAngles(&ghoul2[cg.testModel], CG_Argv(1), angles, BONE_ANGLES_POSTMULT, POSITIVE_X, POSITIVE_Z, POSITIVE_Y, NULL, 0, 0);
}
void CG_TestModelAnimate_f(void)
{
char boneName[100];
CGhoul2Info_v &ghoul2 = *((CGhoul2Info_v *)cg.testModelEntity.ghoul2);
Q_strncpyz(boneName, CG_Argv(1), sizeof(boneName));
gi.G2API_SetBoneAnim(&ghoul2[cg.testModel], boneName, atoi(CG_Argv(2)), atoi(CG_Argv(3)), BONE_ANIM_OVERRIDE_LOOP, atof(CG_Argv(4)), cg.time, -1, -1);
}
/*
Ghoul2 Insert End
*/
/*
=================
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 ( cgi_Argc() < 2 ) {
return;
}
Q_strncpyz (cg.testModelName, CG_Argv( 1 ), MAX_QPATH );
cg.testModelEntity.hModel = cgi_R_RegisterModel( cg.testModelName );
if ( cgi_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.refdefViewAngles[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_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 = cgi_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;
}
}
cgi_R_AddRefEntityToScene( &cg.testModelEntity );
}
//============================================================================
/*
=================
CG_CalcVrect
Sets the coordinates of the rendered window
=================
*/
void CG_CalcVrect (void) {
const int size = 100;
cg.refdef.width = cgs.glconfig.vidWidth * size * 0.01;
cg.refdef.width &= ~1;
cg.refdef.height = cgs.glconfig.vidHeight * size * 0.01;
cg.refdef.height &= ~1;
cg.refdef.x = (cgs.glconfig.vidWidth - cg.refdef.width) * 0.5;
cg.refdef.y = (cgs.glconfig.vidHeight - cg.refdef.height) * 0.5;
}
//==============================================================================
//==============================================================================
#define CAMERA_DAMP_INTERVAL 50
#define CAMERA_CROUCH_NUDGE 6
static vec3_t cameramins = { -CAMERA_SIZE, -CAMERA_SIZE, -CAMERA_SIZE };
static vec3_t cameramaxs = { CAMERA_SIZE, CAMERA_SIZE, CAMERA_SIZE };
vec3_t camerafwd, cameraup, camerahorizdir;
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.refdefViewAngles
--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.
===============
*/
/*
===============
CG_CalcIdealThirdPersonViewTarget
===============
*/
static void CG_CalcIdealThirdPersonViewTarget(void)
{
// Initialize IdealTarget
qboolean usesViewEntity = (qboolean)(cg.snap->ps.viewEntity && cg.snap->ps.viewEntity < ENTITYNUM_WORLD);
VectorCopy(cg.refdef.vieworg, cameraFocusLoc);
if ( usesViewEntity )
{
gentity_t *gent = &g_entities[cg.snap->ps.viewEntity];
if ( gent->client && (gent->client->NPC_class == CLASS_GONK
|| gent->client->NPC_class == CLASS_INTERROGATOR
|| gent->client->NPC_class == CLASS_SENTRY
|| gent->client->NPC_class == CLASS_PROBE
|| gent->client->NPC_class == CLASS_MOUSE
|| gent->client->NPC_class == CLASS_R2D2
|| gent->client->NPC_class == CLASS_R5D2) )
{ // Droids use a generic offset
cameraFocusLoc[2] += 4;
VectorCopy( cameraFocusLoc, cameraIdealTarget );
return;
}
if( gent->client->ps.pm_flags & PMF_DUCKED )
{ // sort of a nasty hack in order to get this to work. Don't tell Ensiform, or I'll have to kill him. --eez
cameraFocusLoc[2] -= CAMERA_CROUCH_NUDGE*4;
}
}
// Add in the new viewheight
cameraFocusLoc[2] += cg.predicted_player_state.viewheight;
if ( cg.overrides.active & CG_OVERRIDE_3RD_PERSON_VOF )
{
// Add in a vertical offset from the viewpoint, which puts the actual target above the head, regardless of angle.
VectorCopy( cameraFocusLoc, cameraIdealTarget );
cameraIdealTarget[2] += cg.overrides.thirdPersonVertOffset;
//VectorMA(cameraFocusLoc, cg.overrides.thirdPersonVertOffset, cameraup, cameraIdealTarget);
}
else
{
// Add in a vertical offset from the viewpoint, which puts the actual target above the head, regardless of angle.
VectorCopy( cameraFocusLoc, cameraIdealTarget );
cameraIdealTarget[2] += cg_thirdPersonVertOffset.value;
//VectorMA(cameraFocusLoc, cg_thirdPersonVertOffset.value, cameraup, cameraIdealTarget);
}
// Now, if the player is crouching, do a little special tweak. The problem is that the player's head is way out of his bbox.
if (cg.predicted_player_state.pm_flags & PMF_DUCKED)
{ // Nudge to focus location up a tad.
vec3_t nudgepos;
trace_t trace;
VectorCopy(cameraFocusLoc, nudgepos);
nudgepos[2]+=CAMERA_CROUCH_NUDGE;
CG_Trace(&trace, cameraFocusLoc, cameramins, cameramaxs, nudgepos, cg.predicted_player_state.clientNum, MASK_CAMERACLIP);
if (trace.fraction < 1.0)
{
VectorCopy(trace.endpos, cameraFocusLoc);
}
else
{
VectorCopy(nudgepos, cameraFocusLoc);
}
}
}
/*
===============
CG_CalcIdealThirdPersonViewLocation
===============
*/
static void CG_CalcIdealThirdPersonViewLocation(void)
{
gentity_t *player = &g_entities[0];
if ( cg.overrides.active & CG_OVERRIDE_3RD_PERSON_RNG )
{
VectorMA(cameraIdealTarget, -(cg.overrides.thirdPersonRange), camerafwd, cameraIdealLoc);
}
else
{
VectorMA(cameraIdealTarget, -(cg_thirdPersonRange.value), camerafwd, cameraIdealLoc);
}
if ( cg.renderingThirdPerson && (cg.snap->ps.forcePowersActive&(1<client->ps.forcePowerDuration[FP_SPEED] )
{
float timeLeft = player->client->ps.forcePowerDuration[FP_SPEED] - cg.time;
float length = FORCE_SPEED_DURATION*forceSpeedValue[player->client->ps.forcePowerLevel[FP_SPEED]];
float amt = forceSpeedRangeMod[player->client->ps.forcePowerLevel[FP_SPEED]];
if ( timeLeft < 500 )
{//start going back
VectorMA(cameraIdealLoc, (timeLeft)/500*amt, camerafwd, cameraIdealLoc);
}
else if ( length - timeLeft < 1000 )
{//start zooming in
VectorMA(cameraIdealLoc, (length - timeLeft)/1000*amt, camerafwd, cameraIdealLoc);
}
else
{
VectorMA(cameraIdealLoc, amt, 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.predicted_player_state.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.predicted_player_state.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_OnMovingPlat( &cg.snap->ps ) )
{//if moving on a plat, camera is *tight*
VectorCopy(cameraIdealTarget, cameraCurTarget);
}
else if (cg_thirdPersonTargetDamp.value>=1.0)//||cg.thisFrameTeleport)
{ // 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/cg_timescale.value) * (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 = pow(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.predicted_player_state.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.
static int camWaterAdjust = 0;
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.0f;
if ( CG_OnMovingPlat( &cg.snap->ps ) )
{//if moving on a plat, camera is *tight*
dampfactor=1.0f;
}
else if ( cg.overrides.active & CG_OVERRIDE_3RD_PERSON_CDP )
{
if ( cg.overrides.thirdPersonCameraDamp != 0.0f )
{
double pitch;
// 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 /= 89.0;
dampfactor = (1.0-cg.overrides.thirdPersonCameraDamp)*(pitch*pitch);
dampfactor += cg.overrides.thirdPersonCameraDamp;
}
}
else if ( cg_thirdPersonCameraDamp.value != 0.0f )
{
double pitch;
// 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 /= 89.0;
dampfactor = (1.0-cg_thirdPersonCameraDamp.value)*(pitch*pitch);
dampfactor += cg_thirdPersonCameraDamp.value;
// 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/cg_timescale.value) * (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 = pow(dampfactor, dtime);
// This value is how much distance is "left" from the ideal.
VectorMA(cameraIdealLoc, -ratio, locdiff, cameraCurLoc);
/////////////////////////////////////////////////////////////////////////////////////////////////////////
}
// Now we trace from the first person viewpoint to the new view location, to make sure there is nothing in the way between the user and the camera...
// CG_Trace(&trace, cameraFocusLoc, cameramins, cameramaxs, cameraCurLoc, cg.predicted_player_state.clientNum, MASK_CAMERACLIP);
// (OLD) 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.predicted_player_state.clientNum, MASK_CAMERACLIP);
if ( trace.fraction < 1.0f )
{
VectorCopy( trace.endpos, cameraCurLoc );
// We didn't trace all the way back, so push down the target accordingly.
// VectorSubtract(cameraCurTarget, cameraFocusLoc, locdiff);
// VectorMA(cameraFocusLoc, trace.fraction, locdiff, cameraCurTarget);
//FIXME: when the trace hits movers, it gets very very jaggy... ?
/*
//this doesn't actually help any
if ( trace.entityNum != ENTITYNUM_WORLD )
{
centity_t *cent = &cg_entities[trace.entityNum];
gentity_t *gent = &g_entities[trace.entityNum];
if ( cent != NULL && gent != NULL )
{
if ( cent->currentState.pos.trType == TR_LINEAR || cent->currentState.pos.trType == TR_LINEAR_STOP )
{
vec3_t diff;
VectorSubtract( cent->lerpOrigin, gent->currentOrigin, diff );
VectorAdd( cameraCurLoc, diff, 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 qboolean MatrixMode;
static void CG_OffsetThirdPersonView( void )
{
vec3_t diff;
float deltayaw;
camWaterAdjust = 0;
cameraStiffFactor = 0.0;
// Set camera viewing direction.
VectorCopy( cg.refdefViewAngles, cameraFocusAngles );
// if dead, look at killer
if ( cg.predicted_player_state.stats[STAT_HEALTH] <= 0 )
{
//Do nothing
/* if ( MatrixMode )
{
if ( cg.overrides.active & CG_OVERRIDE_3RD_PERSON_ANG )
{
cameraFocusAngles[YAW] += cg.overrides.thirdPersonAngle;
}
else
{
cameraFocusAngles[YAW] = cg.predicted_player_state.stats[STAT_DEAD_YAW];
cameraFocusAngles[YAW] += cg_thirdPersonAngle.value;
}
}
else
{
cameraFocusAngles[YAW] = cg.predicted_player_state.stats[STAT_DEAD_YAW];
}*/
}
else
{ // Add in the third Person Angle.
if ( cg.overrides.active & CG_OVERRIDE_3RD_PERSON_ANG )
{
cameraFocusAngles[YAW] += cg.overrides.thirdPersonAngle;
}
else
{
cameraFocusAngles[YAW] += cg_thirdPersonAngle.value;
}
if ( cg.overrides.active & CG_OVERRIDE_3RD_PERSON_POF )
{
cameraFocusAngles[PITCH] += cg.overrides.thirdPersonPitchOffset;
}
else
{
cameraFocusAngles[PITCH] += cg_thirdPersonPitchOffset.value;
}
}
if ( !cg.renderingThirdPerson && (cg.snap->ps.weapon == WP_SABER||cg.snap->ps.weapon == WP_MELEE) )
{// First person saber
// FIXME: use something network-friendly
vec3_t org, viewDir;
VectorCopy( cg_entities[0].gent->client->renderInfo.eyePoint, org );
float blend = 1.0f - fabs(cg.refdefViewAngles[PITCH])/90.0f;
AngleVectors( cg.refdefViewAngles, viewDir, NULL, NULL );
VectorMA( org, -8, viewDir, org );
VectorScale( org, 1.0f - blend, org );
VectorMA( org, blend, cg.refdef.vieworg, cg.refdef.vieworg );
return;
}
// 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 (cameraFocusAngles[PITCH] > 89.0)
{
cameraFocusAngles[PITCH] = 89.0;
}
else if (cameraFocusAngles[PITCH] < -89.0)
{
cameraFocusAngles[PITCH] = -89.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);
//Com_Printf( "%s\n", vtos(diff) );
float dist = VectorNormalize(diff);
if ( dist < 1.0f )
{//must be hitting something, need some value to calc angles, so use cam forward
VectorCopy( camerafwd, diff );
}
vectoangles(diff, cg.refdefViewAngles);
// Temp: just move the camera to the side a bit
extern vmCvar_t cg_thirdPersonHorzOffset;
if ( cg_thirdPersonHorzOffset.value != 0.0f )
{
AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
VectorMA( cameraCurLoc, cg_thirdPersonHorzOffset.value, 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);
//if we hit the water, do a last-minute adjustment
if ( camWaterAdjust )
{
cg.refdef.vieworg[2] += camWaterAdjust;
}
cameraLastFrame=cg.time;
}
/*
===============
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.predicted_player_state.viewheight;
VectorCopy( cg.refdefViewAngles, focusAngles );
// if dead, look at killer
if ( cg.predicted_player_state.stats[STAT_HEALTH] <= 0 ) {
focusAngles[YAW] = cg.predicted_player_state.stats[STAT_DEAD_YAW];
cg.refdefViewAngles[YAW] = cg.predicted_player_state.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.refdefViewAngles[PITCH] *= 0.5;
AngleVectors( cg.refdefViewAngles, forward, right, up );
float tpAngle = cg.overrides.thirdPersonAngle ? cg.overrides.thirdPersonAngle : cg_thirdPersonAngle.value;
forwardScale = cos( tpAngle / 180 * M_PI );
sideScale = sin( tpAngle / 180 * M_PI );
VectorMA( view, -tpAngle * forwardScale, forward, view );
VectorMA( view, -tpAngle * 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
CG_Trace( &trace, cg.refdef.vieworg, mins, maxs, view, cg.predicted_player_state.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.predicted_player_state.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.refdefViewAngles[PITCH] = -180 / M_PI * atan2( focusPoint[2], focusDist );
cg.refdefViewAngles[YAW] -= tpAngle;
}
#define MIN_CAMERA_HEIGHT 75
#define MIN_CAMERA_PITCH 40
#define MAX_CAMERA_PITCH 90
//----------------------------------------------
static void CG_OffsetThirdPersonOverheadView( void ) {
vec3_t view, angs;
trace_t trace;
static vec3_t mins = { -4, -4, -4 };
static vec3_t maxs = { 4, 4, 4 };
VectorCopy( cg.refdef.vieworg, view );
// Move straight up from the player, making sure to always go at least the min camera height,
// otherwise, the camera will clip into the head of the player.
float tpRange = cg.overrides.thirdPersonRange ? cg.overrides.thirdPersonRange : cg_thirdPersonRange.value;
if ( tpRange < MIN_CAMERA_HEIGHT )
{
view[2] += MIN_CAMERA_HEIGHT;
}
else
{
view[2] += tpRange;
}
// Now adjust the camera angles, but we shouldn't adjust the viewAngles...only the viewAxis
VectorCopy( cg.refdefViewAngles, angs );
angs[PITCH] = cg.overrides.thirdPersonAngle ? cg.overrides.thirdPersonAngle : cg_thirdPersonAngle.value;
// Simple clamp to weed out any really obviously nasty angles
if ( angs[PITCH] < MIN_CAMERA_PITCH )
{
angs[PITCH] = MIN_CAMERA_PITCH;
}
else if ( angs[PITCH] > MAX_CAMERA_PITCH )
{
angs[PITCH] = MAX_CAMERA_PITCH;
}
// Convert our new desired camera angles and store them where they will get used by the engine
// when setting up the actual camera view.
AnglesToAxis( angs, cg.refdef.viewaxis );
cg.refdefViewAngles[PITCH] = 0;
g_entities[0].client->ps.delta_angles[PITCH] = 0;
// Trace a ray from the origin to the viewpoint to make sure the view isn't
// in a solid block.
CG_Trace( &trace, cg.refdef.vieworg, mins, maxs, view, cg.predicted_player_state.clientNum, MASK_CAMERACLIP);
if ( trace.fraction != 1.0 )
{
VectorCopy( trace.endpos, cg.refdef.vieworg );
}
else
{
VectorCopy( view, cg.refdef.vieworg );
}
}
*/
// 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
===============
*/
extern qboolean PM_InForceGetUp( playerState_t *ps );
extern qboolean PM_InGetUp( playerState_t *ps );
extern qboolean PM_InKnockDown( playerState_t *ps );
extern int PM_AnimLength( int index, animNumber_t anim );
static void CG_OffsetFirstPersonView( qboolean firstPersonSaber ) {
float *origin;
float *angles;
float bob;
float ratio;
float delta;
float speed;
float f;
vec3_t predictedVelocity;
int timeDelta;
if ( cg.snap->ps.pm_type == PM_INTERMISSION ) {
return;
}
origin = cg.refdef.vieworg;
angles = cg.refdefViewAngles;
// 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.predicted_player_state.viewheight;
return;
}
if ( g_entities[0].client && PM_InKnockDown( &g_entities[0].client->ps ) )
{
float perc, animLen = (float)PM_AnimLength( g_entities[0].client->clientInfo.animFileIndex, (animNumber_t)g_entities[0].client->ps.legsAnim );
if ( PM_InGetUp( &g_entities[0].client->ps ) || PM_InForceGetUp( &g_entities[0].client->ps ) )
{//start righting the view
perc = (float)g_entities[0].client->ps.legsAnimTimer/animLen*2;
}
else
{//tilt the view
perc = (animLen-g_entities[0].client->ps.legsAnimTimer)/animLen*2;
}
if ( perc > 1.0f )
{
perc = 1.0f;
}
angles[ROLL] = perc*40;
angles[PITCH] = perc*-15;
}
// add angles based on weapon kick
//VectorAdd (angles, 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.predicted_player_state.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.predicted_player_state.pm_flags & PMF_DUCKED)
delta *= 3; // crouching
angles[PITCH] += delta;
delta = cg.bobfracsin * cg_bobroll.value * speed;
if (cg.predicted_player_state.pm_flags & PMF_DUCKED)
delta *= 3; // crouching accentuates roll
if (cg.bobcycle & 1)
delta = -delta;
angles[ROLL] += delta;
//===================================
if ( !firstPersonSaber )//First person saber
{
// add view height
if ( cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )
{
if ( &g_entities[cg.snap->ps.viewEntity] &&
g_entities[cg.snap->ps.viewEntity].client &&
g_entities[cg.snap->ps.viewEntity].client->ps.viewheight )
{
origin[2] += g_entities[cg.snap->ps.viewEntity].client->ps.viewheight;
}
else
{
origin[2] += 4;//???
}
}
else
{
origin[2] += cg.predicted_player_state.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();
if(cg.snap->ps.leanofs != 0)
{
vec3_t right;
//add leaning offset
//FIXME: when crouching, this bounces up and down?!
cg.refdefViewAngles[2] += (float)cg.snap->ps.leanofs/2;
AngleVectors(cg.refdefViewAngles, NULL, right, NULL);
VectorMA(cg.refdef.vieworg, (float)cg.snap->ps.leanofs, right, cg.refdef.vieworg);
}
// 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.refdefViewAngles, forward, NULL, up );
VectorMA( cg.refdef.vieworg, 3, forward, cg.refdef.vieworg );
VectorMA( cg.refdef.vieworg, NECK_LENGTH, up, cg.refdef.vieworg );
}
#endif
}
//======================================================================
/*
void CG_ZoomDown_f( void )
{
// Ignore zoom requests when yer paused
if ( cg_paused.integer || in_camera )
{
return;
}
// The zoom hasn't been started yet, so do it now
if ( cg.zoomMode == 0 )
{
cg.zoomLocked = qfalse;
cg.zoomMode = 1;
if ( cg.overrides.active & CG_OVERRIDE_FOV )
{
cg_zoomFov = cg.overrides.fov;
}
else
{
cg_zoomFov = cg_fov.value;
}
cg.zoomTime = cg.time;
cgi_S_StartSound( cg.refdef.vieworg, ENTITYNUM_WORLD, CHAN_AUTO, cgs.media.zoomStart );
return;
}
// Can only snap out of the zoom mode if it has already been locked (CG_ZoomUp_f has been called)
if ( cg.zoomLocked )
{
// Snap out of zoom mode
cg.zoomMode = 0;
cg.zoomTime = cg.time;
cgi_S_StartSound( cg.refdef.vieworg, ENTITYNUM_WORLD, CHAN_AUTO, cgs.media.zoomEnd );
}
}
void CG_ZoomUp_f( void )
{
// Ignore zoom requests when yer paused
if ( cg_paused.integer || in_camera )
{
return;
}
if ( cg.zoomMode ) {
// Freeze the zoom mode
cg.zoomLocked = qtrue;
}
}
*/
/*
====================
CG_CalcFovFromX
Calcs Y FOV from given X FOV
====================
*/
#define WAVE_AMPLITUDE 1
#define WAVE_FREQUENCY 0.4
qboolean CG_CalcFOVFromX( float fov_x )
{
float x;
float fov_y;
qboolean inwater;
if ( cg_fovAspectAdjust.integer ) {
// Based on LordHavoc's code for Darkplaces
// http://www.quakeworld.nu/forum/topic/53/what-does-your-qw-look-like/page/30
const float baseAspect = 0.75f; // 3/4
const float aspect = (float)cgs.glconfig.vidWidth/(float)cgs.glconfig.vidHeight;
const float desiredFov = fov_x;
fov_x = atan( tan( desiredFov*M_PI / 360.0f ) * baseAspect*aspect )*360.0f / M_PI;
}
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 1
// warp if underwater
float phase;
float v;
int contents;
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
// see if we are drugged by an interrogator. We muck with the FOV here, a bit later, after viewangles are calc'ed, I muck with those too.
if ( cg.wonkyTime > 0 && cg.wonkyTime > cg.time )
{
float perc = (float)(cg.wonkyTime - cg.time) / 10000.0f; // goes for 10 seconds
fov_x += ( 25.0f * perc );
fov_y -= ( cos( cg.time * 0.0008f ) * 5.0f * perc );
}
// set it
cg.refdef.fov_x = fov_x;
cg.refdef.fov_y = fov_y;
return (inwater);
}
float CG_ForceSpeedFOV( float infov )
{
gentity_t *player = &g_entities[0];
float fov;
float timeLeft = player->client->ps.forcePowerDuration[FP_SPEED] - cg.time;
float length = FORCE_SPEED_DURATION*forceSpeedValue[player->client->ps.forcePowerLevel[FP_SPEED]];
float amt = forceSpeedFOVMod[player->client->ps.forcePowerLevel[FP_SPEED]];
if ( timeLeft < 500 )
{//start going back
fov = infov + (timeLeft)/500*amt;
}
else if ( length - timeLeft < 1000 )
{//start zooming in
fov = infov + (length - timeLeft)/1000*amt;
}
else
{//stay at this FOV
fov = infov+amt;
}
return fov;
}
/*
====================
CG_CalcFov
Fixed fov at intermissions, otherwise account for fov variable and zooms.
====================
*/
//extern float g_fov;
static qboolean CG_CalcFov( void ) {
float fov_x;
float f;
gentity_t *player = &g_entities[0];
if ( cg.predicted_player_state.pm_type == PM_INTERMISSION ) {
// if in intermission, use a fixed value
fov_x = 80;
}
else if ( cg.snap
&& cg.snap->ps.viewEntity > 0
&& cg.snap->ps.viewEntity < ENTITYNUM_WORLD
&& (!cg.renderingThirdPerson || g_entities[cg.snap->ps.viewEntity].e_DieFunc == dieF_camera_die) )
{
// if in entity camera view, use a special FOV
if ( &g_entities[cg.snap->ps.viewEntity] &&
g_entities[cg.snap->ps.viewEntity].NPC )
{//FIXME: looks bad when take over a jedi... but never really do that, do we?
//fov_x = g_entities[cg.snap->ps.viewEntity].NPC->stats.hfov;
fov_x = vr ? vr->fov : cg_fov.value;
//sanity-cap?
if ( fov_x > 120 )
{
fov_x = 120;
}
else if ( fov_x < 10 )
{
fov_x = 10;
}
}
else
{
if ( cg.overrides.active & CG_OVERRIDE_FOV )
{
fov_x = cg.overrides.fov;
}
else
{
//fov_x = 120;//FIXME: read from the NPC's fov stats?
fov_x = vr ? vr->fov : cg_fov.value;
}
}
}
else if ( (!cg.zoomMode || cg.zoomMode > 2) && (cg.snap->ps.forcePowersActive&(1<client->ps.forcePowerDuration[FP_SPEED] )//cg.renderingThirdPerson &&
{
fov_x = CG_ForceSpeedFOV(vr ? vr->fov : cg_fov.value);
} else {
/*
// user selectable
if ( cg.overrides.active & CG_OVERRIDE_FOV )
{
fov_x = cg.overrides.fov;
}
else
{
fov_x = cg_fov.value;
}
if ( fov_x < 1 ) {
fov_x = 1;
} else if ( fov_x > 160 ) {
fov_x = 160;
}*/
fov_x = vr ? vr->fov : cg_fov.value;
// Disable zooming when in third person
if ( cg.zoomMode && cg.zoomMode < 3 )//&& !cg.renderingThirdPerson ) // light amp goggles do none of the zoom silliness
{
if ( !cg.zoomLocked )
{
if ( cg.zoomMode == 1 )
{
// binoculars zooming either in or out
cg_zoomFov += cg.zoomDir * cg.frametime * 0.05f;
}
else
{
// disruptor zooming in faster
cg_zoomFov -= cg.frametime * 0.075f;
}
// Clamp zoomFov
float actualFOV = (cg.overrides.active&CG_OVERRIDE_FOV) ? cg.overrides.fov : cg_fov.value;
if ( cg_zoomFov < MAX_ZOOM_FOV )
{
cg_zoomFov = MAX_ZOOM_FOV;
}
else if ( cg_zoomFov > actualFOV )
{
cg_zoomFov = actualFOV;
}
else
{//still zooming
static int zoomSoundTime = 0;
if ( zoomSoundTime < cg.time )
{
sfxHandle_t snd;
if ( cg.zoomMode == 1 )
{
snd = cgs.media.zoomLoop;
}
else
{
snd = cgs.media.disruptorZoomLoop;
}
// huh? This could probably just be added as a looping sound??
cgi_S_StartSound( cg.refdef.vieworg, ENTITYNUM_WORLD, CHAN_LOCAL, snd );
zoomSoundTime = cg.time + 150;
}
}
}
fov_x = cg_zoomFov;
} else {
f = ( cg.time - cg.zoomTime ) / ZOOM_OUT_TIME;
if ( f <= 1.0 ) {
fov_x = cg_zoomFov + f * ( fov_x - cg_zoomFov );
}
}
}
// g_fov = fov_x;
return ( CG_CalcFOVFromX( fov_x ) );
}
/*
===============
CG_DamageBlendBlob
===============
*/
static void CG_DamageBlendBlob( void )
{
int t;
int maxTime;
refEntity_t ent;
if ( !cg.damageValue ) {
return;
}
maxTime = DAMAGE_TIME;
t = cg.time - cg.damageTime;
if ( t <= 0 || t >= maxTime ) {
return;
}
memset( &ent, 0, sizeof( ent ) );
ent.reType = RT_SPRITE;
ent.renderfx = RF_FIRST_PERSON;
VectorMA( cg.refdef.vieworg, 8, cg.refdef.viewaxis[0], ent.origin );
VectorMA( ent.origin, cg.damageX * -8, cg.refdef.viewaxis[1], ent.origin );
VectorMA( ent.origin, cg.damageY * 8, cg.refdef.viewaxis[2], ent.origin );
ent.radius = cg.damageValue * 3 * ( 1.0 - ((float)t / maxTime) );
ent.customShader = cgs.media.damageBlendBlobShader;
ent.shaderRGBA[0] = 180 * ( 1.0 - ((float)t / maxTime) );
ent.shaderRGBA[1] = 50 * ( 1.0 - ((float)t / maxTime) );
ent.shaderRGBA[2] = 50 * ( 1.0 - ((float)t / maxTime) );
ent.shaderRGBA[3] = 255;
cgi_R_AddRefEntityToScene( &ent );
}
/*
====================
CG_SaberClashFlare
====================
*/
extern int g_saberFlashTime;
extern vec3_t g_saberFlashPos;
extern qboolean CG_WorldCoordToScreenCoord(vec3_t worldCoord, int *x, int *y);
void CG_SaberClashFlare( void )
{
int t, maxTime = 150;
t = cg.time - g_saberFlashTime;
if ( t <= 0 || t >= maxTime )
{
return;
}
vec3_t dif;
// Don't do clashes for things that are behind us
VectorSubtract( g_saberFlashPos, cg.refdef.vieworg, dif );
if ( DotProduct( dif, cg.refdef.viewaxis[0] ) < 0.2 )
{
return;
}
trace_t tr;
CG_Trace( &tr, cg.refdef.vieworg, NULL, NULL, g_saberFlashPos, -1, CONTENTS_SOLID );
if ( tr.fraction < 1.0f )
{
return;
}
vec3_t color;
int x,y;
float v, len = VectorNormalize( dif );
// clamp to a known range
if ( len > 800 )
{
len = 800;
}
v = ( 1.0f - ((float)t / maxTime )) * ((1.0f - ( len / 800.0f )) * 2.0f + 0.35f);
CG_WorldCoordToScreenCoord( g_saberFlashPos, &x, &y );
VectorSet( color, 0.8f, 0.8f, 0.8f );
cgi_R_SetColor( color );
CG_DrawPic( x - ( v * 300 ), y - ( v * 300 ),
v * 600, v * 600,
cgi_R_RegisterShader( "gfx/effects/saberFlare" ));
}
/*
===============
CG_CalcViewValues
Sets cg.refdef view values
===============
*/
static qboolean CG_CalcViewValues( void ) {
playerState_t *ps;
qboolean viewEntIsCam = qfalse;
//extern vec3_t cgRefdefVieworg;
memset( &cg.refdef, 0, sizeof( cg.refdef ) );
// calculate size of 3D view
CG_CalcVrect();
if( cg.snap->ps.viewEntity != 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )
{
if( g_entities[cg.snap->ps.viewEntity].client && g_entities[cg.snap->ps.viewEntity].NPC )
{
ps = &g_entities[cg.snap->ps.viewEntity].client->ps;
}
else
{
ps = &cg.predicted_player_state;
viewEntIsCam = qtrue;
}
}
else
{
ps = &cg.predicted_player_state;
}
#ifndef FINAL_BUILD
trap_Com_SetOrgAngles(ps->origin,ps->viewangles);
#endif
// intermission view
if ( ps->pm_type == PM_INTERMISSION ) {
VectorCopy( ps->origin, cg.refdef.vieworg );
VectorCopy( ps->viewangles, cg.refdefViewAngles );
AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
return CG_CalcFov();
}
cg.bobcycle = ( ps->bobCycle & 128 ) >> 7;
cg.bobfracsin = fabs( sin( ( ps->bobCycle & 127 ) / 127.0 * M_PI ) );
cg.xyspeed = sqrt( ps->velocity[0] * ps->velocity[0] +
ps->velocity[1] * ps->velocity[1] );
if ( cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )
{//in an entity camera view
/*
if ( g_entities[cg.snap->ps.viewEntity].client && cg.renderingThirdPerson )
{
VectorCopy( g_entities[cg.snap->ps.viewEntity].client->renderInfo.eyePoint, cg.refdef.vieworg );
}
else
*/
{
VectorCopy( cg_entities[cg.snap->ps.viewEntity].lerpOrigin, cg.refdef.vieworg );
}
VectorCopy( cg_entities[cg.snap->ps.viewEntity].lerpAngles, cg.refdefViewAngles );
if ( !Q_stricmp( "misc_camera", g_entities[cg.snap->ps.viewEntity].classname ) || g_entities[cg.snap->ps.viewEntity].s.weapon == WP_TURRET )
{
viewEntIsCam = qtrue;
}
}
else if ( cg.renderingThirdPerson && !cg.zoomMode && (cg.overrides.active&CG_OVERRIDE_3RD_PERSON_ENT) )
{//different center, same angle
VectorCopy( cg_entities[cg.overrides.thirdPersonEntity].lerpOrigin, cg.refdef.vieworg );
VectorCopy( ps->viewangles, cg.refdefViewAngles );
}
else
{//player's center and angles
VectorCopy( ps->origin, cg.refdef.vieworg );
VectorCopy( ps->viewangles, cg.refdefViewAngles );
}
// add error decay
if ( cg_errorDecay.value > 0 ) {
int t;
float f;
t = cg.time - cg.predictedErrorTime;
f = ( cg_errorDecay.value - t ) / cg_errorDecay.value;
if ( f > 0 && f < 1 ) {
VectorMA( cg.refdef.vieworg, f, cg.predictedError, cg.refdef.vieworg );
} else {
cg.predictedErrorTime = 0;
}
}
if ( (cg.renderingThirdPerson) //||cg.snap->ps.weapon == WP_SABER||cg.snap->ps.weapon == WP_MELEE)
&& !cg.zoomMode
&& !viewEntIsCam )
{
// back away from character
// if ( cg_thirdPerson.integer == CG_CAM_ABOVE)
// { `
// CG_OffsetThirdPersonOverheadView();
// }
// else
// {
// First person saber
if ( !cg.renderingThirdPerson )
{
if ( cg.snap->ps.weapon == WP_SABER||cg.snap->ps.weapon == WP_MELEE )
{
vec3_t dir;
CG_OffsetFirstPersonView( qtrue );
cg.refdef.vieworg[2] += 32;
AngleVectors( cg.refdefViewAngles, dir, NULL, NULL );
VectorMA( cg.refdef.vieworg, -2, dir, cg.refdef.vieworg );
}
}
CG_OffsetThirdPersonView();
// }
}
else
{
// offset for local bobbing and kicks
CG_OffsetFirstPersonView( qfalse );
centity_t *playerCent = &cg_entities[0];
if ( playerCent && playerCent->gent && playerCent->gent->client )
{
VectorCopy( cg.refdef.vieworg, playerCent->gent->client->renderInfo.eyePoint );
VectorCopy( cg.refdefViewAngles, playerCent->gent->client->renderInfo.eyeAngles );
if ( cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )
{//in an entity camera view
if ( cg_entities[cg.snap->ps.viewEntity].gent->client )
{//looking through a client's eyes
VectorCopy( cg.refdef.vieworg, cg_entities[cg.snap->ps.viewEntity].gent->client->renderInfo.eyePoint );
VectorCopy( cg.refdefViewAngles, cg_entities[cg.snap->ps.viewEntity].gent->client->renderInfo.eyeAngles );
}
else
{//looking through a regular ent's eyes
VectorCopy( cg.refdef.vieworg, cg_entities[cg.snap->ps.viewEntity].lerpOrigin );
VectorCopy( cg.refdefViewAngles, cg_entities[cg.snap->ps.viewEntity].lerpAngles );
}
}
VectorCopy( playerCent->gent->client->renderInfo.eyePoint, playerCent->gent->client->renderInfo.headPoint );
if ( cg.snap->ps.viewEntity <= 0 || cg.snap->ps.viewEntity >= ENTITYNUM_WORLD )
{//not in entity cam
playerCent->gent->client->renderInfo.headPoint[2] -= 8;
}
}
}
//VectorCopy( cg.refdef.vieworg, cgRefdefVieworg );
// shake the camera if necessary
CGCam_UpdateSmooth( cg.refdef.vieworg, cg.refdefViewAngles );
CGCam_UpdateShake( cg.refdef.vieworg, cg.refdefViewAngles );
/*
if ( in_camera )
{
Com_Printf( "%s %s\n", vtos(client_camera.origin), vtos(cg.refdef.vieworg) );
}
*/
// see if we are drugged by an interrogator. We muck with the angles here, just a bit earlier, we mucked with the FOV
if ( cg.wonkyTime > 0 && cg.wonkyTime > cg.time )
{
float perc = (float)(cg.wonkyTime - cg.time) / 10000.0f; // goes for 10 seconds
cg.refdefViewAngles[ROLL] += ( sin( cg.time * 0.0004f ) * 7.0f * perc );
cg.refdefViewAngles[PITCH] += ( 26.0f * perc + sin( cg.time * 0.0011f ) * 3.0f * perc );
}
AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
if ( cg.hyperspace )
{
cg.refdef.rdflags |= RDF_NOWORLDMODEL | RDF_HYPERSPACE;
}
// field of view
return CG_CalcFov();
}
/*
=====================
CG_PowerupTimerSounds
=====================
*/
static void CG_PowerupTimerSounds( void )
{
int i, time;
// powerup timers going away
for ( i = 0 ; i < MAX_POWERUPS ; i++ )
{
time = cg.snap->ps.powerups[i];
if ( time > 0 && time < cg.time )
{
// add any special powerup expiration sounds here
// switch( i )
// {
// case PW_WEAPON_OVERCHARGE:
// cgi_S_StartSound( NULL, cg.snap->ps.clientNum, CHAN_ITEM, cgs.media.overchargeEndSound );
// break;
// }
}
}
}
//----------------------------
void CG_RunEmplacedWeapon()
{
gentity_t *player = &g_entities[0],
*gun = player->owner;
// Override the camera when we are locked onto the gun.
if ( player && gun && ( player->s.eFlags & EF_LOCKED_TO_WEAPON ))
{
// float dist = -1; // default distance behind gun
// don't let the player try and change this
cg.renderingThirdPerson = qtrue;
// cg.refdefViewAngles[PITCH] += cg.overrides.thirdPersonPitchOffset? cg.overrides.thirdPersonPitchOffset: cg_thirdPersonPitchOffset.value;
// cg.refdefViewAngles[YAW] += cg.overrides.thirdPersonAngle ? cg.overrides.thirdPersonAngle : cg_thirdPersonAngle.value;;
AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
// Slide in behind the gun.
// if ( gun->delay + 500 > cg.time )
// {
// dist -= (( gun->delay + 500 ) - cg.time ) * 0.02f;
// }
VectorCopy( gun->pos2, cg.refdef.vieworg );
VectorMA( cg.refdef.vieworg, -20.0f, gun->pos3, cg.refdef.vieworg );
if ( cg.snap->ps.viewEntity <= 0 || cg.snap->ps.viewEntity >= ENTITYNUM_WORLD )
{
VectorMA( cg.refdef.vieworg, 35.0f, gun->pos4, cg.refdef.vieworg );
}
}
}
//=========================================================================
/*
=================
CG_DrawActiveFrame
Generates and draws a game scene and status information at the given time.
=================
*/
extern void CG_BuildSolidList( void );
void cgi_CM_SnapPVS(vec3_t origin,byte *buffer);
extern vec3_t serverViewOrg;
void CG_DrawActiveFrame( int serverTime, stereoFrame_t stereoView ) {
qboolean inwater = qfalse;
cg.time = serverTime;
// update cvars
CG_UpdateCvars();
// if we are only updating the screen as a loading
// pacifier, don't even try to read snapshots
if ( cg.infoScreenText[0] != 0 ) {
CG_DrawInformation();
return;
}
CG_RunLightStyles();
// any looped sounds will be respecified as entities
// are added to the render list
cgi_S_ClearLoopingSounds();
// clear all the render lists
cgi_R_ClearScene();
CG_BuildSolidList();
// set up cg.snap and possibly cg.nextSnap
CG_ProcessSnapshots();
// if we haven't received any snapshots yet, all
// we can draw is the information screen
if ( !cg.snap ) {
CG_DrawInformation();
return;
}
// make sure the lagometerSample and frame timing isn't done twice when in stereo
if ( stereoView != STEREO_RIGHT ) {
cg.frametime = cg.time - cg.oldTime;
cg.oldTime = cg.time;
}
// Make sure the helper has the updated time
theFxHelper.AdjustTime( cg.frametime );
// let the client system know what our weapon and zoom settings are
//FIXME: should really send forcePowersActive over network onto cg.snap->ps...
float speed = cg.refdef.fov_y / 75.0 * ((cg_entities[0].gent->client->ps.forcePowersActive&(1<client->ps.forcePowersActive&(1<ps.clientNum == 0 )
{//pointless check, but..
if ( cg_entities[0].gent->s.eFlags & EF_LOCKED_TO_WEAPON )
{
speed *= 0.25f;
}
if ( cg_entities[0].gent->s.eFlags & EF_IN_ATST )
{
mPitchOverride = 0.01f;
mYawOverride = 0.0075f;
}
}
cgi_SetUserCmdValue( cg.weaponSelect, speed, mPitchOverride, mYawOverride );
if ( stereoView == STEREO_LEFT ) {
// this counter will be bumped for every valid scene we generate
cg.clientFrame++;
// update cg.predicted_player_state
CG_PredictPlayerState();
}
// decide on third person view
cg.renderingThirdPerson = (qboolean)(
cg_thirdPerson.integer ||
(cg.snap->ps.stats[STAT_HEALTH] <= 0) ||
(g_entities[0].client &&
g_entities[0].client->NPC_class == CLASS_ATST));
if ( cg.zoomMode )
{
// zoomed characters should never do third person stuff??
cg.renderingThirdPerson = qfalse;
}
vr->in_camera = in_camera;
if ( in_camera )
{
// The camera takes over the view
CGCam_RenderScene();
}
else
{
//Finish any fading that was happening
CGCam_UpdateFade();
// build cg.refdef
inwater = CG_CalcViewValues();
}
// NOTE: this may completely override the camera
CG_RunEmplacedWeapon();
// first person blend blobs, done after AnglesToAxis
if ( !cg.renderingThirdPerson ) {
CG_DamageBlendBlob();
}
// build the render lists
if ( !cg.hyperspace ) {
CG_AddPacketEntities(); // adter calcViewValues, so predicted player state is correct
CG_AddMarks();
CG_AddLocalEntities();
}
//check for opaque water
if ( 1 )
{
vec3_t camTest;
VectorCopy( cg.refdef.vieworg, camTest );
camTest[2] += 6;
if ( !(CG_PointContents( camTest, 0 )&CONTENTS_SOLID) && !gi.inPVS( cg.refdef.vieworg, camTest ) )
{//crossed visible line into another room
cg.refdef.vieworg[2] -= 6;
//cgi_CM_SnapPVS(cg.refdef.vieworg,cg.snap->areamask);
}
else
{
VectorCopy( cg.refdef.vieworg, camTest );
camTest[2] -= 6;
if ( !(CG_PointContents( camTest, 0 )&CONTENTS_SOLID) && !gi.inPVS( cg.refdef.vieworg, camTest ) )
{
cg.refdef.vieworg[2] += 6;
//cgi_CM_SnapPVS(cg.refdef.vieworg,cg.snap->areamask);
}
else //if ( inwater )
{//extra-special hack... sometimes when crouched in water with first person lightsaber, your PVS is wrong???
/*
if ( !cg.renderingThirdPerson && (cg.snap->ps.weapon == WP_SABER||cg.snap->ps.weapon == WP_MELEE) )
{//pseudo first-person for saber and fists
cgi_CM_SnapPVS(cg.refdef.vieworg,cg.snap->areamask);
}
*/
}
}
}
//FIXME: first person crouch-uncrouch STILL FUCKS UP THE AREAMASK!!!
//if ( !VectorCompare2( cg.refdef.vieworg, cg.snap->ps.serverViewOrg ) && !gi.inPVS( cg.refdef.vieworg, cg.snap->ps.serverViewOrg ) )
{//actual view org and server's view org don't match and aren't same PVS, rebuild the areamask
//Com_Printf( S_COLOR_RED"%s != %s\n", vtos(cg.refdef.vieworg), vtos(cg.snap->ps.serverViewOrg) );
cgi_CM_SnapPVS( cg.refdef.vieworg, cg.snap->areamask );
}
if (vr->item_selector)
{
CG_DrawItemSelector();
}
else {
// Don't draw the in-view weapon when in camera mode
if (!in_camera
&& !cg_pano.integer
&& cg.snap->ps.weapon != WP_SABER
&& (cg.snap->ps.viewEntity == 0 || cg.snap->ps.viewEntity >= ENTITYNUM_WORLD)) {
CG_AddViewWeapon(&cg.predicted_player_state);
} else if (cg.snap->ps.viewEntity != 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD &&
g_entities[cg.snap->ps.viewEntity].client) {
CG_AddViewWeapon(
&g_entities[cg.snap->ps.viewEntity].client->ps); // HAX - because I wanted to --eez
}
if (!in_camera
&& !cg.renderingThirdPerson
&& cg.predicted_player_state.stats[STAT_HEALTH] > 0
&& cg.snap->ps.weapon != WP_MELEE
&& !vr->weapon_stabilised
&& !cg_pano.integer
&& (cg.snap->ps.viewEntity == 0 || cg.snap->ps.viewEntity >= ENTITYNUM_WORLD))
{
vec3_t end, forward;
refEntity_t handEnt;
memset( &handEnt, 0, sizeof(refEntity_t) );
BG_CalculateVROffHandPosition(handEnt.origin, handEnt.angles);
//Move it back a bit?
AngleVectors(handEnt.angles, forward, NULL, NULL);
VectorMA( handEnt.origin, -1.0f, forward, handEnt.origin );
handEnt.renderfx = RF_DEPTHHACK;
handEnt.hModel = cgi_R_RegisterModel( "models/players/kyle/lhand_r.md3" );
VectorCopy(handEnt.origin, handEnt.oldorigin);
AnglesToAxis(handEnt.angles, handEnt.axis);
cgi_R_AddRefEntityToScene(&handEnt);
}
}
if ( !cg.hyperspace )
{
//Add all effects
theFxScheduler.AddScheduledEffects( );
}
// finish up the rest of the refdef
if ( cg.testModelEntity.hModel ) {
CG_AddTestModel();
}
cg.refdef.time = cg.time;
memcpy( cg.refdef.areamask, cg.snap->areamask, sizeof( cg.refdef.areamask ) );
// update audio positions
//This is done from the vieworg to get origin for non-attenuated sounds
cgi_S_UpdateAmbientSet( CG_ConfigString( CS_AMBIENT_SET ), cg.refdef.vieworg );
//NOTE: if we want to make you be able to hear far away sounds with electrobinoculars, add the hacked-in positional offset here (base on fov)
cgi_S_Respatialize( cg.snap->ps.clientNum, cg.refdef.vieworg, cg.refdef.viewaxis, inwater );
// warning sounds when powerup is wearing off
CG_PowerupTimerSounds();
if ( cg_pano.integer ) { // let's grab a panorama!
cg.levelShot = qtrue; //hide the 2d
VectorClear(cg.refdefViewAngles);
cg.refdefViewAngles[YAW] = -360 * cg_pano.integer/cg_panoNumShots.integer; //choose angle
AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
CG_DrawActive( stereoView );
cg.levelShot = qfalse;
} else {
// actually issue the rendering calls
CG_DrawActive( stereoView );
}
/*
if ( in_camera && !cg_skippingcin.integer )
{
Com_Printf( S_COLOR_GREEN"ang: %s\n", vtos(cg.refdefViewAngles) );
}
*/
}