VoidfallStyle.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "HudContext.hpp"
#include "HudTypes.hpp"
 
namespace voidfall
{
 
// ── Palette (matches prototype's CSS custom properties) ─────────────────────

constexpr HudColor k_bgVoid{0.08f, 0.075f, 0.07f, 0.96f};
constexpr HudColor k_bgPanel{0.10f, 0.095f, 0.085f, 0.92f};
constexpr HudColor k_bgPanelSolid{0.09f, 0.085f, 0.075f, 0.96f};
constexpr HudColor k_bgInset{0.12f, 0.115f, 0.105f, 0.92f};

constexpr HudColor k_lineDim{0.32f, 0.30f, 0.28f, 0.7f};
constexpr HudColor k_line{0.42f, 0.40f, 0.37f, 0.95f};
constexpr HudColor k_lineBright{0.62f, 0.59f, 0.56f, 1.0f};

constexpr HudColor k_textDim{0.78f, 0.76f, 0.73f, 1.0f};
constexpr HudColor k_text{0.92f, 0.90f, 0.87f, 1.0f};
constexpr HudColor k_textBright{1.00f, 0.99f, 0.97f, 1.0f};

constexpr HudColor k_amber{1.00f, 0.71f, 0.18f, 1.0f};
constexpr HudColor k_amberDim{0.78f, 0.55f, 0.14f, 1.0f};
constexpr HudColor k_amberDeep{0.50f, 0.35f, 0.10f, 1.0f};
constexpr HudColor k_amberGlow{1.00f, 0.71f, 0.18f, 0.18f};

constexpr HudColor k_red{0.92f, 0.30f, 0.20f, 1.0f};
constexpr HudColor k_redBright{0.95f, 0.45f, 0.25f, 1.0f};
constexpr HudColor k_redDim{0.65f, 0.20f, 0.15f, 1.0f};

constexpr HudColor k_cyan{0.45f, 0.78f, 0.96f, 1.0f};
constexpr HudColor k_cyanDim{0.20f, 0.50f, 0.70f, 1.0f};

constexpr HudColor k_green{0.30f, 0.86f, 0.45f, 1.0f};

constexpr HudColor k_pickupBg{0.13f, 0.12f, 0.11f, 0.82f};
 
// ── Weapon-type accent colors (Apex convention) ───────────────────────────
//
// Each weapon class has its own bright accent: AR teal, sniper purple,
// pistol green, SMG amber, shotgun red.  Used for the weapon-panel
// underline, fire-mode tag border, slot-tab top-edge, and slot-index pill
// background — so the player parses *what* they're holding by color
// before reading the name.
constexpr HudColor k_typeAr{0.20f, 0.65f, 0.70f, 1.0f};      // teal
constexpr HudColor k_typeSniper{0.40f, 0.30f, 0.75f, 1.0f};  // purple
constexpr HudColor k_typePistol{0.20f, 0.75f, 0.45f, 1.0f};  // green
constexpr HudColor k_typeSmg{0.95f, 0.65f, 0.18f, 1.0f};     // amber
constexpr HudColor k_typeShotgun{0.85f, 0.30f, 0.20f, 1.0f}; // red

constexpr HudColor weaponTypeAccent(int weaponId)
{
    switch (weaponId) {
    case 0:  // Rifle — full-auto AR
        return k_typeAr;
    case 1:  // Rocket — explosive, treat as shotgun-class
        return k_typeShotgun;
    case 2:  // RailGun — single-shot precision
        return k_typeSniper;
    case 3:  // EnergyGun — beam SMG-class
        return k_typeSmg;
    default: // grenades / unknown — fall back to generic amber
        return k_amber;
    }
}

constexpr HudColor withAlpha(HudColor c, float alpha)
{
    return HudColor{c.r, c.g, c.b, c.a * alpha};
}
 
// ── Mil-spec bracket corners ────────────────────────────────────────────────

inline void drawCornerBrackets(HudContext& ctx,
                               float x,
                               float y,
                               float w,
                               float h,
                               float armLen = 10.f,
                               float thickness = 1.f,
                               float outset = 0.f,
                               HudColor color = k_amber)
{
    const float bx = x - outset;
    const float by = y - outset;
    const float bw = w + outset * 2.f;
    const float bh = h + outset * 2.f;
 
    // Top-left.
    ctx.rect(bx, by, armLen, thickness, color);
    ctx.rect(bx, by, thickness, armLen, color);
    // Top-right.
    ctx.rect(bx + bw - armLen, by, armLen, thickness, color);
    ctx.rect(bx + bw - thickness, by, thickness, armLen, color);
    // Bottom-left.
    ctx.rect(bx, by + bh - thickness, armLen, thickness, color);
    ctx.rect(bx, by + bh - armLen, thickness, armLen, color);
    // Bottom-right.
    ctx.rect(bx + bw - armLen, by + bh - thickness, armLen, thickness, color);
    ctx.rect(bx + bw - thickness, by + bh - armLen, thickness, armLen, color);
}

inline void drawPanel(HudContext& ctx,
                      float x,
                      float y,
                      float w,
                      float h,
                      HudColor fill = k_bgPanel,
                      HudColor border = k_line,
                      float thickness = 1.f)
{
    ctx.rect(x, y, w, h, fill);
    ctx.rectOutline(x, y, w, h, thickness, border);
}

inline void drawTrailBar(HudContext& ctx,
                         float x,
                         float y,
                         float w,
                         float h,
                         float fill01,
                         float trail01,
                         HudColor fillColor,
                         HudColor trailColor = HudColor{0.95f, 0.95f, 0.95f, 0.45f},
                         HudColor bgColor = k_bgInset,
                         HudColor borderColor = k_lineDim)
{
    // Background.
    ctx.rect(x, y, w, h, bgColor);
    // Ghost trail (drained portion drawn first, so live fill overlays it).
    if (trail01 > fill01)
        ctx.rect(x, y, w * trail01, h, trailColor);
    // Live fill.
    if (fill01 > 0.f)
        ctx.rect(x, y, w * fill01, h, fillColor);
    // Hairline border.
    ctx.rectOutline(x, y, w, h, 1.f, borderColor);
}

constexpr HudColor lerpColor(HudColor a, HudColor b, float t)
{
    return HudColor{
        a.r + (b.r - a.r) * t,
        a.g + (b.g - a.g) * t,
        a.b + (b.b - a.b) * t,
        a.a + (b.a - a.a) * t,
    };
}

inline void drawGradientTrailBar(HudContext& ctx,
                                 float x,
                                 float y,
                                 float w,
                                 float h,
                                 float fill01,
                                 float trail01,
                                 HudColor fillLeft,
                                 HudColor fillRight,
                                 HudColor trailColor = HudColor{0.95f, 0.95f, 0.95f, 0.45f},
                                 HudColor bgColor = k_bgInset,
                                 HudColor borderColor = k_lineDim)
{
    ctx.rect(x, y, w, h, bgColor);
    if (trail01 > fill01)
        ctx.rect(x, y, w * trail01, h, trailColor);
    if (fill01 > 0.f) {
        // Right endpoint of the visible fill = same point in the underlying
        // gradient, so the bar drains cleanly without color compression.
        const HudColor visibleRight = lerpColor(fillLeft, fillRight, fill01);
        ctx.gradientRect(x, y, w * fill01, h, fillLeft, visibleRight);
    }
    ctx.rectOutline(x, y, w, h, 1.f, borderColor);
}

inline void drawKeyTab(HudContext& ctx,
                       const char* key,
                       float x,
                       float y,
                       float fontSize,
                       float padX = 3.f,
                       float padY = 1.f,
                       HudColor bgColor = HudColor{0.f, 0.f, 0.f, 0.45f},
                       HudColor borderColor = k_lineBright,
                       HudColor textColor = k_textDim)
{
    const float capH = fontSize * 0.72f;
    const float w = ctx.measureText(key, fontSize) + padX * 2.f;
    const float h = capH + padY * 2.f;
    ctx.rect(x, y, w, h, bgColor);
    ctx.rectOutline(x, y, w, h, 1.f, borderColor);
    ctx.text(key, x + w * 0.5f, y - fontSize * 0.28f + padY, fontSize, textColor, HudAlign::Center);
}
 
} // namespace voidfall