1da178d9ba
The dense-Arwic re-measure crashed with VK_ERROR_DEVICE_LOST: between ordered ranges the walk leaf draws (terrain, shells, sky, punch fans) and RetailAlphaQueue flushes rebind the SAME set-0 storage slots to their own sections, so the bind-once latch made the next range draw against foreign buffers - out-of-bounds instance reads and a GPU fault. Sections now re-bind on every DrawOrderedRange call, exactly like the proven DrawPreparedAlphaBatchRhi; the once-per-frame ring WRITES in PrepareOrderedStream (the actual measured cost) are unchanged. The bind-once referee test flips to assert per-range rebinds with unchanged draw coverage. Suites: full Release build 0 warnings; hermetic 6,758/0. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
789 lines
30 KiB
C#
789 lines
30 KiB
C#
using System.Collections.ObjectModel;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Numerics;
|
|
using AcDream.App.Rendering;
|
|
using AcDream.App.Rendering.Gpu;
|
|
using AcDream.App.Rendering.Gpu.Vk;
|
|
using AcDream.App.Rendering.Wb;
|
|
using AcDream.App.Rendering.Walk;
|
|
using AcDream.App.Tests.Rendering.Gpu;
|
|
using AcDream.Content;
|
|
using AcDream.Core.Meshing;
|
|
using DatReaderWriter;
|
|
using DatReaderWriter.DBObjs;
|
|
using DatReaderWriter.Enums;
|
|
using DatReaderWriter.Lib.IO;
|
|
using Microsoft.Extensions.Logging.Abstractions;
|
|
|
|
namespace AcDream.App.Tests.Rendering.Walk;
|
|
|
|
/// <summary>
|
|
/// Campaign FW stage FW2: <see cref="WbDrawDispatcher.BuildOrderedMergeRuns"/>
|
|
/// (pure CPU merge-run legality) and, from Campaign FW stage FW3.4a,
|
|
/// <see cref="WbDrawDispatcher.PrepareOrderedStream"/> +
|
|
/// <see cref="WbDrawDispatcher.DrawOrderedRange"/> (the same legality proven
|
|
/// through actual recorded RHI calls against <see cref="RecordingGpuDevice"/>,
|
|
/// replacing the single <c>SubmitOrderedStream</c> call those two now split).
|
|
/// </summary>
|
|
public sealed class OrderPreservingSubmitterTests
|
|
{
|
|
private static OrderedDrawCommand MakeCommand(
|
|
int index,
|
|
WalkDrawStage stage = WalkDrawStage.Terrain,
|
|
TranslucencyKind translucency = TranslucencyKind.Opaque,
|
|
CullMode cullMode = CullMode.CounterClockwise,
|
|
uint detailCategory = 0) =>
|
|
new(
|
|
Key: new GroupKey(
|
|
FirstIndex: (uint)index * 3,
|
|
BaseVertex: index * 4,
|
|
IndexCount: 3,
|
|
TextureSlot: new GpuTextureSlot((uint)index),
|
|
TextureLayer: 0,
|
|
Translucency: translucency,
|
|
FoliageFlags: 0,
|
|
CullMode: cullMode),
|
|
Transform: Matrix4x4.CreateTranslation(index, index * 2, index * 3),
|
|
Stage: stage,
|
|
CellId: 0x8C040100u + (uint)index,
|
|
ClipSlot: 0,
|
|
Lights: WbDrawDispatcher.InstanceLightSet.Disabled,
|
|
IndoorFlag: 0,
|
|
Alpha: 1f,
|
|
SelectionLighting: Vector2.Zero,
|
|
DetailCategory: detailCategory);
|
|
|
|
private static OrderedDrawStream StreamOf(params OrderedDrawCommand[] commands)
|
|
{
|
|
var stream = new OrderedDrawStream();
|
|
foreach (OrderedDrawCommand command in commands)
|
|
stream.Append(command);
|
|
return stream;
|
|
}
|
|
|
|
// ── Pure BuildOrderedMergeRuns — no GPU device ─────────────────────────
|
|
|
|
[Fact]
|
|
public void BuildOrderedMergeRuns_MergesThreeAdjacentSameStateCommandsIntoOneRun()
|
|
{
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0), MakeCommand(1), MakeCommand(2));
|
|
|
|
List<WbDrawDispatcher.OrderedMergeRun> runs =
|
|
WbDrawDispatcher.BuildOrderedMergeRuns(stream);
|
|
|
|
WbDrawDispatcher.OrderedMergeRun run = Assert.Single(runs);
|
|
Assert.Equal(0, run.FirstCommand);
|
|
Assert.Equal(3, run.CommandCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void BuildOrderedMergeRuns_SplitsOnAPipelineBucketChange()
|
|
{
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0, translucency: TranslucencyKind.Opaque),
|
|
MakeCommand(1, translucency: TranslucencyKind.Opaque),
|
|
MakeCommand(2, translucency: TranslucencyKind.AlphaBlend));
|
|
|
|
List<WbDrawDispatcher.OrderedMergeRun> runs =
|
|
WbDrawDispatcher.BuildOrderedMergeRuns(stream);
|
|
|
|
Assert.Equal(
|
|
[
|
|
new WbDrawDispatcher.OrderedMergeRun(0, 2),
|
|
new WbDrawDispatcher.OrderedMergeRun(2, 1),
|
|
],
|
|
runs);
|
|
}
|
|
|
|
[Fact]
|
|
public void BuildOrderedMergeRuns_SplitsOnACullModeChange()
|
|
{
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0, cullMode: CullMode.None),
|
|
MakeCommand(1, cullMode: CullMode.None),
|
|
MakeCommand(2, cullMode: CullMode.Clockwise));
|
|
|
|
List<WbDrawDispatcher.OrderedMergeRun> runs =
|
|
WbDrawDispatcher.BuildOrderedMergeRuns(stream);
|
|
|
|
Assert.Equal(
|
|
[
|
|
new WbDrawDispatcher.OrderedMergeRun(0, 2),
|
|
new WbDrawDispatcher.OrderedMergeRun(2, 1),
|
|
],
|
|
runs);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The load-bearing new assertion: two commands whose material state
|
|
/// (bucket, cull mode, detail category) is IDENTICAL still split into two
|
|
/// runs when their <see cref="WalkDrawStage"/> differs. Nothing about the
|
|
/// deferred-alpha template this submitter borrows from ever had to
|
|
/// consider stage — walk order introduces it.
|
|
/// </summary>
|
|
[Fact]
|
|
public void BuildOrderedMergeRuns_SplitsOnAStageChangeEvenWithIdenticalMaterialState()
|
|
{
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0, stage: WalkDrawStage.Terrain),
|
|
MakeCommand(1, stage: WalkDrawStage.CellStatic));
|
|
|
|
List<WbDrawDispatcher.OrderedMergeRun> runs =
|
|
WbDrawDispatcher.BuildOrderedMergeRuns(stream);
|
|
|
|
Assert.Equal(
|
|
[
|
|
new WbDrawDispatcher.OrderedMergeRun(0, 1),
|
|
new WbDrawDispatcher.OrderedMergeRun(1, 1),
|
|
],
|
|
runs);
|
|
}
|
|
|
|
[Fact]
|
|
public void BuildOrderedMergeRuns_ADetailCategoryCommandIsAlwaysSolo()
|
|
{
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0),
|
|
MakeCommand(1, detailCategory: 1),
|
|
MakeCommand(2));
|
|
|
|
List<WbDrawDispatcher.OrderedMergeRun> runs =
|
|
WbDrawDispatcher.BuildOrderedMergeRuns(stream);
|
|
|
|
Assert.Equal(
|
|
[
|
|
new WbDrawDispatcher.OrderedMergeRun(0, 1),
|
|
new WbDrawDispatcher.OrderedMergeRun(1, 1),
|
|
new WbDrawDispatcher.OrderedMergeRun(2, 1),
|
|
],
|
|
runs);
|
|
}
|
|
|
|
[Fact]
|
|
public void BuildOrderedMergeRuns_ThrowsNotSupportedForAPortalPunchCommand()
|
|
{
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0, stage: WalkDrawStage.Terrain),
|
|
MakeCommand(1, stage: WalkDrawStage.PortalPunch));
|
|
|
|
Assert.Throws<NotSupportedException>(
|
|
() => WbDrawDispatcher.BuildOrderedMergeRuns(stream));
|
|
}
|
|
|
|
[Fact]
|
|
public void BuildOrderedMergeRuns_EveryCommandBelongsToExactlyOneRunInOrderWithNoGaps()
|
|
{
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0, stage: WalkDrawStage.Terrain, translucency: TranslucencyKind.Opaque, cullMode: CullMode.None),
|
|
MakeCommand(1, stage: WalkDrawStage.Terrain, translucency: TranslucencyKind.Opaque, cullMode: CullMode.None),
|
|
MakeCommand(2, stage: WalkDrawStage.Terrain, translucency: TranslucencyKind.AlphaBlend, cullMode: CullMode.None),
|
|
MakeCommand(3, stage: WalkDrawStage.Terrain, translucency: TranslucencyKind.AlphaBlend, cullMode: CullMode.Clockwise),
|
|
MakeCommand(4, stage: WalkDrawStage.CellStatic, translucency: TranslucencyKind.AlphaBlend, cullMode: CullMode.Clockwise),
|
|
MakeCommand(5, stage: WalkDrawStage.CellStatic, translucency: TranslucencyKind.AlphaBlend, cullMode: CullMode.Clockwise, detailCategory: 1),
|
|
MakeCommand(6, stage: WalkDrawStage.CellStatic, translucency: TranslucencyKind.AlphaBlend, cullMode: CullMode.Clockwise));
|
|
|
|
List<WbDrawDispatcher.OrderedMergeRun> runs =
|
|
WbDrawDispatcher.BuildOrderedMergeRuns(stream);
|
|
|
|
int coveredThrough = 0;
|
|
int totalCommands = 0;
|
|
foreach (WbDrawDispatcher.OrderedMergeRun run in runs)
|
|
{
|
|
Assert.Equal(coveredThrough, run.FirstCommand);
|
|
Assert.True(run.CommandCount > 0);
|
|
coveredThrough = run.FirstCommand + run.CommandCount;
|
|
totalCommands += run.CommandCount;
|
|
}
|
|
Assert.Equal(stream.Count, coveredThrough);
|
|
Assert.Equal(stream.Count, totalCommands);
|
|
}
|
|
|
|
// ── PrepareOrderedStream + DrawOrderedRange — recorded RHI calls against
|
|
// RecordingGpuDevice. Campaign FW3.4a replaced the single
|
|
// SubmitOrderedStream call with this pair (prepare the whole stream once,
|
|
// draw it via one or more ranges) — every test below that used to call
|
|
// SubmitOrderedStream now calls Prepare once and Draw the WHOLE stream as
|
|
// ONE range, which is exactly SubmitOrderedStream's old behavior; the
|
|
// "several ranges" and "bind once" shapes get their own tests further
|
|
// down since they have no FW2 analogue. ────────────────────────────────
|
|
|
|
private static void PrepareAndDrawWhole(WbDrawDispatcher dispatcher, DrawScope draw, OrderedDrawStream stream)
|
|
{
|
|
dispatcher.PrepareOrderedStream(draw.Frame, stream, Matrix4x4.Identity);
|
|
if (stream.Count > 0)
|
|
dispatcher.DrawOrderedRange(draw.Pass, 0, stream.Count);
|
|
}
|
|
|
|
[Fact]
|
|
public void PrepareThenDraw_AlternatingStateCommandsRecordOneDrawEachInOrder()
|
|
{
|
|
using var fx = new DispatcherFixture();
|
|
using DrawScope draw = fx.BeginDraw();
|
|
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0, translucency: TranslucencyKind.Opaque),
|
|
MakeCommand(1, translucency: TranslucencyKind.AlphaBlend),
|
|
MakeCommand(2, translucency: TranslucencyKind.Opaque),
|
|
MakeCommand(3, translucency: TranslucencyKind.AlphaBlend));
|
|
|
|
PrepareAndDrawWhole(fx.Dispatcher, draw, stream);
|
|
|
|
List<(int Start, int Count)> ranges = DecodeDrawRanges(fx.Device);
|
|
Assert.Equal([(0, 1), (1, 1), (2, 1), (3, 1)], ranges);
|
|
}
|
|
|
|
[Fact]
|
|
public void PrepareThenDraw_MergesAdjacentSameStateCommandsIntoOneMultiDrawIndirect()
|
|
{
|
|
using var fx = new DispatcherFixture();
|
|
using DrawScope draw = fx.BeginDraw();
|
|
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0), MakeCommand(1), MakeCommand(2));
|
|
|
|
PrepareAndDrawWhole(fx.Dispatcher, draw, stream);
|
|
|
|
List<(int Start, int Count)> ranges = DecodeDrawRanges(fx.Device);
|
|
Assert.Equal([(0, 3)], ranges);
|
|
}
|
|
|
|
[Fact]
|
|
public void PrepareThenDraw_CullModeChangeRecordsSeparateCullCallsAndSplitsTheDraw()
|
|
{
|
|
using var fx = new DispatcherFixture();
|
|
using DrawScope draw = fx.BeginDraw();
|
|
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0, cullMode: CullMode.None),
|
|
MakeCommand(1, cullMode: CullMode.None),
|
|
MakeCommand(2, cullMode: CullMode.Clockwise));
|
|
|
|
PrepareAndDrawWhole(fx.Dispatcher, draw, stream);
|
|
|
|
Assert.Equal([(0, 2), (2, 1)], DecodeDrawRanges(fx.Device));
|
|
|
|
List<GpuCullMode> cullCalls =
|
|
[.. fx.Device.Calls.OfType<GpuRecordedCullMode>().Select(c => c.CullMode)];
|
|
// ApplyCullModeRhi: CullMode.None -> GpuCullMode.None, CullMode.Clockwise -> GpuCullMode.Front.
|
|
Assert.Equal([GpuCullMode.None, GpuCullMode.Front], cullCalls);
|
|
}
|
|
|
|
[Fact]
|
|
public void PrepareThenDraw_StageChangeSplitsTheDrawEvenWithIdenticalMaterialState()
|
|
{
|
|
using var fx = new DispatcherFixture();
|
|
using DrawScope draw = fx.BeginDraw();
|
|
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0, stage: WalkDrawStage.Terrain),
|
|
MakeCommand(1, stage: WalkDrawStage.CellStatic));
|
|
|
|
PrepareAndDrawWhole(fx.Dispatcher, draw, stream);
|
|
|
|
Assert.Equal([(0, 1), (1, 1)], DecodeDrawRanges(fx.Device));
|
|
}
|
|
|
|
[Fact]
|
|
public void PrepareThenDraw_ADetailCategoryCommandRecordsItsOwnSoloDraw()
|
|
{
|
|
using var fx = new DispatcherFixture();
|
|
using DrawScope draw = fx.BeginDraw();
|
|
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0),
|
|
MakeCommand(1, detailCategory: 1),
|
|
MakeCommand(2));
|
|
|
|
PrepareAndDrawWhole(fx.Dispatcher, draw, stream);
|
|
|
|
Assert.Equal([(0, 1), (1, 1), (2, 1)], DecodeDrawRanges(fx.Device));
|
|
}
|
|
|
|
[Fact]
|
|
public void PrepareThenDraw_OpaqueRunUsesRenderPassZeroAndAlphaBlendRunUsesRenderPassOne()
|
|
{
|
|
using var fx = new DispatcherFixture();
|
|
using DrawScope draw = fx.BeginDraw();
|
|
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0, translucency: TranslucencyKind.Opaque),
|
|
MakeCommand(1, translucency: TranslucencyKind.AlphaBlend));
|
|
|
|
PrepareAndDrawWhole(fx.Dispatcher, draw, stream);
|
|
|
|
List<(GpuPushConstants Constants, int Start, int Count)> runs = DecodeRuns(fx.Device);
|
|
Assert.Equal(2, runs.Count);
|
|
Assert.Equal(0, runs[0].Constants.RenderPass);
|
|
Assert.Equal(1, runs[1].Constants.RenderPass);
|
|
}
|
|
|
|
[Fact]
|
|
public void PrepareOrderedStream_ThrowsNotSupportedForAPortalPunchCommandBeforeAnyDraw()
|
|
{
|
|
using var fx = new DispatcherFixture();
|
|
using DrawScope draw = fx.BeginDraw();
|
|
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0, stage: WalkDrawStage.PortalPunch));
|
|
|
|
Assert.Throws<NotSupportedException>(
|
|
() => fx.Dispatcher.PrepareOrderedStream(draw.Frame, stream, Matrix4x4.Identity));
|
|
|
|
Assert.Empty(fx.Device.Calls.OfType<GpuRecordedMultiDrawIndirect>());
|
|
Assert.Empty(fx.Device.Calls.OfType<GpuRecordedStorageBind>());
|
|
}
|
|
|
|
[Fact]
|
|
public void PrepareOrderedStream_EmptyStreamRecordsNoDraws()
|
|
{
|
|
using var fx = new DispatcherFixture();
|
|
using DrawScope draw = fx.BeginDraw();
|
|
|
|
fx.Dispatcher.PrepareOrderedStream(draw.Frame, new OrderedDrawStream(), Matrix4x4.Identity);
|
|
|
|
Assert.Empty(fx.Device.Calls.OfType<GpuRecordedMultiDrawIndirect>());
|
|
}
|
|
|
|
// ── Campaign FW3.4a — the shapes with no FW2 analogue: drawing the SAME
|
|
// prepared stream as several ranges, the bind-once optimization, the
|
|
// fail-loud range check, and the assert-don't-slice straddle guard. ───
|
|
|
|
/// <summary>
|
|
/// The whole point of the split: drawing the SAME stream as TWO ranges
|
|
/// (with the boundary between them supplied to Prepare, exactly as
|
|
/// WalkFrameDriver.Replay supplies its recorded mark positions) produces
|
|
/// the identical total recorded draw/cull/push-constant calls as drawing
|
|
/// it as one range — the range split changes nothing about what reaches
|
|
/// the GPU, only how many DrawOrderedRange calls got there.
|
|
/// </summary>
|
|
[Fact]
|
|
public void DrawOrderedRange_AsTwoRangesAtASegmentBoundary_MatchesOneRangeOverTheWholeStream()
|
|
{
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0, translucency: TranslucencyKind.Opaque),
|
|
MakeCommand(1, translucency: TranslucencyKind.Opaque),
|
|
MakeCommand(2, translucency: TranslucencyKind.Opaque),
|
|
MakeCommand(3, translucency: TranslucencyKind.Opaque));
|
|
|
|
using var wholeFx = new DispatcherFixture();
|
|
using (DrawScope draw = wholeFx.BeginDraw())
|
|
{
|
|
wholeFx.Dispatcher.PrepareOrderedStream(draw.Frame, stream, Matrix4x4.Identity);
|
|
wholeFx.Dispatcher.DrawOrderedRange(draw.Pass, 0, stream.Count);
|
|
}
|
|
List<(int Start, int Count)> wholeRanges = DecodeDrawRanges(wholeFx.Device);
|
|
|
|
using var splitFx = new DispatcherFixture();
|
|
using (DrawScope draw = splitFx.BeginDraw())
|
|
{
|
|
// Command 2 is a segment boundary (mirrors a mark WalkFrameDriver
|
|
// would record there, e.g. a cell shell between two same-state
|
|
// segments) — without it, all four commands would merge into ONE
|
|
// run; the boundary forces two.
|
|
splitFx.Dispatcher.PrepareOrderedStream(
|
|
draw.Frame, stream, Matrix4x4.Identity, forcedBreaksAscending: [2]);
|
|
splitFx.Dispatcher.DrawOrderedRange(draw.Pass, 0, 2);
|
|
splitFx.Dispatcher.DrawOrderedRange(draw.Pass, 2, 2);
|
|
}
|
|
List<(int Start, int Count)> splitRanges = DecodeDrawRanges(splitFx.Device);
|
|
|
|
// The split path draws two runs where the whole-range path drew one
|
|
// (the forced boundary is the only difference) — but every command
|
|
// reaches the GPU exactly once, in order, with identical coverage.
|
|
Assert.Equal([(0, 4)], wholeRanges);
|
|
Assert.Equal([(0, 2), (2, 2)], splitRanges);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The FW3.4a perf shape itself: the nine per-instance storage binds plus
|
|
/// the warm-up pipeline bind happen on the FIRST DrawOrderedRange call in
|
|
/// a frame only — a second call over the same prepared payload issues no
|
|
/// further StorageBind calls, which is the whole reason this stage exists
|
|
/// (the old SubmitOrderedStream rebound everything on every call).
|
|
/// </summary>
|
|
[Fact]
|
|
public void DrawOrderedRange_EveryCallRebindsTheStorageSections()
|
|
{
|
|
// The corrected FW3.4a contract (the dense-Arwic device-lost fix):
|
|
// between ordered ranges the walk's leaf draws and RetailAlphaQueue
|
|
// flushes rebind the SAME set-0 slots to THEIR sections, so every
|
|
// DrawOrderedRange call must re-bind its own — a latched skip draws
|
|
// the next range against foreign buffers. Only the ring WRITES are
|
|
// once-per-frame (PrepareOrderedStream); binds repeat per range,
|
|
// exactly like DrawPreparedAlphaBatchRhi.
|
|
using var fx = new DispatcherFixture();
|
|
using DrawScope draw = fx.BeginDraw();
|
|
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0, stage: WalkDrawStage.Terrain),
|
|
MakeCommand(1, stage: WalkDrawStage.CellStatic));
|
|
|
|
fx.Dispatcher.PrepareOrderedStream(draw.Frame, stream, Matrix4x4.Identity);
|
|
fx.Dispatcher.DrawOrderedRange(draw.Pass, 0, 1);
|
|
int boundAfterFirst = fx.Device.Calls.OfType<GpuRecordedStorageBind>().Count();
|
|
Assert.True(boundAfterFirst > 0);
|
|
|
|
fx.Dispatcher.DrawOrderedRange(draw.Pass, 1, 1);
|
|
int boundAfterSecond = fx.Device.Calls.OfType<GpuRecordedStorageBind>().Count();
|
|
|
|
Assert.Equal(boundAfterFirst * 2, boundAfterSecond);
|
|
// Both commands drew; the rebinds changed nothing about coverage.
|
|
Assert.Equal([(0, 1), (1, 1)], DecodeDrawRanges(fx.Device));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fail-loud range check (mirrors DrawPreparedAlphaBatchRhi's): a range
|
|
/// outside what PrepareOrderedStream uploaded throws rather than drawing
|
|
/// garbage or silently clamping — including a draw attempted before ANY
|
|
/// Prepare call this frame.
|
|
/// </summary>
|
|
[Fact]
|
|
public void DrawOrderedRange_RangeExceedingThePreparedPayload_Throws()
|
|
{
|
|
using var fx = new DispatcherFixture();
|
|
using DrawScope draw = fx.BeginDraw();
|
|
|
|
OrderedDrawStream stream = StreamOf(MakeCommand(0));
|
|
fx.Dispatcher.PrepareOrderedStream(draw.Frame, stream, Matrix4x4.Identity);
|
|
|
|
Assert.Throws<ArgumentOutOfRangeException>(
|
|
() => fx.Dispatcher.DrawOrderedRange(draw.Pass, 0, 2));
|
|
Assert.Throws<ArgumentOutOfRangeException>(
|
|
() => fx.Dispatcher.DrawOrderedRange(draw.Pass, 1, 1));
|
|
}
|
|
|
|
[Fact]
|
|
public void DrawOrderedRange_BeforeAnyPrepareCallThisFrame_Throws()
|
|
{
|
|
using var fx = new DispatcherFixture();
|
|
using DrawScope draw = fx.BeginDraw();
|
|
|
|
Assert.Throws<ArgumentOutOfRangeException>(
|
|
() => fx.Dispatcher.DrawOrderedRange(draw.Pass, 0, 1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// The plan's "assert it" rule: a range that does not align with a merge
|
|
/// run boundary throws rather than silently slicing the run — proven
|
|
/// directly here (skipping the boundary a real WalkFrameDriver mark would
|
|
/// supply) since production code always supplies the boundary and would
|
|
/// never exercise this path.
|
|
/// </summary>
|
|
[Fact]
|
|
public void DrawOrderedRange_RangeStraddlingAMergeRun_Throws()
|
|
{
|
|
using var fx = new DispatcherFixture();
|
|
using DrawScope draw = fx.BeginDraw();
|
|
|
|
// All four commands share stage/bucket/cull — ONE merge run [0, 4) —
|
|
// and no forced break is supplied, so a [0, 2) range straddles it.
|
|
OrderedDrawStream stream = StreamOf(
|
|
MakeCommand(0), MakeCommand(1), MakeCommand(2), MakeCommand(3));
|
|
fx.Dispatcher.PrepareOrderedStream(draw.Frame, stream, Matrix4x4.Identity);
|
|
|
|
Assert.Throws<InvalidOperationException>(
|
|
() => fx.Dispatcher.DrawOrderedRange(draw.Pass, 0, 2));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fail-loud invariant: whatever the state pattern, the recorded
|
|
/// MultiDrawIndirect calls' DrawCounts always sum to the stream's Count —
|
|
/// no command is ever silently skipped, and none is drawn twice.
|
|
/// </summary>
|
|
[Fact]
|
|
public void PrepareThenDraw_TotalRecordedDrawCountAlwaysEqualsTheStreamCount()
|
|
{
|
|
using var fx = new DispatcherFixture();
|
|
using DrawScope draw = fx.BeginDraw();
|
|
|
|
var stream = new OrderedDrawStream();
|
|
var stages = new[] { WalkDrawStage.Terrain, WalkDrawStage.CellStatic, WalkDrawStage.BuildingShell };
|
|
var blends = new[]
|
|
{
|
|
TranslucencyKind.Opaque, TranslucencyKind.AlphaBlend,
|
|
TranslucencyKind.Additive, TranslucencyKind.InvAlpha,
|
|
};
|
|
var culls = new[] { CullMode.None, CullMode.Clockwise, CullMode.CounterClockwise };
|
|
const int commandCount = 11;
|
|
for (int i = 0; i < commandCount; i++)
|
|
{
|
|
stream.Append(MakeCommand(
|
|
i,
|
|
stage: stages[i % stages.Length],
|
|
translucency: blends[i % blends.Length],
|
|
cullMode: culls[i % culls.Length],
|
|
detailCategory: i == 5 ? 1u : 0u));
|
|
}
|
|
|
|
PrepareAndDrawWhole(fx.Dispatcher, draw, stream);
|
|
|
|
List<(int Start, int Count)> ranges = DecodeDrawRanges(fx.Device);
|
|
int sum = ranges.Sum(r => r.Count);
|
|
Assert.Equal(commandCount, sum);
|
|
|
|
int coveredThrough = 0;
|
|
foreach ((int start, int count) in ranges)
|
|
{
|
|
Assert.Equal(coveredThrough, start);
|
|
coveredThrough += count;
|
|
}
|
|
Assert.Equal(commandCount, coveredThrough);
|
|
}
|
|
|
|
// ── Decode helpers ──────────────────────────────────────────────────────
|
|
|
|
private static List<(int Start, int Count)> DecodeDrawRanges(RecordingGpuDevice device) =>
|
|
[.. DecodeRuns(device).Select(r => (r.Start, r.Count))];
|
|
|
|
private static List<(GpuPushConstants Constants, int Start, int Count)> DecodeRuns(
|
|
RecordingGpuDevice device)
|
|
{
|
|
GpuPushConstants? lastConstants = null;
|
|
uint? commandBase = null;
|
|
var result = new List<(GpuPushConstants, int, int)>();
|
|
foreach (var call in device.Calls)
|
|
{
|
|
if (call is GpuRecordedPushConstants pc)
|
|
{
|
|
lastConstants = pc.Constants;
|
|
}
|
|
else if (call is GpuRecordedMultiDrawIndirect mdi)
|
|
{
|
|
Assert.Equal((uint)WbDrawDispatcher.DrawCommandStride, mdi.StrideBytes);
|
|
commandBase ??= mdi.OffsetBytes;
|
|
int start = (int)((mdi.OffsetBytes - commandBase.Value) / mdi.StrideBytes);
|
|
Assert.NotNull(lastConstants);
|
|
result.Add((lastConstants!.Value, start, (int)mdi.DrawCount));
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// ── Fixture: a real WbDrawDispatcher against RecordingGpuDevice ─────────
|
|
|
|
private readonly struct DrawScope : IDisposable
|
|
{
|
|
private readonly IDisposable _publication;
|
|
private readonly IGpuPassEncoder _pass;
|
|
|
|
public DrawScope(IGpuFrame frame, IGpuPassEncoder pass, IDisposable publication)
|
|
{
|
|
Frame = frame;
|
|
_pass = pass;
|
|
_publication = publication;
|
|
}
|
|
|
|
public IGpuFrame Frame { get; }
|
|
|
|
public IGpuPassEncoder Pass => _pass;
|
|
|
|
public void Dispose()
|
|
{
|
|
_publication.Dispose();
|
|
_pass.Dispose();
|
|
}
|
|
}
|
|
|
|
private sealed class DispatcherFixture : IDisposable
|
|
{
|
|
private readonly WbMeshAdapter _meshAdapter;
|
|
private readonly TextureCache _textures;
|
|
|
|
public DispatcherFixture()
|
|
{
|
|
Device = new RecordingGpuDevice();
|
|
FrameLifetime = new GpuDeviceFrameLifetime(Device);
|
|
Scope = new VulkanWorldPassScope(sampleCount: 1);
|
|
_textures = new TextureCache(Device, new NoopDatReaderWriter());
|
|
_meshAdapter = new WbMeshAdapter(
|
|
Device,
|
|
new NoopDatReaderWriter(),
|
|
new NullPreparedAssetSource(),
|
|
NullLogger<WbMeshAdapter>.Instance,
|
|
Device.Retirement);
|
|
var entitySpawnAdapter = new EntitySpawnAdapter(
|
|
_textures,
|
|
_ => throw new NotSupportedException(
|
|
"Not exercised by SubmitOrderedStream tests."));
|
|
|
|
Dispatcher = new WbDrawDispatcher(
|
|
Device,
|
|
FrameLifetime,
|
|
Scope,
|
|
_textures,
|
|
_meshAdapter,
|
|
entitySpawnAdapter,
|
|
new EntityClassificationCache(),
|
|
new AcDream.Core.Rendering.TranslucencyFadeManager());
|
|
}
|
|
|
|
public RecordingGpuDevice Device { get; }
|
|
|
|
public GpuDeviceFrameLifetime FrameLifetime { get; }
|
|
|
|
public VulkanWorldPassScope Scope { get; }
|
|
|
|
public WbDrawDispatcher Dispatcher { get; }
|
|
|
|
/// <summary>Opens a frame and a backbuffer pass, publishes it on
|
|
/// <see cref="Scope"/>, then clears the recorded calls so a test only
|
|
/// sees what its own <c>SubmitOrderedStream</c> call produced.</summary>
|
|
public DrawScope BeginDraw()
|
|
{
|
|
FrameLifetime.BeginFrame();
|
|
IGpuFrame frame = FrameLifetime.CurrentFrame!;
|
|
IGpuPassEncoder pass = frame.BeginPass(
|
|
GpuPassDescription.BackbufferClear(
|
|
"fw2-ordered-stream-test", Vector4.Zero, sampleCount: 1));
|
|
IDisposable publication = Scope.Publish(pass);
|
|
Device.Clear();
|
|
return new DrawScope(frame, pass, publication);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Dispatcher.Dispose();
|
|
_meshAdapter.Dispose();
|
|
_textures.Dispose();
|
|
Device.Dispose();
|
|
}
|
|
}
|
|
|
|
private sealed class NullPreparedAssetSource : IPreparedAssetSource
|
|
{
|
|
public PreparedAssetSourceStats Stats => default;
|
|
|
|
public CacheStats DecodedTextureCacheStats => default;
|
|
|
|
public PreparedAssetPresence Probe(
|
|
AcDream.Content.Pak.PakAssetType type,
|
|
uint sourceFileId) =>
|
|
PreparedAssetPresence.Missing;
|
|
|
|
public PreparedAssetReadResult Read(
|
|
in PreparedAssetRequest request,
|
|
CancellationToken cancellationToken = default) =>
|
|
PreparedAssetReadResult.Missing;
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
}
|
|
|
|
private sealed class NoopDatReaderWriter : IDatReaderWriter
|
|
{
|
|
private readonly StubDatabase _portal = new();
|
|
private readonly StubDatabase _highRes = new();
|
|
private readonly StubDatabase _language = new();
|
|
private readonly StubDatabase _cell = new();
|
|
|
|
public string SourceDirectory => string.Empty;
|
|
|
|
public IDatDatabase Portal => _portal;
|
|
|
|
public IDatDatabase Cell => _cell;
|
|
|
|
public ReadOnlyDictionary<uint, IDatDatabase> CellRegions { get; } =
|
|
new(new Dictionary<uint, IDatDatabase>());
|
|
|
|
public IDatDatabase HighRes => _highRes;
|
|
|
|
public IDatDatabase Language => _language;
|
|
|
|
public IDatDatabase Local => _language;
|
|
|
|
public ReadOnlyDictionary<uint, uint> RegionFileMap { get; } =
|
|
new(new Dictionary<uint, uint>());
|
|
|
|
public int PortalIteration => 0;
|
|
|
|
public int CellIteration => 0;
|
|
|
|
public int HighResIteration => 0;
|
|
|
|
public int LanguageIteration => 0;
|
|
|
|
public bool TryGetFileBytes(
|
|
uint regionId,
|
|
uint fileId,
|
|
ref byte[] bytes,
|
|
out int bytesRead)
|
|
{
|
|
bytesRead = 0;
|
|
return false;
|
|
}
|
|
|
|
public IEnumerable<uint> GetAllIdsOfType<T>() where T : IDBObj =>
|
|
Array.Empty<uint>();
|
|
|
|
public IEnumerable<IDatReaderWriter.IdResolution> ResolveId(uint id) =>
|
|
Array.Empty<IDatReaderWriter.IdResolution>();
|
|
|
|
public bool TrySave<T>(T obj, int iteration = 0) where T : IDBObj =>
|
|
throw new NotSupportedException();
|
|
|
|
public bool TrySave<T>(
|
|
uint regionId,
|
|
T obj,
|
|
int iteration = 0) where T : IDBObj =>
|
|
throw new NotSupportedException();
|
|
|
|
[return: MaybeNull]
|
|
public T Get<T>(uint fileId) where T : IDBObj => default;
|
|
|
|
public bool TryGet<T>(
|
|
uint fileId,
|
|
[MaybeNullWhen(false)] out T value) where T : IDBObj
|
|
{
|
|
value = default;
|
|
return false;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
|
|
private sealed class StubDatabase : IDatDatabase
|
|
{
|
|
public DatDatabase Db => throw new NotSupportedException();
|
|
|
|
public int Iteration => 0;
|
|
|
|
public IEnumerable<uint> GetAllIdsOfType<T>() where T : IDBObj =>
|
|
Array.Empty<uint>();
|
|
|
|
public bool TryGet<T>(
|
|
uint fileId,
|
|
[MaybeNullWhen(false)] out T value) where T : IDBObj
|
|
{
|
|
value = default;
|
|
return false;
|
|
}
|
|
|
|
public bool TryGetFileBytes(
|
|
uint fileId,
|
|
[MaybeNullWhen(false)] out byte[] value)
|
|
{
|
|
value = null;
|
|
return false;
|
|
}
|
|
|
|
public bool TryGetFileBytes(
|
|
uint fileId,
|
|
ref byte[] bytes,
|
|
out int bytesRead)
|
|
{
|
|
bytesRead = 0;
|
|
return false;
|
|
}
|
|
|
|
public bool TrySave<T>(T obj, int iteration = 0) where T : IDBObj =>
|
|
throw new NotSupportedException();
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|