draw_core.qc File Reference

#include "draw_core.qh"
#include <client/draw.qh>

Include dependency graph for draw_core.qc:

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

Go to the source code of this file.

Functions
void	StrafeHUD_DrawAngleIndicator (float angle, vector line_size, float arrow_size, int num_dashes, bool has_top_arrow, bool has_bottom_arrow, vector color, float alpha, float hudangle)
void	StrafeHUD_DrawAngleIndicatorArrow (float size, float offset, vector line_size, vector color, float alpha, bool top)
void	StrafeHUD_DrawAngleIndicatorLine (vector size, float offset, int num_dashes, vector color, float alpha)
void	StrafeHUD_DrawDirectionIndicator (int direction, bool opposite_direction, bool fwd)
void	StrafeHUD_DrawStrafeMeter (float shiftangle, float wishangle, float absolute_bestangle, float absolute_prebestangle, float absolute_overturnangle, bool moving, float hudangle)

Function Documentation

StrafeHUD_DrawAngleIndicator()

void StrafeHUD_DrawAngleIndicator	(	float	angle,
		vector	line_size,
		float	arrow_size,
		int	num_dashes,
		bool	has_top_arrow,
		bool	has_bottom_arrow,
		vector	color,
		float	alpha,
		float	hudangle )

Definition at line 140 of file draw_core.qc.

{
    if (alpha <= 0)
        return;
 
    // bound to HUD area
    angle = bound(hudangle * -0.5, angle, hudangle * 0.5);
 
    float offset = StrafeHUD_AngleToOffset(angle, hudangle);
    offset = StrafeHUD_ProjectOffset(offset, hudangle, false);
 
    StrafeHUD_DrawAngleIndicatorLine(line_size, offset, num_dashes, color, alpha);
 
    if (has_top_arrow)
        StrafeHUD_DrawAngleIndicatorArrow(arrow_size, offset, line_size, color, alpha, true);
 
    if (has_bottom_arrow)
        StrafeHUD_DrawAngleIndicatorArrow(arrow_size, offset, line_size, color, alpha, false);
}

References alpha, angle, bound(), color, StrafeHUD_AngleToOffset(), StrafeHUD_DrawAngleIndicatorArrow(), StrafeHUD_DrawAngleIndicatorLine(), StrafeHUD_ProjectOffset(), and vector.

Referenced by HUD_StrafeHUD().

StrafeHUD_DrawAngleIndicatorArrow()

void StrafeHUD_DrawAngleIndicatorArrow	(	float	size,
		float	offset,
		vector	line_size,
		vector	color,
		float	alpha,
		bool	top )

Definition at line 184 of file draw_core.qc.

{
    if (size <= 0)
        return;
 
    if (top)
        StrafeHUD_DrawStrafeArrow(
            panel_pos + eY * ((panel_size.y - line_size.y) * 0.5) + eX * offset,
            size, color, alpha * panel_fg_alpha, true, line_size.x);
    else
        StrafeHUD_DrawStrafeArrow(
            panel_pos + eY * ((panel_size.y - line_size.y) * 0.5 + line_size.y) + eX * offset,
            size, color, alpha * panel_fg_alpha, false, line_size.x);
}

References alpha, color, eX, eY, panel_fg_alpha, panel_pos, panel_size, size, StrafeHUD_DrawStrafeArrow(), and vector.

Referenced by StrafeHUD_DrawAngleIndicator().

StrafeHUD_DrawAngleIndicatorLine()

void StrafeHUD_DrawAngleIndicatorLine	(	vector	size,
		float	offset,
		int	num_dashes,
		vector	color,
		float	alpha )

Definition at line 163 of file draw_core.qc.

{
    if (num_dashes <= 0 || size.x <= 0 || size.y <= 0)
        return;
 
    vector segment_size = size;
    segment_size.y = size.y / (bound(1, num_dashes, size.y) * 2 - 1);
 
    for (float i = 0; i < size.y; i += segment_size.y * 2)
    {
        // check if last iteration
        if (i + segment_size.y * 2 >= size.y)
            segment_size.y = size.y - i;
 
        drawfill(
            panel_pos - eY * ((size.y - panel_size.y) * 0.5 - i) + eX * (offset - segment_size.x * 0.5),
            segment_size, color, alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
    }
}

References alpha, bound(), color, drawfill, DRAWFLAG_NORMAL, eX, eY, panel_fg_alpha, panel_pos, panel_size, size, and vector.

Referenced by StrafeHUD_DrawAngleIndicator().

StrafeHUD_DrawDirectionIndicator()

void StrafeHUD_DrawDirectionIndicator	(	int	direction,
		bool	opposite_direction,
		bool	fwd )

Definition at line 200 of file draw_core.qc.

{
    vector direction_size_vertical;
    direction_size_vertical.x = max(panel_size.y * min(autocvar_hud_panel_strafehud_direction_width, 1), 1);
    direction_size_vertical.y = panel_size.y + direction_size_vertical.x * 2;
    direction_size_vertical.z = 0;
 
    vector direction_size_horizontal;
    direction_size_horizontal.x = panel_size.x * min(autocvar_hud_panel_strafehud_direction_length, 0.5);
    direction_size_horizontal.y = direction_size_vertical.x;
    direction_size_horizontal.z = 0;
 
    if (direction != STRAFEHUD_DIRECTION_NONE
        && direction_size_vertical.x > 0
        && autocvar_hud_panel_strafehud_direction_alpha > 0)
    {
        bool indicator_direction = direction == STRAFEHUD_DIRECTION_LEFT;
 
        // invert left/right when strafing backwards or when strafing towards the opposite side indicated by the direction variable
        // if both conditions are true then it's inverted twice hence not inverted at all
        if (!fwd != opposite_direction)
            indicator_direction = !indicator_direction;
 
        // draw the direction indicator caps at the sides of the hud
        // vertical line
        if (direction_size_vertical.y > 0)
            drawfill(
                panel_pos - eY * direction_size_horizontal.y + eX * (indicator_direction ? -direction_size_vertical.x : panel_size.x),
                direction_size_vertical, autocvar_hud_panel_strafehud_direction_color,
                autocvar_hud_panel_strafehud_direction_alpha * panel_fg_alpha,
                DRAWFLAG_NORMAL);
 
        // top horizontal line
        drawfill(
            panel_pos + eX * (indicator_direction ? 0 : panel_size.x - direction_size_horizontal.x) - eY * direction_size_horizontal.y,
            direction_size_horizontal, autocvar_hud_panel_strafehud_direction_color,
            autocvar_hud_panel_strafehud_direction_alpha * panel_fg_alpha,
            DRAWFLAG_NORMAL);
 
        // bottom horizontal line
        drawfill(
            panel_pos + eX * (indicator_direction ? 0 : panel_size.x - direction_size_horizontal.x) + eY * panel_size.y,
            direction_size_horizontal, autocvar_hud_panel_strafehud_direction_color,
            autocvar_hud_panel_strafehud_direction_alpha * panel_fg_alpha,
            DRAWFLAG_NORMAL);
    }
}

References autocvar_hud_panel_strafehud_direction_alpha, autocvar_hud_panel_strafehud_direction_color, autocvar_hud_panel_strafehud_direction_length, autocvar_hud_panel_strafehud_direction_width, drawfill, DRAWFLAG_NORMAL, eX, eY, max(), min(), panel_fg_alpha, panel_pos, panel_size, STRAFEHUD_DIRECTION_LEFT, STRAFEHUD_DIRECTION_NONE, and vector.

Referenced by HUD_StrafeHUD().

StrafeHUD_DrawStrafeMeter()

void StrafeHUD_DrawStrafeMeter	(	float	shiftangle,
		float	wishangle,
		float	absolute_bestangle,
		float	absolute_prebestangle,
		float	absolute_overturnangle,
		bool	moving,
		float	hudangle )

Definition at line 5 of file draw_core.qc.

{
    // the neutral zone fills the whole strafe bar
    if (!moving)
    {
        // draw neutral zone
        if (panel_size.x > 0 && panel_size.y > 0 && autocvar_hud_panel_strafehud_bar_neutral_alpha > 0)
        {
            switch (autocvar_hud_panel_strafehud_style)
            {
                default:
                case STRAFEHUD_STYLE_DRAWFILL:
                    drawfill(
                        panel_pos, panel_size,
                        autocvar_hud_panel_strafehud_bar_neutral_color,
                        autocvar_hud_panel_strafehud_bar_neutral_alpha * panel_fg_alpha,
                        DRAWFLAG_NORMAL);
                    break;
 
                case STRAFEHUD_STYLE_PROGRESSBAR:
                    HUD_Panel_DrawProgressBar(
                        panel_pos, panel_size, "progressbar", 1, 0, 0,
                        autocvar_hud_panel_strafehud_bar_neutral_color,
                        autocvar_hud_panel_strafehud_bar_neutral_alpha * panel_fg_alpha,
                        DRAWFLAG_NORMAL);
                    break;
            }
        }
    }
    else
    {
        // calculate various zones of the strafe-o-meter
        float accelzone_left_startangle;
        float accelzone_right_startangle;
        float preaccelzone_left_startangle;
        float preaccelzone_right_startangle;
        float neutral_startangle;
        float overturn_startangle;
 
        float accelzone_offsetangle = absolute_overturnangle - absolute_bestangle;
        float preaccelzone_offsetangle = fabs(absolute_bestangle - absolute_prebestangle);
        float neutral_offsetangle = 360;
        float overturn_offsetangle = 360 - absolute_overturnangle * 2;
 
        if (!autocvar_hud_panel_strafehud_bar_preaccel)
            preaccelzone_offsetangle = 0;
 
        // assign starting angles and shift the current offset for every element
        float current_startangle = 0;
 
        preaccelzone_right_startangle = current_startangle;
        current_startangle += preaccelzone_offsetangle;
 
        accelzone_right_startangle = current_startangle;
        current_startangle += accelzone_offsetangle;
 
        overturn_startangle = current_startangle;
        current_startangle += overturn_offsetangle;
 
        accelzone_left_startangle = current_startangle;
        current_startangle += accelzone_offsetangle;
 
        preaccelzone_left_startangle = current_startangle;
        current_startangle += preaccelzone_offsetangle;
 
        neutral_startangle = current_startangle;
        neutral_offsetangle = 360 - current_startangle;
 
        // calculate how far off-center the strafe zones currently are
        shiftangle += neutral_offsetangle * 0.5 - wishangle;
 
        // shift strafe zones into correct place
        neutral_startangle += shiftangle;
        accelzone_left_startangle += shiftangle;
        accelzone_right_startangle += shiftangle;
        preaccelzone_left_startangle += shiftangle;
        preaccelzone_right_startangle += shiftangle;
        overturn_startangle += shiftangle;
 
        // draw left acceleration zone
        if (accelzone_offsetangle > 0)
            StrafeHUD_DrawStrafeHUD(
                accelzone_left_startangle, accelzone_offsetangle,
                autocvar_hud_panel_strafehud_bar_accel_color,
                autocvar_hud_panel_strafehud_bar_accel_alpha * panel_fg_alpha,
                autocvar_hud_panel_strafehud_style, STRAFEHUD_GRADIENT_LEFT,
                hudangle);
        if (autocvar_hud_panel_strafehud_bar_preaccel && preaccelzone_offsetangle > 0)
            StrafeHUD_DrawStrafeHUD(
                preaccelzone_left_startangle, preaccelzone_offsetangle,
                autocvar_hud_panel_strafehud_bar_preaccel_color,
                autocvar_hud_panel_strafehud_bar_preaccel_alpha * panel_fg_alpha,
                autocvar_hud_panel_strafehud_style, STRAFEHUD_GRADIENT_RIGHT,
                hudangle);
 
        // draw right acceleration zone
        if (accelzone_offsetangle > 0)
            StrafeHUD_DrawStrafeHUD(
                accelzone_right_startangle, accelzone_offsetangle,
                autocvar_hud_panel_strafehud_bar_accel_color,
                autocvar_hud_panel_strafehud_bar_accel_alpha * panel_fg_alpha,
                autocvar_hud_panel_strafehud_style, STRAFEHUD_GRADIENT_RIGHT,
                hudangle);
        if (autocvar_hud_panel_strafehud_bar_preaccel && preaccelzone_offsetangle > 0)
            StrafeHUD_DrawStrafeHUD(
                preaccelzone_right_startangle, preaccelzone_offsetangle,
                autocvar_hud_panel_strafehud_bar_preaccel_color,
                autocvar_hud_panel_strafehud_bar_preaccel_alpha * panel_fg_alpha,
                autocvar_hud_panel_strafehud_style, STRAFEHUD_GRADIENT_LEFT,
                hudangle);
 
        // draw overturn zone
        if (overturn_offsetangle > 0)
            StrafeHUD_DrawStrafeHUD(
                overturn_startangle, overturn_offsetangle,
                autocvar_hud_panel_strafehud_bar_overturn_color,
                autocvar_hud_panel_strafehud_bar_overturn_alpha * panel_fg_alpha,
                autocvar_hud_panel_strafehud_style, STRAFEHUD_GRADIENT_BOTH,
                hudangle);
 
        // draw neutral zone
        if (neutral_offsetangle > 0)
            StrafeHUD_DrawStrafeHUD(
                neutral_startangle, neutral_offsetangle,
                autocvar_hud_panel_strafehud_bar_neutral_color,
                autocvar_hud_panel_strafehud_bar_neutral_alpha * panel_fg_alpha,
                autocvar_hud_panel_strafehud_style, STRAFEHUD_GRADIENT_NONE,
                hudangle);
    }
}

References autocvar_hud_panel_strafehud_bar_accel_alpha, autocvar_hud_panel_strafehud_bar_accel_color, autocvar_hud_panel_strafehud_bar_neutral_alpha, autocvar_hud_panel_strafehud_bar_neutral_color, autocvar_hud_panel_strafehud_bar_overturn_alpha, autocvar_hud_panel_strafehud_bar_overturn_color, autocvar_hud_panel_strafehud_bar_preaccel, autocvar_hud_panel_strafehud_bar_preaccel_alpha, autocvar_hud_panel_strafehud_bar_preaccel_color, autocvar_hud_panel_strafehud_style, drawfill, DRAWFLAG_NORMAL, fabs(), HUD_Panel_DrawProgressBar(), panel_fg_alpha, panel_pos, panel_size, StrafeHUD_DrawStrafeHUD(), STRAFEHUD_GRADIENT_BOTH, STRAFEHUD_GRADIENT_LEFT, STRAFEHUD_GRADIENT_NONE, STRAFEHUD_GRADIENT_RIGHT, STRAFEHUD_STYLE_DRAWFILL, and STRAFEHUD_STYLE_PROGRESSBAR.

Referenced by HUD_StrafeHUD().