view.h File Reference

#include "qtypes.h"
#include "matrixlib.h"

Include dependency graph for view.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	V_CalcRefdef (void)
void	V_CalcRefdefUsing (const matrix4x4_t *entrendermatrix, const vec3_t clviewangles, qbool teleported, qbool clonground, qbool clcmdjump, float clstatsviewheight, qbool cldead, const vec3_t clvelocity)
void	V_CalcViewBlend (void)
void	V_DriftPitch (void)
void	V_FadeViewFlashs (void)
void	V_Init (void)
void	V_MakeViewIsometric (void)
void	V_ParseDamage (void)
void	V_StartPitchDrift (void)
void	V_StartPitchDrift_f (struct cmd_state_s *cmd)
void	V_StopPitchDrift (void)
void	V_UpdateBlends (void)

Function Documentation

V_CalcRefdef()

void V_CalcRefdef

(

void

)

Definition at line 944 of file view.c.

{
    entity_t *ent;
    qbool cldead;
 
    if (cls.state == ca_connected && cls.signon == SIGNONS && !cl.csqc_server2csqcentitynumber[cl.viewentity])
    {
        // ent is the view entity (visible when out of body)
        ent = &cl.entities[cl.viewentity];
 
        cldead = (cl.stats[STAT_HEALTH] <= 0 && cl.stats[STAT_HEALTH] != -666 && cl.stats[STAT_HEALTH] != -2342);
        V_CalcRefdefUsing(&ent->render.matrix, cl.viewangles, !ent->persistent.trail_allowed, cl.onground, cl.cmd.jump, cl.stats[STAT_VIEWHEIGHT], cldead, cl.velocity); // FIXME use a better way to detect teleport/warp than trail_allowed
    }
    else
    {
        viewmodelmatrix_nobob = identitymatrix;
        viewmodelmatrix_withbob = identitymatrix;
        cl.csqc_viewmodelmatrixfromengine = identitymatrix;
        r_refdef.view.matrix = identitymatrix;
        VectorClear(cl.csqc_vieworiginfromengine);
        VectorCopy(cl.viewangles, cl.csqc_viewanglesfromengine);
    }
}

References ca_connected, cl, cls, identitymatrix, entity_render_t::matrix, entity_t::persistent, r_refdef, entity_t::render, SIGNONS, STAT_HEALTH, STAT_VIEWHEIGHT, entity_persistent_t::trail_allowed, V_CalcRefdefUsing(), VectorClear, VectorCopy, viewmodelmatrix_nobob, and viewmodelmatrix_withbob.

Referenced by CL_UpdateWorld().

V_CalcRefdefUsing()

void V_CalcRefdefUsing	(	const matrix4x4_t *	entrendermatrix,
		const vec3_t	clviewangles,
		qbool	teleported,
		qbool	clonground,
		qbool	clcmdjump,
		float	clstatsviewheight,
		qbool	cldead,
		const vec3_t	clvelocity )

Definition at line 512 of file view.c.

{
    float vieworg[3], viewangles[3], smoothtime;
    float gunorg[3], gunangles[3];
    matrix4x4_t tmpmatrix;
    static float viewheightavg;
    float viewheight;
    trace_t trace;
 
    // react to clonground state changes (for gun bob)
    if (clonground)
    {
        if (!cl.oldonground)
            cl.hitgroundtime = cl.movecmd[0].time;
        cl.lastongroundtime = cl.movecmd[0].time;
    }
    cl.oldonground = clonground;
    cl.calcrefdef_prevtime = max(cl.calcrefdef_prevtime, cl.oldtime);
 
    VectorClear(gunangles);
    VectorClear(gunorg);
    viewmodelmatrix_nobob = identitymatrix;
    viewmodelmatrix_withbob = identitymatrix;
    r_refdef.view.matrix = identitymatrix;
 
    // player can look around, so take the origin from the entity,
    // and the angles from the input system
    Matrix4x4_OriginFromMatrix(entrendermatrix, vieworg);
    VectorCopy(clviewangles, viewangles);
 
    // calculate how much time has passed since the last V_CalcRefdef
    smoothtime = bound(0, cl.time - cl.stairsmoothtime, 0.1);
    cl.stairsmoothtime = cl.time;
 
    // fade damage flash
    if (v_dmg_time > 0)
        v_dmg_time -= bound(0, smoothtime, 0.1);
 
    if (cl.intermission)
        V_CalcIntermissionRefdef(vieworg, viewangles, entrendermatrix, clstatsviewheight);
    else
    {
        // smooth stair stepping, but only if clonground and enabled
        if (!clonground || cl_stairsmoothspeed.value <= 0 || teleported)
            cl.stairsmoothz = vieworg[2];
        else
        {
            if (cl.stairsmoothz < vieworg[2])
                vieworg[2] = cl.stairsmoothz = bound(vieworg[2] - cl.movevars_stepheight, cl.stairsmoothz + smoothtime * cl_stairsmoothspeed.value, vieworg[2]);
            else if (cl.stairsmoothz > vieworg[2])
                vieworg[2] = cl.stairsmoothz = bound(vieworg[2], cl.stairsmoothz - smoothtime * cl_stairsmoothspeed.value, vieworg[2] + cl.movevars_stepheight);
        }
 
        // apply qw weapon recoil effect (this did not work in QW)
        // TODO: add a cvar to disable this
        viewangles[PITCH] += cl.qw_weaponkick;
 
        // apply the viewofs (even if chasecam is used)
        // Samual: Lets add smoothing for this too so that things like crouching are done with a transition.
        viewheight = bound(0, (cl.time - cl.calcrefdef_prevtime) / max(0.0001, cl_smoothviewheight.value), 1);
        viewheightavg = viewheightavg * (1 - viewheight) + clstatsviewheight * viewheight;
        vieworg[2] += viewheightavg;
 
        if (chase_active.value)
        {
            // observing entity from third person. Added "campitch" by Alexander "motorsep" Zubov
            vec_t camback, camup, dist, campitch, forward[3], chase_dest[3];
 
            camback = chase_back.value;
            camup = chase_up.value;
            campitch = chase_pitchangle.value;
 
            AngleVectors(viewangles, forward, NULL, NULL);
 
            if (chase_overhead.integer)
            {
                vec3_t offset;
                vec3_t bestvieworg;
                vec3_t up;
                viewangles[PITCH] = 0;
                AngleVectors(viewangles, forward, NULL, up);
                // trace a little further so it hits a surface more consistently (to avoid 'snapping' on the edge of the range)
                chase_dest[0] = vieworg[0] - forward[0] * camback + up[0] * camup;
                chase_dest[1] = vieworg[1] - forward[1] * camback + up[1] * camup;
                chase_dest[2] = vieworg[2] - forward[2] * camback + up[2] * camup;
                // trace from first person view location to our chosen third person view location
                trace = CL_TraceLine(vieworg, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
                VectorCopy(trace.endpos, bestvieworg);
                offset[2] = 0;
                for (offset[0] = -16;offset[0] <= 16;offset[0] += 8)
                {
                    for (offset[1] = -16;offset[1] <= 16;offset[1] += 8)
                    {
                        AngleVectors(viewangles, NULL, NULL, up);
                        chase_dest[0] = vieworg[0] - forward[0] * camback + up[0] * camup + offset[0];
                        chase_dest[1] = vieworg[1] - forward[1] * camback + up[1] * camup + offset[1];
                        chase_dest[2] = vieworg[2] - forward[2] * camback + up[2] * camup + offset[2];
                        trace = CL_TraceLine(vieworg, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
                        if (bestvieworg[2] > trace.endpos[2])
                            bestvieworg[2] = trace.endpos[2];
                    }
                }
                bestvieworg[2] -= 8;
                VectorCopy(bestvieworg, vieworg);
                viewangles[PITCH] = campitch;
            }
            else
            {
                if (gamemode == GAME_GOODVSBAD2 && chase_stevie.integer)
                {
                    // look straight down from high above
                    viewangles[PITCH] = 90;
                    camback = 2048;
                    VectorSet(forward, 0, 0, -1);
                }
 
                // trace a little further so it hits a surface more consistently (to avoid 'snapping' on the edge of the range)
                dist = -camback - 8;
                chase_dest[0] = vieworg[0] + forward[0] * dist;
                chase_dest[1] = vieworg[1] + forward[1] * dist;
                chase_dest[2] = vieworg[2] + forward[2] * dist + camup;
                trace = CL_TraceLine(vieworg, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
                VectorMAMAM(1, trace.endpos, 8, forward, 4, trace.plane.normal, vieworg);
            }
        }
        else
        {
            // first person view from entity
            // angles
            if (cldead && v_deathtilt.integer)
                viewangles[ROLL] = v_deathtiltangle.value;
 
            // origin
            VectorAdd(vieworg, cl.punchvector, vieworg);
            if (!cldead)
            {
                double xyspeed = 0, bob = 0, bobfall = 0;
                double cycle = 0; // double-precision because cl.time can be a very large number, where float would get stuttery at high time values
                vec_t frametime;
 
                frametime = (cl.time - cl.calcrefdef_prevtime) * cl.movevars_timescale;
 
                if(cl_followmodel.integer || cl_leanmodel.integer)
                {
                    // 1. if we teleported, clear the frametime... the lowpass will recover the previous value then
                    if(teleported)
                    {
                        // try to fix the first highpass; result is NOT
                        // perfect! TODO find a better fix
                        VectorCopy(viewangles, cl.gunangles_prev);
                        VectorCopy(vieworg, cl.gunorg_prev);
                    }
 
                    // 2. for the gun origin, only keep the high frequency (non-DC) parts, which is "somewhat like velocity"
                    VectorAdd(cl.gunorg_highpass, cl.gunorg_prev, cl.gunorg_highpass);
                    highpass3_limited(vieworg, frametime*cl_followmodel_side_highpass1.value, cl_followmodel_side_limit.value, frametime*cl_followmodel_side_highpass1.value, cl_followmodel_side_limit.value, frametime*cl_followmodel_up_highpass1.value, cl_followmodel_up_limit.value, cl.gunorg_highpass, gunorg);
                    VectorCopy(vieworg, cl.gunorg_prev);
                    VectorSubtract(cl.gunorg_highpass, cl.gunorg_prev, cl.gunorg_highpass);
 
                    // in the highpass, we _store_ the DIFFERENCE to the actual view angles...
                    VectorAdd(cl.gunangles_highpass, cl.gunangles_prev, cl.gunangles_highpass);
                    cl.gunangles_highpass[PITCH] += 360 * floor((viewangles[PITCH] - cl.gunangles_highpass[PITCH]) / 360 + 0.5);
                    cl.gunangles_highpass[YAW] += 360 * floor((viewangles[YAW] - cl.gunangles_highpass[YAW]) / 360 + 0.5);
                    cl.gunangles_highpass[ROLL] += 360 * floor((viewangles[ROLL] - cl.gunangles_highpass[ROLL]) / 360 + 0.5);
                    highpass3_limited(viewangles, frametime*cl_leanmodel_up_highpass1.value, cl_leanmodel_up_limit.value, frametime*cl_leanmodel_side_highpass1.value, cl_leanmodel_side_limit.value, 0, 0, cl.gunangles_highpass, gunangles);
                    VectorCopy(viewangles, cl.gunangles_prev);
                    VectorSubtract(cl.gunangles_highpass, cl.gunangles_prev, cl.gunangles_highpass);
 
                    // 3. calculate the RAW adjustment vectors
                    gunorg[0] *= -cl_followmodel_side_speed.value;
                    gunorg[1] *= -cl_followmodel_side_speed.value;
                    gunorg[2] *= -cl_followmodel_up_speed.value;
 
                    gunangles[PITCH] *= -cl_leanmodel_up_speed.value;
                    gunangles[YAW] *= -cl_leanmodel_side_speed.value;
                    gunangles[ROLL] = 0;
 
                    // 4. perform highpass/lowpass on the adjustment vectors (turning velocity into acceleration!)
                    //    trick: we must do the lowpass LAST, so the lowpass vector IS the final vector!
                    highpass3(gunorg, frametime*cl_followmodel_side_highpass.value, frametime*cl_followmodel_side_highpass.value, frametime*cl_followmodel_up_highpass.value, cl.gunorg_adjustment_highpass, gunorg);
                    lowpass3(gunorg, frametime*cl_followmodel_side_lowpass.value, frametime*cl_followmodel_side_lowpass.value, frametime*cl_followmodel_up_lowpass.value, cl.gunorg_adjustment_lowpass, gunorg);
                    // we assume here: PITCH = 0, YAW = 1, ROLL = 2
                    highpass3(gunangles, frametime*cl_leanmodel_up_highpass.value, frametime*cl_leanmodel_side_highpass.value, 0, cl.gunangles_adjustment_highpass, gunangles);
                    lowpass3(gunangles, frametime*cl_leanmodel_up_lowpass.value, frametime*cl_leanmodel_side_lowpass.value, 0, cl.gunangles_adjustment_lowpass, gunangles);
 
                    // 5. use the adjusted vectors
                    VectorAdd(vieworg, gunorg, gunorg);
                    VectorAdd(viewangles, gunangles, gunangles);
                }
                else
                {
                    // Just initialize gunorg/gunangles.
                    VectorCopy(vieworg, gunorg);
                    VectorCopy(viewangles, gunangles);
                }
 
                // bounded XY speed, used by several effects below
                xyspeed = bound (0, sqrt(clvelocity[0]*clvelocity[0] + clvelocity[1]*clvelocity[1]), cl_bob_velocity_limit.value);
 
                // vertical view bobbing code
                if (cl_bob.value && cl_bobcycle.value)
                {
                    float bob_limit = cl_bobmodel_classic.integer ? 4 : cl_bob_limit.value;
 
                    if (cl_bob_limit_heightcheck.integer)
                    {
                        // use traces to determine what range the view can bob in, and scale down the bob as needed
                        float trace1fraction;
                        float trace2fraction;
                        vec3_t bob_height_check_dest;
 
                        // these multipliers are expanded a bit (the actual bob sin range is from -0.4 to 1.0) to reduce nearclip issues, especially on water surfaces
                        bob_height_check_dest[0] = vieworg[0];
                        bob_height_check_dest[1] = vieworg[1];
                        bob_height_check_dest[2] = vieworg[2] + cl_bob_limit.value * 1.1f;
                        trace = CL_TraceLine(vieworg, bob_height_check_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY | (cl_bob_limit_heightcheck_dontcrosswatersurface.integer ? SUPERCONTENTS_LIQUIDSMASK : 0), 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
                        trace1fraction = trace.fraction;
 
                        bob_height_check_dest[0] = vieworg[0];
                        bob_height_check_dest[1] = vieworg[1];
                        bob_height_check_dest[2] = vieworg[2] + cl_bob_limit.value * -0.5f;
                        trace = CL_TraceLine(vieworg, bob_height_check_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY | (cl_bob_limit_heightcheck_dontcrosswatersurface.integer ? SUPERCONTENTS_LIQUIDSMASK : 0), 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
                        trace2fraction = trace.fraction;
 
                        bob_limit *= min(trace1fraction, trace2fraction);
                    }
 
                    // LadyHavoc: this code is *weird*, but not replacable (I think it
                    // should be done in QC on the server, but oh well, quake is quake)
                    // LadyHavoc: figured out bobup: the time at which the sin is at 180
                    // degrees (which allows lengthening or squishing the peak or valley)
                    cycle = cl.time / cl_bobcycle.value;
                    cycle -= (int) cycle;
                    if (cycle < cl_bobup.value)
                        cycle = M_PI * cycle / cl_bobup.value;
                    else
                        cycle = M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value);
                    // bob is proportional to velocity in the xy plane
                    // (don't count Z, or jumping messes it up)
                    bob = xyspeed * cl_bob.value;
                    bob = bob*0.3 + bob*0.7*sin(cycle);
                    bob = bound(-7, bob, bob_limit);
 
                    vieworg[2] += bob;
 
                    // we also need to adjust gunorg, or this appears like pushing the gun!
                    // In the old code, this was applied to vieworg BEFORE copying to gunorg,
                    // but this is not viable with the new followmodel code as that would mean
                    // that followmodel would work on the munged-by-bob vieworg and do feedback
                    if(!cl_bobmodel_classic.integer)
                        gunorg[2] += bob;
                }
 
                // horizontal view bobbing code
                if (cl_bob2.value && cl_bob2cycle.value)
                {
                    vec3_t bob2vel;
                    vec3_t forward, right, up;
                    float side, front;
 
                    cycle = cl.time / cl_bob2cycle.value;
                    cycle -= (int) cycle;
                    if (cycle < 0.5)
                        cycle = cos(M_PI * cycle / 0.5); // cos looks better here with the other view bobbing using sin
                    else
                        cycle = cos(M_PI + M_PI * (cycle-0.5)/0.5);
                    bob = cl_bob2.value * cycle;
 
                    // this value slowly decreases from 1 to 0 when we stop touching the ground.
                    // The cycle is later multiplied with it so the view smooths back to normal
                    if (clonground && !clcmdjump) // also block the effect while the jump button is pressed, to avoid twitches when bunny-hopping
                        cl.bob2_smooth = 1;
                    else
                    {
                        if(cl.bob2_smooth > 0)
                            cl.bob2_smooth -= bound(0, cl_bob2smooth.value, 1);
                        else
                            cl.bob2_smooth = 0;
                    }
 
                    // calculate the front and side of the player between the X and Y axes
                    AngleVectors(viewangles, forward, right, up);
                    // now get the speed based on those angles. The bounds should match the same value as xyspeed's
                    side = bound(-cl_bob_velocity_limit.value, DotProduct (clvelocity, right) * cl.bob2_smooth, cl_bob_velocity_limit.value);
                    front = bound(-cl_bob_velocity_limit.value, DotProduct (clvelocity, forward) * cl.bob2_smooth, cl_bob_velocity_limit.value);
                    VectorScale(forward, bob, forward);
                    VectorScale(right, bob, right);
                    // we use side with forward and front with right, so the bobbing goes
                    // to the side when we walk forward and to the front when we strafe
                    VectorMAMAM(side, forward, front, right, 0, up, bob2vel);
                    vieworg[0] += bob2vel[0];
                    vieworg[1] += bob2vel[1];
                    // we also need to adjust gunorg, or this appears like pushing the gun!
                    // In the old code, this was applied to vieworg BEFORE copying to gunorg,
                    // but this is not viable with the new followmodel code as that would mean
                    // that followmodel would work on the munged-by-bob vieworg and do feedback
                    gunorg[0] += bob2vel[0];
                    gunorg[1] += bob2vel[1];
                }
 
                // fall bobbing code
                // causes the view to swing down and back up when touching the ground
                if (cl_bobfall.value && cl_bobfallcycle.value)
                {
                    if (!clonground)
                    {
                        cl.bobfall_speed = bound(-400, clvelocity[2], 0) * bound(0, cl_bobfall.value, 0.1);
                        if (clvelocity[2] < -cl_bobfallminspeed.value)
                            cl.bobfall_swing = 1;
                        else
                            cl.bobfall_swing = 0; // TODO really?
                    }
                    else
                    {
                        cl.bobfall_swing = max(0, cl.bobfall_swing - cl_bobfallcycle.value * frametime);
 
                        bobfall = sin(M_PI * cl.bobfall_swing) * cl.bobfall_speed;
                        vieworg[2] += bobfall;
                        gunorg[2] += bobfall;
                    }
                }
                VectorCopy(clviewangles, viewangles);
 
                // Hanicef: don't apply punchangle twice if the scene is rendered more than once.
                if (!cl_punchangle_applied)
                {
                    VectorAdd(viewangles, cl.punchangle, viewangles);
                    cl_punchangle_applied = 1;
                }
                viewangles[ROLL] += Com_CalcRoll(clviewangles, clvelocity, cl_rollangle.value, cl_rollspeed.value);
 
                if (v_dmg_time > 0)
                {
                    viewangles[ROLL] += v_dmg_time/v_kicktime.value*v_dmg_roll;
                    viewangles[PITCH] += v_dmg_time/v_kicktime.value*v_dmg_pitch;
                }
 
                // gun model bobbing code
                if (cl_bobmodel.value)
                {
                    vec3_t forward, right, up;
                    AngleVectors (gunangles, forward, right, up);
 
                    if(!cl_bobmodel_classic.integer)
                    {
                        // calculate for swinging gun model
                        // the gun bobs when running on the ground, but doesn't bob when you're in the air.
                        // Sajt: I tried to smooth out the transitions between bob and no bob, which works
                        // for the most part, but for some reason when you go through a message trigger or
                        // pick up an item or anything like that it will momentarily jolt the gun.
                        float bspeed;
                        float s;
                        float t;
 
                        s = cl.time * cl_bobmodel_speed.value;
                        if (clonground)
                        {
                            if (cl.time - cl.hitgroundtime < 0.2)
                            {
                                // just hit the ground, speed the bob back up over the next 0.2 seconds
                                t = cl.time - cl.hitgroundtime;
                                t = bound(0, t, 0.2);
                                t *= 5;
                            }
                            else
                                t = 1;
                        }
                        else
                        {
                            // recently left the ground, slow the bob down over the next 0.2 seconds
                            t = cl.time - cl.lastongroundtime;
                            t = 0.2 - bound(0, t, 0.2);
                            t *= 5;
                        }
 
                        bspeed = xyspeed * 0.01f;
                        bob = bspeed * cl_bobmodel_side.value * cl_viewmodel_scale.value * sin (s) * t;
                        VectorMA (gunorg, bob, right, gunorg);
                        bob = bspeed * cl_bobmodel_up.value * cl_viewmodel_scale.value * cos (s * 2) * t;
                        VectorMA (gunorg, bob, up, gunorg);
                    }
                    else
                    {
                        // Classic Quake bobbing
                        for (int i = 0; i < 3; i++)
                            gunorg[i] += forward[i]*bob*0.4;
                        gunorg[2] += bob;
 
                        if (r_viewmodel_quake.value)
                        {
                            if (scr_viewsize.value == 110)
                                gunorg[2] += 1;
                            else if (scr_viewsize.value == 100)
                                gunorg[2] += 2;
                            else if (scr_viewsize.value == 90)
                                gunorg[2] += 1;
                            else if (scr_viewsize.value == 80)
                                gunorg[2] += 0.5;
                        }
                    }
                }
            }
        }
        // calculate a view matrix for rendering the scene
        if (v_idlescale.value)
        {
            viewangles[0] += v_idlescale.value * sin(cl.time*v_ipitch_cycle.value) * v_ipitch_level.value;
            viewangles[1] += v_idlescale.value * sin(cl.time*v_iyaw_cycle.value) * v_iyaw_level.value;
            viewangles[2] += v_idlescale.value * sin(cl.time*v_iroll_cycle.value) * v_iroll_level.value;
        }
        Matrix4x4_CreateFromQuakeEntity(&r_refdef.view.matrix, vieworg[0], vieworg[1], vieworg[2], viewangles[0], viewangles[1], viewangles[2], 1);
        if (v_yshearing.value > 0)
            Matrix4x4_QuakeToDuke3D(&r_refdef.view.matrix, &r_refdef.view.matrix, v_yshearing.value);
 
        // calculate a viewmodel matrix for use in view-attached entities
        Matrix4x4_Copy(&viewmodelmatrix_nobob, &r_refdef.view.matrix);
        Matrix4x4_ConcatScale(&viewmodelmatrix_nobob, cl_viewmodel_scale.value);
 
        Matrix4x4_CreateFromQuakeEntity(&viewmodelmatrix_withbob, gunorg[0], gunorg[1], gunorg[2], gunangles[0], gunangles[1], gunangles[2], cl_viewmodel_scale.value);
        if (v_yshearing.value > 0)
            Matrix4x4_QuakeToDuke3D(&viewmodelmatrix_withbob, &viewmodelmatrix_withbob, v_yshearing.value);
 
        VectorCopy(vieworg, cl.csqc_vieworiginfromengine);
        VectorCopy(viewangles, cl.csqc_viewanglesfromengine);
 
        Matrix4x4_Invert_Simple(&tmpmatrix, &r_refdef.view.matrix);
        Matrix4x4_Concat(&cl.csqc_viewmodelmatrixfromengine, &tmpmatrix, &viewmodelmatrix_withbob);
    }
 
    cl.calcrefdef_prevtime = cl.time;
}

References AngleVectors(), bound, chase_active, chase_back, chase_overhead, chase_pitchangle, chase_stevie, chase_up, cl, cl_bob, cl_bob2, cl_bob2cycle, cl_bob2smooth, cl_bob_limit, cl_bob_limit_heightcheck, cl_bob_limit_heightcheck_dontcrosswatersurface, cl_bob_velocity_limit, cl_bobcycle, cl_bobfall, cl_bobfallcycle, cl_bobfallminspeed, cl_bobmodel, cl_bobmodel_classic, cl_bobmodel_side, cl_bobmodel_speed, cl_bobmodel_up, cl_bobup, cl_followmodel, cl_followmodel_side_highpass, cl_followmodel_side_highpass1, cl_followmodel_side_limit, cl_followmodel_side_lowpass, cl_followmodel_side_speed, cl_followmodel_up_highpass, cl_followmodel_up_highpass1, cl_followmodel_up_limit, cl_followmodel_up_lowpass, cl_followmodel_up_speed, cl_leanmodel, cl_leanmodel_side_highpass, cl_leanmodel_side_highpass1, cl_leanmodel_side_limit, cl_leanmodel_side_lowpass, cl_leanmodel_side_speed, cl_leanmodel_up_highpass, cl_leanmodel_up_highpass1, cl_leanmodel_up_limit, cl_leanmodel_up_lowpass, cl_leanmodel_up_speed, cl_punchangle_applied, cl_rollangle, cl_rollspeed, cl_smoothviewheight, cl_stairsmoothspeed, CL_TraceLine(), cl_viewmodel_scale, collision_extendmovelength, Com_CalcRoll(), cos(), DotProduct, trace_t::endpos, floor(), forward, trace_t::fraction, frametime, GAME_GOODVSBAD2, gamemode, highpass3(), highpass3_limited(), identitymatrix, int(), lowpass3(), M_PI, MATERIALFLAGMASK_TRANSLUCENT, Matrix4x4_Concat(), Matrix4x4_ConcatScale(), Matrix4x4_Copy(), Matrix4x4_CreateFromQuakeEntity(), Matrix4x4_Invert_Simple(), Matrix4x4_OriginFromMatrix(), Matrix4x4_QuakeToDuke3D(), max, min, MOVE_NOMONSTERS, plane_t::normal, NULL, offset, PITCH, trace_t::plane, r_refdef, r_viewmodel_quake, right, ROLL, scr_viewsize, sin(), sqrt(), SUPERCONTENTS_LIQUIDSMASK, SUPERCONTENTS_SKY, SUPERCONTENTS_SOLID, up, V_CalcIntermissionRefdef(), v_deathtilt, v_deathtiltangle, v_dmg_pitch, v_dmg_roll, v_dmg_time, v_idlescale, v_ipitch_cycle, v_ipitch_level, v_iroll_cycle, v_iroll_level, v_iyaw_cycle, v_iyaw_level, v_kicktime, v_yshearing, VectorAdd, VectorClear, VectorCopy, VectorMA, VectorMAMAM, VectorScale, VectorSet, VectorSubtract, viewmodelmatrix_nobob, viewmodelmatrix_withbob, and YAW.

Referenced by V_CalcRefdef(), and VM_CL_V_CalcRefdef().

V_CalcViewBlend()

void V_CalcViewBlend

(

void

)

Definition at line 1043 of file view.c.

{
    float a2;
    int j;
    r_refdef.viewblend[0] = 0;
    r_refdef.viewblend[1] = 0;
    r_refdef.viewblend[2] = 0;
    r_refdef.viewblend[3] = 0;
    r_refdef.frustumscale_x = 1;
    r_refdef.frustumscale_y = 1;
    if (cls.state == ca_connected && cls.signon == SIGNONS)
    {
        // set contents color
        int supercontents;
        vec3_t vieworigin;
        Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, vieworigin);
        supercontents = CL_PointSuperContents(vieworigin);
        if (supercontents & SUPERCONTENTS_LIQUIDSMASK)
        {
            cl.view_underwater = true;
            r_refdef.frustumscale_x *= 1 - (((sin(cl.time * 4.7) + 1) * 0.015) * r_waterwarp.value);
            r_refdef.frustumscale_y *= 1 - (((sin(cl.time * 3.0) + 1) * 0.015) * r_waterwarp.value);
            if (supercontents & SUPERCONTENTS_LAVA)
            {
                cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 255;
                cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 80;
                cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 0;
            }
            else if (supercontents & SUPERCONTENTS_SLIME)
            {
                cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 0;
                cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 25;
                cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 5;
            }
            else
            {
                cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 130;
                cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 80;
                cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 50;
            }
            cl.cshifts[CSHIFT_CONTENTS].percent = 150 * 0.5;
        }
        else
        {
            cl.view_underwater = false;
            cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 0;
            cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 0;
            cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 0;
            cl.cshifts[CSHIFT_CONTENTS].percent = 0;
        }
 
        if (gamemode != GAME_TRANSFUSION)
        {
            if (cl.stats[STAT_ITEMS] & IT_QUAD)
            {
                cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
                cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 0;
                cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 255;
                cl.cshifts[CSHIFT_POWERUP].percent = 30;
            }
            else if (cl.stats[STAT_ITEMS] & IT_SUIT)
            {
                cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
                cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
                cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
                cl.cshifts[CSHIFT_POWERUP].percent = 20;
            }
            else if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY)
            {
                cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 100;
                cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 100;
                cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 100;
                cl.cshifts[CSHIFT_POWERUP].percent = 100;
            }
            else if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY)
            {
                cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 255;
                cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
                cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
                cl.cshifts[CSHIFT_POWERUP].percent = 30;
            }
            else
                cl.cshifts[CSHIFT_POWERUP].percent = 0;
        }
 
        cl.cshifts[CSHIFT_VCSHIFT].destcolor[0] = v_cshift.destcolor[0];
        cl.cshifts[CSHIFT_VCSHIFT].destcolor[1] = v_cshift.destcolor[1];
        cl.cshifts[CSHIFT_VCSHIFT].destcolor[2] = v_cshift.destcolor[2];
        cl.cshifts[CSHIFT_VCSHIFT].percent = v_cshift.percent;
 
        // LadyHavoc: fixed V_CalcBlend
        for (j = 0;j < NUM_CSHIFTS;j++)
        {
            a2 = bound(0.0f, cl.cshifts[j].percent * (1.0f / 255.0f), 1.0f);
            if (a2 > 0)
            {
                VectorLerp(r_refdef.viewblend, a2, cl.cshifts[j].destcolor, r_refdef.viewblend);
                r_refdef.viewblend[3] = (1 - (1 - r_refdef.viewblend[3]) * (1 - a2)); // correct alpha multiply...  took a while to find it on the web
            }
        }
        // saturate color (to avoid blending in black)
        if (r_refdef.viewblend[3])
        {
            a2 = 1 / r_refdef.viewblend[3];
            VectorScale(r_refdef.viewblend, a2, r_refdef.viewblend);
        }
        r_refdef.viewblend[0] = bound(0.0f, r_refdef.viewblend[0], 255.0f);
        r_refdef.viewblend[1] = bound(0.0f, r_refdef.viewblend[1], 255.0f);
        r_refdef.viewblend[2] = bound(0.0f, r_refdef.viewblend[2], 255.0f);
        r_refdef.viewblend[3] = bound(0.0f, r_refdef.viewblend[3] * gl_polyblend.value, 1.0f);
        if (vid.sRGB3D)
        {
            r_refdef.viewblend[0] = Image_LinearFloatFromsRGB(r_refdef.viewblend[0]);
            r_refdef.viewblend[1] = Image_LinearFloatFromsRGB(r_refdef.viewblend[1]);
            r_refdef.viewblend[2] = Image_LinearFloatFromsRGB(r_refdef.viewblend[2]);
        }
        else
        {
            r_refdef.viewblend[0] *= (1.0f/256.0f);
            r_refdef.viewblend[1] *= (1.0f/256.0f);
            r_refdef.viewblend[2] *= (1.0f/256.0f);
        }
        
        // Samual: Ugly hack, I know. But it's the best we can do since
        // there is no way to detect client states from the engine.
        if (cl.stats[STAT_HEALTH] <= 0 && cl.stats[STAT_HEALTH] != -666 && 
            cl.stats[STAT_HEALTH] != -2342 && cl_deathfade.value > 0)
        {
            cl.deathfade += cl_deathfade.value * max(0.00001, cl.time - cl.oldtime);
            cl.deathfade = bound(0.0f, cl.deathfade, 0.9f);
        }
        else
            cl.deathfade = 0.0f;
 
        if(cl.deathfade > 0)
        {
            float a;
            float deathfadevec[3] = {0.3f, 0.0f, 0.0f};
            a = r_refdef.viewblend[3] + cl.deathfade - r_refdef.viewblend[3]*cl.deathfade;
            if(a > 0)
                VectorMAM(r_refdef.viewblend[3] * (1 - cl.deathfade) / a, r_refdef.viewblend, cl.deathfade / a, deathfadevec, r_refdef.viewblend);
            r_refdef.viewblend[3] = a;
        }
    }
}

References a, bound, ca_connected, cl, cl_deathfade, CL_PointSuperContents, cls, CSHIFT_CONTENTS, CSHIFT_POWERUP, CSHIFT_VCSHIFT, GAME_TRANSFUSION, gamemode, gl_polyblend, Image_LinearFloatFromsRGB, IT_INVISIBILITY, IT_INVULNERABILITY, IT_QUAD, IT_SUIT, Matrix4x4_OriginFromMatrix(), max, NUM_CSHIFTS, r_refdef, r_waterwarp, SIGNONS, sin(), STAT_HEALTH, STAT_ITEMS, SUPERCONTENTS_LAVA, SUPERCONTENTS_LIQUIDSMASK, SUPERCONTENTS_SLIME, v_cshift, VectorLerp, VectorMAM, VectorScale, and vid.

Referenced by CSQC_RelinkAllEntities().

V_DriftPitch()

void V_DriftPitch

(

void

)

Definition at line 189 of file view.c.

{
    float       delta, move;
 
    if (noclip_anglehack || !cl.onground || cls.demoplayback )
    {
        cl.driftmove = 0;
        cl.pitchvel = 0;
        return;
    }
 
// don't count small mouse motion
    if (cl.nodrift)
    {
        if ( fabs(cl.cmd.forwardmove) < cl_forwardspeed.value)
            cl.driftmove = 0;
        else
            cl.driftmove += cl.realframetime;
 
        if ( cl.driftmove > v_centermove.value)
        {
            V_StartPitchDrift ();
        }
        return;
    }
 
    delta = cl.idealpitch - cl.viewangles[PITCH];
 
    if (!delta)
    {
        cl.pitchvel = 0;
        return;
    }
 
    move = cl.realframetime * cl.pitchvel;
    cl.pitchvel += cl.realframetime * v_centerspeed.value;
 
    if (delta > 0)
    {
        if (move > delta)
        {
            cl.pitchvel = 0;
            move = delta;
        }
        cl.viewangles[PITCH] += move;
    }
    else if (delta < 0)
    {
        if (move > -delta)
        {
            cl.pitchvel = 0;
            move = -delta;
        }
        cl.viewangles[PITCH] -= move;
    }
}

References cl, cl_forwardspeed, cls, fabs(), noclip_anglehack, PITCH, v_centermove, v_centerspeed, and V_StartPitchDrift().

Referenced by CL_UpdateWorld().

V_FadeViewFlashs()

void V_FadeViewFlashs

(

void

)

Definition at line 1028 of file view.c.

{
    // don't flash if time steps backwards
    if (cl.time <= cl.oldtime)
        return;
    // drop the damage value
    cl.cshifts[CSHIFT_DAMAGE].percent -= (cl.time - cl.oldtime)*cl.cshifts[CSHIFT_DAMAGE].alphafade;
    if (cl.cshifts[CSHIFT_DAMAGE].percent <= 0)
        cl.cshifts[CSHIFT_DAMAGE].percent = 0;
    // drop the bonus value
    cl.cshifts[CSHIFT_BONUS].percent -= (cl.time - cl.oldtime)*cl.cshifts[CSHIFT_BONUS].alphafade;
    if (cl.cshifts[CSHIFT_BONUS].percent <= 0)
        cl.cshifts[CSHIFT_BONUS].percent = 0;
}

References cl, CSHIFT_BONUS, and CSHIFT_DAMAGE.

Referenced by CL_UpdateWorld().

V_Init()

void V_Init

(

void

)

Definition at line 1196 of file view.c.

{
    Cmd_AddCommand(CF_CLIENT | CF_CLIENT_FROM_SERVER, "v_cshift", V_cshift_f, "sets tint color of view");
    Cmd_AddCommand(CF_CLIENT | CF_CLIENT_FROM_SERVER, "bf", V_BonusFlash_f, "briefly flashes a bright color tint on view (used when items are picked up); optionally takes R G B [A [alphafade]] arguments to specify how the flash looks");
    Cmd_AddCommand(CF_CLIENT, "centerview", V_StartPitchDrift_f, "gradually recenter view (stop looking up/down)");
 
    Cvar_RegisterVariable (&v_centermove);
    Cvar_RegisterVariable (&v_centerspeed);
 
    Cvar_RegisterVariable (&v_iyaw_cycle);
    Cvar_RegisterVariable (&v_iroll_cycle);
    Cvar_RegisterVariable (&v_ipitch_cycle);
    Cvar_RegisterVariable (&v_iyaw_level);
    Cvar_RegisterVariable (&v_iroll_level);
    Cvar_RegisterVariable (&v_ipitch_level);
 
    Cvar_RegisterVariable(&v_isometric);
    Cvar_RegisterVariable(&v_isometric_verticalfov);
    Cvar_RegisterVariable(&v_isometric_xx);
    Cvar_RegisterVariable(&v_isometric_xy);
    Cvar_RegisterVariable(&v_isometric_xz);
    Cvar_RegisterVariable(&v_isometric_yx);
    Cvar_RegisterVariable(&v_isometric_yy);
    Cvar_RegisterVariable(&v_isometric_yz);
    Cvar_RegisterVariable(&v_isometric_zx);
    Cvar_RegisterVariable(&v_isometric_zy);
    Cvar_RegisterVariable(&v_isometric_zz);
    Cvar_RegisterVariable(&v_isometric_tx);
    Cvar_RegisterVariable(&v_isometric_ty);
    Cvar_RegisterVariable(&v_isometric_tz);
    Cvar_RegisterVariable(&v_isometric_rot_pitch);
    Cvar_RegisterVariable(&v_isometric_rot_yaw);
    Cvar_RegisterVariable(&v_isometric_rot_roll);
    Cvar_RegisterVariable(&v_isometric_relx);
    Cvar_RegisterVariable(&v_isometric_rely);
    Cvar_RegisterVariable(&v_isometric_relz);
    Cvar_RegisterVariable(&v_isometric_flipcullface);
    Cvar_RegisterVariable(&v_isometric_locked_orientation);
    Cvar_RegisterVariable(&v_isometric_usevieworiginculling);
 
    Cvar_RegisterVariable (&v_idlescale);
    Cvar_RegisterVariable (&crosshair);
 
    Cvar_RegisterVariable (&cl_rollspeed);
    Cvar_RegisterVariable (&cl_rollangle);
    Cvar_RegisterVariable (&cl_bob);
    Cvar_RegisterVariable (&cl_bobcycle);
    Cvar_RegisterVariable (&cl_bobup);
    Cvar_RegisterVariable (&cl_bob2);
    Cvar_RegisterVariable (&cl_bob2cycle);
    Cvar_RegisterVariable (&cl_bob2smooth);
    Cvar_RegisterVariable (&cl_bobfall);
    Cvar_RegisterVariable (&cl_bobfallcycle);
    Cvar_RegisterVariable (&cl_bobfallminspeed);
    Cvar_RegisterVariable (&cl_bobmodel);
    Cvar_RegisterVariable (&cl_bobmodel_side);
    Cvar_RegisterVariable (&cl_bobmodel_up);
    Cvar_RegisterVariable (&cl_bobmodel_forward);
    Cvar_RegisterVariable (&cl_bobmodel_classic);
    Cvar_RegisterVariable (&cl_bobmodel_speed);
    Cvar_RegisterVariable (&cl_bob_limit);
    Cvar_RegisterVariable (&cl_bob_limit_heightcheck);
    Cvar_RegisterVariable (&cl_bob_limit_heightcheck_dontcrosswatersurface);
    Cvar_RegisterVariable (&cl_bob_velocity_limit);
 
    Cvar_RegisterVariable (&cl_leanmodel);
    Cvar_RegisterVariable (&cl_leanmodel_side_speed);
    Cvar_RegisterVariable (&cl_leanmodel_side_limit);
    Cvar_RegisterVariable (&cl_leanmodel_side_highpass1);
    Cvar_RegisterVariable (&cl_leanmodel_side_lowpass);
    Cvar_RegisterVariable (&cl_leanmodel_side_highpass);
    Cvar_RegisterVariable (&cl_leanmodel_up_speed);
    Cvar_RegisterVariable (&cl_leanmodel_up_limit);
    Cvar_RegisterVariable (&cl_leanmodel_up_highpass1);
    Cvar_RegisterVariable (&cl_leanmodel_up_lowpass);
    Cvar_RegisterVariable (&cl_leanmodel_up_highpass);
 
    Cvar_RegisterVariable (&cl_followmodel);
    Cvar_RegisterVariable (&cl_followmodel_side_speed);
    Cvar_RegisterVariable (&cl_followmodel_side_limit);
    Cvar_RegisterVariable (&cl_followmodel_side_highpass1);
    Cvar_RegisterVariable (&cl_followmodel_side_lowpass);
    Cvar_RegisterVariable (&cl_followmodel_side_highpass);
    Cvar_RegisterVariable (&cl_followmodel_up_speed);
    Cvar_RegisterVariable (&cl_followmodel_up_limit);
    Cvar_RegisterVariable (&cl_followmodel_up_highpass1);
    Cvar_RegisterVariable (&cl_followmodel_up_lowpass);
    Cvar_RegisterVariable (&cl_followmodel_up_highpass);
 
    Cvar_RegisterVariable (&cl_viewmodel_scale);
 
    Cvar_RegisterVariable (&v_kicktime);
    Cvar_RegisterVariable (&v_kickroll);
    Cvar_RegisterVariable (&v_kickpitch);
 
    Cvar_RegisterVariable (&cl_stairsmoothspeed);
    
    Cvar_RegisterVariable (&cl_smoothviewheight);
 
    Cvar_RegisterVariable (&chase_back);
    Cvar_RegisterVariable (&chase_up);
    Cvar_RegisterVariable (&chase_active);
    Cvar_RegisterVariable (&chase_overhead);
    Cvar_RegisterVariable (&chase_pitchangle);
    Cvar_RegisterVariable (&chase_stevie);
 
    Cvar_RegisterVariable (&v_deathtilt);
    Cvar_RegisterVariable (&v_deathtiltangle);
 
    Cvar_RegisterVariable (&v_yshearing);
    Cvar_RegisterVariable (&r_viewmodel_quake);
}

References CF_CLIENT, CF_CLIENT_FROM_SERVER, chase_active, chase_back, chase_overhead, chase_pitchangle, chase_stevie, chase_up, cl_bob, cl_bob2, cl_bob2cycle, cl_bob2smooth, cl_bob_limit, cl_bob_limit_heightcheck, cl_bob_limit_heightcheck_dontcrosswatersurface, cl_bob_velocity_limit, cl_bobcycle, cl_bobfall, cl_bobfallcycle, cl_bobfallminspeed, cl_bobmodel, cl_bobmodel_classic, cl_bobmodel_forward, cl_bobmodel_side, cl_bobmodel_speed, cl_bobmodel_up, cl_bobup, cl_followmodel, cl_followmodel_side_highpass, cl_followmodel_side_highpass1, cl_followmodel_side_limit, cl_followmodel_side_lowpass, cl_followmodel_side_speed, cl_followmodel_up_highpass, cl_followmodel_up_highpass1, cl_followmodel_up_limit, cl_followmodel_up_lowpass, cl_followmodel_up_speed, cl_leanmodel, cl_leanmodel_side_highpass, cl_leanmodel_side_highpass1, cl_leanmodel_side_limit, cl_leanmodel_side_lowpass, cl_leanmodel_side_speed, cl_leanmodel_up_highpass, cl_leanmodel_up_highpass1, cl_leanmodel_up_limit, cl_leanmodel_up_lowpass, cl_leanmodel_up_speed, cl_rollangle, cl_rollspeed, cl_smoothviewheight, cl_stairsmoothspeed, cl_viewmodel_scale, Cmd_AddCommand(), crosshair, Cvar_RegisterVariable(), r_viewmodel_quake, V_BonusFlash_f(), v_centermove, v_centerspeed, V_cshift_f(), v_deathtilt, v_deathtiltangle, v_idlescale, v_ipitch_cycle, v_ipitch_level, v_iroll_cycle, v_iroll_level, v_isometric, v_isometric_flipcullface, v_isometric_locked_orientation, v_isometric_relx, v_isometric_rely, v_isometric_relz, v_isometric_rot_pitch, v_isometric_rot_roll, v_isometric_rot_yaw, v_isometric_tx, v_isometric_ty, v_isometric_tz, v_isometric_usevieworiginculling, v_isometric_verticalfov, v_isometric_xx, v_isometric_xy, v_isometric_xz, v_isometric_yx, v_isometric_yy, v_isometric_yz, v_isometric_zx, v_isometric_zy, v_isometric_zz, v_iyaw_cycle, v_iyaw_level, v_kickpitch, v_kickroll, v_kicktime, V_StartPitchDrift_f(), and v_yshearing.

Referenced by CL_Init().

V_MakeViewIsometric()

void V_MakeViewIsometric

(

void

)

Definition at line 968 of file view.c.

{
    // when using isometric view to play normal games we have to rotate the camera to make the Ortho matrix do the right thing (forward as up the screen, etc)
    matrix4x4_t relative;
    matrix4x4_t modifiedview;
    matrix4x4_t modify;
    vec3_t forward, left, up, org;
    float t[16];
 
    r_refdef.view.useperspective = false;
    r_refdef.view.usevieworiginculling = !r_trippy.value && v_isometric_usevieworiginculling.integer;
    r_refdef.view.frustum_y = v_isometric_verticalfov.value * cl.viewzoom;
    r_refdef.view.frustum_x = r_refdef.view.frustum_y * (float)r_refdef.view.width / (float)r_refdef.view.height / vid_pixelheight.value;
    r_refdef.view.frustum_x *= r_refdef.frustumscale_x;
    r_refdef.view.frustum_y *= r_refdef.frustumscale_y;
    r_refdef.view.ortho_x = r_refdef.view.frustum_x; // used by VM_CL_R_SetView
    r_refdef.view.ortho_y = r_refdef.view.frustum_y; // used by VM_CL_R_SetView
 
    t[0]  = v_isometric_xx.value;
    t[1]  = v_isometric_xy.value;
    t[2]  = v_isometric_xz.value;
    t[3]  = 0.0f;
    t[4]  = v_isometric_yx.value;
    t[5]  = v_isometric_yy.value;
    t[6]  = v_isometric_yz.value;
    t[7]  = 0.0f;
    t[8]  = v_isometric_zx.value;
    t[9]  = v_isometric_zy.value;
    t[10] = v_isometric_zz.value;
    t[11] = 0.0f;
    t[12] = 0.0f;
    t[13] = 0.0f;
    t[14] = 0.0f;
    t[15] = 1.0f;
    Matrix4x4_FromArrayFloatGL(&modify, t);
 
    // if the orientation is locked, extract the origin and create just a translate matrix to start with
    if (v_isometric_locked_orientation.integer)
    {
        vec3_t vx, vy, vz, origin;
        Matrix4x4_ToVectors(&r_refdef.view.matrix, vx, vy, vz, origin);
        Matrix4x4_CreateTranslate(&r_refdef.view.matrix, origin[0], origin[1], origin[2]);
    }
 
    Matrix4x4_Concat(&modifiedview, &r_refdef.view.matrix, &modify);
    Matrix4x4_CreateFromQuakeEntity(&relative, v_isometric_tx.value, v_isometric_ty.value, v_isometric_tz.value, v_isometric_rot_pitch.value, v_isometric_rot_yaw.value, v_isometric_rot_roll.value, 1.0f);
    Matrix4x4_Concat(&r_refdef.view.matrix, &modifiedview, &relative);
    Matrix4x4_ToVectors(&r_refdef.view.matrix, forward, left, up, org);
    VectorMAMAMAM(1.0f, org, v_isometric_relx.value, forward, v_isometric_rely.value, left, v_isometric_relz.value, up, org);
    Matrix4x4_FromVectors(&r_refdef.view.matrix, forward, left, up, org);
 
    if (v_isometric_flipcullface.integer)
    {
        int a = r_refdef.view.cullface_front;
        r_refdef.view.cullface_front = r_refdef.view.cullface_back;
        r_refdef.view.cullface_back = a;
    }
}

V_ParseDamage()

void V_ParseDamage

(

void

)

Definition at line 261 of file view.c.

{
    int armor, blood;
    vec3_t from;
    //vec3_t forward, right;
    vec3_t localfrom;
    entity_t *ent;
    //float side;
    float count;
 
    armor = MSG_ReadByte(&cl_message);
    blood = MSG_ReadByte(&cl_message);
    MSG_ReadVector(&cl_message, from, cls.protocol);
 
    // Send the Dmg Globals to CSQC
    CL_VM_UpdateDmgGlobals(blood, armor, from);
 
    count = blood*0.5 + armor*0.5;
    if (count < 10)
        count = 10;
 
    cl.faceanimtime = cl.time + 0.2;        // put sbar face into pain frame
 
    cl.cshifts[CSHIFT_DAMAGE].percent += 3*count;
    cl.cshifts[CSHIFT_DAMAGE].alphafade = 150;
    if (cl.cshifts[CSHIFT_DAMAGE].percent < 0)
        cl.cshifts[CSHIFT_DAMAGE].percent = 0;
    if (cl.cshifts[CSHIFT_DAMAGE].percent > 150)
        cl.cshifts[CSHIFT_DAMAGE].percent = 150;
 
    if (armor > blood)
    {
        cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 200;
        cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 100;
        cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 100;
    }
    else if (armor)
    {
        cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 220;
        cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 50;
        cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 50;
    }
    else
    {
        cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 255;
        cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 0;
        cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 0;
    }
 
    // calculate view angle kicks
    if (cl.entities[cl.viewentity].state_current.active)
    {
        ent = &cl.entities[cl.viewentity];
        Matrix4x4_Transform(&ent->render.inversematrix, from, localfrom);
        VectorNormalize(localfrom);
        v_dmg_pitch = count * localfrom[0] * v_kickpitch.value;
        v_dmg_roll = count * localfrom[1] * v_kickroll.value;
        v_dmg_time = v_kicktime.value;
    }
}

References cl, cl_message, CL_VM_UpdateDmgGlobals(), cls, count, CSHIFT_DAMAGE, entity_render_t::inversematrix, Matrix4x4_Transform(), MSG_ReadByte, MSG_ReadVector(), entity_t::render, v_dmg_pitch, v_dmg_roll, v_dmg_time, v_kickpitch, v_kickroll, v_kicktime, and VectorNormalize.

Referenced by CL_ParseServerMessage().

V_StartPitchDrift()

void V_StartPitchDrift

(

void

)

Definition at line 151 of file view.c.

{
    if (cl.laststop == cl.time)
        return;     // something else is keeping it from drifting
 
    if (cl.nodrift || !cl.pitchvel)
    {
        cl.pitchvel = v_centerspeed.value;
        cl.nodrift = false;
        cl.driftmove = 0;
    }
}

References cl, and v_centerspeed.

Referenced by V_DriftPitch(), and V_StartPitchDrift_f().

V_StartPitchDrift_f()

void V_StartPitchDrift_f

(

struct cmd_state_s *

cmd

)

References cmd().

V_StopPitchDrift()

void V_StopPitchDrift

(

void

)

Definition at line 169 of file view.c.

{
    cl.laststop = cl.time;
    cl.nodrift = true;
    cl.pitchvel = 0;
}

References cl.

Referenced by CL_AdjustAngles(), and CL_Input().

V_UpdateBlends()

void V_UpdateBlends

(

void

)