viewloc.qc File Reference

#include "viewloc.qh"
#include <common/util.qh>
#include <common/constants.qh>

Include dependency graph for viewloc.qc:

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

Go to the source code of this file.

Functions
vector	CursorToWorldCoord (vector mpos)
	STATIC_INIT_LATE (viewloc_cursor)
void	viewloc_PlayerPhysics (entity this)
void	viewloc_SetTags (entity this)
void	viewloc_SetViewLocation ()

Variables
vector	old_camera_angle = '0 0 0'

Function Documentation

CursorToWorldCoord()

vector CursorToWorldCoord

(

vector

mpos

)

Definition at line 88 of file viewloc.qc.

{
    vector wnear = cs_unproject(vec2(mpos)); // determine the world coordinate for the mouse cursor upon the near clip plane
    vector wfar = cs_unproject(vec3(mpos.x, mpos.y, max_shot_distance)); // determine the world coordinate for the mouse cursor upon the far clip plane, with an outrageously large value as a workaround for dp.
    traceline(wnear, wfar, MOVE_NOMONSTERS, NULL);
    return trace_endpos;
}

References max_shot_distance, MOVE_NOMONSTERS, NULL, trace_endpos, vec2, vec3, and vector.

Referenced by viewloc_SetViewLocation().

STATIC_INIT_LATE()

STATIC_INIT_LATE

(

viewloc_cursor

)

Definition at line 200 of file viewloc.qc.

{
    // fix the mouse position on init so it isn't in the corner
    viewloc_mousepos = '0.5 0 0' * autocvar_vid_conwidth + '0 0.5 0' * autocvar_vid_conheight;
}

References autocvar_vid_conheight, autocvar_vid_conwidth, and viewloc_mousepos.

viewloc_PlayerPhysics()

void viewloc_PlayerPhysics

(

entity

this

)

Definition at line 13 of file viewloc.qc.

{
    if(this.viewloc)
    {
        if(this.viewloc.goalentity == this.viewloc.enemy)
            return; // we can't side-scroll in this case
 
        vector old_movement = PHYS_CS(this).movement;
        PHYS_CS(this).movement_x = old_movement_y;
        if((this.viewloc.spawnflags & VIEWLOC_FREEMOVE) && !this.ladder_entity)
            PHYS_CS(this).movement_y = old_movement_x;
        else
            PHYS_CS(this).movement_y = 0;
 
        vector level_start, level_end;
        level_start = this.viewloc.enemy.origin;
        level_end = this.viewloc.goalentity.origin;
        vector forward = vectoangles(normalize(level_end - level_start));
        vector backward = vectoangles(normalize(level_start - level_end));
 
        if((this.viewloc.spawnflags & VIEWLOC_FREEMOVE) && this.angles_y < 0 && !this.ladder_entity)
            PHYS_CS(this).movement_y = -PHYS_CS(this).movement_y;
 
        if(this.viewloc.spawnflags & VIEWLOC_FREEAIM)
        {
            if(this.angles_y > 0)
                PHYS_CS(this).movement_x = -PHYS_CS(this).movement_x;
        }
        else
        {
            if(PHYS_CS(this).movement_x < 0)
                PHYS_CS(this).movement_x = -PHYS_CS(this).movement_x;
 
            if(PHYS_CS(this).movement_x < 0) // left
                this.angles_y = backward.y;
            if(PHYS_CS(this).movement_x > 0) // right
                this.angles_y = forward.y;
        }
    #if 0
        //if(!PHYS_INPUT_BUTTON_CROUCH(this) && !IS_DUCKED(this))
        if(!(this.viewloc.spawnflags & VIEWLOC_FREEMOVE))
        {
#ifdef SVQC
            //PHYS_INPUT_BUTTON_CROUCH(this) = (old_movement_x < 0);
            if (old_movement.x < 0)
                PHYS_INPUT_BUTTON_CROUCH(this) = true;
#elif defined(CSQC)
            if (old_movement.x < 0)
            {
                input_buttons |= BIT(4);
                this.flags |= FL_DUCKED;
            }
            //else { input_buttons &= ~16; this.flags &= ~FL_DUCKED; }
#endif
        }
    #endif
    }
}

References angles_y, BIT, entity(), FL_DUCKED, flags, input_buttons, normalize(), PHYS_CS, PHYS_INPUT_BUTTON_CROUCH, vectoangles(), vector, viewloc, VIEWLOC_FREEAIM, and VIEWLOC_FREEMOVE.

Referenced by sys_phys_update().

viewloc_SetTags()

void viewloc_SetTags

(

entity

this

)

Definition at line 74 of file viewloc.qc.

{
    if(this.viewloc && wasfreed(this.viewloc))
        this.viewloc = NULL;
 
    if(this.viewloc.entnum != this.tag_networkviewloc)
    {
        if(this.tag_networkviewloc == 0)
            this.viewloc = NULL;
        else
            this.viewloc = findfloat(NULL, entnum, this.tag_networkviewloc);
    }
}

References entity(), entnum, findfloat(), NULL, tag_networkviewloc, and viewloc.

Referenced by NET_HANDLE().

viewloc_SetViewLocation()

void viewloc_SetViewLocation

(

)

Definition at line 97 of file viewloc.qc.

{
    entity view = CSQCModel_server2csqc(player_localentnum - 1);
    if (!view) return;
    entity viewloc_ent = view.viewloc;
    if(viewloc_ent && !wasfreed(viewloc_ent) && viewloc_ent.enemy && viewloc_ent.goalentity)
    {
        bool have_sidescroll = (viewloc_ent.enemy != viewloc_ent.goalentity);
        vector position_a = viewloc_ent.enemy.origin;
        vector position_b = viewloc_ent.goalentity.origin;
        vector camera_angle = '0 0 0';
        vector camera_position;
 
        /*TODO: have the camera only move when a player moves too much from the center of the camera
         * basically the player would move around in a small "box" in the center of the screen with out changing the camera position or angles */
        camera_position = vec_bounds_in(view.origin, position_a, position_b);
 
        // use camera's angle when possible
        if (!(viewloc_ent.spawnflags & VIEWLOC_CAM_NOANGLE)) {
            camera_angle = viewloc_ent.enemy.movedir;
        }
 
        // a tracking camera follows the player when it leaves the world box
        if ((viewloc_ent.spawnflags & VIEWLOC_CAM_TRACK) || !have_sidescroll) {
            camera_angle = aim_vec (camera_position, view.origin);
        }
 
        // hard snap changes the angle as soon as it crosses over the nearest 90 degree mark
        if (viewloc_ent.spawnflags & VIEWLOC_CAM_SNAP_HARD) {
            camera_angle = angle_snap_vec(aim_vec(camera_position, view.origin), 90);
        }
 
        // tries to avoid snapping unless it *really* needs to
        if (viewloc_ent.spawnflags & VIEWLOC_CAM_SNAP_CLOSE) {
            // like hard snap, but don't snap angles yet.
            camera_angle = aim_vec(camera_position, view.origin);
 
            /* if the difference between the old and new angle is 60 degrees or more, switch angles.
             * NOTE: bug/feature: this will use non-snaped angles for one frame.
             * doing this results in less code, faster code, and a smoother transisition between angles.
             */
            float camera_angle_diff = max(camera_angle.y, old_camera_angle.y) - min(camera_angle.y, old_camera_angle.y);
 
            if (60 <= camera_angle_diff) { // use new angles
                old_camera_angle.y = angle_snap_f(camera_angle.y, 90);
            } else { // use old angles
                camera_angle.y = old_camera_angle.y;
            }
        }
 
        //unlocking this allows the camera to look up and down. this also allows a top-down view.
        if (!(viewloc_ent.spawnflags & VIEWLOC_CAM_SNAP_UNLOCK)) {
            camera_angle.x = 0;
            camera_angle.z = 0;
        }
 
#if 0
        LOG_TRACE(vtos(camera_position));
        LOG_TRACE(vtos(old_camera_angle));
        LOG_TRACE(vtos(camera_angle));
#endif
 
        freeze_org = getpropertyvec(VF_ORIGIN);
        freeze_ang = getpropertyvec(VF_ANGLES);
        setproperty(VF_ORIGIN, camera_position);
        setproperty(VF_ANGLES, camera_angle);
 
        if(spectatee_status)
            return; // if spectating, don't replace angles or inputs!
 
        if (have_sidescroll) {
            vector view_angle = view.angles;
            if (!(viewloc_ent.spawnflags & VIEWLOC_FREEAIM)) {
                vector avatar_facing_dir;
                // get the player's forward-facing direction, based on positions a and b
                if (0 == input_movevalues.y) {
                    avatar_facing_dir = view_angle; // default to the previous values
                } else if (0 > input_movevalues.y) { // left is forward
                    avatar_facing_dir = vectoangles(normalize(vec_to_max(position_b, position_a) - vec_to_min(position_b, position_a)));
                } else { // right is forward
                    avatar_facing_dir = vectoangles(normalize(vec_to_min(position_b, position_a) - vec_to_max(position_b, position_a)));
                }
                view_angle.y = avatar_facing_dir.y; // snap avatar to look on along the correct axis
 
                // if (0 == input_movevalues.x) look straight ahead
                if (!(viewloc_ent.spawnflags & VIEWLOC_FREEMOVE)) {
                    if (0 > input_movevalues.x) { // look up
                        view_angle.x = 50;
                    } else if (0 < input_movevalues.x) { // look down
                        view_angle.x = -50;
                    }
                }
            } else {
                vector mpos = CursorToWorldCoord(viewloc_mousepos);
                mpos.x = view.origin.x; // replace the cursor's x position with the player's
                view_angle = aim_vec(view.origin + view.view_ofs, mpos); // get new angles
            }
            view.angles_y = view_angle.y;
            setproperty(VF_CL_VIEWANGLES, view_angle);
        }
    }
}

References aim_vec(), angle_snap_f(), angle_snap_vec(), CSQCModel_server2csqc(), CursorToWorldCoord(), entity(), freeze_ang, freeze_org, input_movevalues, LOG_TRACE, max(), min(), normalize(), old_camera_angle, player_localentnum, spectatee_status, vec_bounds_in(), vec_to_max(), vec_to_min(), vectoangles(), vector, VF_ANGLES, VF_CL_VIEWANGLES, VF_ORIGIN, VIEWLOC_CAM_NOANGLE, VIEWLOC_CAM_SNAP_CLOSE, VIEWLOC_CAM_SNAP_HARD, VIEWLOC_CAM_SNAP_UNLOCK, VIEWLOC_CAM_TRACK, VIEWLOC_FREEAIM, VIEWLOC_FREEMOVE, viewloc_mousepos, and vtos().

Variable Documentation

old_camera_angle

vector old_camera_angle = '0 0 0'

Definition at line 96 of file viewloc.qc.

Referenced by viewloc_SetViewLocation().