From 308f40a3fb4848d8c6af32fa80dde986881efcbe Mon Sep 17 00:00:00 2001 From: Erik Date: Sat, 15 Aug 2026 11:05:59 +0200 Subject: [PATCH] =?UTF-8?q?fix(ui):=20Campaign=20LA=20gate=20round=202=20?= =?UTF-8?q?=E2=80=94=20fixed-canvas=20stretch=20filters=20bilinearly=20lik?= =?UTF-8?q?e=20retail's=20presentation=20blit?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit AD-98's fixed-canvas stretch (73041d70) scales every retained-UI quad at TextRenderer.AppendQuad, but the live gate reported it JAGGED — text especially. Cause: dat-font glyph atlases and IconComposer's composited icons upload nearest (TextureCache.UploadUiTexture's UiNearestRepeat sampler) — correct at the native 1:1 scale (pixel-exact retail art), but aliased once magnified 2.4x1.8. Chrome/background art was already fine: it uploads through GpuSamplerDescription.WorldRepeat (linear) by default. Retail's own fixed-canvas presentation is a single bilinear-filtered frame blit, never a per-texture stretch — this closes that gap one step earlier, at the source texture, without adding RHI surface area. - TextureCache.GetOrCreateLinearUiTwin: lazily registers a SECOND table slot for a nearest handle's IGpuTexture, sampled WorldRepeat (linear) instead of nearest — no re-decode, no re-upload, no extra memory-ledger bytes. Returns the handle unchanged for anything never registered nearest (chrome, UiTextureTableHandle.None), so it's a cheap unconditional probe. Twin slots are released in Dispose without double-disposing the shared texture. - TextRenderer.LinearTwinResolver + the DrawSprite chokepoint: swaps a sprite's texture handle through the resolver only while CanvasScale != One. At CanvasScale == One the resolver is never even called — zero overhead on the ordinary in-world/UI path. - InteractionRetainedUiComposition wires the resolver to TextureCache right after every UiHost acquisition (the lease can hand back a host from a prior session against a fresh TextureCache). - AD-98's register row gets one added sentence recording the fix. Tests: TextRendererLinearTwinTests pins the renderer-side handle-swap seam GPU-free (segment handle selection); TextureCacheLinearTwinTests pins twin creation/reuse/dispose against RecordingGpuDevice. App suite 5097/3 skips (Release, ACDREAM_PROBE_LIVE_MOUNT=1 live-DAT probes included). Full solution builds clean. Co-Authored-By: Claude Fable 5 --- .../retail-divergence-register.md | 2 +- .../InteractionRetainedUiComposition.cs | 6 + src/AcDream.App/Rendering/TextRenderer.cs | 24 ++++ src/AcDream.App/Rendering/TextureCache.cs | 85 ++++++++++++ .../Rendering/TextRendererLinearTwinTests.cs | 106 +++++++++++++++ .../Rendering/TextureCacheLinearTwinTests.cs | 124 ++++++++++++++++++ 6 files changed, 346 insertions(+), 1 deletion(-) create mode 100644 tests/AcDream.App.Tests/Rendering/TextRendererLinearTwinTests.cs create mode 100644 tests/AcDream.App.Tests/Rendering/TextureCacheLinearTwinTests.cs diff --git a/docs/architecture/retail-divergence-register.md b/docs/architecture/retail-divergence-register.md index aef92786..6e05a0c9 100644 --- a/docs/architecture/retail-divergence-register.md +++ b/docs/architecture/retail-divergence-register.md @@ -189,7 +189,7 @@ readiness/requeue adaptation. See | AD-92 | **Filed 2026-08-13 at the #376/#388 review fix round (blast M6 / mechanism M4).** Two switcher adaptations with no retail counterpart: (1) the fullscreen refresh rate is the monitor's HIGHEST for the picked WxH — retail passed the device mode's own refresh as-is (`Device::ForceDisplayResolution`); (2) an invalid/unsupported fullscreen request is a logged refusal that leaves the window unchanged — retail attempted the switch and surfaced the device error. The persisted-flag divergence a refusal leaves behind is ISSUES #392. | `src/AcDream.App/Settings/DisplayModeSwitching.cs` (`TryFindRefreshRate`, the refusal paths); `src/AcDream.App/Settings/RuntimeSettingsTargets.cs` (`Apply`'s refused-mode logging) | Highest-refresh is strictly better on modern variable-refresh panels (retail predates them); refuse-and-log is #388's own no-crash requirement. | A capture comparing retail's exact chosen refresh for a mode will differ; a server/tooling flow expecting an error dialog on an invalid mode sees a console line instead. | `Device::ForceDisplayResolution @gmClient::Init 0x004047af`; docs/research/2026-08-13-376-388-{mechanism,blast}-review.md | | AD-94 | **Filed 2026-08-14 at the secure-trade feature.** Retail's `Event_AcceptTrade` payload (`Trade::Pack @0x005B9FF0`) appends two `PackableList` staged-item lists after the six fixed fields; acdream sends both as ZERO-COUNT lists. ACE parses and then discards the ENTIRE payload (`HandleActionAcceptTrade()` takes zero arguments — server trade state is fully self-derived; lane B §quirks), so the difference is unobservable against ACE; a byte-capture comparison against a real retail client would differ from offset 40. | `src/AcDream.Core.Net/Messages/TradeRequests.cs` (`BuildAcceptTrade`) | The `ContentProfile` pack layout was not byte-verified (ACE never reads it — no reader to check against), and guessing a wire struct violates the workflow; zero-count lists are well-formed `PackableList`s. | A future server that actually validates the accept echo would see empty item lists and could refuse or desync the accept. | `Trade::Pack @0x005B9FF0`; `GameActionAcceptTrade.cs:11-16`; `docs/research/2026-08-14-trade-laneB-wire.md` Table 1 | | AD-96 | **Filed 2026-08-14 at the OP8 re-gate fix round (key-name display).** Retail's `GetNameFromKey_Internal @0x00687800` falls back from the DAT string tables (key enum 4 → `0x2300000A`, meta enum 5 → `0x2300000B`) to the OS keyboard layout's own key name via DirectInput `IDirectInputDevice8::GetObjectInfo` (`tszName` — "SKIFT" on a Swedish layout). acdream reads the SAME layout-resident name data through Win32 `GetKeyNameTextW` instead (no DirectInput device exists in-process); on non-Windows hosts there is no OS lookup at all and the DIK-suffix spelling shows (un-localized English, e.g. "LSHIFT"). Mouse chords keep the pre-existing enum spelling — retail names them through the DirectInput mouse device. | `src/AcDream.App/Platform/PlatformKeyNameProvider.cs`; `src/AcDream.App/UI/Layout/RetailKeyNames.cs` (`Describe`, the mouse-device early-out) | GetKeyNameText and DirectInput's key names both come from the active keyboard-layout tables; adding a DirectInput device solely for name strings would be a heavyweight, dead-end dependency. Linux graphical work is parked at Slice L1. | A key whose GetKeyNameTextW name differs from DirectInput's `tszName` on some layout shows a slightly different caption than retail did; Linux graphical shows English DIK-suffix names where retail-on-Wine would localize; a mouse-chord caption reads as the Silk enum, not retail's device string. | `CInputManager_WIN32::GetNameFromKey_Internal @0x00687800`; `GetNameFromKey @0x00687F40`; `ControlSpecification::GetDIKName @0x0068ACB0`; `DBCache::GetDIDFromEnumStatic` category-4 probe 2026-08-14 (`KeyboardConfigLiveMountProbeTests.ProbeKeyboardFontsAndKeyNameStrings`) | -| AD-98 | **Filed 2026-08-15 at Campaign LA gate round 2 (character-select background tiling).** The LA8 root (0x1000039A) authors LeftEdge=TopEdge=RightEdge=BottomEdge=0 ("no anchor") in the installed DAT, so retail's own `UIElement::UpdateForParentSizeChange` (0x00462640) never resizes this element — it stays a fixed 800x600 rect in retail's own widget tree. Retail's generic sprite blit, `Graphic::Draw` (0x00693b20) dispatching to `Graphic::PutImage` (0x00693a30) for an exact/undersized destination or a modulo-wrapped tile loop otherwise, has no third "stretch" mode (confirmed against `BlitMode`, acclient.h ~line 3135, and `MD_Data_Image::m_drawMode`/`DrawModeType` — both are COLOR-blend selectors, not tile-vs-stretch geometry modes). The only way retail's whole pre-world scene (background AND buttons AND listbox together) can still fill an arbitrary window resolution with no element ever resizing and a blitter that can only copy-or-tile is that these "flow" screens render into a fixed 800x600 target and the WHOLE FRAME is stretched once at presentation, outside the UI element/sprite system. **COMPLETED 2026-08-15 (same gate round, misalignment follow-up):** the first substitution (resize the mounted root + stretch only its own background) stretched the ART but left the authored child widgets at 800x600 pixel positions — misaligned against a background whose painting CARRIES visual anchors (the World/Characters captions are art). The substitution now reproduces retail's whole-frame behavior: the root KEEPS its authored 800x600 extent, and while the screen is active `UiRoot.FixedCanvasSize` scales EVERY emitted quad (widgets, glyphs, art, dialogs) uniformly at `TextRenderer.AppendQuad`, with the exact inverse applied to mouse coordinates at the `UiRoot` entry points so hit-testing lives in canvas space. Non-uniform window/canvas stretch, retail-authentic (no letterbox). `UiDatElement` keeps retail's pure copy-or-tile blit; the interim `StretchOwnBackgroundToFill` flag is deleted. | `src/AcDream.App/UI/UiRoot.cs` (`FixedCanvasSize`, `CanvasScale`, `MapWindowToCanvas`, `Draw`); `src/AcDream.App/Rendering/TextRenderer.cs` (`CanvasScale`, `AppendQuad`); `src/AcDream.App/UI/Layout/CharacterManagementUiController.cs` (activate/deactivate/dispose set+clear the canvas) | Reproducing retail's literal mechanism (an offscreen fixed-resolution UI render target scaled at presentation) would add RHI surface area for an identical pixel result; scaling at the one quad-emission chokepoint with an inverse input mapping is the same math applied one stage earlier, and the world-space HUD stays native because the scale is scoped to `UiRoot.Draw`. | Glyphs stretch with the frame (retail-authentic blur at large windows). Any future fixed-canvas screen (login/disconnected/datapatch) sets `UiRoot.FixedCanvasSize` while active — per-screen opt-in, not automatic. If a genuine present-time frame-stretch pass ever lands, this collapses into it. | `Graphic::Draw` 0x00693b20; `Graphic::PutImage` 0x00693a30; `UIElement::UpdateForParentSizeChange` 0x00462640; `BlitMode` acclient.h ~3135; `UIElementManager::CreateRootElement` 0x0045d020; `CharacterManagementLiveDatTests.RootAuthorsNoEdgeAnchors_RetailNeverResizesItSelf`; `UiRootFixedCanvasTests`; `UiDatElementTests.CanvasScale_StretchesQuadGeometry_LeavesUvsAuthored` | +| AD-98 | **Filed 2026-08-15 at Campaign LA gate round 2 (character-select background tiling).** The LA8 root (0x1000039A) authors LeftEdge=TopEdge=RightEdge=BottomEdge=0 ("no anchor") in the installed DAT, so retail's own `UIElement::UpdateForParentSizeChange` (0x00462640) never resizes this element — it stays a fixed 800x600 rect in retail's own widget tree. Retail's generic sprite blit, `Graphic::Draw` (0x00693b20) dispatching to `Graphic::PutImage` (0x00693a30) for an exact/undersized destination or a modulo-wrapped tile loop otherwise, has no third "stretch" mode (confirmed against `BlitMode`, acclient.h ~line 3135, and `MD_Data_Image::m_drawMode`/`DrawModeType` — both are COLOR-blend selectors, not tile-vs-stretch geometry modes). The only way retail's whole pre-world scene (background AND buttons AND listbox together) can still fill an arbitrary window resolution with no element ever resizing and a blitter that can only copy-or-tile is that these "flow" screens render into a fixed 800x600 target and the WHOLE FRAME is stretched once at presentation, outside the UI element/sprite system. **COMPLETED 2026-08-15 (same gate round, misalignment follow-up):** the first substitution (resize the mounted root + stretch only its own background) stretched the ART but left the authored child widgets at 800x600 pixel positions — misaligned against a background whose painting CARRIES visual anchors (the World/Characters captions are art). The substitution now reproduces retail's whole-frame behavior: the root KEEPS its authored 800x600 extent, and while the screen is active `UiRoot.FixedCanvasSize` scales EVERY emitted quad (widgets, glyphs, art, dialogs) uniformly at `TextRenderer.AppendQuad`, with the exact inverse applied to mouse coordinates at the `UiRoot` entry points so hit-testing lives in canvas space. Non-uniform window/canvas stretch, retail-authentic (no letterbox). `UiDatElement` keeps retail's pure copy-or-tile blit; the interim `StretchOwnBackgroundToFill` flag is deleted. | `src/AcDream.App/UI/UiRoot.cs` (`FixedCanvasSize`, `CanvasScale`, `MapWindowToCanvas`, `Draw`); `src/AcDream.App/Rendering/TextRenderer.cs` (`CanvasScale`, `AppendQuad`); `src/AcDream.App/UI/Layout/CharacterManagementUiController.cs` (activate/deactivate/dispose set+clear the canvas) | Reproducing retail's literal mechanism (an offscreen fixed-resolution UI render target scaled at presentation) would add RHI surface area for an identical pixel result; scaling at the one quad-emission chokepoint with an inverse input mapping is the same math applied one stage earlier, and the world-space HUD stays native because the scale is scoped to `UiRoot.Draw`. | Glyphs stretch with the frame (retail-authentic blur at large windows). **Gate round 2 filtering follow-up (2026-08-15):** the stretch now filters bilinearly — `TextureCache.GetOrCreateLinearUiTwin` gives every nearest-sampled UI texture (dat-font glyphs, composited icons) a linear-sampled twin that `TextRenderer.DrawSprite` swaps to while `CanvasScale != One` — matching retail's own bilinear-filtered presentation blit instead of aliasing the point-sampled art. Any future fixed-canvas screen (login/disconnected/datapatch) sets `UiRoot.FixedCanvasSize` while active — per-screen opt-in, not automatic. If a genuine present-time frame-stretch pass ever lands, this collapses into it. | `Graphic::Draw` 0x00693b20; `Graphic::PutImage` 0x00693a30; `UIElement::UpdateForParentSizeChange` 0x00462640; `BlitMode` acclient.h ~3135; `UIElementManager::CreateRootElement` 0x0045d020; `CharacterManagementLiveDatTests.RootAuthorsNoEdgeAnchors_RetailNeverResizesItSelf`; `UiRootFixedCanvasTests`; `UiDatElementTests.CanvasScale_StretchesQuadGeometry_LeavesUvsAuthored` | | AD-97 | **Filed 2026-08-14 at Campaign LA slice LA7a (character-restore request tail).** Retail's `CharacterRestore` request (`0xF7D9`) is ≥16 bytes: `CPlayerSystem::RestoreCharacter @0x0055d760` is, in the PDB-paired binary, `push 0x008173B4; push 0x008173B4; push guid; call Proto_UI::SendAdminRestoreCharacter @0x00546cf0`, and the callee packs BOTH constant `PStringBase*` arguments (`PStringBase::Pack @0x004fc6f0` emits ≥4 bytes even empty). Binary Ninja renders the two pushes as an uninitialized `edx` local plus `this` — a rendering artifact around constant `0x008173B4` (all 3 of its other pseudo-C appearances sit in provably-broken decompiles), but the arguments are real. acdream sends the 8-byte guid-only form. What the two constant strings contain is unresolved (a live cdb `db poi(0x008173b4)` would settle it). | `src/AcDream.Core.Net/Messages/CharacterRestore.cs` (`BuildRequestBody`) | ACE reads only `ReadUInt32()` and ignores any tail (`CharacterHandler.cs:331-385`), and holtburger ships guid-only from a real client command path against ACE successfully — the tail is unread by every server we can test against, and packing two strings whose CONTENT we cannot verify would be a guess. | A byte-capture comparison against a real retail client differs from offset 8; a future server that validates the full retail shape would reject our 8-byte request. | `CPlayerSystem::RestoreCharacter @0x0055d760` (binary bytes, not the BN rendering); `Proto_UI::SendAdminRestoreCharacter @0x00546cf0`; `PStringBase::Pack @0x004fc6f0`; ACE `CharacterHandler.cs:331-385`; holtburger `character_selection.rs:79-82`; LA7a Opus review F1 (2026-08-14) | | AD-93 | **Filed 2026-08-13 at social gate round 2, item 5 (the refused-drop notice port).** Two narrow gaps in the `ServerSaysAttemptFailed @0x0058EAE0` port: (1) **latched-guid preference** — retail's 0x00A0 dispatcher (`@0x0055B342`) PREFERS `prevRequestObjectID` over the wire guid when picking the item to name; acdream's `InventoryTransactionState.OnMoveFailed` instead REQUIRES the wire guid to match the latch (unobservable against ACE, which always sends the request's own guid on 0x00A0, and it protects a stale latch from mislabeling an unrelated failure — acdream has no retail-style latch timeout). (2) **unlatched request kinds** — retail latches `IR_MOVE`/`IR_WIELD` too; acdream's kind enum has no Move/Wield rows because wields ride `AutoWieldController` outside the single-request gate, so a refused wield/3D-move shows only the generic `HandleFailureEvent` leg, never "The X can't be wielded/moved". | `src/AcDream.Core/Items/InventoryTransactionState.cs` (`OnMoveFailed`); `src/AcDream.Core/Chat/InventoryFailureMessages.cs` (`Compose`'s absent Move/Wield rows); `src/AcDream.App/UI/ItemInteractionController.cs` (`OnInventoryRequestFailed`) | The match requirement is the compensating guard for the missing latch timeout; adding Wield/Move kinds means routing those sends through the single-request gate they deliberately bypass today — a behavior change beyond this gate item. | Only observable against a server that sends 0x00A0 with a guid that differs from the request's item (ACE never does), or on a refused wield/move, which shows no "can't be wielded/moved" verb line where retail would show one. | `ACCWeenieObject::ServerSaysAttemptFailed @0x0058EAE0`; the 0x00A0 dispatcher `@0x0055B342`; `ACCWeenieObject::RecordRequest @0x0058C220`; `docs/research/2026-08-13-confirm-and-weenie-error-display.md` §2 | diff --git a/src/AcDream.App/Composition/InteractionRetainedUiComposition.cs b/src/AcDream.App/Composition/InteractionRetainedUiComposition.cs index 4b16c5fd..b54b1f67 100644 --- a/src/AcDream.App/Composition/InteractionRetainedUiComposition.cs +++ b/src/AcDream.App/Composition/InteractionRetainedUiComposition.cs @@ -484,6 +484,12 @@ internal sealed class RetailInteractionRetainedUiCompositionFactory d.DebugFont, d.HostQuiescence)); checkpoint(InteractionRetainedUiCompositionPoint.UiHostAcquired); + // AD-98 filtering fidelity: re-wired unconditionally on every + // composition, same as the UiLocked assignment below — the lease can + // hand back a HOST from a previous session while d.TextureCache is a + // fresh instance for this one, so a stale resolver would keep + // resolving twins against a disposed TextureCache. + host.TextRenderer.LinearTwinResolver = d.TextureCache.GetOrCreateLinearUiTwin; inputCapture = d.RetainedInputCapture.Bind(host.Root); checkpoint(InteractionRetainedUiCompositionPoint.InputCaptureBound); // D7 Group-C re-point (Campaign OP OP4, 2026-08-11): server diff --git a/src/AcDream.App/Rendering/TextRenderer.cs b/src/AcDream.App/Rendering/TextRenderer.cs index 4aac444e..c66882f4 100644 --- a/src/AcDream.App/Rendering/TextRenderer.cs +++ b/src/AcDream.App/Rendering/TextRenderer.cs @@ -218,6 +218,21 @@ public sealed class TextRenderer : IDisposable /// internal Vector2 CanvasScale = Vector2.One; + /// + /// Campaign LA gate round 2 (register AD-98 filtering fidelity): resolves a + /// UI texture handle to its linear-sampled twin + /// (), consulted by + /// only while is not One. + /// Wired once by the composition root right after TextureCache exists; + /// left null by any test/host that never sets it, in which case a scaled + /// draw keeps sampling its original slot — nearest stays nearest, exactly + /// today's (jagged) behavior, rather than throwing. Nearest-sampled dat-font + /// glyphs and composited icons are the only handles this ever changes — + /// see the resolver's own doc comment for why chrome/background art passes + /// through unchanged. + /// + internal Func? LinearTwinResolver { get; set; } + /// Begin a HUD pass. Call once per frame before any Draw* calls. public void Begin(Vector2 screenSize) { @@ -365,6 +380,15 @@ public sealed class TextRenderer : IDisposable public void DrawSprite(uint texture, float x, float y, float w, float h, float u0, float v0, float u1, float v1, Vector4 tint) { + // AD-98 filtering fidelity: while a fixed-canvas screen is stretching + // every quad (CanvasScale != One), sample nearest-registered handles + // through their linear twin instead — see LinearTwinResolver's doc + // comment. The resolver itself is the identity for any handle that + // isn't a nearest-sampled UI texture, so this is safe to call + // unconditionally rather than needing its own "is this nearest" check. + if (CanvasScale != Vector2.One && LinearTwinResolver is { } resolve) + texture = resolve(texture); + SpriteSeg seg = OverlayMode ? NextSpriteSeg(_overlaySpriteSegs, ref _overlaySegUsed, texture) : NextSpriteSeg(_spriteSegs, ref _segUsed, texture); diff --git a/src/AcDream.App/Rendering/TextureCache.cs b/src/AcDream.App/Rendering/TextureCache.cs index 4a3ead6f..7dd8a312 100644 --- a/src/AcDream.App/Rendering/TextureCache.cs +++ b/src/AcDream.App/Rendering/TextureCache.cs @@ -53,6 +53,20 @@ public sealed class TextureCache // GPU texture objects/slots until process exit. private readonly List _adhocGpuTextures = new(); + // Campaign LA gate round 2 (AD-98 filtering fidelity): the ORIGINAL IGpuTexture + // behind every handle UploadUiTexture registered nearest (dat-font glyph + // atlases, IconComposer's composited icons). Populated at upload time so + // GetOrCreateLinearUiTwin never has to search either keyed family above to + // find the pixels a twin should reuse. Chrome/background art (nearest: false) + // never enters this table — it already samples GpuSamplerDescription.WorldRepeat + // (linear) and has no twin to create. + private readonly Dictionary _nearestUiTextureSources = new(); + + // The LINEAR-sampled twin handle for a nearest handle, created lazily by + // GetOrCreateLinearUiTwin on its first request and reused after. Empty for + // the lifetime of a session that never activates a fixed-canvas screen. + private readonly Dictionary _linearUiTwinHandles = new(); + private readonly CompositeTextureArrayCache? _compositeTextures; private bool _destinationRevealUploadPriority; @@ -359,6 +373,14 @@ public sealed class TextureCache IGpuSampler sampler = _device.CreateSampler(nearest ? UiNearestRepeat : GpuSamplerDescription.WorldRepeat); GpuTextureSlot slot = _device.RegisterTexture(texture, sampler); + uint handle = UiTextureTableHandle.FromSlot(slot); + if (nearest) + { + // AD-98 filtering fidelity: remember the source texture under its + // handle so a fixed-canvas screen can request a linear twin of it + // later without re-decoding. See GetOrCreateLinearUiTwin. + _nearestUiTextureSources[handle] = texture; + } return new GpuUiTextureEntry(texture, slot, glName, decoded.Width, decoded.Height); } catch @@ -368,6 +390,60 @@ public sealed class TextureCache } } + /// + /// Campaign LA gate round 2 (register AD-98): the LINEAR-sampled twin of a + /// nearest-sampled UI texture handle, created and table-registered the first + /// time it is requested and reused after. + /// + /// + /// Nearest is correct at the UI's native 1:1 scale — it is what makes + /// dat-font glyphs and composited item icons pixel-exact retail art. Retail's + /// own fixed-canvas pre-world screens never stretch a source texture at all: + /// they compose at authored size and the WHOLE FRAME goes through a single + /// bilinear-filtered presentation blit (see + /// 's doc comment for the + /// retail citation). acdream has no present-time frame stretch to hang that + /// on, so the equivalent has to live one step earlier, at the source texture: + /// while is scaling the composed quads + /// themselves, this method gives a nearest handle a same-pixels twin sampled + /// LINEAR instead, so the stretch softens the way retail's frame blit did + /// rather than aliasing. + /// + /// + /// + /// Returns UNCHANGED for anything this cache never + /// registered nearest — chrome/background art already samples + /// (linear) and has nothing to + /// swap, and (DrawFill's untextured + /// branch) is not a texture at all. Callers do not need to know which case + /// they're in: this is a cheap dictionary probe either way, so + /// can call it unconditionally whenever + /// the canvas is scaled. + /// + /// + /// + /// The twin reuses the ORIGINAL — no re-decode, no + /// second upload, no additional bytes tracked in the memory ledger — and + /// occupies one more device texture-table slot, exactly the shape + /// 's (surface, wrap) keying already uses to + /// register one texture under two samplers. Lazy: a session that never + /// activates a fixed-canvas screen never creates one. + /// + /// + internal uint GetOrCreateLinearUiTwin(uint handle) + { + if (!_nearestUiTextureSources.TryGetValue(handle, out IGpuTexture? texture)) + return handle; + if (_linearUiTwinHandles.TryGetValue(handle, out uint twin)) + return twin; + + IGpuSampler linearSampler = _device.CreateSampler(GpuSamplerDescription.WorldRepeat); + GpuTextureSlot twinSlot = _device.RegisterTexture(texture, linearSampler); + uint twinHandle = UiTextureTableHandle.FromSlot(twinSlot); + _linearUiTwinHandles[handle] = twinHandle; + return twinHandle; + } + /// /// The identity a UI upload is accounted under. There is no GL name on the /// Vulkan-only backend, so a descending synthetic counter supplies one; the @@ -994,6 +1070,15 @@ public sealed class TextureCache _paletteIndexedByTexture.Clear(); + // Campaign LA gate round 2 (AD-98): linear twin slots. Each one is a + // SECOND table registration of a texture another family below owns and + // disposes — release the slot here, before that texture goes away, and + // never touch the texture itself (that would double-dispose it). + foreach (uint twinHandle in _linearUiTwinHandles.Values) + _device.ReleaseTextureSlot(UiTextureTableHandle.ToSlot(twinHandle)); + _linearUiTwinHandles.Clear(); + _nearestUiTextureSources.Clear(); + // RenderSurface (UI sprite) textures — Campaign V slice V4a: each // entry's IGpuTexture.Dispose() releases the underlying GL name // through the device's own retirement queue, so only the memory- diff --git a/tests/AcDream.App.Tests/Rendering/TextRendererLinearTwinTests.cs b/tests/AcDream.App.Tests/Rendering/TextRendererLinearTwinTests.cs new file mode 100644 index 00000000..89402a52 --- /dev/null +++ b/tests/AcDream.App.Tests/Rendering/TextRendererLinearTwinTests.cs @@ -0,0 +1,106 @@ +using System.Numerics; +using AcDream.App.Rendering; +using AcDream.App.Rendering.Gpu; +using AcDream.App.Tests.Rendering.Gpu; +using Xunit; + +namespace AcDream.App.Tests.Rendering; + +/// +/// Campaign LA gate round 2 (register AD-98 filtering fidelity, 2026-08-15): +/// pins 's texture-swap seam — +/// , consulted only while +/// is not — the +/// half of the fix that doesn't need a live GPU. The user-visible symptom this +/// answers: the fixed-canvas char-select stretch (73041d70) reported JAGGED +/// text, because dat-font glyph atlases upload nearest (pixel-exact at 1:1) and +/// stayed nearest even while every quad was being magnified 2.4×1.8. The actual +/// linear-twin CREATION lives in TextureCache.GetOrCreateLinearUiTwin +/// (GPU-backed, see TextureCacheLinearTwinTests); this file proves the +/// RENDERER SIDE of the seam — segment handle selection — using a fake resolver +/// so the assertion doesn't depend on TextureCache's own wiring being correct. +/// +public sealed class TextRendererLinearTwinTests +{ + private sealed class NullGpuFrameSource : ICurrentGpuFrameSource + { + public IGpuFrame? CurrentFrame => null; + } + + private static TextRenderer BuildRenderer() + { + var device = new RecordingGpuDevice(); + var renderer = new TextRenderer(device, new NullGpuFrameSource(), "unused"); + renderer.Begin(new Vector2(800f, 600f)); + return renderer; + } + + [Fact] + public void CanvasScaleOne_DrawSprite_NeverConsultsResolver_KeepsOriginalHandle() + { + // At the native 1:1 scale (every in-world/UI frame today) the resolver + // must not even be CALLED, not just "called and return the same value" — + // a resolver that throws proves the ordinary path pays zero overhead for + // a feature it never activates, exactly the "lazy" design constraint the + // Campaign LA round-2 follow-up was scoped to. + TextRenderer renderer = BuildRenderer(); + renderer.LinearTwinResolver = _ => throw new System.InvalidOperationException( + "LinearTwinResolver must not be consulted while CanvasScale == One."); + + renderer.DrawSprite(5u, 0, 0, 10, 10, 0, 0, 1, 1, Vector4.One); + + var seg = Assert.Single(renderer.DebugSpriteSegments); + Assert.Equal(5u, seg.Texture); + } + + [Fact] + public void CanvasScaleNotOne_DrawSprite_SwapsHandleThroughResolver() + { + // The fixed-canvas case: CanvasScale is set by UiRoot.Draw for the + // duration of a fixed-canvas screen's tree. A nearest-registered dat-font + // glyph handle (5) must draw through its linear twin (999), not itself. + TextRenderer renderer = BuildRenderer(); + renderer.CanvasScale = new Vector2(2.4f, 1.8f); + renderer.LinearTwinResolver = handle => handle == 5u ? 999u : handle; + + renderer.DrawSprite(5u, 0, 0, 10, 10, 0, 0, 1, 1, Vector4.One); + + var seg = Assert.Single(renderer.DebugSpriteSegments); + Assert.Equal(999u, seg.Texture); + } + + [Fact] + public void CanvasScaleNotOne_ResolverIsIdentityForUnknownHandles() + { + // Chrome/background art (never registered nearest) and + // UiTextureTableHandle.None (DrawFill's untextured branch) are the + // majority of scaled-canvas draws. TextureCache.GetOrCreateLinearUiTwin + // returns them unchanged; this pins that TextRenderer forwards whatever + // the resolver returns without a separate "was this swapped" branch. + TextRenderer renderer = BuildRenderer(); + renderer.CanvasScale = new Vector2(2.4f, 1.8f); + renderer.LinearTwinResolver = handle => handle == 5u ? 999u : handle; + + renderer.DrawSprite(7u, 0, 0, 10, 10, 0, 0, 1, 1, Vector4.One); + + var seg = Assert.Single(renderer.DebugSpriteSegments); + Assert.Equal(7u, seg.Texture); + } + + [Fact] + public void CanvasScaleNotOne_NoResolverWired_KeepsOriginalHandle_DoesNotThrow() + { + // A host/test that never wires LinearTwinResolver (every existing + // TextRenderer construction site before this change, and any future + // test double) must keep drawing — nearest stays nearest, the + // pre-existing (if jagged) behavior, rather than a null-reference + // failure the moment a fixed-canvas screen activates. + TextRenderer renderer = BuildRenderer(); + renderer.CanvasScale = new Vector2(2.4f, 1.8f); + + renderer.DrawSprite(5u, 0, 0, 10, 10, 0, 0, 1, 1, Vector4.One); + + var seg = Assert.Single(renderer.DebugSpriteSegments); + Assert.Equal(5u, seg.Texture); + } +} diff --git a/tests/AcDream.App.Tests/Rendering/TextureCacheLinearTwinTests.cs b/tests/AcDream.App.Tests/Rendering/TextureCacheLinearTwinTests.cs new file mode 100644 index 00000000..d960d25a --- /dev/null +++ b/tests/AcDream.App.Tests/Rendering/TextureCacheLinearTwinTests.cs @@ -0,0 +1,124 @@ +using System.Linq; +using AcDream.App.Rendering; +using AcDream.App.Rendering.Gpu; +using AcDream.App.Tests.Rendering.Gpu; +using Xunit; + +namespace AcDream.App.Tests.Rendering; + +/// +/// Campaign LA gate round 2 (register AD-98 filtering fidelity, 2026-08-15): +/// pins — the GPU-table half +/// of the fixed-canvas jagged-text fix (TextRendererLinearTwinTests pins +/// the renderer-side handle swap this method feeds). +/// +/// +/// Uses rather than +/// to get a nearest-sampled +/// handle without any DAT fixture — UploadRgba8 never touches the injected +/// IDatReaderWriter, so the simple TextureCache(device, dats) +/// constructor can run with / +/// and no live GPU, matching this suite's existing renderer-test-double idiom. +/// +/// +public sealed class TextureCacheLinearTwinTests +{ + private static (RecordingGpuDevice device, TextureCache cache) Build() + { + var device = new RecordingGpuDevice(); + // UploadRgba8/GetOrCreateLinearUiTwin/Dispose never touch the dats + // reference — see the class doc comment. + var cache = new TextureCache(device, dats: null!); + // RecordingGpuDevice's own constructor registers a 1x1 default-white + // placeholder (DefaultTextureSlot) — clear that registration out of the + // recorded call log so each test's assertions only see the + // registrations IT caused. Clear() only wipes the call log, not the + // slot/sampler state, so DefaultTextureSlot itself is untouched. + device.Clear(); + return (device, cache); + } + + [Fact] + public void UnknownHandle_ReturnsUnchanged() + { + // Chrome/background art (never registered nearest) and any handle this + // cache never saw (including UiTextureTableHandle.None == 0) pass + // through untouched — there is nothing to swap. + (_, TextureCache cache) = Build(); + + Assert.Equal(0u, cache.GetOrCreateLinearUiTwin(0u)); + Assert.Equal(12345u, cache.GetOrCreateLinearUiTwin(12345u)); + } + + [Fact] + public void NearestHandle_GetsADifferentTwinHandle_SampledLinear() + { + (RecordingGpuDevice device, TextureCache cache) = Build(); + byte[] rgba = new byte[4 * 4 * 4]; + uint nearestHandle = cache.UploadRgba8(rgba, 4, 4, nearest: true); + + uint twinHandle = cache.GetOrCreateLinearUiTwin(nearestHandle); + + Assert.NotEqual(0u, twinHandle); + Assert.NotEqual(nearestHandle, twinHandle); + + // The SECOND registration recorded against the device (the first is the + // original nearest upload) must carry a linear filter — the whole point + // of the twin. + var registrations = device.OfKind().ToList(); + Assert.Equal(2, registrations.Count); + Assert.Equal(GpuFilter.Nearest, registrations[0].Sampler.MinFilter); + Assert.Equal(GpuFilter.Linear, registrations[1].Sampler.MinFilter); + Assert.Equal(GpuFilter.Linear, registrations[1].Sampler.MagFilter); + + // Both registrations name the SAME underlying texture — the twin reuses + // the original decoded pixels rather than re-uploading. + Assert.Equal(registrations[0].TextureName, registrations[1].TextureName); + } + + [Fact] + public void NearestHandle_RepeatedRequest_ReturnsTheSameCachedTwin() + { + (RecordingGpuDevice device, TextureCache cache) = Build(); + byte[] rgba = new byte[4 * 4 * 4]; + uint nearestHandle = cache.UploadRgba8(rgba, 4, 4, nearest: true); + + uint first = cache.GetOrCreateLinearUiTwin(nearestHandle); + uint second = cache.GetOrCreateLinearUiTwin(nearestHandle); + + Assert.Equal(first, second); + // Exactly one twin registration — the second request must not create + // another device-table slot. + Assert.Equal(2, device.OfKind().Count()); + } + + [Fact] + public void NonNearestUpload_HasNoTwin() + { + // UploadRgba8's default (nearest: false) mirrors chrome/background art: + // it already samples GpuSamplerDescription.WorldRepeat (linear), so it + // never enters the nearest-source table and GetOrCreateLinearUiTwin + // hands the same handle straight back. + (_, TextureCache cache) = Build(); + byte[] rgba = new byte[4 * 4 * 4]; + uint linearHandle = cache.UploadRgba8(rgba, 4, 4, nearest: false); + + Assert.Equal(linearHandle, cache.GetOrCreateLinearUiTwin(linearHandle)); + } + + [Fact] + public void Dispose_ReleasesTheTwinSlot() + { + (RecordingGpuDevice device, TextureCache cache) = Build(); + byte[] rgba = new byte[4 * 4 * 4]; + uint nearestHandle = cache.UploadRgba8(rgba, 4, 4, nearest: true); + uint twinHandle = cache.GetOrCreateLinearUiTwin(nearestHandle); + GpuTextureSlot twinSlot = UiTextureTableHandle.ToSlot(twinHandle); + + cache.Dispose(); + + Assert.Contains( + device.OfKind(), + release => release.Slot == twinSlot.Index); + } +}