PreciseCrosshair

override void WorldTick()
{
  if (!_isInitialized) { initialize(); }
  prepareProjection();
}

override void RenderOverlay(RenderEvent event)
{
  if (!_isInitialized || !_isPrepared) { return; }

  PlayerInfo player = players[consolePlayer];

  if (player == NULL) { return; }

  loadTarget(event.viewAngle, event.viewPitch);
  loadCrosshair(player);
  drawCrosshair(player, event);
}

private void initialize()
{
  PlayerInfo player = players[consolePlayer];

  _glProjection  = new("pc_GlScreen");
  _swProjection  = new("pc_SwScreen");
  _cvarRenderer  = Cvar.GetCvar("vid_rendermode", player);
  _settings      = new("pc_Settings").init(player);

  _yPositionInterpolator = DynamicValueInterpolator.Create(Screen.GetHeight() / 2,
                                                           0.5,
                                                           1,
                                                           1000000);

  _cvarCrosshairColorFull = Cvar.getCvar("crosshairColorFull", player);
  _cvarCrosshairColorMax  = Cvar.getCvar("crosshairColorMax", player);

  _isInitialized = true;
}

private void prepareProjection ()
{
  if(_cvarRenderer)
  {
    switch (_cvarRenderer.GetInt())
    {
    default:
      _projection = _glProjection;
      break;

    case 0:
    case 1:
      _projection = _swProjection;
      break;
    }
  }
  else
  {
    Console.printf("WARNING: cannot get render mode");
    _projection = _glProjection;
  }

  _isPrepared = (_projection != NULL);
}

private void loadTarget(double angle, double pitch) const
{
  PlayerInfo p = players[consolePlayer];
  PlayerPawn a = p.mo;
  pitch = a.AimTarget() ? a.BulletSlope(NULL, ALF_PORTALRESTRICT) : pitch;

  FLineTraceData data;
  double hitHeight = a.height / 2 + a.AttackZOffset * p.crouchFactor;
  _hasTargetPos    = a.LineTrace(angle, 4000.0, pitch, 0, hitHeight, 0, 0, data);
  if (_hasTargetPos)
  {
    _targetPos = data.hitlocation;
    _distToTarget = data.distance;
  }
}

private ui void drawCrosshair(PlayerInfo player, RenderEvent event)
{
  Vector2 drawPos = makeDrawPos(player, event);

  setExternalY(player, drawPos.y);

  if (  !_isCrossExisting
     || gamestate == GS_TITLELEVEL
     || player.mo.health <= 0
     || automapactive
     || !pc_enable
     || disabledOnSlot1(player)
     || disabledWhenNotReady(player)
     || disabledOnNoWeapon(player)
     || event.camera != player.mo
     || disabledOnNoTarget(player)
     )
  {
    return;
  }

  int screenWidth  = Screen.GetWidth();
  int screenHeight = Screen.GetHeight();

  int mult = max(screenHeight / 720, 1); // 1080p: 1, 1440p: 2, 4K: 3
  double size = ((crosshairscale > 0.0f) ? crosshairscale : 1.0) * mult;

  if (crosshairgrow) size *= StatusBar.crosshairSize;

  vector2 textureSize = TexMan.getScaledSize(_crosshairTexture) * size;
  double width  = round(textureSize.x);
  double height = round(textureSize.y);

  if (_settings.isScaledByDistance())
  {
    double distFac = GetDistanceScale(0, 512);
    width *= distFac;
    height *= distFac;
  }

  let [hasHealth, health] = getHealths(player);

  bool isNewColorFormula = _settings.isNewColorFormula();
  int crossColor = !hasHealth
    ? crosshaircolor
    : isNewColorFormula
      ? makeNewCrosshairColor(health)
      : makeOldCrosshairColor(health);

  _yPositionInterpolator.Update(int(drawPos.y));

  Screen.DrawTexture( _crosshairTexture
                    , false
                    , screenWidth / 2
                    , _yPositionInterpolator.GetValue()
                    , DTA_DestWidthF    , width
                    , DTA_DestHeightF   , height
                    , DTA_AlphaChannel , true
                    , DTA_KeepRatio    , true
                    , DTA_FillColor    , crossColor & 0xFFFFFF
                    , DTA_FlipX        , _settings.isFlipX()
                    , DTA_FlipY        , _settings.isFlipY()
                    );
}

// Returns noHealth flag, current health (scaled to 0-100).
private ui bool, int getHealths(PlayerInfo player)
{
  if (!_settings.isTargetHealth())
    return true, scale(player.health, 100, getDefaultHealth(player));

  let aimTarget = getAimTarget(player.mo);
  if (aimTarget)
    return true, scale(aimTarget.health, 100, aimTarget.getSpawnHealth());
  else
    return false, 0;
}

private ui static int scale(int value, int scaleMax, int valueMax)
{
  return value * scaleMax / valueMax;
}

private play Actor getAimTarget(Actor a) const
{
  return a.AimTarget();
}

// Color functions are adapted from UZDoom/src/utility/colorspace.cpp

private ui Color makeNewCrosshairColor(int health)
{
  if (crosshairhealth == 0) return crosshaircolor;
  if (crosshairhealth == 3) return 0xffffff;
  if (_cvarCrosshairColorFull == NULL || _cvarCrosshairColorMax == NULL)
    return makeOldCrosshairColor(health);

  int health = clamp(health, 0, (crosshairhealth == 1) ? 100 : 200);

  int hi = _cvarCrosshairColorFull.getInt();
  int lo = crosshaircolor;
  double mix = 1.0;

  if (health > 100)
  {
    lo = hi;
    hi = _cvarCrosshairColorMax.getInt();
    mix = (health - 100) / 100.0;
  }
  else if (health <= 85)
  {
    mix = health / 85.0;
  }

  let c = mixColor(lo, hi, mix);

  return Color(c.r, c.g, c.b);
}

private static ui Color mixColor(Color a, Color b, double mix)
{
  if (mix <= 0) return a;
  if (mix >= 1) return b;

  let [al, ac, ah] = rgbToOklch(a);
  let [bl, bc, bh] = rgbToOklch(b);

  double l = lerp(al, bl, mix);
  double c = lerp(ac, bc, mix);
  double h = alerp(ah, bh, mix);

  return oklchToRgb(l, c, h);
}

private static ui double, double, double rgbToOklch(Color a)
{
  let [l, a, b] = rgbToOklab(a);
  let [c, h] = oklabToOklch(a, b);
  return l, c, h;
}

private static ui double, double, double rgbToOklab(Color a)
{
  double r = linear(a.r / 255.0);
  double g = linear(a.g / 255.0);
  double b = linear(a.b / 255.0);
  double l = (0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b) ** (1.0 / 3);
  double m = (0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b) ** (1.0 / 3);
  double s = (0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b) ** (1.0 / 3);

  return
    (l * +0.2104542553 + m * +0.7936177850 + s * -0.0040720468),
    (l * +1.9779984951 + m * -2.4285922050 + s * +0.4505937099),
    (l * +0.0259040371 + m * +0.7827717662 + s * -0.8086757660);
}

private static ui double linear(double c)
{
  return (c >= 0.04045)
    ? (((c + 0.055) / 1.055) ** 2.4)
    : (c / 12.92);
}

private static ui double, double oklabToOklch(double a, double b)
{
  double c = sqrt(a * a + b * b);

  if (c < 0.0001)
    return c, double.NAN;

  double h = atan2(b, a);

  if (h >= 0)
    return c, h;

  return c, h + 360;
}

private static ui Color oklchToRgb(double l, double c, double h)
{
  let [a, b] = oklchToOklab(c, h);
  return oklabToRgb(l, a, b);
}

private static ui double, double oklchToOklab(double c, double h)
{
  double a = (h == double.NAN) ? 0 : c * cos(h);
  double b = (h == double.NAN) ? 0 : c * sin(h);
  return a, b;
}

private static ui Color oklabToRgb(double l, double a, double b)
{
  double l2 = (L + a * +0.3963377774 + b * +0.2158037573) ** 3;
  double m  = (L + a * -0.1055613458 + b * -0.0638541728) ** 3;
  double s  = (L + a * -0.0894841775 + b * -1.2914855480) ** 3;

  double r = gamma(l2 * +4.0767416621 + m * -3.3077115913 + s * +0.2309699292);
  double g = gamma(l2 * -1.2684380046 + m * +2.6097574011 + s * -0.3413193965);
  double b = gamma(l2 * -0.0041960863 + m * -0.7034186147 + s * +1.7076147010);

  return Color(int(255 * r), int(255 * g), int(255 * b));
}

private static ui double gamma(double c)
{
  return clamp(((c >= 0.0031308) ? (1.055 * (c ** (1 / 2.4)) - 0.055) : (12.92 * c)),
               0.0,
               1.0);
}

private static ui double lerp(double a, double b, double t)
{
  // Naive, good enough.
  return a + t * (b - a);
}

private static ui double alerp(double a, double b, double t)
{
  double delta = (b - a) % 360;
  if (delta > 180) delta -= 360;
  if (delta < -180) delta += 360;
  return (a + delta * t + 360) % 360;
}

private static ui Color makeOldCrosshairColor(int health)
{
  if (crosshairhealth == 1)
  {
    // "Standard" crosshair health (green-red)
    if (health >= 85)
    {
      return 0x00ff00;
    }
    else
    {
      int red;
      int green;

      health -= 25;
      if (health <  0) { health = 0; }
      if (health < 30)
      {
        red   = 255;
        green = health * 255 / 30;
      }
      else
      {
        red   = (60 - health) * 255 / 30;
        green = 255;
      }
      return Color(red, green, 0);
    }
  }
  else if (crosshairhealth == 2)
  {
    // "Enhanced" crosshair health (blue-green-yellow-red)
    int health = clamp(health, 0, 200);
    double rr;
    double gg;
    double bb;

    double saturation = health < 150 ? 1.0 : 1.0 - (health - 150) / 100.0;

    HSVtoRGB(rr, gg, bb, health * 1.2f, saturation, 1);
    int red   = int(rr * 255);
    int green = int(gg * 255);
    int blue  = int(bb * 255);

    return Color(red, green, blue);
  }

  return crosshaircolor;
}

private ui Vector2 makeDrawPos(PlayerInfo player, RenderEvent event)
{
  if (!_hasTargetPos)
  {
    int x, y, width, height;
    [x, y, width, height] = Screen.GetViewWindow();
    int screenHeight      = Screen.GetHeight();
    int statusBarHeight   = screenHeight - height - x;
    return (Screen.GetWidth() / 2, (Screen.GetHeight() - statusBarHeight) / 2);
  }

  _projection.CacheResolution();
  _projection.CacheFov(player.fov);
  _projection.OrientForRenderOverlay(event);
  _projection.BeginProjection();

  _projection.ProjectWorldPos(_targetPos);

  pc_Viewport viewport;
  viewport.FromHud();

  Vector2 drawPos = viewport.SceneToWindow(_projection.ProjectToNormal());

  return drawPos;
}

private ui void loadCrosshair(PlayerInfo player)
{
  int num = 0;

  if (!crosshairforce
     && NULL != player.camera
     && NULL != player.camera.player
     && NULL != player.camera.player.readyWeapon)
  {
    num = player.camera.player.readyWeapon.crosshair;
  }
  if (num == 0)
  {
    num = crosshair;
  }
  if (_crosshairnum == num && _isCrossExisting)
  {
    return;
  }

  if (num <= 0)
  {
    _crosshairNum    = 0;
    _isCrossExisting = false;
    return;
  }
  string size = (Screen.GetWidth() < 640) ? "S" : "B";

  string texName = String.Format("XHAIR%s%d", size, num);
  TextureID texId = checkTexture(texName);
  if (!texId.isValid())
  {
    texName = String.Format("XHAIR%s1", size);
    texId = checkTexture(texName);
    if (!texId.isValid())
    {
      texId = checkTexture("XHAIRS1");
    }
  }

  _crosshairNum     = num;
  _crosshairTexture = texId;
  _isCrossExisting  = true;
}

private ui TextureId checkTexture(string name)
{
  return TexMan.checkForTexture(name,
                                TexMan.Type_MiscPatch,
                                TexMan.TryAny | TexMan.ShortNameOnly);
}

private play void setExternalY(PlayerInfo player, double y) const
{
  if (_externalY == NULL)
    _externalY = Cvar.GetCVar("pc_y", player);

  _externalY.SetFloat(y);
}

private play void setExternalScale (PlayerInfo player, double scale) const
{
  if (_externalScale == NULL)
    _externalScale = Cvar.GetCVar("pc_scale", player);

  _externalScale.SetFloat(scale);
}

private ui static int getDefaultHealth(PlayerInfo player)
{
  class<PlayerPawn> type = player.mo.GetClassName();
  let default = GetDefaultByType(type);
  return default.health;
}

private play bool disabledOnSlot1(PlayerInfo player) const
{
  return _settings.isDisabledOnSlot1() && isSlot1(player);
}

private play bool disabledWhenNotReady(PlayerInfo player) const
{
  return _settings.isDisabledOnNotReady() && !isWeaponReady(player);
}

private play bool disabledOnNoWeapon(PlayerInfo player) const
{
  return _settings.isDisabledOnNoWeapon() && isNoWeapon(player);
}

private play bool disabledOnNoTarget(PlayerInfo player) const
{
  return _settings.isDisabledOnNoTarget() && (getAimTarget(player.mo) == NULL);
}

private static bool isSlot1(PlayerInfo player)
{
  Weapon w = player.readyWeapon;
  if (w == NULL) { return false; }

  int located;
  int slot;
  [located, slot] = player.weapons.LocateWeapon(w.GetClassName());

  bool slot1 = (slot == 1);
  return slot1;
}

private static bool isWeaponReady(PlayerInfo player)
{
  bool isReady
     = player.WeaponState & WF_WEAPONREADY
    || player.WeaponState & WF_WEAPONREADYALT
    || player.WeaponState & WF_WEAPONZOOMOK
    || player.WeaponState & WF_WEAPONSWITCHOK
    || player.cmd.buttons & BT_ATTACK
    || player.cmd.buttons & BT_ALTATTACK;

  return isReady;
}

private static bool isNoWeapon(PlayerInfo player)
{
  Weapon w    = player.readyWeapon;
  bool   isNo = (w == NULL) || (w.GetClassName() == "m8f_wm_Holstered");

  return isNo;
}

private static ui void HSVtoRGB(out double r,
                                out double g,
                                out double b,
                                double h,
                                double s,
                                double v)
{
  int i;
  double f, p, q, t;

  if (s == 0)
  { // achromatic (grey)
    r = g = b = v;
    return;
  }

  h /= 60;                                    // sector 0 to 5
  i = int(floor(h));
  f = h - i;                                  // factorial part of h
  p = v * (1 - s);
  q = v * (1 - s * f);
  t = v * (1 - s * (1 - f));

  switch (i)
  {
  case 0:     r = v; g = t; b = p; break;
  case 1:     r = q; g = v; b = p; break;
  case 2:     r = p; g = v; b = t; break;
  case 3:     r = p; g = q; b = v; break;
  case 4:     r = t; g = p; b = v; break;
  default:    r = v; g = p; b = q; break;
  }
}

private static clearscope double linearMap(double val,
                                           double source_min,
                                           double source_max,
                                           double out_min,
                                           double out_max)
{
  return (val - source_min) * (out_max - out_min) / (source_max - source_min) + out_min;
}

private ui double getDistanceScale(double minDist = 0,
                                   double maxDist = 1024,
                                   double minScale = 1.0,
                                   double maxScale = 4.0)
{
  double scale = minScale;
  if (_distToTarget < maxDist)
  {
    double dist = Clamp(_distToTarget, minDist, maxDist);
    scale = LinearMap(dist, maxdist, mindist, minscale, maxscale);
  }
  setExternalScale(players[consoleplayer], scale);
  return scale;
}