erik/acdream
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions

feat(render): Campaign V slice V4a - port TextRenderer/BitmapFont/DebugLineRenderer/TextureCache UI path onto IGpuDevice

Browse source 
Second attempt at V4a after ceec3bc4 was reverted at 9aaf97e7 for losing world
multisampling and a 334-file scope explosion. This lands the same functional
slice with a much smaller footprint and the two structural fixes the revert
postmortem (docs/plans/2026-07-27-vulkan-campaign.md SS7.1) called for.

What moved onto the RHI:
- TextRenderer: the ui_text shader now compiles through IGpuDevice.CreatePipeline
  (one IGpuPipeline, replacing the old hand-rolled Shader class); its three
  fence-buffered per-flight VBOs are gone in favour of a per-IGpuFrame ring
  allocation per draw bucket; its 1x1 white fill texture is created via
  IGpuDevice.CreateTexture and registered into the device's texture table.
  Flush keeps TextRenderGlStateScope and the manual GL disable block verbatim
  (TextRendererFailureSafetyTests pins their literal presence) alongside the
  new pipeline bind - both target the identical final GL state, so this is
  redundant, not contradictory. Sprite/font texture binding stays classic
  (glActiveTexture/glBindTexture) because DrawSprite receives arbitrary
  externally-owned GL texture names from dozens of UI call sites outside this
  slice's scope; IGpuPassEncoder has no verb for that, by design (every other
  RHI consumer samples through the bindless texture table).
- BitmapFont: the stb-baked R8 atlas is created/uploaded through
  IGpuDevice.CreateTexture; TextureId stays a raw GL name extracted from the
  IGpuTexture, since its only consumer is TextRenderer's classic path above.
- DebugLineRenderer: the debug_line shader compiles through
  IGpuDevice.CreatePipeline (LineList topology, depth disabled); Flush ring-
  allocates its vertex data and draws through IGpuPassEncoder. uView/uProjection
  don't fit the shared GpuPushConstants block (one combined VP matrix) so they
  are set directly on the pipeline's compiled program, mirroring TextRenderer.
- TextureCache: GetOrUploadRenderSurface and the public UploadRgba8(byte[],...)
  wrapper now create IGpuTexture+GpuTextureSlot internally, extracting the raw
  GL name for their unchanged uint return type - DrawSprite's signature and its
  16 call sites across the UI are untouched. The world-material path
  (GetOrUpload, the raw layer-array upload) is untouched.
- UiViewport: TextureHandle (uint) -> TextureSlot (GpuTextureSlot), resolved
  back to a raw GL name via TextRenderer.ResolveExternalTextureSlot at draw
  time. Its texture is produced by PaperdollViewportRenderer/
  PrivateEntityViewportRenderer, both still raw GL until V4g, so
  RetailPaperdollFrameView/RetailCreatureAppraisalFrameView register it through
  the pre-approved GlGpuDevice.RegisterExternalColorTexture transitional seam
  (campaign doc SS7.1's final paragraph) instead of inventing anything broader.

The two revert-postmortem fixes, both in Gpu/Gl (never in the pinned Gpu/
contract):
- GlGpuDevice.BeginPass now resets the render-state cache unconditionally on
  every pass, not only a clearing one. The first attempt's crash came from
  exactly this gap: a raw-GL renderer running between two RHI passes changes
  GL program/blend/depth/cull state the cache never observes, so a later
  BindPipeline skipped re-issuing glUseProgram and the following push-constant
  upload threw GL_INVALID_OPERATION.
- GlGpuPassEncoder now captures ambient GL capability state (program, VAO,
  array buffer, texture0 binding, depth test/write/func, blend enable+func,
  cull enable+mode, front face, alpha-to-coverage, multisample) on construction
  and restores it on Dispose, generalizing what TextRenderGlStateScope already
  did for TextRenderer specifically to every RHI pass - this is what stops
  DebugLineRenderer's pipeline bind (which has no scope of its own) from
  leaking state into the next raw-GL renderer. Both are marked transitional,
  deleted at V4h once nothing raw-GL remains.

Frame lifecycle (additive, per the task's own description of this piece):
new GpuDeviceFrameLifetime wraps IGpuDevice.BeginFrame()/IGpuFrame.End() and
exposes the open frame via ICurrentGpuFrameSource. RenderFrameOrchestrator's
IRenderFrameLifetime now routes through this wrapper instead of calling
GpuFrameFlightController directly - GlGpuDevice.BeginFrame already calls
straight through to that same controller, so the fence/slot-rotation contract
is unchanged; the wrapper only additionally yields the IGpuFrame ported
renderers need. No clears moved, no framebuffer binding changed, frame-graph
phase order is untouched. The two now-dead per-slot TextRenderer.BeginFrame(int)
calls in RuntimeRenderFrameBeginResources are removed. The UI Studio
(RenderBootstrap/StudioWindow) gets its own independent RHI device+lifetime,
mirroring the production composition.

Real bug found and fixed while exercising this for the first time: both
BitmapFont and TextureCache's nearest-filter override called TexParameter
AFTER RegisterTexture, which made the bindless handle resident - GL_ARB_
bindless_texture forbids modifying a texture's parameters once its handle is
resident, so this threw GL_INVALID_OPERATION building the retained UI's own
TextRenderer. Fixed by moving both TexParameter blocks before RegisterTexture.

Scope note: touches 25 files (24 modified + this commit's one new file), not
the ~10 the brief estimated, because the frame-lifecycle wiring and the
viewport escape hatch (both explicitly asked for) ripple through five
composition files and two frame presenters that thread IGpuDevice/
ICurrentGpuFrameSource to construction sites. No file outside that necessary
set was touched: no visibility sweep beyond the specific constructors/
properties whose new parameter types are internal (TextRenderer/BitmapFont/
DebugLineRenderer/UiHost's constructors, TextureCache's otherwise-orphaned
convenience overload, UiViewport.TextureSlot), no world-mesh/terrain/particle/
sky file touched, no test deleted or weakened - three source-text conformance
tests (TextRendererPublishesEveryConstructorResourceBeforeLaterGlWork,
GlTextureOwnershipTests' TextRenderer.cs check, and
RenderFrameResourceControllerTests' frame-order check) were replaced with
equivalent assertions against the new construction/wiring shape, since their
pinned invariant was specifically the old raw-GL shape this slice legitimately
replaces.

Gates:
- dotnet build -c Release: 0 warnings, 0 errors.
- dotnet test tests/AcDream.App.Tests -c Release: 3,843 passed / 3 skipped -
  exactly the baseline. Complete solution: 8,906 passed / 5 skipped across all
  nine test projects.
- Offline pixel gate (tools/run-offline-pixel-gate.ps1, parent a97e04ae vs this
  commit): 26 differing pixels of 563,200 compared (fraction 4.62e-05), pass
  against the 0.001/563-pixel threshold. Verified against a same-commit control
  (two captures at this commit differ by 20 pixels) rather than accepted at
  face value - the two numbers are in the same band, confirming this is normal
  animated-content/frame-pacing noise and not the systematic silhouette-edge
  loss (1,791 pixels, 224x higher) the first attempt's revert diagnosed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Erik 2026-07-27 19:37:19 +02:00
parent a97e04ae3d
commit 096dd203fa
26 changed files with 954 additions and 467 deletions
Download patch file Download diff file Expand all files Collapse all files

4
tests/AcDream.App.Tests/Composition/HostInputCameraCompositionTests.cs
View file

@ -159,6 +159,7 @@ public sealed class HostInputCameraCompositionTests
{
public GpuFrameFlightController? GpuFrames { get; private set; }
public IGpuDevice? GpuDevice { get; private set; }
public GpuDeviceFrameLifetime? GpuFrameLifetime { get; private set; }
public SilkKeyboardSource? Keyboard { get; private set; }
public SilkMouseSource? Mouse { get; private set; }
public IMouseLookCursor? Cursor { get; private set; }
@ -172,6 +173,9 @@ public sealed class HostInputCameraCompositionTests
public void PublishGpuDevice(IGpuDevice value) =>
GpuDevice = PublishOnce(GpuDevice, value);
public void PublishGpuFrameLifetime(GpuDeviceFrameLifetime value) =>
GpuFrameLifetime = PublishOnce(GpuFrameLifetime, value);
public void PublishKeyboardSource(SilkKeyboardSource value) =>
Keyboard = PublishOnce(Keyboard, value);

4
tests/AcDream.App.Tests/Composition/InteractionRetainedUiCompositionTests.cs
View file

@ -215,7 +215,9 @@ public sealed class InteractionRetainedUiCompositionTests
ExistingVitals: null,
Toast: null,
ClientTime: static () => 0d,
Log: static _ => { });
Log: static _ => { },
GpuDevice: null!,
GpuFrameSource: null!);
}
public InteractionRetainedUiDependencies Dependencies { get; }

1
tests/AcDream.App.Tests/Composition/SettingsDevToolsCompositionTests.cs
View file

@ -218,6 +218,7 @@ public sealed class SettingsDevToolsCompositionTests
null!,
null!,
null!,
null!,
null,
null,
null,

16
tests/AcDream.App.Tests/Composition/WorldRenderCompositionTests.cs
View file

@ -2,9 +2,11 @@ using System.Collections.Concurrent;
using System.Runtime.CompilerServices;
using AcDream.App.Composition;
using AcDream.App.Rendering;
using AcDream.App.Rendering.Gpu;
using AcDream.App.Rendering.Wb;
using AcDream.App.Rendering.Residency;
using AcDream.App.World;
using AcDream.App.Tests.Rendering.Gpu;
using AcDream.Content;
using AcDream.Core.Physics;
using AcDream.Core.Terrain;
@ -147,6 +149,7 @@ public sealed class WorldRenderCompositionTests
{
private readonly WorldRenderCompositionPoint? _failurePoint;
private readonly ResidencyBudgetOptions _budgets;
private readonly IGpuDevice _gpuDevice = new RecordingGpuDevice();
public Fixture(
bool hasFont = true,
@ -179,7 +182,9 @@ public sealed class WorldRenderCompositionTests
_budgets,
0xA9B4FFFFu,
Path.Combine(Path.GetTempPath(), "acdream-tests"),
_ => { }),
_ => { },
_gpuDevice,
new GpuDeviceFrameLifetime(_gpuDevice)),
Publication,
Factory,
point =>
@ -248,15 +253,17 @@ public sealed class WorldRenderCompositionTests
public SceneLightingUboBinding CreateSceneLighting(GL gl) =>
Resource<SceneLightingUboBinding>("scene lighting");
public DebugLineRenderer CreateDebugLines(GL gl, string shadersDirectory) =>
public DebugLineRenderer CreateDebugLines(
IGpuDevice device, ICurrentGpuFrameSource frameSource, string shadersDirectory) =>
Resource<DebugLineRenderer>("debug lines");
public byte[]? TryLoadDebugFont() => hasFont ? [1] : null;
public BitmapFont CreateDebugFont(GL gl, byte[] bytes) =>
public BitmapFont CreateDebugFont(IGpuDevice device, byte[] bytes) =>
Resource<BitmapFont>("debug font");
public TextRenderer CreateTextRenderer(GL gl, string shadersDirectory) =>
public TextRenderer CreateTextRenderer(
IGpuDevice device, ICurrentGpuFrameSource frameSource, string shadersDirectory) =>
Resource<TextRenderer>("text renderer");
public TerrainModernRenderer CreateTerrain(
@ -295,6 +302,7 @@ public sealed class WorldRenderCompositionTests
public TextureCache CreateTextureCache(
GL gl,
IGpuDevice device,
IDatReaderWriter dats,
BindlessSupport bindless,
IGpuResourceRetirementQueue retirement,

30
tests/AcDream.App.Tests/Rendering/GlTextureOwnershipTests.cs
View file

@ -104,6 +104,14 @@ public sealed class GlTextureOwnershipTests
root, "src", "AcDream.App", "Rendering", "ShaderProgramConstruction.cs"));
string terrain = File.ReadAllText(Path.Combine(
root, "src", "AcDream.App", "Rendering", "TerrainAtlas.cs"));
// Campaign V slice V4a: TextRenderer's shader/texture creation moved
// from raw GlResourceCommand calls to IGpuDevice.CreatePipeline/
// CreateTexture, whose own checked-commit construction
// (GlResourceCommand.CreateName / ShaderProgramConstruction.Build,
// predating this slice) is what those two now delegate to. What
// TextRenderer's OWN constructor still owns is the ordered
// pipeline-then-texture sequence and disposing whichever of the two
// it already created if the other throws.
string text = File.ReadAllText(Path.Combine(
root, "src", "AcDream.App", "Rendering", "TextRenderer.cs"));
string bindless = File.ReadAllText(Path.Combine(
@ -116,12 +124,30 @@ public sealed class GlTextureOwnershipTests
Assert.Contains("GlResourceCommand.DeleteProgram", shaderPrograms, StringComparison.Ordinal);
Assert.Contains("_anisotropyBindingMutation.Execute", terrain, StringComparison.Ordinal);
Assert.Contains("GlResourceCommand.DeleteTexture", terrain, StringComparison.Ordinal);
Assert.Contains("GlResourceCommand.CreateTexture", text, StringComparison.Ordinal);
Assert.Contains("GlResourceCommand.Execute", text, StringComparison.Ordinal);
AssertAppearsInOrder(
text,
"pipeline = device.CreatePipeline(",
"whiteTexture = device.CreateTexture(",
"catch",
"whiteTexture?.Dispose();",
"pipeline?.Dispose();",
"throw;");
Assert.Contains("make bindless handle", bindless, StringComparison.Ordinal);
Assert.Contains("GlResourceCommand.Execute", bindless, StringComparison.Ordinal);
}
private static void AssertAppearsInOrder(string source, params string[] needles)
{
int cursor = -1;
foreach (string needle in needles)
{
int next = source.IndexOf(needle, cursor + 1, StringComparison.Ordinal);
Assert.True(next >= 0, $"Missing expected source fragment: {needle}");
Assert.True(next > cursor, $"Out-of-order source fragment: {needle}");
cursor = next;
}
}
[Fact]
public void SecondBindlessAcquireFailureRollsBackFirstHandle()
{

7
tests/AcDream.App.Tests/Rendering/RenderFrameResourceControllerTests.cs
View file

@ -49,6 +49,11 @@ public sealed class RenderFrameResourceControllerTests
{
string source = ResourceSource();
// Campaign V slice V4a: the world-HUD and retained-UI TextRenderers no
// longer take a per-slot begin call — they now read the shared
// IGpuFrame ring reset once per frame by IGpuDevice.BeginFrame() (see
// GpuDeviceFrameLifetime), so _worldText/_uiText are gone from this
// sequence.
AssertAppearsInOrder(
source,
"_textures?.BeginCompositeTextureFrame();",
@ -56,8 +61,6 @@ public sealed class RenderFrameResourceControllerTests
"_dispatcher?.BeginFrame(gpuSlot);",
"_environmentCells?.BeginFrame(gpuSlot);",
"_portalDepth?.BeginFrame(gpuSlot);",
"_worldText?.BeginFrame(gpuSlot);",
"_uiText?.BeginFrame(gpuSlot);",
"_clip?.BeginFrame(gpuSlot);",
"_terrain?.BeginFrame(gpuSlot);",
"_lighting?.BeginFrame(gpuSlot);");

46
tests/AcDream.App.Tests/Rendering/ResourceCleanupGroupTests.cs
View file

@ -130,8 +130,19 @@ public sealed class ResourceCleanupGroupTests
StringComparison.Ordinal);
}
/// <summary>
/// Campaign V slice V4a: TextRenderer's constructor no longer owns raw
/// VAO/VBO/texture GL names through a ResourceCleanupGroup ledger — it
/// creates exactly two device-owned resources (a pipeline, then the white
/// fill texture) and, since a later failure could otherwise orphan an
/// already-created pipeline, disposes whichever of the two it already
/// created if the other throws. This replaces the pre-V4a assertion of
/// the same name, which pinned the old multi-resource raw-GL shape
/// (Shader + three flight-indexed VAO/VBO pairs + a hand-rolled white
/// texture) that no longer exists.
/// </summary>
[Fact]
public void TextRendererPublishesEveryConstructorResourceBeforeLaterGlWork()
public void TextRendererDisposesWhicheverConstructorResourceAlreadyExistsOnFailure()
{
string source = File.ReadAllText(Path.Combine(
FindRepoRoot(),
@ -142,27 +153,18 @@ public sealed class ResourceCleanupGroupTests
AssertAppearsInOrder(
source,
"shader = new Shader(gl,",
"resources.Add(\"text shader\", shader.Dispose);",
"frameBuffers[i] = CreateFrameBufferSet(resources);",
"whiteTexture = GlResourceCommand.CreateTexture(",
"resources.Add(",
"\"white texture\"",
"GlResourceCommand.Execute(",
"initialize TextRenderer white texture",
"resources.RetryCleanup();",
"_resources = resources;");
AssertAppearsInOrder(
source,
"private FrameBufferSet CreateFrameBufferSet(ResourceCleanupGroup resources)",
"TrackedGlResource.CreateVertexArray(",
"resources.Add(\"frame VAO\", vaoRelease.Run);",
"TrackedGlResource.CreateBuffer(",
"resources.Add(",
"\"frame VBO\"");
Assert.Contains("_resources.RetryCleanup();", source, StringComparison.Ordinal);
Assert.DoesNotContain("private FrameBufferSet CreateFrameBufferSet()", source,
StringComparison.Ordinal);
"IGpuPipeline? pipeline = null;",
"IGpuTexture? whiteTexture = null;",
"try",
"pipeline = device.CreatePipeline(",
"whiteTexture = device.CreateTexture(",
"device.RegisterTexture(whiteTexture, whiteSampler);",
"catch",
"whiteTexture?.Dispose();",
"pipeline?.Dispose();",
"throw;",
"_pipeline = pipeline;",
"_whiteTexture = whiteTexture;");
}
[Fact]