qcsrc/client/hud/crosshair.qc

   1 #include "crosshair.qh"
   2
   3 #include <client/draw.qh>
   4 #include <client/hud/panel/scoreboard.qh>
   5 #include <client/view.qh>
   6 #include <common/deathtypes/all.qh>
   7 #include <common/ent_cs.qh>
   8 #include <common/mapobjects/trigger/viewloc.qh>
   9 #include <common/minigames/cl_minigames.qh>
  10 #include <common/minigames/cl_minigames_hud.qh>
  11 #include <common/mutators/mutator/overkill/oknex.qh>
  12 #include <common/vehicles/all.qh>
  13 #include <common/viewloc.qh>
  14 #include <common/wepent.qh>
  15 #include <lib/csqcmodel/cl_player.qh>
  16 #include <lib/warpzone/common.qh>
  17
  18 float pickup_crosshair_time, pickup_crosshair_size;
  19 float hitindication_crosshair_size;
  20 float use_vortex_chargepool;
  21
  22 float reticle_type;
  23
  24 vector wcross_origin;
  25 float wcross_scale_prev, wcross_alpha_prev;
  26 vector wcross_color_prev;
  27 float wcross_scale_goal_prev, wcross_alpha_goal_prev;
  28 vector wcross_color_goal_prev;
  29 float wcross_changedonetime;
  30
  31 string wcross_name_goal_prev, wcross_name_goal_prev_prev;
  32 float wcross_resolution_goal_prev, wcross_resolution_goal_prev_prev;
  33 float wcross_name_changestarttime, wcross_name_changedonetime;
  34 float wcross_name_alpha_goal_prev, wcross_name_alpha_goal_prev_prev;
  35
  36 float wcross_ring_prev;
  37
  38 entity trueaim;
  39 entity trueaim_rifle;
  40
  41 const float SHOTTYPE_HITTEAM = 1;
  42 const float SHOTTYPE_HITOBSTRUCTION = 2;
  43 const float SHOTTYPE_HITWORLD = 3;
  44 const float SHOTTYPE_HITENEMY = 4;
  45
  46 void TrueAim_Init()
  47 {
  48         (trueaim = new_pure(trueaim)).dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_CORPSE;
  49         (trueaim_rifle = new_pure(trueaim_rifle)).dphitcontentsmask = DPCONTENTS_BODY | DPCONTENTS_CORPSE;
  50 }
  51
  52 float EnemyHitCheck()
  53 {
  54         float t, n;
  55         wcross_origin = project_3d_to_2d(trace_endpos);
  56         wcross_origin.z = 0;
  57         if(trace_ent)
  58                 n = trace_ent.entnum;
  59         else
  60                 n = trace_networkentity;
  61         if(n < 1)
  62                 return SHOTTYPE_HITWORLD;
  63         if(n > maxclients)
  64                 return SHOTTYPE_HITWORLD;
  65         t = entcs_GetTeam(n - 1);
  66         if(teamplay)
  67                 if(t == myteam)
  68                         return SHOTTYPE_HITTEAM;
  69         if(t == NUM_SPECTATOR)
  70                 return SHOTTYPE_HITWORLD;
  71         return SHOTTYPE_HITENEMY;
  72 }
  73
  74 float TrueAimCheck(entity wepent)
  75 {
  76         if(wepent.activeweapon.spawnflags & WEP_FLAG_NOTRUEAIM)
  77                 return SHOTTYPE_HITWORLD;
  78
  79         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?
  80         vector vecs, trueaimpoint, w_shotorg;
  81         vector mi, ma, dv;
  82         float shottype;
  83         entity ta;
  84         float mv;
  85
  86         mi = ma = '0 0 0';
  87         ta = trueaim;
  88         mv = MOVE_NOMONSTERS;
  89
  90         switch(wepent.activeweapon) // WEAPONTODO
  91         {
  92                 case WEP_VORTEX:
  93                 case WEP_OVERKILL_NEX:
  94                 case WEP_VAPORIZER:
  95                         mv = MOVE_NORMAL;
  96                         break;
  97                 case WEP_RIFLE:
  98                         ta = trueaim_rifle;
  99                         mv = MOVE_NORMAL;
 100                         if(zoomscript_caught)
 101                         {
 102                                 tracebox(view_origin, '0 0 0', '0 0 0', view_origin + view_forward * max_shot_distance, mv, ta);
 103                                 return EnemyHitCheck();
 104                         }
 105                         break;
 106                 case WEP_DEVASTATOR: // projectile has a size!
 107                         mi = '-3 -3 -3';
 108                         ma = '3 3 3';
 109                         break;
 110                 case WEP_FIREBALL: // projectile has a size!
 111                         mi = '-16 -16 -16';
 112                         ma = '16 16 16';
 113                         break;
 114                 case WEP_SEEKER: // projectile has a size!
 115                         mi = '-2 -2 -2';
 116                         ma = '2 2 2';
 117                         break;
 118                 case WEP_ELECTRO: // projectile has a size!
 119                         mi = '0 0 -3';
 120                         ma = '0 0 -3';
 121                         break;
 122         }
 123
 124         vector traceorigin = entcs_receiver(player_localentnum - 1).origin + (eZ * STAT(VIEWHEIGHT));
 125
 126         vecs = decompressShotOrigin(STAT(SHOTORG));
 127
 128         traceline(traceorigin, traceorigin + view_forward * max_shot_distance, mv, ta);
 129         trueaimpoint = trace_endpos;
 130         // move trueaimpoint a little bit forward to make the final tracebox reliable
 131         // since it sometimes doesn't reach a teammate by a hair
 132         trueaimpoint += view_forward;
 133
 134         if(vdist((trueaimpoint - traceorigin), <, g_trueaim_minrange))
 135                 trueaimpoint = traceorigin + view_forward * g_trueaim_minrange;
 136
 137         if(vecs.x > 0)
 138                 vecs.y = -vecs.y;
 139         else
 140                 vecs = '0 0 0';
 141
 142         dv = view_right * vecs.y + view_up * vecs.z;
 143         w_shotorg = traceorigin + dv;
 144
 145         // now move the vecs forward as much as requested if possible
 146         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
 147         w_shotorg = trace_endpos - view_forward * nudge;
 148
 149         tracebox(w_shotorg, mi, ma, trueaimpoint, MOVE_NORMAL, ta);
 150         shottype = EnemyHitCheck();
 151         if(shottype != SHOTTYPE_HITWORLD)
 152                 return shottype;
 153
 154 #if 0
 155         // FIXME WHY DOES THIS NOT WORK FOR THE ROCKET LAUNCHER?
 156         // or rather, I know why, but see no fix
 157         if(vlen(trace_endpos - trueaimpoint) > vlen(ma) + vlen(mi) + 1)
 158                 // 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
 159                 return SHOTTYPE_HITOBSTRUCTION;
 160 #endif
 161
 162         return SHOTTYPE_HITWORLD;
 163 }
 164
 165 void HUD_Crosshair_Vehicle(entity this)
 166 {
 167         if(hud != HUD_BUMBLEBEE_GUN)
 168         {
 169                 Vehicle info = REGISTRY_GET(Vehicles, hud);
 170                 info.vr_crosshair(info, this);
 171         }
 172 }
 173
 174 vector crosshair_getcolor(entity this, float health_stat)
 175 {
 176         static float rainbow_last_flicker;
 177         static vector rainbow_prev_color;
 178         vector wcross_color = '0 0 0';
 179         switch(autocvar_crosshair_color_special)
 180         {
 181                 case 1: // weapon color
 182                 {
 183                         if(this != WEP_Null && hud == HUD_NORMAL)
 184                         {
 185                                 wcross_color = this.wpcolor;
 186                                 break;
 187                         }
 188                         else { goto normalcolor; }
 189                 }
 190
 191                 case 2: // color based on health and armor
 192                 {
 193                         vector v = healtharmor_maxdamage(health_stat, STAT(ARMOR), armorblockpercent, DEATH_WEAPON.m_id);
 194                         float health_and_armor = floor(v.x + 1);
 195                         wcross_color = HUD_Get_Num_Color(health_and_armor, 200, false);
 196                         break;
 197                 }
 198
 199                 case 3: // rainbow/random color
 200                 {
 201                         if(time >= rainbow_last_flicker)
 202                         {
 203                                 rainbow_prev_color = randomvec() * autocvar_crosshair_color_special_rainbow_brightness;
 204                                 rainbow_last_flicker = time + autocvar_crosshair_color_special_rainbow_delay;
 205                         }
 206                         wcross_color = rainbow_prev_color;
 207                         break;
 208                 }
 209 LABEL(normalcolor)
 210                 default: { wcross_color = stov(autocvar_crosshair_color); break; }
 211         }
 212
 213         return wcross_color;
 214 }
 215
 216 .entity tag_entity;
 217 void HUD_Crosshair_ApplyPlayerAlpha(float new_alpha)
 218 {
 219         csqcplayer.alpha = new_alpha;
 220         FOREACH_ENTITY_CLASS("ENT_CLIENT_MODEL", it.tag_entity == csqcplayer,
 221         {
 222                 it.alpha = new_alpha;
 223         });
 224 }
 225
 226 void HUD_Crosshair(entity this)
 227 {
 228         // reset player's alpha here upon death since forced scoreboard prevents running the crosshair_chase code
 229         if(autocvar_chase_active > 0 && autocvar_crosshair_chase && STAT(HEALTH) <= 0 && csqcplayer)
 230                 csqcplayer.alpha = csqcplayer.m_alpha;
 231
 232         if (autocvar_chase_active > 0 && (autocvar_chase_front || autocvar_cl_lockview))
 233         {
 234                 if (csqcplayer.alpha != csqcplayer.m_alpha)
 235                         HUD_Crosshair_ApplyPlayerAlpha(csqcplayer.m_alpha);
 236                 return;
 237         }
 238
 239         float f, i, j;
 240         vector v;
 241         if(!scoreboard_active && !camera_active && intermission != 2 && !STAT(GAME_STOPPED) && !autocvar_cl_lockview
 242                 && spectatee_status != -1 && (!csqcplayer.viewloc || (!spectatee_status && (csqcplayer.viewloc.spawnflags & VIEWLOC_FREEAIM))) && !MUTATOR_CALLHOOK(DrawCrosshair)
 243                 && !HUD_MinigameMenu_IsOpened())
 244         {
 245                 if (!autocvar_crosshair_enabled) // main toggle for crosshair rendering
 246                         return;
 247
 248                 if (spectatee_status > 0 && STAT(CAMERA_SPECTATOR) == 2)
 249                         return;
 250
 251                 if (hud != HUD_NORMAL)
 252                 {
 253                         HUD_Crosshair_Vehicle(this);
 254                         return;
 255                 }
 256
 257                 string wcross_style;
 258                 float wcross_alpha, wcross_resolution;
 259                 wcross_style = autocvar_crosshair;
 260                 if (csqcplayer.viewloc && (csqcplayer.viewloc.spawnflags & VIEWLOC_FREEAIM) && autocvar_crosshair_2d != "")
 261                         wcross_style = autocvar_crosshair_2d;
 262                 if (wcross_style == "0")
 263                         return;
 264                 wcross_resolution = autocvar_crosshair_size;
 265                 if (wcross_resolution == 0)
 266                         return;
 267                 wcross_alpha = autocvar_crosshair_alpha;
 268                 if (wcross_alpha == 0)
 269                         return;
 270
 271                 // TrueAim check
 272                 float shottype;
 273
 274                 static int crosshair_chase_state = 0;
 275
 276                 // wcross_origin = '0.5 0 0' * vid_conwidth + '0 0.5 0' * vid_conheight;
 277                 if(csqcplayer.viewloc && (csqcplayer.viewloc.spawnflags & VIEWLOC_FREEAIM))
 278                         wcross_origin = viewloc_mousepos;
 279                 else if(autocvar_chase_active > 0 && autocvar_crosshair_chase)
 280                 {
 281                         vector player_org = ((csqcplayer) ? csqcplayer.origin + csqcplayer.view_ofs : view_origin);
 282                         float my_alpha = (!csqcplayer.m_alpha) ? 1 : csqcplayer.m_alpha;
 283                         float chase_playeralpha = bound(0.001, autocvar_crosshair_chase_playeralpha, 1);
 284                         if(csqcplayer && chase_playeralpha < 1 && my_alpha > chase_playeralpha)
 285                         {
 286                                 crosshair_chase_state = 2;
 287                                 bool hit = false;
 288                                 if (pointinsidebox(view_origin, csqcplayer.absmin, csqcplayer.absmax))
 289                                         hit = true;
 290                                 else
 291                                 {
 292                                         WarpZone_TraceLine(view_origin, view_origin + max_shot_distance * view_forward, MOVE_NORMAL, NULL);
 293                                         if(trace_ent == csqcplayer)
 294                                                 hit = true;
 295                                 }
 296                                 float prev_alpha = csqcplayer.alpha;
 297                                 float new_alpha;
 298                                 if(hit)
 299                                         new_alpha = max(csqcplayer.alpha - frametime * 5, chase_playeralpha);
 300                                 else
 301                                         new_alpha = min(csqcplayer.alpha + frametime * 5, my_alpha);
 302
 303                                 if (new_alpha != prev_alpha)
 304                                         HUD_Crosshair_ApplyPlayerAlpha(new_alpha);
 305                         }
 306                         traceline(player_org, player_org + max_shot_distance * view_forward, MOVE_WORLDONLY, NULL);
 307                         wcross_origin = project_3d_to_2d(trace_endpos);
 308                 }
 309                 else
 310                         wcross_origin = project_3d_to_2d(view_origin + max_shot_distance * view_forward);
 311                 wcross_origin.z = 0;
 312                 if (crosshair_chase_state == 2) // enabled (this frame)
 313                         crosshair_chase_state = 1;
 314                 else if (crosshair_chase_state == 1) // turned off in the previous frame
 315                 {
 316                         // reset player alpha only in this frame
 317                         if (csqcplayer)
 318                                 HUD_Crosshair_ApplyPlayerAlpha(csqcplayer.m_alpha);
 319                         crosshair_chase_state = 0; // turned off and alpha reset
 320                 }
 321
 322                 if(autocvar_crosshair_hittest)
 323                 {
 324                         vector wcross_oldorigin;
 325                         entity thiswep = viewmodels[0]; // TODO: unhardcode
 326                         wcross_oldorigin = wcross_origin;
 327                         shottype = TrueAimCheck(thiswep);
 328                         if(shottype == SHOTTYPE_HITWORLD)
 329                         {
 330                                 v = wcross_origin - wcross_oldorigin;
 331                                 v.x /= vid_conwidth;
 332                                 v.y /= vid_conheight;
 333                                 if(vdist(v, >, 0.01))
 334                                         shottype = SHOTTYPE_HITOBSTRUCTION;
 335                         }
 336                         if(!autocvar_crosshair_hittest_showimpact)
 337                                 wcross_origin = wcross_oldorigin;
 338                 }
 339                 else
 340                         shottype = SHOTTYPE_HITWORLD;
 341
 342                 vector wcross_color = '0 0 0', wcross_size = '0 0 0';
 343                 string wcross_name = "";
 344                 float wcross_scale, wcross_blur;
 345
 346                 entity e = WEP_Null;
 347                 if(autocvar_crosshair_per_weapon || (autocvar_crosshair_color_special == 1))
 348                 {
 349                         entity wepent = viewmodels[0]; // TODO: unhardcode
 350                         e = wepent.switchingweapon;
 351                         if(e)
 352                         {
 353                                 if(autocvar_crosshair_per_weapon)
 354                                 {
 355                                         // WEAPONTODO: access these through some general settings (with non-balance config settings)
 356                                         //wcross_resolution *= cvar(strcat("crosshair_", wcross_wep, "_size"));
 357                                         //if (wcross_resolution == 0)
 358                                                 //return;
 359
 360                                         //wcross_style = cvar_string(strcat("crosshair_", wcross_wep));
 361                                         wcross_resolution *= e.w_crosshair_size;
 362                                         wcross_name = e.w_crosshair;
 363                                 }
 364                         }
 365                 }
 366
 367                 if(wcross_name == "")
 368                         wcross_name = strcat("gfx/crosshair", wcross_style);
 369
 370                 // MAIN CROSSHAIR COLOR DECISION
 371                 wcross_color = crosshair_getcolor(e, STAT(HEALTH));
 372
 373                 if(autocvar_crosshair_effect_scalefade)
 374                 {
 375                         wcross_scale = wcross_resolution;
 376                         wcross_resolution = 1;
 377                 }
 378                 else
 379                 {
 380                         wcross_scale = 1;
 381                 }
 382
 383                 if(autocvar_crosshair_pickup)
 384                 {
 385                         float stat_pickup_time = STAT(LAST_PICKUP);
 386
 387                         if(pickup_crosshair_time < stat_pickup_time)
 388                         {
 389                                 if(time - stat_pickup_time < 5) // don't trigger the animation if it's too old
 390                                         pickup_crosshair_size = 1;
 391
 392                                 pickup_crosshair_time = stat_pickup_time;
 393                         }
 394
 395                         if(pickup_crosshair_size > 0)
 396                                 pickup_crosshair_size -= autocvar_crosshair_pickup_speed * frametime;
 397                         else
 398                                 pickup_crosshair_size = 0;
 399
 400                         wcross_scale += sin(pickup_crosshair_size) * autocvar_crosshair_pickup;
 401                 }
 402
 403                 // todo: make crosshair hit indication dependent on damage dealt
 404                 if(autocvar_crosshair_hitindication)
 405                 {
 406                         vector col = ((autocvar_crosshair_color_special == 1) ? stov(autocvar_crosshair_hitindication_per_weapon_color) : stov(autocvar_crosshair_hitindication_color));
 407
 408                         if(unaccounted_damage)
 409                         {
 410                                 hitindication_crosshair_size = 1;
 411                         }
 412
 413                         if(hitindication_crosshair_size > 0)
 414                                 hitindication_crosshair_size -= autocvar_crosshair_hitindication_speed * frametime;
 415                         else
 416                                 hitindication_crosshair_size = 0;
 417
 418                         wcross_scale += sin(hitindication_crosshair_size) * autocvar_crosshair_hitindication;
 419                         wcross_color.x += sin(hitindication_crosshair_size) * col.x;
 420                         wcross_color.y += sin(hitindication_crosshair_size) * col.y;
 421                         wcross_color.z += sin(hitindication_crosshair_size) * col.z;
 422                 }
 423
 424                 // no effects needed for targeting enemies, this can't possibly span all valid targets!
 425                 // just show for teammates to give a sign that they're an invalid target
 426                 //if(shottype == SHOTTYPE_HITENEMY)
 427                         //wcross_scale *= autocvar_crosshair_hittest; // is not queried if hittest is 0
 428                 if(shottype == SHOTTYPE_HITTEAM)
 429                         wcross_scale /= autocvar_crosshair_hittest; // is not queried if hittest is 0
 430
 431                 f = fabs(autocvar_crosshair_effect_time);
 432                 if(wcross_scale != wcross_scale_goal_prev || wcross_alpha != wcross_alpha_goal_prev || wcross_color != wcross_color_goal_prev)
 433                 {
 434                         wcross_changedonetime = time + f;
 435                 }
 436                 if(wcross_name != wcross_name_goal_prev || wcross_resolution != wcross_resolution_goal_prev)
 437                 {
 438                         wcross_name_changestarttime = time;
 439                         wcross_name_changedonetime = time + f;
 440                         if(wcross_name_goal_prev_prev)
 441                                 strunzone(wcross_name_goal_prev_prev);
 442                         wcross_name_goal_prev_prev = wcross_name_goal_prev;
 443                         wcross_name_goal_prev = strzone(wcross_name);
 444                         wcross_name_alpha_goal_prev_prev = wcross_name_alpha_goal_prev;
 445                         wcross_resolution_goal_prev_prev = wcross_resolution_goal_prev;
 446                         wcross_resolution_goal_prev = wcross_resolution;
 447                 }
 448
 449                 wcross_scale_goal_prev = wcross_scale;
 450                 wcross_alpha_goal_prev = wcross_alpha;
 451                 wcross_color_goal_prev = wcross_color;
 452
 453                 if((shottype == SHOTTYPE_HITTEAM && autocvar_crosshair_hittest_blur_teammate)
 454                         || (shottype == SHOTTYPE_HITOBSTRUCTION && autocvar_crosshair_hittest_blur_wall && !autocvar_chase_active))
 455                 {
 456                         wcross_blur = 1;
 457                         wcross_alpha *= 0.75;
 458                 }
 459                 else
 460                         wcross_blur = 0;
 461                 // *_prev is at time-frametime
 462                 // * is at wcross_changedonetime+f
 463                 // what do we have at time?
 464                 if(time < wcross_changedonetime)
 465                 {
 466                         f = frametime / (wcross_changedonetime - time + frametime);
 467                         wcross_scale = f * wcross_scale + (1 - f) * wcross_scale_prev;
 468                         wcross_alpha = f * wcross_alpha + (1 - f) * wcross_alpha_prev;
 469                         wcross_color = f * wcross_color + (1 - f) * wcross_color_prev;
 470                 }
 471
 472                 wcross_scale_prev = wcross_scale;
 473                 wcross_alpha_prev = wcross_alpha;
 474                 wcross_color_prev = wcross_color;
 475
 476                 MUTATOR_CALLHOOK(UpdateCrosshair);
 477
 478                 wcross_scale *= 1 - autocvar__menu_alpha;
 479                 wcross_alpha *= 1 - autocvar__menu_alpha;
 480                 wcross_size = draw_getimagesize(wcross_name) * wcross_scale;
 481
 482                 if(wcross_scale >= 0.001 && wcross_alpha >= 0.001)
 483                 {
 484                         // crosshair rings for weapon stats
 485                         if (autocvar_crosshair_ring || autocvar_crosshair_ring_reload)
 486                         {
 487                                 // declarations and stats
 488                                 float ring_value = 0, ring_scale = 0, ring_alpha = 0, ring_inner_value = 0, ring_inner_alpha = 0;
 489                                 string ring_image = string_null, ring_inner_image = string_null;
 490                                 vector ring_rgb = '0 0 0', ring_inner_rgb = '0 0 0';
 491
 492                                 ring_scale = autocvar_crosshair_ring_size;
 493
 494                                 entity wepent = viewmodels[0]; // TODO: unhardcode
 495
 496                                 int weapon_clipload = wepent.clip_load;
 497                                 int weapon_clipsize = wepent.clip_size;
 498
 499                                 float arc_heat = wepent.arc_heat_percent;
 500
 501                                 if(vortex_charge_movingavg == 0) // this should only happen if we have just loaded up the game
 502                                         vortex_charge_movingavg = wepent.vortex_charge;
 503
 504                                 float charge = 0;
 505                                 float chargepool = 0;
 506                                 bool ring_vortex_enabled = false;
 507                                 if (autocvar_crosshair_ring && autocvar_crosshair_ring_vortex)
 508                                 {
 509                                         if (wepent.activeweapon == WEP_VORTEX)
 510                                         {
 511                                                 charge = wepent.vortex_charge;
 512                                                 chargepool = wepent.vortex_chargepool_ammo;
 513                                         }
 514                                         else if (wepent.activeweapon == WEP_OVERKILL_NEX)
 515                                         {
 516                                                 charge = wepent.oknex_charge;
 517                                                 chargepool = wepent.oknex_chargepool_ammo;
 518                                         }
 519                                         if (charge)
 520                                                 ring_vortex_enabled = true;
 521                                 }
 522
 523                                 if (ring_vortex_enabled)
 524                                 {
 525                                         if (chargepool || use_vortex_chargepool) {
 526                                                 use_vortex_chargepool = 1;
 527                                                 ring_inner_value = chargepool;
 528                                         } else {
 529                                                 float rate = autocvar_crosshair_ring_vortex_currentcharge_movingavg_rate;
 530                                                 vortex_charge_movingavg = (1 - rate) * vortex_charge_movingavg + rate * charge;
 531                                                 ring_inner_value = bound(0, autocvar_crosshair_ring_vortex_currentcharge_scale * (charge - vortex_charge_movingavg), 1);
 532                                         }
 533
 534                                         ring_inner_alpha = autocvar_crosshair_ring_vortex_inner_alpha;
 535                                         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);
 536                                         ring_inner_image = "gfx/crosshair_ring_inner";
 537
 538                                         // draw the outer ring to show the current charge of the weapon
 539                                         ring_value = charge;
 540                                         ring_alpha = autocvar_crosshair_ring_vortex_alpha;
 541                                         ring_rgb = wcross_color;
 542                                         ring_image = "gfx/crosshair_ring_nexgun";
 543                                 }
 544                                 else if (autocvar_crosshair_ring && wepent.activeweapon == WEP_MINE_LAYER && WEP_CVAR(minelayer, limit) && autocvar_crosshair_ring_minelayer)
 545                                 {
 546                                         ring_value = bound(0, wepent.minelayer_mines / WEP_CVAR(minelayer, limit), 1);
 547                                         ring_alpha = autocvar_crosshair_ring_minelayer_alpha;
 548                                         ring_rgb = wcross_color;
 549                                         ring_image = "gfx/crosshair_ring";
 550                                 }
 551                                 else if (wepent.activeweapon == WEP_HAGAR && wepent.hagar_load && autocvar_crosshair_ring_hagar)
 552                                 {
 553                                         ring_value = bound(0, wepent.hagar_load / WEP_CVAR_SEC(hagar, load_max), 1);
 554                                         ring_alpha = autocvar_crosshair_ring_hagar_alpha;
 555                                         ring_rgb = wcross_color;
 556                                         ring_image = "gfx/crosshair_ring";
 557                                 }
 558                                 else if(autocvar_crosshair_ring_reload && weapon_clipsize) // forces there to be only an ammo ring
 559                                 {
 560                                         ring_value = bound(0, weapon_clipload / weapon_clipsize, 1);
 561                                         ring_scale = autocvar_crosshair_ring_reload_size;
 562                                         ring_alpha = autocvar_crosshair_ring_reload_alpha;
 563                                         ring_rgb = wcross_color;
 564
 565                                         // Note: This is to stop Taoki from complaining that the image doesn't match all potential balances.
 566                                         // if a new image for another weapon is added, add the code (and its respective file/value) here
 567                                         if ((wepent.activeweapon == WEP_RIFLE) && (weapon_clipsize == 80))
 568                                                 ring_image = "gfx/crosshair_ring_rifle";
 569                                         else
 570                                                 ring_image = "gfx/crosshair_ring";
 571                                 }
 572                                 else if ( autocvar_crosshair_ring && autocvar_crosshair_ring_arc && arc_heat && wepent.activeweapon == WEP_ARC )
 573                                 {
 574                                         ring_value = arc_heat;
 575                                         ring_alpha = (1-arc_heat)*autocvar_crosshair_ring_arc_cold_alpha +
 576                                                 arc_heat*autocvar_crosshair_ring_arc_hot_alpha;
 577                                         ring_rgb = (1-arc_heat)*wcross_color + arc_heat*autocvar_crosshair_ring_arc_hot_color;
 578                                         ring_image = "gfx/crosshair_ring";
 579                                 }
 580
 581                                 // if in weapon switch animation, fade ring out/in
 582                                 if(autocvar_crosshair_effect_time > 0)
 583                                 {
 584                                         f = (time - wcross_name_changestarttime) / autocvar_crosshair_effect_time;
 585                                         if (f >= 1)
 586                                         {
 587                                                 wcross_ring_prev = ((ring_image) ? true : false);
 588                                         }
 589
 590                                         if(wcross_ring_prev)
 591                                         {
 592                                                 if(f < 1)
 593                                                         ring_alpha *= fabs(1 - bound(0, f, 1));
 594                                         }
 595                                         else
 596                                         {
 597                                                 if(f < 1)
 598                                                         ring_alpha *= bound(0, f, 1);
 599                                         }
 600                                 }
 601
 602                                 if (autocvar_crosshair_ring_inner && ring_inner_value) // lets draw a ring inside a ring so you can ring while you ring
 603                                         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);
 604
 605                                 if (ring_value)
 606                                         DrawCircleClippedPic(wcross_origin, wcross_size.x * wcross_resolution * ring_scale, ring_image, ring_value, ring_rgb, wcross_alpha * ring_alpha, DRAWFLAG_ADDITIVE);
 607                         }
 608
 609 #define CROSSHAIR_DO_BLUR(M,sz,wcross_name,wcross_alpha) \
 610                         MACRO_BEGIN \
 611                                 vector scaled_sz = sz * wcross_size; \
 612                                 if(wcross_blur > 0) \
 613                                 { \
 614                                         for(i = -2; i <= 2; ++i) \
 615                                         for(j = -2; j <= 2; ++j) \
 616                                         M(i,j,sz,scaled_sz,wcross_name,wcross_alpha*0.04); \
 617                                 } \
 618                                 else \
 619                                 { \
 620                                         M(0,0,sz,scaled_sz,wcross_name,wcross_alpha); \
 621                                 } \
 622                         MACRO_END
 623
 624 #define CROSSHAIR_DRAW_SINGLE(i,j,sz,scaled_sz,wcross_name,wcross_alpha) \
 625                         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)
 626
 627 #define CROSSHAIR_DRAW(sz,wcross_name,wcross_alpha) \
 628                         CROSSHAIR_DO_BLUR(CROSSHAIR_DRAW_SINGLE,sz,wcross_name,wcross_alpha)
 629
 630                         if(time < wcross_name_changedonetime && wcross_name != wcross_name_goal_prev_prev && wcross_name_goal_prev_prev)
 631                         {
 632                                 f = (wcross_name_changedonetime - time) / (wcross_name_changedonetime - wcross_name_changestarttime);
 633                                 wcross_size = draw_getimagesize(wcross_name_goal_prev_prev) * wcross_scale;
 634                                 CROSSHAIR_DRAW(wcross_resolution_goal_prev_prev, wcross_name_goal_prev_prev, wcross_alpha * f * wcross_name_alpha_goal_prev_prev);
 635                                 f = 1 - f;
 636                         }
 637                         else
 638                         {
 639                                 f = 1;
 640                         }
 641                         wcross_name_alpha_goal_prev = f;
 642
 643                         wcross_size = draw_getimagesize(wcross_name) * wcross_scale;
 644                         CROSSHAIR_DRAW(wcross_resolution, wcross_name, wcross_alpha * f);
 645
 646                         if(autocvar_crosshair_dot)
 647                         {
 648                                 vector wcross_color_old;
 649                                 wcross_color_old = wcross_color;
 650
 651                                 if((autocvar_crosshair_dot_color_custom) && (autocvar_crosshair_dot_color != "0"))
 652                                         wcross_color = stov(autocvar_crosshair_dot_color);
 653
 654                                 CROSSHAIR_DRAW(wcross_resolution * autocvar_crosshair_dot_size, "gfx/crosshairdot", f * autocvar_crosshair_dot_alpha);
 655                                 // FIXME why don't we use wcross_alpha here?
 656                                 wcross_color = wcross_color_old;
 657                         }
 658                 }
 659         }
 660         else
 661         {
 662                 wcross_scale_prev = 0;
 663                 wcross_alpha_prev = 0;
 664                 wcross_scale_goal_prev = 0;
 665                 wcross_alpha_goal_prev = 0;
 666                 wcross_changedonetime = 0;
 667                 strfree(wcross_name_goal_prev);
 668                 strfree(wcross_name_goal_prev_prev);
 669                 wcross_name_changestarttime = 0;
 670                 wcross_name_changedonetime = 0;
 671                 wcross_name_alpha_goal_prev = 0;
 672                 wcross_name_alpha_goal_prev_prev = 0;
 673                 wcross_resolution_goal_prev = 0;
 674                 wcross_resolution_goal_prev_prev = 0;
 675         }
 676 }
 677
 678 void DrawReticle(entity this)
 679 {
 680         if(!autocvar_cl_reticle || MUTATOR_CALLHOOK(DrawReticle))
 681         {
 682                 reticle_type = 0;
 683                 return;
 684         }
 685
 686         float is_dead = (STAT(HEALTH) <= 0);
 687         string reticle_image = string_null;
 688         bool wep_zoomed = false;
 689         for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
 690         {
 691                 entity wepe = viewmodels[slot];
 692                 Weapon wep = wepe.activeweapon;
 693                 if(wep != WEP_Null && wep.wr_zoom)
 694                 {
 695                         bool do_zoom = wep.wr_zoom(wep, NULL);
 696                         if(!reticle_image && wep.w_reticle && wep.w_reticle != "")
 697                                 reticle_image = wep.w_reticle;
 698                         wep_zoomed += do_zoom;
 699                 }
 700         }
 701         // Draw the aiming reticle for weapons that use it
 702         // reticle_type is changed to the item we are zooming / aiming with, to decide which reticle to use
 703         // It must be a persisted float for fading out to work properly (you let go of the zoom button for
 704         // the view to go back to normal, so reticle_type would become 0 as we fade out)
 705         if(spectatee_status || is_dead || hud != HUD_NORMAL || this.viewloc)
 706         {
 707                 // no zoom reticle while dead
 708                 reticle_type = 0;
 709         }
 710         else if(wep_zoomed && autocvar_cl_reticle_weapon)
 711         {
 712                 if(reticle_image) { reticle_type = 2; }
 713                 else { reticle_type = 0; }
 714         }
 715         else if(button_zoom || zoomscript_caught)
 716         {
 717                 // normal zoom
 718                 reticle_type = 1;
 719         }
 720
 721         if(reticle_type)
 722         {
 723                 vector reticle_pos = '0 0 0', reticle_size = '0 0 0';
 724                 if(autocvar_cl_reticle_stretch)
 725                 {
 726                         reticle_size.x = vid_conwidth;
 727                         reticle_size.y = vid_conheight;
 728                         reticle_pos.x = 0;
 729                         reticle_pos.y = 0;
 730                 }
 731                 else
 732                 {
 733                         reticle_size.x = max(vid_conwidth, vid_conheight);
 734                         reticle_size.y = max(vid_conwidth, vid_conheight);
 735                         reticle_pos.x = (vid_conwidth - reticle_size.x) / 2;
 736                         reticle_pos.y = (vid_conheight - reticle_size.y) / 2;
 737                 }
 738
 739                 float f = (zoomscript_caught) ? 1 : current_zoomfraction;
 740
 741                 if(f)
 742                 {
 743                         switch(reticle_type)
 744                         {
 745                                 case 1: drawpic(reticle_pos, "gfx/reticle_normal", reticle_size, '1 1 1', f * autocvar_cl_reticle_normal_alpha, DRAWFLAG_NORMAL); break;
 746                                 case 2: if(reticle_image) drawpic(reticle_pos, reticle_image, reticle_size, '1 1 1', f * autocvar_cl_reticle_weapon_alpha, DRAWFLAG_NORMAL); break;
 747                         }
 748                 }
 749         }
 750 }