40c97a53ac
Visual verification caught it: a no-mana scroll's icon edges are BLACK in retail but rendered WHITE in acdream. Cause = the effects!=0 gate (registered AP-44) that skipped retail's effects==0 recolor. Retail's effect tile is non-null even for effects==0 (the 0x21 SOLID-BLACK fallback 0x060011C5), so RenderIcons recolors pure-white pixels to black on mundane items and to the effect hue on magical ones. Remove the gate (always recolor); retire AP-44 (now faithful). TryGetEffectColor made internal + a golden test pins effects==0 -> ~black. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
269 lines
13 KiB
C#
269 lines
13 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Numerics;
|
||
using AcDream.App.Rendering;
|
||
using AcDream.Core.Items;
|
||
using AcDream.Core.Textures;
|
||
using DatReaderWriter;
|
||
using DatReaderWriter.DBObjs;
|
||
|
||
namespace AcDream.App.UI;
|
||
|
||
/// <summary>
|
||
/// Builds an item icon by alpha-compositing its RenderSurface layers into one 32x32
|
||
/// texture, mirroring retail IconData::RenderIcons (decomp 407524) and
|
||
/// DBCache::GetDIDFromEnum (0x413940). Each layer is a 0x06 RenderSurface decoded
|
||
/// DIRECTLY (the D.2b RenderSurface-vs-Surface rule).
|
||
///
|
||
/// Layer order (bottom → top), matching retail:
|
||
/// 1. type-default underlay (OPAQUE backing; resolved via EnumIDMap 0x10000004 from
|
||
/// the portal MasterMap) — <see cref="ResolveUnderlayDid"/>
|
||
/// 2. item custom underlay (e.g. "magic" tint strip)
|
||
/// 3. base icon
|
||
/// 4. item custom overlay (e.g. "enchanted" sparkle)
|
||
///
|
||
/// The type-default underlay is the key to non-transparent filled slots: because it
|
||
/// is fully opaque and is layer 0, <see cref="Compose"/> sizes the output to it and
|
||
/// the alpha-over pass fills every pixel. The overlay ReplaceColor tint and the effect
|
||
/// overlay (RenderIcons 407546) remain out of scope (paperdoll phase).
|
||
///
|
||
/// Composited textures are cached by their (typeUnderlay, underlay, base, overlay) tuple.
|
||
/// </summary>
|
||
public sealed class IconComposer
|
||
{
|
||
private readonly DatCollection _dats;
|
||
private readonly TextureCache _cache;
|
||
private readonly Dictionary<(uint, uint, uint, uint, uint), uint> _byTuple = new();
|
||
|
||
// ── type-default underlay resolve (EnumIDMap 0x10000004) ─────────────────
|
||
// Portal MasterMap (0x25000000) maps enum 0x10000004 → submap DID (0x25000008).
|
||
// Submap maps index → 0x06 RenderSurface DID. index = LSB(itemType)+1, or 0x21.
|
||
// Refs: IconData::RenderIcons 0058d214–0058d22c; DBCache::GetDIDFromEnum 0x413940.
|
||
private EnumIDMap? _underlaySubMap;
|
||
private bool _underlayResolveTried;
|
||
private readonly Dictionary<uint, uint> _underlayDidByIndex = new();
|
||
|
||
// ── effect overlay resolve (EnumIDMap 0x10000005) ────────────────────────
|
||
// Portal MasterMap (0x25000000) maps enum 0x10000005 → submap DID (0x25000009).
|
||
// Submap maps index → 0x06 RenderSurface DID. index = LSB(effects)+1, fallback 0x21.
|
||
// Refs: IconData::RenderIcons 0x0058d180 (effect path); the effect tile is a
|
||
// ReplaceColor tint SOURCE, not a blit layer (see RESOLVED doc, divergence DR-1).
|
||
private EnumIDMap? _effectSubMap;
|
||
private bool _effectResolveTried;
|
||
private readonly Dictionary<uint, uint> _effectDidByIndex = new();
|
||
private readonly Dictionary<uint, (byte r, byte g, byte b, byte a)> _effectColorByDid = new();
|
||
|
||
public IconComposer(DatCollection dats, TextureCache cache)
|
||
{
|
||
_dats = dats;
|
||
_cache = cache;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Resolve the type-default underlay DID for <paramref name="itemType"/> via the
|
||
/// two-level EnumIDMap chain (retail: IconData::RenderIcons 0058d214–0058d22c +
|
||
/// DBCache::GetDIDFromEnum 0x413940).
|
||
///
|
||
/// <para>index = LowestSetBit(itemType) + 1, or 0x21 when itemType has no bits set.</para>
|
||
///
|
||
/// <para>NOTE: retail RenderIcons (407546) has a special paperdoll IsThePlayer case
|
||
/// that uses GetDIDByEnum(0x10000004, 7) + TYPE_CONTAINER for the player doll — that
|
||
/// path is out of scope here (paperdoll phase).</para>
|
||
/// </summary>
|
||
internal uint ResolveUnderlayDid(ItemType itemType)
|
||
{
|
||
uint raw = (uint)itemType;
|
||
int lsb = raw == 0 ? -1 : BitOperations.TrailingZeroCount(raw);
|
||
uint index = lsb < 0 ? 0x21u : (uint)(lsb + 1);
|
||
if (_underlayDidByIndex.TryGetValue(index, out var cached)) return cached;
|
||
EnsureUnderlaySubMap();
|
||
uint did = 0;
|
||
if (_underlaySubMap is { } sub && sub.ClientEnumToID.TryGetValue(index, out var d)) did = d;
|
||
_underlayDidByIndex[index] = did;
|
||
return did;
|
||
}
|
||
|
||
private void EnsureUnderlaySubMap()
|
||
{
|
||
if (_underlayResolveTried) return;
|
||
_underlayResolveTried = true;
|
||
uint masterDid = (uint)_dats.Portal.Header.MasterMapId; // = 0x25000000
|
||
if (masterDid == 0) return;
|
||
if (!_dats.Portal.TryGet<EnumIDMap>(masterDid, out var master)) return;
|
||
if (!master.ClientEnumToID.TryGetValue(0x10000004u, out var subDid)) return; // → 0x25000008
|
||
if (_dats.Portal.TryGet<EnumIDMap>(subDid, out var sub)) _underlaySubMap = sub;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Resolve the effect-overlay DID for <paramref name="effects"/> via the EnumIDMap
|
||
/// 0x10000005 chain. index = LowestSetBit(effects)+1; if the entry is missing/zero,
|
||
/// retail falls back to index 0x21 (the solid-black tile). NOTE: the effect path has
|
||
/// NO lsb==-1 pre-check (unlike the type underlay), so effects==0 → index 0 → miss →
|
||
/// fallback. (Retail IconData::RenderIcons 0x0058d180.)
|
||
/// </summary>
|
||
internal uint ResolveEffectDid(uint effects)
|
||
{
|
||
int lsb = effects == 0 ? -1 : BitOperations.TrailingZeroCount(effects);
|
||
uint index = (uint)(lsb + 1);
|
||
if (_effectDidByIndex.TryGetValue(index, out var cached)) return cached;
|
||
EnsureEffectSubMap();
|
||
uint did = 0;
|
||
if (_effectSubMap is { } sub && sub.ClientEnumToID.TryGetValue(index, out var d)) did = d;
|
||
if (did == 0 && _effectSubMap is { } sub2 && sub2.ClientEnumToID.TryGetValue(0x21u, out var fb))
|
||
did = fb;
|
||
_effectDidByIndex[index] = did;
|
||
return did;
|
||
}
|
||
|
||
private void EnsureEffectSubMap()
|
||
{
|
||
if (_effectResolveTried) return;
|
||
_effectResolveTried = true;
|
||
uint masterDid = (uint)_dats.Portal.Header.MasterMapId; // = 0x25000000
|
||
if (masterDid == 0) return;
|
||
if (!_dats.Portal.TryGet<EnumIDMap>(masterDid, out var master)) return;
|
||
if (!master.ClientEnumToID.TryGetValue(0x10000005u, out var subDid)) return; // → 0x25000009
|
||
if (_dats.Portal.TryGet<EnumIDMap>(subDid, out var sub)) _effectSubMap = sub;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Retail <c>SurfaceWindow::ReplaceColor</c> (0x00441530) with the icon-composite's
|
||
/// fixed source color: replace pixels exactly equal to pure-white-opaque
|
||
/// (RGBAColor(1,1,1,1) → 0xFFFFFFFF) with <paramref name="dest"/>. Mutates in place.
|
||
/// </summary>
|
||
internal static void ReplaceColorWhite(byte[] rgba, int w, int h, (byte r, byte g, byte b, byte a) dest)
|
||
{
|
||
for (int i = 0; i < w * h; i++)
|
||
{
|
||
if (rgba[i * 4] == 255 && rgba[i * 4 + 1] == 255 &&
|
||
rgba[i * 4 + 2] == 255 && rgba[i * 4 + 3] == 255)
|
||
{
|
||
rgba[i * 4] = dest.r; rgba[i * 4 + 1] = dest.g;
|
||
rgba[i * 4 + 2] = dest.b; rgba[i * 4 + 3] = dest.a;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// The effect tint color for <paramref name="effects"/>: the effect tile's mean-opaque
|
||
/// color (blue=Magical, green=Poisoned, …). The exact retail color byte is a
|
||
/// decompiler-ambiguous SurfaceWindow-header read; the tile IS the per-effect color, so
|
||
/// its representative color is the faithful equivalent (divergence DR-2). Cached per DID.
|
||
/// </summary>
|
||
internal bool TryGetEffectColor(uint effects, out (byte r, byte g, byte b, byte a) color)
|
||
{
|
||
color = default;
|
||
uint did = ResolveEffectDid(effects);
|
||
if (did == 0) return false;
|
||
if (_effectColorByDid.TryGetValue(did, out var cached)) { color = cached; return true; }
|
||
if (!TryDecode(did, out var d)) return false;
|
||
long sr = 0, sg = 0, sb = 0; int n = 0;
|
||
for (int i = 0; i < d.Width * d.Height; i++)
|
||
{
|
||
if (d.Rgba8[i * 4 + 3] == 0) continue;
|
||
sr += d.Rgba8[i * 4]; sg += d.Rgba8[i * 4 + 1]; sb += d.Rgba8[i * 4 + 2]; n++;
|
||
}
|
||
if (n == 0) return false;
|
||
var rep = ((byte)(sr / n), (byte)(sg / n), (byte)(sb / n), (byte)255);
|
||
_effectColorByDid[did] = rep;
|
||
color = rep;
|
||
return true;
|
||
}
|
||
|
||
private bool TryDecode(uint renderSurfaceId, out DecodedTexture decoded)
|
||
{
|
||
decoded = null!;
|
||
if (renderSurfaceId == 0) return false;
|
||
if (!_dats.Portal.TryGet<RenderSurface>(renderSurfaceId, out var rs) &&
|
||
!_dats.HighRes.TryGet<RenderSurface>(renderSurfaceId, out rs))
|
||
return false;
|
||
decoded = SurfaceDecoder.DecodeRenderSurface(rs, palette: null);
|
||
return true;
|
||
}
|
||
|
||
/// <summary>Pure alpha-over composite, bottom->top. Layers may differ in size;
|
||
/// the result is sized to the FIRST (bottom) layer and upper layers are sampled
|
||
/// top-left aligned (all icon layers are 32x32 in practice).</summary>
|
||
public static (byte[] rgba, int w, int h) Compose(IReadOnlyList<(byte[] rgba, int w, int h)> layers)
|
||
{
|
||
if (layers.Count == 0) return (Array.Empty<byte>(), 0, 0);
|
||
var (baseRgba, w, h) = layers[0];
|
||
var outp = (byte[])baseRgba.Clone();
|
||
for (int li = 1; li < layers.Count; li++)
|
||
{
|
||
var (src, sw, sh) = layers[li];
|
||
int cw = Math.Min(w, sw), ch = Math.Min(h, sh);
|
||
for (int y = 0; y < ch; y++)
|
||
for (int x = 0; x < cw; x++)
|
||
{
|
||
int di = (y * w + x) * 4, si = (y * sw + x) * 4;
|
||
float sa = src[si + 3] / 255f;
|
||
if (sa <= 0f) continue;
|
||
float da = 1f - sa;
|
||
outp[di] = (byte)(src[si] * sa + outp[di] * da);
|
||
outp[di + 1] = (byte)(src[si + 1] * sa + outp[di + 1] * da);
|
||
outp[di + 2] = (byte)(src[si + 2] * sa + outp[di + 2] * da);
|
||
outp[di + 3] = (byte)Math.Min(255f, src[si + 3] + outp[di + 3] * da);
|
||
}
|
||
}
|
||
return (outp, w, h);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Resolve (and cache) the composited GL texture for an item's icon state.
|
||
/// Returns 0 if no base icon. Mirrors retail IconData::RenderIcons (0x0058d180):
|
||
/// a DRAG composite (base + custom overlay + effect recolor) blitted over the
|
||
/// type-default underlay + custom underlay. The effect tile (enum 0x10000005) is a
|
||
/// ReplaceColor tint SOURCE, not a blit layer (DR-1). The recolor runs for ALL items:
|
||
/// effects==0 resolves to the 0x21 solid-black fallback tile, so pure-white pixels become
|
||
/// black (matching retail); magical items take the per-effect hue instead.
|
||
/// </summary>
|
||
public uint GetIcon(ItemType itemType, uint iconId, uint underlayId, uint overlayId, uint effects)
|
||
{
|
||
if (iconId == 0) return 0;
|
||
uint typeUnderlayDid = ResolveUnderlayDid(itemType);
|
||
var key = (typeUnderlayDid, iconId, underlayId, overlayId, effects);
|
||
if (_byTuple.TryGetValue(key, out var tex)) return tex;
|
||
|
||
// Stage 1 — retail m_pDragIcon: base + custom overlay, then the effect recolor.
|
||
var dragLayers = new List<(byte[] rgba, int w, int h)>();
|
||
AddLayer(dragLayers, iconId);
|
||
AddLayer(dragLayers, overlayId);
|
||
(byte[] rgba, int w, int h)? drag = null;
|
||
if (dragLayers.Count > 0)
|
||
{
|
||
var composed = Compose(dragLayers);
|
||
// Effect recolor — ALWAYS, matching retail IconData::RenderIcons (0x0058d180):
|
||
// the effect tile (enum 0x10000005, lsb(effects)+1, fallback 0x21) is non-null
|
||
// even for effects==0 (the 0x21 SOLID-BLACK tile 0x060011C5), so retail recolors
|
||
// pure-white pixels to BLACK on mundane items and to the effect hue on magical
|
||
// ones. Visually confirmed against retail 2026-06-17: the no-mana scroll's edges
|
||
// are BLACK, not white — the earlier `effects != 0` gate (AP-44) was wrong.
|
||
if (TryGetEffectColor(effects, out var ec))
|
||
ReplaceColorWhite(composed.rgba, composed.w, composed.h, ec);
|
||
drag = composed;
|
||
}
|
||
|
||
// Stage 2 — retail m_pIcon: type-default underlay (opaque) + custom underlay + drag.
|
||
var layers = new List<(byte[] rgba, int w, int h)>();
|
||
AddLayer(layers, typeUnderlayDid);
|
||
AddLayer(layers, underlayId);
|
||
if (drag is { } d) layers.Add(d);
|
||
if (layers.Count == 0) return 0;
|
||
|
||
var (rgba, w, h) = Compose(layers);
|
||
uint handle = _cache.UploadRgba8(rgba, w, h, nearest: true);
|
||
_byTuple[key] = handle;
|
||
return handle;
|
||
}
|
||
|
||
private void AddLayer(List<(byte[], int, int)> layers, uint renderSurfaceId)
|
||
{
|
||
if (renderSurfaceId == 0) return;
|
||
if (!_dats.Portal.TryGet<RenderSurface>(renderSurfaceId, out var rs) &&
|
||
!_dats.HighRes.TryGet<RenderSurface>(renderSurfaceId, out rs))
|
||
return;
|
||
var decoded = SurfaceDecoder.DecodeRenderSurface(rs, palette: null);
|
||
layers.Add((decoded.Rgba8, decoded.Width, decoded.Height));
|
||
}
|
||
}
|