229 lines
12 KiB
C#
229 lines
12 KiB
C#
using System.Numerics;
|
|
|
|
namespace AcDream.App.UI;
|
|
|
|
/// <summary>
|
|
/// A horizontal vital bar (retail HP/Stamina/Mana style): a background rect, a
|
|
/// partial-width solid fill, and an optional centered "current/max" numeric
|
|
/// overlay. <see cref="Fill"/> returns 0..1 (null = no data → empty bar);
|
|
/// <see cref="Label"/> returns the overlay text (null = no number).
|
|
///
|
|
/// <para>
|
|
/// Solid-color fill + debug font for Spec 1. The retail gradient bar sprite
|
|
/// (glassy center highlight) and the retail dat font are a later polish pass —
|
|
/// retail's vitals are bars exactly like this, just sprited.
|
|
/// </para>
|
|
/// </summary>
|
|
public sealed class UiMeter : UiElement
|
|
{
|
|
|
|
/// <summary>Fill fraction provider; a null result draws an empty bar.</summary>
|
|
public Func<float?> Fill { get; set; } = () => 0f;
|
|
/// <summary>Centered overlay text provider (e.g. "291/291"); null = none.</summary>
|
|
public Func<string?> Label { get; set; } = () => null;
|
|
public Vector4 BarColor { get; set; } = new(1f, 0f, 0f, 1f);
|
|
public Vector4 BgColor { get; set; } = new(0f, 0f, 0f, 0.5f);
|
|
public Vector4 LabelColor { get; set; } = new(1f, 1f, 1f, 1f);
|
|
|
|
/// <summary>Retail dat font (Font 0x40000000) for the "cur/max" overlay. When
|
|
/// set, the label renders through the dat-font two-pass blit (outline + fill);
|
|
/// when null, the debug <see cref="UiRenderContext.DefaultFont"/> bitmap font
|
|
/// is used instead. Set by the host when the retail UI is active.</summary>
|
|
public UiDatFont? DatFont { get; set; }
|
|
|
|
/// <summary>Resolver from a RenderSurface DataId to (GL handle, w, h). When set
|
|
/// with the 9-slice ids below, the bar draws the retail sprites instead of solid color.</summary>
|
|
public Func<uint, (uint tex, int w, int h)>? SpriteResolve { get; set; }
|
|
|
|
// Retail vital bars are a horizontal 3-slice: a fixed-width bevelled left-cap,
|
|
// a TILED gradient middle (the "fill-tile" repeats at native width — it does not
|
|
// stretch), and a fixed-width right-cap. The "back" slice is the empty track
|
|
// (drawn full width); the "front" slice is the coloured fill (drawn full-geometry
|
|
// but CLIPPED to the fill fraction — its own right-cap shows at 100%, the back's
|
|
// shows through when partial). Ids come from the stacked vitals LayoutDesc
|
|
// (0x2100006C) via the dump-vitals-layout CLI; 0 = none.
|
|
/// <summary>Empty-track left-cap RenderSurface id.</summary>
|
|
public uint BackLeft { get; set; }
|
|
/// <summary>Empty-track middle (tiled gradient) RenderSurface id.</summary>
|
|
public uint BackTile { get; set; }
|
|
/// <summary>Empty-track right-cap RenderSurface id.</summary>
|
|
public uint BackRight { get; set; }
|
|
/// <summary>Coloured-fill left-cap RenderSurface id.</summary>
|
|
public uint FrontLeft { get; set; }
|
|
/// <summary>Coloured-fill middle (tiled gradient) RenderSurface id.</summary>
|
|
public uint FrontTile { get; set; }
|
|
/// <summary>Coloured-fill right-cap RenderSurface id.</summary>
|
|
public uint FrontRight { get; set; }
|
|
|
|
/// <summary>Vertical orientation (retail <c>m_eDirection</c> 2/4). Default false =
|
|
/// horizontal (direction 1). The burden bar is the only vertical meter today.</summary>
|
|
public bool Vertical { get; set; }
|
|
|
|
/// <summary>For a vertical meter, fill grows from the bottom up (retail direction 4)
|
|
/// when true, top-down (direction 2) when false. Default bottom-up. Visual-confirmed.</summary>
|
|
public bool FillFromBottom { get; set; } = true;
|
|
|
|
public UiMeter() { ClickThrough = true; }
|
|
|
|
/// <summary>The meter draws its own 3-slice bars; the importer must not build its
|
|
/// grandchild slice/text elements as separate widgets.</summary>
|
|
public override bool ConsumesDatChildren => true;
|
|
|
|
/// <summary>Clamp <paramref name="pct"/> to [0,1] and return the fill rect
|
|
/// (local px) for a bar of <paramref name="w"/> x <paramref name="h"/>.</summary>
|
|
public static (float x, float y, float w, float h) ComputeFillRect(
|
|
float pct, float w, float h)
|
|
{
|
|
if (pct < 0f) pct = 0f;
|
|
if (pct > 1f) pct = 1f;
|
|
return (0f, 0f, w * pct, h);
|
|
}
|
|
|
|
/// <summary>Clamp <paramref name="pct"/> to [0,1] and return the vertical fill rect
|
|
/// (local px). <paramref name="fromBottom"/> true → the fill occupies the bottom
|
|
/// <c>h*pct</c> px (retail direction 4); false → the top (direction 2).</summary>
|
|
public static (float x, float y, float w, float h) ComputeVFillRect(
|
|
float pct, float w, float h, bool fromBottom)
|
|
{
|
|
if (pct < 0f) pct = 0f;
|
|
if (pct > 1f) pct = 1f;
|
|
float fh = h * pct;
|
|
return (0f, fromBottom ? h - fh : 0f, w, fh);
|
|
}
|
|
|
|
protected override void OnDraw(UiRenderContext ctx)
|
|
{
|
|
float? pct = Fill();
|
|
float p = pct is float pf ? (pf < 0f ? 0f : pf > 1f ? 1f : pf) : 0f;
|
|
|
|
if (SpriteResolve is { } resolve && (BackLeft != 0 || BackTile != 0 || FrontTile != 0))
|
|
{
|
|
if (Vertical)
|
|
{
|
|
// Track full height, fill clipped to the fraction along the fill direction.
|
|
// The burden meter is a single-tile bar (BackTile/FrontTile, no caps).
|
|
DrawVBar(ctx, resolve, BackTile, Height, fromBottom: FillFromBottom, isFill: false);
|
|
if (pct is not null && p > 0f)
|
|
DrawVBar(ctx, resolve, FrontTile, Height * p, fromBottom: FillFromBottom, isFill: true);
|
|
}
|
|
else
|
|
{
|
|
// Retail meter (UIElement_Meter::DrawChildren): the BACK 3-slice is the
|
|
// empty track, drawn full width; the FRONT 3-slice is the coloured fill,
|
|
// drawn at FULL width too but horizontally CLIPPED to the fill fraction.
|
|
// The front carries its own right-cap (shown at 100%); clipping below 100%
|
|
// removes it and reveals the back track's right-cap — retail's scissor-fill.
|
|
DrawHBar(ctx, resolve, BackLeft, BackTile, BackRight, Width);
|
|
if (pct is not null && p > 0f)
|
|
DrawHBar(ctx, resolve, FrontLeft, FrontTile, FrontRight, Width * p);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Placeholder solid-color fallback.
|
|
ctx.DrawRect(0, 0, Width, Height, BgColor);
|
|
if (pct is not null && p > 0f)
|
|
{
|
|
var (fx, fy, fw, fh) = ComputeFillRect(p, Width, Height);
|
|
if (fw > 0f) ctx.DrawRect(fx, fy, fw, fh, BarColor);
|
|
}
|
|
}
|
|
|
|
string? label = Label();
|
|
if (!string.IsNullOrEmpty(label))
|
|
{
|
|
if (DatFont is { } datFont)
|
|
{
|
|
// Retail path: centered cur/max via the dat font's two-pass blit.
|
|
float tw = datFont.MeasureWidth(label);
|
|
float tx = (Width - tw) * 0.5f;
|
|
float ty = (Height - datFont.LineHeight) * 0.5f;
|
|
ctx.DrawStringDat(datFont, label, tx, ty, LabelColor);
|
|
}
|
|
else if (ctx.DefaultFont is { } font)
|
|
{
|
|
// Fallback: debug bitmap font (no dat font available).
|
|
float tw = font.MeasureWidth(label);
|
|
float tx = (Width - tw) * 0.5f;
|
|
float ty = (Height - font.LineHeight) * 0.5f;
|
|
ctx.DrawString(label, tx, ty, LabelColor);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Draws the full-width horizontal 3-slice (native-width left-cap, stretched
|
|
/// middle, native-width right-cap) over this meter's rect, horizontally CLIPPED
|
|
/// so nothing past <paramref name="clipW"/> (local px from the left) is drawn.
|
|
/// The back track passes <c>clipW = Width</c>; the front fill passes
|
|
/// <c>clipW = Width * fraction</c>. Clipping UV-crops each slice proportionally,
|
|
/// so the fill ends cleanly and the back's right-cap shows through when partial.
|
|
/// A 0 id skips that slice.
|
|
/// </summary>
|
|
private void DrawHBar(
|
|
UiRenderContext ctx, Func<uint, (uint tex, int w, int h)> resolve,
|
|
uint leftId, uint midId, uint rightId, float clipW)
|
|
{
|
|
if (clipW <= 0f) return;
|
|
float w = Width, h = Height;
|
|
// Only resolve a slice when its id is non-zero. resolve(0) returns the 1x1 MAGENTA
|
|
// placeholder with a NON-ZERO GL handle, so resolving a zero (absent) cap id and then
|
|
// testing `tex != 0` would draw a 1px magenta cap. The single-image meter (toolbar
|
|
// selected-object bar) has no left/right caps (ids 0); the 3-slice vitals meter sets
|
|
// all six ids. Guard on the id, not the resolved handle.
|
|
var (lt, lw, _) = leftId != 0 ? resolve(leftId) : (0u, 0, 0);
|
|
var (mt, mw, _) = midId != 0 ? resolve(midId) : (0u, 0, 0);
|
|
var (rt, rw, _) = rightId != 0 ? resolve(rightId) : (0u, 0, 0);
|
|
|
|
float capL = lt != 0 ? MathF.Min(lw, w) : 0f;
|
|
float capR = rt != 0 ? MathF.Min(rw, w - capL) : 0f;
|
|
float midW = w - capL - capR;
|
|
|
|
// Each slice's texture repeats every NATIVE-width px (UV-repeat; the UI
|
|
// texture is GL_REPEAT-wrapped — TextureCache.UploadRgba8). Caps span their
|
|
// own native width → a single 1:1 copy. The wide middle spans many native
|
|
// widths → it TILES, matching retail's "fill-tile" + ImgTex::TileCSI rather
|
|
// than stretching one copy. (Same UV-repeat the chrome border already uses.)
|
|
DrawPiece(ctx, lt, 0f, capL, lw, h, clipW);
|
|
DrawPiece(ctx, mt, capL, midW, mw, h, clipW);
|
|
DrawPiece(ctx, rt, w - capR, capR, rw, h, clipW);
|
|
}
|
|
|
|
/// <summary>Draws a single-tile vertical bar slice. The track (<paramref name="isFill"/>
|
|
/// false) spans the full height; the fill spans <paramref name="visibleH"/> px from the
|
|
/// bottom (<paramref name="fromBottom"/>) or top, UV-cropped to that fraction of the
|
|
/// sprite so the fill reveals the matching part of the art (retail
|
|
/// UIElement_Meter::DrawChildren Box2D clip, direction 2/4). A 0 id is a no-op.</summary>
|
|
private void DrawVBar(UiRenderContext ctx, Func<uint, (uint tex, int w, int h)> resolve,
|
|
uint tileId, float visibleH, bool fromBottom, bool isFill)
|
|
{
|
|
if (tileId == 0 || visibleH <= 0f) return;
|
|
var (tex, _, _) = resolve(tileId);
|
|
if (tex == 0) return;
|
|
float w = Width, h = Height;
|
|
if (visibleH > h) visibleH = h;
|
|
float frac = h > 0f ? visibleH / h : 0f;
|
|
// Bottom-up fill: bottom of the rect AND bottom of the sprite (v in [1-frac, 1]).
|
|
// Top-down / track: top of the rect AND top of the sprite (v in [0, frac]).
|
|
float y = isFill && fromBottom ? h - visibleH : 0f;
|
|
float v0 = isFill && fromBottom ? 1f - frac : 0f;
|
|
float v1 = isFill && fromBottom ? 1f : frac;
|
|
ctx.DrawSprite(tex, 0f, y, w, visibleH, 0f, v0, 1f, v1, System.Numerics.Vector4.One);
|
|
}
|
|
|
|
/// <summary>Draw a slice over local [<paramref name="pieceX"/>,
|
|
/// pieceX+<paramref name="pieceW"/>], with the texture repeating every
|
|
/// <paramref name="nativeW"/> px (UV-repeat — the UI texture is GL_REPEAT-wrapped).
|
|
/// Clipped so nothing past <paramref name="clipW"/> shows. For a cap (span == native)
|
|
/// this is one 1:1 copy; for the wide middle it tiles; a partial last copy is
|
|
/// UV-cropped.</summary>
|
|
private static void DrawPiece(
|
|
UiRenderContext ctx, uint tex, float pieceX, float pieceW, float nativeW, float h, float clipW)
|
|
{
|
|
if (tex == 0 || pieceW <= 0f || nativeW <= 0f) return;
|
|
float visibleW = MathF.Min(pieceW, clipW - pieceX);
|
|
if (visibleW <= 0f) return;
|
|
float u1 = visibleW / nativeW; // >1 ⇒ texture repeats (tiles); ≤1 ⇒ a partial copy
|
|
ctx.DrawSprite(tex, pieceX, 0f, visibleW, h, 0f, 0f, u1, 1f, Vector4.One);
|
|
}
|
|
}
|