crosshair.qc File Reference

#include "crosshair.qh"
#include <client/draw.qh>
#include <client/hud/panel/scoreboard.qh>
#include <client/view.qh>
#include <common/deathtypes/all.qh>
#include <common/ent_cs.qh>
#include <common/mapobjects/trigger/viewloc.qh>
#include <common/minigames/cl_minigames.qh>
#include <common/minigames/cl_minigames_hud.qh>
#include <common/mutators/mutator/overkill/oknex.qh>
#include <common/vehicles/all.qh>
#include <common/viewloc.qh>
#include <common/wepent.qh>
#include <lib/csqcmodel/cl_player.qh>
#include <lib/warpzone/common.qh>

Include dependency graph for crosshair.qc:

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

Go to the source code of this file.

Macros
#define	CROSSHAIR_DO_BLUR(M, sz, wcross_name, wcross_alpha)
#define	CROSSHAIR_DRAW(sz, wcross_name, wcross_alpha)   CROSSHAIR_DO_BLUR(CROSSHAIR_DRAW_SINGLE,sz,wcross_name,wcross_alpha)
#define	CROSSHAIR_DRAW_SINGLE(i, j, sz, scaled_sz, wcross_name, wcross_alpha)   drawpic(wcross_origin - ('0.5 0 0' * (scaled_sz.x + i * wcross_blur) + '0 0.5 0' * (scaled_sz.y + j * wcross_blur)), wcross_name, scaled_sz, wcross_color, wcross_alpha, DRAWFLAG_NORMAL)

Functions
vector	crosshair_getcolor (entity this, float health_stat)
void	DrawReticle (entity this)
float	EnemyHitCheck ()
void	HUD_Crosshair (entity this)
void	HUD_Crosshair_ApplyPlayerAlpha (float new_alpha)
void	HUD_Crosshair_Vehicle (entity this)
void	TrueAim_Init ()
float	TrueAimCheck (entity wepent)

Variables
float	hitindication_crosshair_size
float	pickup_crosshair_size
float	pickup_crosshair_time
float	reticle_type
const float	SHOTTYPE_HITENEMY = 4
const float	SHOTTYPE_HITOBSTRUCTION = 2
const float	SHOTTYPE_HITTEAM = 1
const float	SHOTTYPE_HITWORLD = 3
entity	tag_entity
entity	trueaim
entity	trueaim_rifle
float	use_vortex_chargepool
float	wcross_alpha_goal_prev
float	wcross_alpha_prev
float	wcross_changedonetime
vector	wcross_color_goal_prev
vector	wcross_color_prev
float	wcross_name_alpha_goal_prev
float	wcross_name_alpha_goal_prev_prev
float	wcross_name_changedonetime
float	wcross_name_changestarttime
string	wcross_name_goal_prev
string	wcross_name_goal_prev_prev
vector	wcross_origin
float	wcross_resolution_goal_prev
float	wcross_resolution_goal_prev_prev
float	wcross_ring_prev
float	wcross_scale_goal_prev
float	wcross_scale_prev

Macro Definition Documentation

CROSSHAIR_DO_BLUR

#define CROSSHAIR_DO_BLUR	(		M,
			sz,
			wcross_name,
			wcross_alpha
	)

Value:

MACRO_BEGIN \
                vector scaled_sz = sz * wcross_size; \
                if(wcross_blur > 0) \
                { \
                    for(i = -2; i <= 2; ++i) \
                    for(j = -2; j <= 2; ++j) \
                    M(i,j,sz,scaled_sz,wcross_name,wcross_alpha*0.04); \
                } \
                else \
                { \
                    M(0,0,sz,scaled_sz,wcross_name,wcross_alpha); \
                } \
            MACRO_END

CROSSHAIR_DRAW

#define CROSSHAIR_DRAW	(		sz,
			wcross_name,
			wcross_alpha
	)		CROSSHAIR_DO_BLUR(CROSSHAIR_DRAW_SINGLE,sz,wcross_name,wcross_alpha)

Referenced by HUD_Crosshair().

CROSSHAIR_DRAW_SINGLE

#define CROSSHAIR_DRAW_SINGLE	(		i,
			j,
			sz,
			scaled_sz,
			wcross_name,
			wcross_alpha
	)		drawpic(wcross_origin - ('0.5 0 0' * (scaled_sz.x + i * wcross_blur) + '0 0.5 0' * (scaled_sz.y + j * wcross_blur)), wcross_name, scaled_sz, wcross_color, wcross_alpha, DRAWFLAG_NORMAL)

Function Documentation

crosshair_getcolor()

vector crosshair_getcolor	(	entity	this,
		float	health_stat
	)

Definition at line 174 of file crosshair.qc.

References armorblockpercent, autocvar_crosshair_color, autocvar_crosshair_color_special, autocvar_crosshair_color_special_rainbow_brightness, autocvar_crosshair_color_special_rainbow_delay, floor(), hud, HUD_Get_Num_Color(), LABEL, randomvec(), stov(), time, v, and vector().

Referenced by HUD_Crosshair(), and Vehicles_drawCrosshair().

{
    static float rainbow_last_flicker;
    static vector rainbow_prev_color;
    vector wcross_color = '0 0 0';
    switch(autocvar_crosshair_color_special)
    {
        case 1: // weapon color
        {
            if(this != WEP_Null && hud == HUD_NORMAL)
            {
                wcross_color = this.wpcolor;
                break;
            }
            else { goto normalcolor; }
        }

        case 2: // color based on health and armor
        {
            vector v = healtharmor_maxdamage(health_stat, STAT(ARMOR), armorblockpercent, DEATH_WEAPON.m_id);
            float health_and_armor = floor(v.x + 1);
            wcross_color = HUD_Get_Num_Color(health_and_armor, 200, false);
            break;
        }

        case 3: // rainbow/random color
        {
            if(time >= rainbow_last_flicker)
            {
                rainbow_prev_color = randomvec() * autocvar_crosshair_color_special_rainbow_brightness;
                rainbow_last_flicker = time + autocvar_crosshair_color_special_rainbow_delay;
            }
            wcross_color = rainbow_prev_color;
            break;
        }
LABEL(normalcolor)
        default: { wcross_color = stov(autocvar_crosshair_color); break; }
    }

    return wcross_color;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DrawReticle()

void DrawReticle

(

entity

this

)

Definition at line 678 of file crosshair.qc.

References autocvar_cl_reticle, autocvar_cl_reticle_normal_alpha, autocvar_cl_reticle_stretch, autocvar_cl_reticle_weapon, autocvar_cl_reticle_weapon_alpha, button_zoom, current_zoomfraction, DRAWFLAG_NORMAL, drawpic(), DrawReticle(), entity(), hud, max(), MAX_WEAPONSLOTS, MUTATOR_CALLHOOK, NULL, reticle_type, spectatee_status, string_null, vector(), vid_conheight, vid_conwidth, viewloc, viewmodels, Weapon::w_reticle, and zoomscript_caught.

Referenced by CSQC_UpdateView(), and DrawReticle().

{
    if(!autocvar_cl_reticle || MUTATOR_CALLHOOK(DrawReticle))
    {
        reticle_type = 0;
        return;
    }

    float is_dead = (STAT(HEALTH) <= 0);
    string reticle_image = string_null;
    bool wep_zoomed = false;
    for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
    {
        entity wepe = viewmodels[slot];
        Weapon wep = wepe.activeweapon;
        if(wep != WEP_Null && wep.wr_zoom)
        {
            bool do_zoom = wep.wr_zoom(wep, NULL);
            if(!reticle_image && wep.w_reticle && wep.w_reticle != "")
                reticle_image = wep.w_reticle;
            wep_zoomed += do_zoom;
        }
    }
    // Draw the aiming reticle for weapons that use it
    // reticle_type is changed to the item we are zooming / aiming with, to decide which reticle to use
    // It must be a persisted float for fading out to work properly (you let go of the zoom button for
    // the view to go back to normal, so reticle_type would become 0 as we fade out)
    if(spectatee_status || is_dead || hud != HUD_NORMAL || this.viewloc)
    {
        // no zoom reticle while dead
        reticle_type = 0;
    }
    else if(wep_zoomed && autocvar_cl_reticle_weapon)
    {
        if(reticle_image) { reticle_type = 2; }
        else { reticle_type = 0; }
    }
    else if(button_zoom || zoomscript_caught)
    {
        // normal zoom
        reticle_type = 1;
    }

    if(reticle_type)
    {
        vector reticle_pos = '0 0 0', reticle_size = '0 0 0';
        if(autocvar_cl_reticle_stretch)
        {
            reticle_size.x = vid_conwidth;
            reticle_size.y = vid_conheight;
            reticle_pos.x = 0;
            reticle_pos.y = 0;
        }
        else
        {
            reticle_size.x = max(vid_conwidth, vid_conheight);
            reticle_size.y = max(vid_conwidth, vid_conheight);
            reticle_pos.x = (vid_conwidth - reticle_size.x) / 2;
            reticle_pos.y = (vid_conheight - reticle_size.y) / 2;
        }

        float f = (zoomscript_caught) ? 1 : current_zoomfraction;

        if(f)
        {
            switch(reticle_type)
            {
                case 1: drawpic(reticle_pos, "gfx/reticle_normal", reticle_size, '1 1 1', f * autocvar_cl_reticle_normal_alpha, DRAWFLAG_NORMAL); break;
                case 2: if(reticle_image) drawpic(reticle_pos, reticle_image, reticle_size, '1 1 1', f * autocvar_cl_reticle_weapon_alpha, DRAWFLAG_NORMAL); break;
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

EnemyHitCheck()

float EnemyHitCheck

(

)

Definition at line 52 of file crosshair.qc.

References maxclients, NUM_SPECTATOR, project_3d_to_2d(), SHOTTYPE_HITENEMY, SHOTTYPE_HITTEAM, SHOTTYPE_HITWORLD, teamplay, trace_endpos, trace_ent, trace_networkentity, and wcross_origin.

Referenced by TrueAimCheck().

{
    float t, n;
    wcross_origin = project_3d_to_2d(trace_endpos);
    wcross_origin.z = 0;
    if(trace_ent)
        n = trace_ent.entnum;
    else
        n = trace_networkentity;
    if(n < 1)
        return SHOTTYPE_HITWORLD;
    if(n > maxclients)
        return SHOTTYPE_HITWORLD;
    t = entcs_GetTeam(n - 1);
    if(teamplay)
        if(t == myteam)
            return SHOTTYPE_HITTEAM;
    if(t == NUM_SPECTATOR)
        return SHOTTYPE_HITWORLD;
    return SHOTTYPE_HITENEMY;
}

Here is the call graph for this function:

Here is the caller graph for this function:

HUD_Crosshair()

void HUD_Crosshair

(

entity

this

)

Definition at line 226 of file crosshair.qc.

References autocvar__menu_alpha, autocvar_chase_active, autocvar_chase_front, autocvar_cl_lockview, autocvar_crosshair, autocvar_crosshair_2d, autocvar_crosshair_alpha, autocvar_crosshair_chase, autocvar_crosshair_chase_playeralpha, autocvar_crosshair_color_special, autocvar_crosshair_dot, autocvar_crosshair_dot_alpha, autocvar_crosshair_dot_color, autocvar_crosshair_dot_color_custom, autocvar_crosshair_dot_size, autocvar_crosshair_effect_scalefade, autocvar_crosshair_effect_time, autocvar_crosshair_enabled, autocvar_crosshair_hitindication, autocvar_crosshair_hitindication_color, autocvar_crosshair_hitindication_per_weapon_color, autocvar_crosshair_hitindication_speed, autocvar_crosshair_hittest, autocvar_crosshair_hittest_blur_teammate, autocvar_crosshair_hittest_blur_wall, autocvar_crosshair_hittest_showimpact, autocvar_crosshair_per_weapon, autocvar_crosshair_pickup, autocvar_crosshair_pickup_speed, autocvar_crosshair_ring, autocvar_crosshair_ring_arc, autocvar_crosshair_ring_arc_cold_alpha, autocvar_crosshair_ring_arc_hot_alpha, autocvar_crosshair_ring_arc_hot_color, autocvar_crosshair_ring_hagar, autocvar_crosshair_ring_hagar_alpha, autocvar_crosshair_ring_inner, autocvar_crosshair_ring_minelayer, autocvar_crosshair_ring_minelayer_alpha, autocvar_crosshair_ring_reload, autocvar_crosshair_ring_reload_alpha, autocvar_crosshair_ring_reload_size, autocvar_crosshair_ring_size, autocvar_crosshair_ring_vortex, autocvar_crosshair_ring_vortex_alpha, autocvar_crosshair_ring_vortex_currentcharge_movingavg_rate, autocvar_crosshair_ring_vortex_currentcharge_scale, autocvar_crosshair_ring_vortex_inner_alpha, autocvar_crosshair_ring_vortex_inner_color_blue, autocvar_crosshair_ring_vortex_inner_color_green, autocvar_crosshair_ring_vortex_inner_color_red, autocvar_crosshair_size, bound(), camera_active, CROSSHAIR_DRAW, crosshair_getcolor(), csqcplayer, DrawCircleClippedPic(), DRAWFLAG_ADDITIVE, entity(), fabs(), frametime, hitindication_crosshair_size, hud, HUD_Crosshair_ApplyPlayerAlpha(), HUD_Crosshair_Vehicle(), HUD_MinigameMenu_IsOpened(), intermission, max(), min(), MOVE_NORMAL, MOVE_WORLDONLY, MUTATOR_CALLHOOK, NULL, pickup_crosshair_size, pickup_crosshair_time, pointinsidebox, project_3d_to_2d(), scoreboard_active, SHOTTYPE_HITOBSTRUCTION, SHOTTYPE_HITTEAM, SHOTTYPE_HITWORLD, sin(), spectatee_status, stov(), strcat(), strfree, string_null, strunzone(), strzone(), time, trace_endpos, trace_ent, TrueAimCheck(), unaccounted_damage, use_vortex_chargepool, v, vdist, vec3, vector(), vid_conheight, vid_conwidth, view_forward, view_origin, VIEWLOC_FREEAIM, viewloc_mousepos, viewmodels, vortex_charge_movingavg, WarpZone_TraceLine(), wcross_alpha_goal_prev, wcross_alpha_prev, wcross_changedonetime, wcross_color_goal_prev, wcross_color_prev, wcross_name_alpha_goal_prev, wcross_name_alpha_goal_prev_prev, wcross_name_changedonetime, wcross_name_changestarttime, wcross_name_goal_prev, wcross_name_goal_prev_prev, wcross_origin, wcross_resolution_goal_prev, wcross_resolution_goal_prev_prev, wcross_ring_prev, wcross_scale_goal_prev, wcross_scale_prev, WEP_CVAR, and WEP_CVAR_SEC.

{
    // reset player's alpha here upon death since forced scoreboard prevents running the crosshair_chase code
    if(autocvar_chase_active > 0 && autocvar_crosshair_chase && STAT(HEALTH) <= 0 && csqcplayer)
        csqcplayer.alpha = csqcplayer.m_alpha;

    if (autocvar_chase_active > 0 && (autocvar_chase_front || autocvar_cl_lockview))
    {
        if (csqcplayer.alpha != csqcplayer.m_alpha)
            HUD_Crosshair_ApplyPlayerAlpha(csqcplayer.m_alpha);
        return;
    }

    float f, i, j;
    vector v;
    if(!scoreboard_active && !camera_active && intermission != 2 && !STAT(GAME_STOPPED) && !autocvar_cl_lockview
        && spectatee_status != -1 && (!csqcplayer.viewloc || (!spectatee_status && (csqcplayer.viewloc.spawnflags & VIEWLOC_FREEAIM))) && !MUTATOR_CALLHOOK(DrawCrosshair)
        && !HUD_MinigameMenu_IsOpened())
    {
        if (!autocvar_crosshair_enabled) // main toggle for crosshair rendering
            return;

        if (spectatee_status > 0 && STAT(CAMERA_SPECTATOR) == 2)
            return;

        if (hud != HUD_NORMAL)
        {
            HUD_Crosshair_Vehicle(this);
            return;
        }

        string wcross_style;
        float wcross_alpha, wcross_resolution;
        wcross_style = autocvar_crosshair;
        if (csqcplayer.viewloc && (csqcplayer.viewloc.spawnflags & VIEWLOC_FREEAIM) && autocvar_crosshair_2d != "")
            wcross_style = autocvar_crosshair_2d;
        if (wcross_style == "0")
            return;
        wcross_resolution = autocvar_crosshair_size;
        if (wcross_resolution == 0)
            return;
        wcross_alpha = autocvar_crosshair_alpha;
        if (wcross_alpha == 0)
            return;

        // TrueAim check
        float shottype;

        static int crosshair_chase_state = 0;

        // wcross_origin = '0.5 0 0' * vid_conwidth + '0 0.5 0' * vid_conheight;
        if(csqcplayer.viewloc && (csqcplayer.viewloc.spawnflags & VIEWLOC_FREEAIM))
            wcross_origin = viewloc_mousepos;
        else if(autocvar_chase_active > 0 && autocvar_crosshair_chase)
        {
            vector player_org = ((csqcplayer) ? csqcplayer.origin + csqcplayer.view_ofs : view_origin);
            float my_alpha = (!csqcplayer.m_alpha) ? 1 : csqcplayer.m_alpha;
            float chase_playeralpha = bound(0.001, autocvar_crosshair_chase_playeralpha, 1);
            if(csqcplayer && chase_playeralpha < 1 && my_alpha > chase_playeralpha)
            {
                crosshair_chase_state = 2;
                bool hit = false;
                if (pointinsidebox(view_origin, csqcplayer.absmin, csqcplayer.absmax))
                    hit = true;
                else
                {
                    WarpZone_TraceLine(view_origin, view_origin + max_shot_distance * view_forward, MOVE_NORMAL, NULL);
                    if(trace_ent == csqcplayer)
                        hit = true;
                }
                float prev_alpha = csqcplayer.alpha;
                float new_alpha;
                if(hit)
                    new_alpha = max(csqcplayer.alpha - frametime * 5, chase_playeralpha);
                else
                    new_alpha = min(csqcplayer.alpha + frametime * 5, my_alpha);

                if (new_alpha != prev_alpha)
                    HUD_Crosshair_ApplyPlayerAlpha(new_alpha);
            }
            traceline(player_org, player_org + max_shot_distance * view_forward, MOVE_WORLDONLY, NULL);
            wcross_origin = project_3d_to_2d(trace_endpos);
        }
        else
            wcross_origin = project_3d_to_2d(view_origin + max_shot_distance * view_forward);
        wcross_origin.z = 0;
        if (crosshair_chase_state == 2) // enabled (this frame)
            crosshair_chase_state = 1;
        else if (crosshair_chase_state == 1) // turned off in the previous frame
        {
            // reset player alpha only in this frame
            if (csqcplayer)
                HUD_Crosshair_ApplyPlayerAlpha(csqcplayer.m_alpha);
            crosshair_chase_state = 0; // turned off and alpha reset
        }

        if(autocvar_crosshair_hittest)
        {
            vector wcross_oldorigin;
            entity thiswep = viewmodels[0]; // TODO: unhardcode
            wcross_oldorigin = wcross_origin;
            shottype = TrueAimCheck(thiswep);
            if(shottype == SHOTTYPE_HITWORLD)
            {
                v = wcross_origin - wcross_oldorigin;
                v.x /= vid_conwidth;
                v.y /= vid_conheight;
                if(vdist(v, >, 0.01))
                    shottype = SHOTTYPE_HITOBSTRUCTION;
            }
            if(!autocvar_crosshair_hittest_showimpact)
                wcross_origin = wcross_oldorigin;
        }
        else
            shottype = SHOTTYPE_HITWORLD;

        vector wcross_color = '0 0 0', wcross_size = '0 0 0';
        string wcross_name = "";
        float wcross_scale, wcross_blur;

        entity e = WEP_Null;
        if(autocvar_crosshair_per_weapon || (autocvar_crosshair_color_special == 1))
        {
            entity wepent = viewmodels[0]; // TODO: unhardcode
            e = wepent.switchingweapon;
            if(e)
            {
                if(autocvar_crosshair_per_weapon)
                {
                    // WEAPONTODO: access these through some general settings (with non-balance config settings)
                    //wcross_resolution *= cvar(strcat("crosshair_", wcross_wep, "_size"));
                    //if (wcross_resolution == 0)
                        //return;

                    //wcross_style = cvar_string(strcat("crosshair_", wcross_wep));
                    wcross_resolution *= e.w_crosshair_size;
                    wcross_name = e.w_crosshair;
                }
            }
        }

        if(wcross_name == "")
            wcross_name = strcat("gfx/crosshair", wcross_style);

        // MAIN CROSSHAIR COLOR DECISION
        wcross_color = crosshair_getcolor(e, STAT(HEALTH));

        if(autocvar_crosshair_effect_scalefade)
        {
            wcross_scale = wcross_resolution;
            wcross_resolution = 1;
        }
        else
        {
            wcross_scale = 1;
        }

        if(autocvar_crosshair_pickup)
        {
            float stat_pickup_time = STAT(LAST_PICKUP);

            if(pickup_crosshair_time < stat_pickup_time)
            {
                if(time - stat_pickup_time < 5) // don't trigger the animation if it's too old
                    pickup_crosshair_size = 1;

                pickup_crosshair_time = stat_pickup_time;
            }

            if(pickup_crosshair_size > 0)
                pickup_crosshair_size -= autocvar_crosshair_pickup_speed * frametime;
            else
                pickup_crosshair_size = 0;

            wcross_scale += sin(pickup_crosshair_size) * autocvar_crosshair_pickup;
        }

        // todo: make crosshair hit indication dependent on damage dealt
        if(autocvar_crosshair_hitindication)
        {
            vector col = ((autocvar_crosshair_color_special == 1) ? stov(autocvar_crosshair_hitindication_per_weapon_color) : stov(autocvar_crosshair_hitindication_color));

            if(unaccounted_damage)
            {
                hitindication_crosshair_size = 1;
            }

            if(hitindication_crosshair_size > 0)
                hitindication_crosshair_size -= autocvar_crosshair_hitindication_speed * frametime;
            else
                hitindication_crosshair_size = 0;

            wcross_scale += sin(hitindication_crosshair_size) * autocvar_crosshair_hitindication;
            wcross_color.x += sin(hitindication_crosshair_size) * col.x;
            wcross_color.y += sin(hitindication_crosshair_size) * col.y;
            wcross_color.z += sin(hitindication_crosshair_size) * col.z;
        }

        // no effects needed for targeting enemies, this can't possibly span all valid targets!
        // just show for teammates to give a sign that they're an invalid target
        //if(shottype == SHOTTYPE_HITENEMY)
            //wcross_scale *= autocvar_crosshair_hittest; // is not queried if hittest is 0
        if(shottype == SHOTTYPE_HITTEAM)
            wcross_scale /= autocvar_crosshair_hittest; // is not queried if hittest is 0

        f = fabs(autocvar_crosshair_effect_time);
        if(wcross_scale != wcross_scale_goal_prev || wcross_alpha != wcross_alpha_goal_prev || wcross_color != wcross_color_goal_prev)
        {
            wcross_changedonetime = time + f;
        }
        if(wcross_name != wcross_name_goal_prev || wcross_resolution != wcross_resolution_goal_prev)
        {
            wcross_name_changestarttime = time;
            wcross_name_changedonetime = time + f;
            if(wcross_name_goal_prev_prev)
                strunzone(wcross_name_goal_prev_prev);
            wcross_name_goal_prev_prev = wcross_name_goal_prev;
            wcross_name_goal_prev = strzone(wcross_name);
            wcross_name_alpha_goal_prev_prev = wcross_name_alpha_goal_prev;
            wcross_resolution_goal_prev_prev = wcross_resolution_goal_prev;
            wcross_resolution_goal_prev = wcross_resolution;
        }

        wcross_scale_goal_prev = wcross_scale;
        wcross_alpha_goal_prev = wcross_alpha;
        wcross_color_goal_prev = wcross_color;

        if((shottype == SHOTTYPE_HITTEAM && autocvar_crosshair_hittest_blur_teammate)
            || (shottype == SHOTTYPE_HITOBSTRUCTION && autocvar_crosshair_hittest_blur_wall && !autocvar_chase_active))
        {
            wcross_blur = 1;
            wcross_alpha *= 0.75;
        }
        else
            wcross_blur = 0;
        // *_prev is at time-frametime
        // * is at wcross_changedonetime+f
        // what do we have at time?
        if(time < wcross_changedonetime)
        {
            f = frametime / (wcross_changedonetime - time + frametime);
            wcross_scale = f * wcross_scale + (1 - f) * wcross_scale_prev;
            wcross_alpha = f * wcross_alpha + (1 - f) * wcross_alpha_prev;
            wcross_color = f * wcross_color + (1 - f) * wcross_color_prev;
        }

        wcross_scale_prev = wcross_scale;
        wcross_alpha_prev = wcross_alpha;
        wcross_color_prev = wcross_color;

        MUTATOR_CALLHOOK(UpdateCrosshair);

        wcross_scale *= 1 - autocvar__menu_alpha;
        wcross_alpha *= 1 - autocvar__menu_alpha;
        wcross_size = draw_getimagesize(wcross_name) * wcross_scale;

        if(wcross_scale >= 0.001 && wcross_alpha >= 0.001)
        {
            // crosshair rings for weapon stats
            if (autocvar_crosshair_ring || autocvar_crosshair_ring_reload)
            {
                // declarations and stats
                float ring_value = 0, ring_scale = 0, ring_alpha = 0, ring_inner_value = 0, ring_inner_alpha = 0;
                string ring_image = string_null, ring_inner_image = string_null;
                vector ring_rgb = '0 0 0', ring_inner_rgb = '0 0 0';

                ring_scale = autocvar_crosshair_ring_size;

                entity wepent = viewmodels[0]; // TODO: unhardcode

                int weapon_clipload = wepent.clip_load;
                int weapon_clipsize = wepent.clip_size;

                float arc_heat = wepent.arc_heat_percent;

                if(vortex_charge_movingavg == 0) // this should only happen if we have just loaded up the game
                    vortex_charge_movingavg = wepent.vortex_charge;

                float charge = 0;
                float chargepool = 0;
                bool ring_vortex_enabled = false;
                if (autocvar_crosshair_ring && autocvar_crosshair_ring_vortex)
                {
                    if (wepent.activeweapon == WEP_VORTEX)
                    {
                        charge = wepent.vortex_charge;
                        chargepool = wepent.vortex_chargepool_ammo;
                    }
                    else if (wepent.activeweapon == WEP_OVERKILL_NEX)
                    {
                        charge = wepent.oknex_charge;
                        chargepool = wepent.oknex_chargepool_ammo;
                    }
                    if (charge)
                        ring_vortex_enabled = true;
                }

                if (ring_vortex_enabled)
                {
                    if (chargepool || use_vortex_chargepool) {
                        use_vortex_chargepool = 1;
                        ring_inner_value = chargepool;
                    } else {
                        float rate = autocvar_crosshair_ring_vortex_currentcharge_movingavg_rate;
                        vortex_charge_movingavg = (1 - rate) * vortex_charge_movingavg + rate * charge;
                        ring_inner_value = bound(0, autocvar_crosshair_ring_vortex_currentcharge_scale * (charge - vortex_charge_movingavg), 1);
                    }

                    ring_inner_alpha = autocvar_crosshair_ring_vortex_inner_alpha;
                    ring_inner_rgb = vec3(autocvar_crosshair_ring_vortex_inner_color_red, autocvar_crosshair_ring_vortex_inner_color_green, autocvar_crosshair_ring_vortex_inner_color_blue);
                    ring_inner_image = "gfx/crosshair_ring_inner";

                    // draw the outer ring to show the current charge of the weapon
                    ring_value = charge;
                    ring_alpha = autocvar_crosshair_ring_vortex_alpha;
                    ring_rgb = wcross_color;
                    ring_image = "gfx/crosshair_ring_nexgun";
                }
                else if (autocvar_crosshair_ring && wepent.activeweapon == WEP_MINE_LAYER && WEP_CVAR(minelayer, limit) && autocvar_crosshair_ring_minelayer)
                {
                    ring_value = bound(0, wepent.minelayer_mines / WEP_CVAR(minelayer, limit), 1);
                    ring_alpha = autocvar_crosshair_ring_minelayer_alpha;
                    ring_rgb = wcross_color;
                    ring_image = "gfx/crosshair_ring";
                }
                else if (wepent.activeweapon == WEP_HAGAR && wepent.hagar_load && autocvar_crosshair_ring_hagar)
                {
                    ring_value = bound(0, wepent.hagar_load / WEP_CVAR_SEC(hagar, load_max), 1);
                    ring_alpha = autocvar_crosshair_ring_hagar_alpha;
                    ring_rgb = wcross_color;
                    ring_image = "gfx/crosshair_ring";
                }
                else if(autocvar_crosshair_ring_reload && weapon_clipsize) // forces there to be only an ammo ring
                {
                    ring_value = bound(0, weapon_clipload / weapon_clipsize, 1);
                    ring_scale = autocvar_crosshair_ring_reload_size;
                    ring_alpha = autocvar_crosshair_ring_reload_alpha;
                    ring_rgb = wcross_color;

                    // Note: This is to stop Taoki from complaining that the image doesn't match all potential balances.
                    // if a new image for another weapon is added, add the code (and its respective file/value) here
                    if ((wepent.activeweapon == WEP_RIFLE) && (weapon_clipsize == 80))
                        ring_image = "gfx/crosshair_ring_rifle";
                    else
                        ring_image = "gfx/crosshair_ring";
                }
                else if ( autocvar_crosshair_ring && autocvar_crosshair_ring_arc && arc_heat && wepent.activeweapon == WEP_ARC )
                {
                    ring_value = arc_heat;
                    ring_alpha = (1-arc_heat)*autocvar_crosshair_ring_arc_cold_alpha +
                        arc_heat*autocvar_crosshair_ring_arc_hot_alpha;
                    ring_rgb = (1-arc_heat)*wcross_color + arc_heat*autocvar_crosshair_ring_arc_hot_color;
                    ring_image = "gfx/crosshair_ring";
                }

                // if in weapon switch animation, fade ring out/in
                if(autocvar_crosshair_effect_time > 0)
                {
                    f = (time - wcross_name_changestarttime) / autocvar_crosshair_effect_time;
                    if (f >= 1)
                    {
                        wcross_ring_prev = ((ring_image) ? true : false);
                    }

                    if(wcross_ring_prev)
                    {
                        if(f < 1)
                            ring_alpha *= fabs(1 - bound(0, f, 1));
                    }
                    else
                    {
                        if(f < 1)
                            ring_alpha *= bound(0, f, 1);
                    }
                }

                if (autocvar_crosshair_ring_inner && ring_inner_value) // lets draw a ring inside a ring so you can ring while you ring
                    DrawCircleClippedPic(wcross_origin, wcross_size.x * wcross_resolution * ring_scale, ring_inner_image, ring_inner_value, ring_inner_rgb, wcross_alpha * ring_inner_alpha, DRAWFLAG_ADDITIVE);

                if (ring_value)
                    DrawCircleClippedPic(wcross_origin, wcross_size.x * wcross_resolution * ring_scale, ring_image, ring_value, ring_rgb, wcross_alpha * ring_alpha, DRAWFLAG_ADDITIVE);
            }

#define CROSSHAIR_DO_BLUR(M,sz,wcross_name,wcross_alpha) \
            MACRO_BEGIN \
                vector scaled_sz = sz * wcross_size; \
                if(wcross_blur > 0) \
                { \
                    for(i = -2; i <= 2; ++i) \
                    for(j = -2; j <= 2; ++j) \
                    M(i,j,sz,scaled_sz,wcross_name,wcross_alpha*0.04); \
                } \
                else \
                { \
                    M(0,0,sz,scaled_sz,wcross_name,wcross_alpha); \
                } \
            MACRO_END

#define CROSSHAIR_DRAW_SINGLE(i,j,sz,scaled_sz,wcross_name,wcross_alpha) \
            drawpic(wcross_origin - ('0.5 0 0' * (scaled_sz.x + i * wcross_blur) + '0 0.5 0' * (scaled_sz.y + j * wcross_blur)), wcross_name, scaled_sz, wcross_color, wcross_alpha, DRAWFLAG_NORMAL)

#define CROSSHAIR_DRAW(sz,wcross_name,wcross_alpha) \
            CROSSHAIR_DO_BLUR(CROSSHAIR_DRAW_SINGLE,sz,wcross_name,wcross_alpha)

            if(time < wcross_name_changedonetime && wcross_name != wcross_name_goal_prev_prev && wcross_name_goal_prev_prev)
            {
                f = (wcross_name_changedonetime - time) / (wcross_name_changedonetime - wcross_name_changestarttime);
                wcross_size = draw_getimagesize(wcross_name_goal_prev_prev) * wcross_scale;
                CROSSHAIR_DRAW(wcross_resolution_goal_prev_prev, wcross_name_goal_prev_prev, wcross_alpha * f * wcross_name_alpha_goal_prev_prev);
                f = 1 - f;
            }
            else
            {
                f = 1;
            }
            wcross_name_alpha_goal_prev = f;

            wcross_size = draw_getimagesize(wcross_name) * wcross_scale;
            CROSSHAIR_DRAW(wcross_resolution, wcross_name, wcross_alpha * f);

            if(autocvar_crosshair_dot)
            {
                vector wcross_color_old;
                wcross_color_old = wcross_color;

                if((autocvar_crosshair_dot_color_custom) && (autocvar_crosshair_dot_color != "0"))
                    wcross_color = stov(autocvar_crosshair_dot_color);

                CROSSHAIR_DRAW(wcross_resolution * autocvar_crosshair_dot_size, "gfx/crosshairdot", f * autocvar_crosshair_dot_alpha);
                // FIXME why don't we use wcross_alpha here?
                wcross_color = wcross_color_old;
            }
        }
    }
    else
    {
        wcross_scale_prev = 0;
        wcross_alpha_prev = 0;
        wcross_scale_goal_prev = 0;
        wcross_alpha_goal_prev = 0;
        wcross_changedonetime = 0;
        strfree(wcross_name_goal_prev);
        strfree(wcross_name_goal_prev_prev);
        wcross_name_changestarttime = 0;
        wcross_name_changedonetime = 0;
        wcross_name_alpha_goal_prev = 0;
        wcross_name_alpha_goal_prev_prev = 0;
        wcross_resolution_goal_prev = 0;
        wcross_resolution_goal_prev_prev = 0;
    }
}

Here is the call graph for this function:

HUD_Crosshair_ApplyPlayerAlpha()

void HUD_Crosshair_ApplyPlayerAlpha

(

float

new_alpha

)

Definition at line 217 of file crosshair.qc.

References csqcplayer, and FOREACH_ENTITY_CLASS.

Referenced by HUD_Crosshair().

{
    csqcplayer.alpha = new_alpha;
    FOREACH_ENTITY_CLASS("ENT_CLIENT_MODEL", it.tag_entity == csqcplayer,
    {
        it.alpha = new_alpha;
    });
}

Here is the caller graph for this function:

HUD_Crosshair_Vehicle()

void HUD_Crosshair_Vehicle

(

entity

this

)

Definition at line 165 of file crosshair.qc.

References hud, and REGISTRY_GET.

Referenced by HUD_Crosshair().

{
    if(hud != HUD_BUMBLEBEE_GUN)
    {
        Vehicle info = REGISTRY_GET(Vehicles, hud);
        info.vr_crosshair(info, this);
    }
}

Here is the caller graph for this function:

TrueAim_Init()

void TrueAim_Init

(

)

Definition at line 46 of file crosshair.qc.

References DPCONTENTS_BODY, DPCONTENTS_CORPSE, DPCONTENTS_SOLID, dphitcontentsmask, new_pure, trueaim, and trueaim_rifle.

Referenced by PostInit().

{
    (trueaim = new_pure(trueaim)).dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_CORPSE;
    (trueaim_rifle = new_pure(trueaim_rifle)).dphitcontentsmask = DPCONTENTS_BODY | DPCONTENTS_CORPSE;
}

Here is the caller graph for this function:

TrueAimCheck()

float TrueAimCheck

(

entity

wepent

)

Definition at line 74 of file crosshair.qc.

References decompressShotOrigin(), EnemyHitCheck(), entity(), eZ, g_trueaim_minrange, MOVE_NOMONSTERS, MOVE_NORMAL, player_localentnum, SHOTTYPE_HITOBSTRUCTION, SHOTTYPE_HITWORLD, trace_endpos, trueaim, trueaim_rifle, vdist, vector(), view_forward, view_origin, view_right, view_up, vlen(), w_shotorg, WEP_FLAG_NOTRUEAIM, and zoomscript_caught.

Referenced by HUD_Crosshair().

{
    if(wepent.activeweapon.spawnflags & WEP_FLAG_NOTRUEAIM)
        return SHOTTYPE_HITWORLD;

    float nudge = 1; // added to traceline target and subtracted from result TOOD(divVerent): do we still need this? Doesn't the engine do this now for us?
    vector vecs, trueaimpoint, w_shotorg;
    vector mi, ma, dv;
    float shottype;
    entity ta;
    float mv;

    mi = ma = '0 0 0';
    ta = trueaim;
    mv = MOVE_NOMONSTERS;

    switch(wepent.activeweapon) // WEAPONTODO
    {
        case WEP_VORTEX:
        case WEP_OVERKILL_NEX:
        case WEP_VAPORIZER:
            mv = MOVE_NORMAL;
            break;
        case WEP_RIFLE:
            ta = trueaim_rifle;
            mv = MOVE_NORMAL;
            if(zoomscript_caught)
            {
                tracebox(view_origin, '0 0 0', '0 0 0', view_origin + view_forward * max_shot_distance, mv, ta);
                return EnemyHitCheck();
            }
            break;
        case WEP_DEVASTATOR: // projectile has a size!
            mi = '-3 -3 -3';
            ma = '3 3 3';
            break;
        case WEP_FIREBALL: // projectile has a size!
            mi = '-16 -16 -16';
            ma = '16 16 16';
            break;
        case WEP_SEEKER: // projectile has a size!
            mi = '-2 -2 -2';
            ma = '2 2 2';
            break;
        case WEP_ELECTRO: // projectile has a size!
            mi = '0 0 -3';
            ma = '0 0 -3';
            break;
    }

    vector traceorigin = entcs_receiver(player_localentnum - 1).origin + (eZ * STAT(VIEWHEIGHT));

    vecs = decompressShotOrigin(STAT(SHOTORG));

    traceline(traceorigin, traceorigin + view_forward * max_shot_distance, mv, ta);
    trueaimpoint = trace_endpos;
    // move trueaimpoint a little bit forward to make the final tracebox reliable
    // since it sometimes doesn't reach a teammate by a hair
    trueaimpoint += view_forward;

    if(vdist((trueaimpoint - traceorigin), <, g_trueaim_minrange))
        trueaimpoint = traceorigin + view_forward * g_trueaim_minrange;

    if(vecs.x > 0)
        vecs.y = -vecs.y;
    else
        vecs = '0 0 0';

    dv = view_right * vecs.y + view_up * vecs.z;
    w_shotorg = traceorigin + dv;

    // now move the vecs forward as much as requested if possible
    tracebox(w_shotorg, mi, ma, w_shotorg + view_forward * (vecs.x + nudge), MOVE_NORMAL, ta); // FIXME this MOVE_NORMAL part will misbehave a little in csqc
    w_shotorg = trace_endpos - view_forward * nudge;

    tracebox(w_shotorg, mi, ma, trueaimpoint, MOVE_NORMAL, ta);
    shottype = EnemyHitCheck();
    if(shottype != SHOTTYPE_HITWORLD)
        return shottype;

#if 0
    // FIXME WHY DOES THIS NOT WORK FOR THE ROCKET LAUNCHER?
    // or rather, I know why, but see no fix
    if(vlen(trace_endpos - trueaimpoint) > vlen(ma) + vlen(mi) + 1)
        // yes, this is an ugly hack... but it seems good enough to find out whether the test hits the same place as the initial trace
        return SHOTTYPE_HITOBSTRUCTION;
#endif

    return SHOTTYPE_HITWORLD;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

hitindication_crosshair_size

float hitindication_crosshair_size

Definition at line 19 of file crosshair.qc.

Referenced by HUD_Crosshair().

pickup_crosshair_size

float pickup_crosshair_size

Definition at line 18 of file crosshair.qc.

Referenced by HUD_Crosshair().

pickup_crosshair_time

float pickup_crosshair_time

Definition at line 18 of file crosshair.qc.

Referenced by HUD_Crosshair().

reticle_type

float reticle_type

Definition at line 22 of file crosshair.qc.

Referenced by DrawReticle().

SHOTTYPE_HITENEMY

const float SHOTTYPE_HITENEMY = 4

Definition at line 44 of file crosshair.qc.

Referenced by EnemyHitCheck().

SHOTTYPE_HITOBSTRUCTION

const float SHOTTYPE_HITOBSTRUCTION = 2

Definition at line 42 of file crosshair.qc.

Referenced by HUD_Crosshair(), and TrueAimCheck().

SHOTTYPE_HITTEAM

const float SHOTTYPE_HITTEAM = 1

Definition at line 41 of file crosshair.qc.

Referenced by EnemyHitCheck(), and HUD_Crosshair().

SHOTTYPE_HITWORLD

const float SHOTTYPE_HITWORLD = 3

Definition at line 43 of file crosshair.qc.

Referenced by EnemyHitCheck(), HUD_Crosshair(), and TrueAimCheck().

tag_entity

entity tag_entity

Definition at line 216 of file crosshair.qc.

trueaim

entity trueaim

Definition at line 38 of file crosshair.qc.

Referenced by TrueAim_Init(), and TrueAimCheck().

trueaim_rifle

entity trueaim_rifle

Definition at line 39 of file crosshair.qc.

Referenced by TrueAim_Init(), and TrueAimCheck().

use_vortex_chargepool

float use_vortex_chargepool

Definition at line 20 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_alpha_goal_prev

float wcross_alpha_goal_prev

Definition at line 27 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_alpha_prev

float wcross_alpha_prev

Definition at line 25 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_changedonetime

float wcross_changedonetime

Definition at line 29 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_color_goal_prev

vector wcross_color_goal_prev

Definition at line 28 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_color_prev

vector wcross_color_prev

Definition at line 26 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_name_alpha_goal_prev

float wcross_name_alpha_goal_prev

Definition at line 34 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_name_alpha_goal_prev_prev

float wcross_name_alpha_goal_prev_prev

Definition at line 34 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_name_changedonetime

float wcross_name_changedonetime

Definition at line 33 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_name_changestarttime

float wcross_name_changestarttime

Definition at line 33 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_name_goal_prev

string wcross_name_goal_prev

Definition at line 31 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_name_goal_prev_prev

string wcross_name_goal_prev_prev

Definition at line 31 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_origin

vector wcross_origin

Definition at line 24 of file crosshair.qc.

Referenced by EnemyHitCheck(), and HUD_Crosshair().

wcross_resolution_goal_prev

float wcross_resolution_goal_prev

Definition at line 32 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_resolution_goal_prev_prev

float wcross_resolution_goal_prev_prev

Definition at line 32 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_ring_prev

float wcross_ring_prev

Definition at line 36 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_scale_goal_prev

float wcross_scale_goal_prev

Definition at line 27 of file crosshair.qc.

Referenced by HUD_Crosshair().

wcross_scale_prev

float wcross_scale_prev

Definition at line 25 of file crosshair.qc.

Referenced by HUD_Crosshair().