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

fix(render): S4 chunk 2 round 1 - particle throw, detail-off immediate draws, EnvCell FIFO, gate honesty

Browse source 
Fix round 1 of the two the plan allows for S4-c2 (048d5b12f), addressing
every item M1-M8/A1-A8 from the campaign branch's packet section 11.

M1 (BLOCKING): ParticleRenderer.DeferToRetailAlphaQueue threw whenever a
mesh-particle batch's TranslucencyKind.Opaque classification (mask 0x00)
reached a non-Append DrawMesh row - a real, reachable outcome since
TryAppendMeshDraws applies no IsOpaque-style pre-filter unlike
WbDrawDispatcher's path. Deleted both throws (ParticleRenderer.cs,
WbDrawDispatcher.cs SubmitToAlphaQueue), extracted the router-input
derivation into internal static ParticleRenderer.RouteParticleSubmission
(directly testable), and implemented rows 1/5's immediate draw by reusing
the existing per-instance billboard/mesh draw code (new
DrawImmediateParticleSubmissionRhi, no new renderer, no sort per A8).
materialHasAlpha (row 4) is derived from CMaterial::CheckAlphaValues
@0x005396a0 (Ghidra-verified 2026-09-04): has_alpha=0 only when
Ambient.a==Diffuse.a==Specular.a==Emissive.a==1.0f, else 1 - and
CMaterial::SetTranslucencySimple @0x005396f0 (reached from
CPhysicsPart::SetTranslucency <- Particle::Update @0x0051c290's per-frame
alpha-fade) sets all four channels to (1f - translucency) uniformly, so
has_alpha == "this particle's current alpha isn't 1.0" - already carried in
ColorArgb's top byte (Lerp(StartAlpha,EndAlpha,tLife), ParticleSystem.cs
1039-1041/1453).

M3: SubmitToAlphaQueue now takes isBuildingShell + viewProjection and feeds
Row 1's detailSurfaceActive gate for translucent building-shell instances
(retail DrawBuilding @0x0059f2a0 installs building detail before its own
shell subsets reach DrawMesh). Row 1 (detail on) draws the instance
immediately at its own walk-stream AlphaSubmitMark via new
DrawImmediateAlphaInstance/DrawImmediateAlphaInstanceRhi (reusing
WriteDeferredAlphaEntrySlot + the drain's pipeline/detail code for slot 0);
never touches _deferredAlpha/the queue for pure-Immediate submissions (fixes
a latent leak: previously reserving a _deferredAlpha slot for every
candidate meant a frame with ALL-immediate content never registered a
source, so ResetAlphaSubmissions never ran). M3c: DrawPreparedAlphaBatchRhi's
own per-command hasDetail/DrawBuildingDetailRangeRhi branch is deleted -
detail-eligible content no longer reaches the drain (spec: delayed replay
is always detailEnabled=0). New AD-120 register row for the "in place -> at
the entity's own stream mark" granularity adaptation this introduces.

M6: RetailPViewPassExecutor.SubmitOrDrawTransparentCellShell routes an
EnvCell's transparent shell through the SAME RetailAlphaMeshRouter table
(mask 0x02, detailSurfaceActive = EnvCellRenderer.TransparentDetailEnabled)
instead of a hand-coded branch. Detail on: unchanged immediate draw. Detail
off: appends ONE token per CELL via new EnvCellAlphaDrawSource (internal,
delegate-based so it's unit-testable without a GPU harness), replayed
through EnvCellRenderer.RenderTransparentOrdered at the next flush -
RenderTransparentOrdered already replayed a cell's batch on demand, so no
new deferred-replay abstraction was needed (the original landing's claim
that one was required is corrected in the packet).

M4: RetailAlphaEntry.IsFirstForList deleted. Retail's per-DrawMesh-
invocation "first for this list" flag is trivially true for every subset
retail ever appends (DrawMesh @0x0059d4a0 sets both flags true at entry,
0059d4cc/0059d4d0, clearing each independently after ITS OWN first append
within that call, 0059d5ef) - the captures confirm it (new=1 on 9,685/10,556
AM lines, impossible under "first since last drain"). acdream's deleted
isFirstForList = target.Count == 0 computed the wrong quantifier. One
acdream append already IS one DrawMesh call, so the field carried no
information and its own pin was vacuous (feedback_every_new_pin_must_be_
shown_to_fail) - deleted rather than kept as an always-true no-op.

M5: split all six AlphaFlushTranscript_* KnownFailure Facts into live
AlphaFlushSites_* (site+threshold sequence only, content-independent,
unconditional pass) and AlphaFlushCounts_* (KnownFailure, full tuple incl.
drained counts) sharing one RunAlphaFlushTranscriptReplay helper. Rewrote
the KnownFailure reason honestly: THREE independent causes, not "harness
content only" - (1) zero live mesh content, (2) acdream appends one entry
per INSTANCE vs retail's one per SUBSET per DrawMesh call, (3) acdream's
CLIP list is structurally empty for ordinary content (M2). Added ONE live
valve pin (WalkFrameDriverTests.SortCellExit_ValveDrainsThroughReplayAtThe
ExactBoundary, a Theory over 2250/2249) that goes through WalkFrameDriver.
Replay's own SortCellExit arm, not RetailAlphaQueue.Flush called directly.

M2/A2/M8c (register): ~~AP-34~~ restored as struck-through RETIRED (it had
been deleted outright, not struck, breaking the register's own convention)
citing residuals AP-238/AP-239/AP-240. The chunk-2 commit's "AP-236"/
"AP-237" collided with an id ALREADY filed-and-retired on main by an
unrelated #132 fix (docs/ISSUES.md:19976) - ids are never reused, so both
are renumbered: AP-236->AP-238 (EnvCell; rewritten per M6 - granularity-only
residual now, "never through the shared queue" is retired), AP-237->AP-239
(mask-reconstruction gap; the dangling "AP-236b" citation in
RetailAlphaMeshRouter.cs never matched either filed id and is corrected to
AP-239). New AP-240 filed for M2: WbDrawDispatcher.IsOpaque filters
ClipMap out upstream, so ordinary clip-mapped content never reaches
retail's CLIP FIFO (draws immediately on the pre-existing
OpaqueAlphaToCoverage pipeline instead) - no pipeline change this round,
per the contract. AP section header recounted honestly: 159 active (was
stale at 161); AD section 92 (was 91, +AD-120).

M7: AP-239's only cited example (cloud GfxObj 0x01004C35, surface
0x08000023) is DISPROVEN - decoded Type=0x10114 has alpha-family bits
that win in BOTH retail's real priority and acdream's reconstruction, so it
never actually diverges. A 2026-09-04 scan of all 6,152 Portal-dat Surfaces
found 27 real Translucent+Base1ClipMap-no-alpha-family instances
(Type=0x14); cross-referencing GfxObjs found surface 0x08000015 on GfxObj
0x010001EC - cited in place of the disproven cloud example.

M8: (a) RenderDeviceD3D::DrawBlock is @0x005a17c0 per symbols.json, not
@0x005a18d0 (that is its per-land-cell loop head) - fixed across
RetailAlphaQueue.cs, RetailPViewPassExecutor.cs, WalkEvents.cs,
WalkFrameDriver.cs (x3), RetailFrameWalk.cs. (b) RetailAlphaQueue.cs's four
FlushAlphaList addresses were labelled "return site" but are the CALL
instruction's own address (x86 CALL rel32 is 5 bytes) - relabelled "call at
X (returns to X+5)". (d) worldbuilder-inventory.md:420's AP-34 citation
updated.

A1: RetailPViewRenderer.cs's outdoor-root passes.FlushLandscapeAlpha() call
(labelled LandscapeFlush) is deleted - retail's real LandscapeFlush
(PView::DrawCells @0x005a4840's own FlushAlphaList(0f) @0x005a4872) sits
strictly inside if (outside_view.view_count > 0) on the INTERIOR PView; an
outdoor root never reaches it (terrace-edge capture: zero 005a4877 FL
lines). Verified no opaque draw intervenes between this deletion point and
RetailAlphaQueue.EndFrame()'s own RenderNormalMode pass-end flush
(WorldSceneRenderer.cs: DrawPostWorldParticles's PView branch is an
explicit no-op; only diagnostic wireframes follow) - #132's "drain after
the finished opaque world" invariant is kept by that flush alone.

A4: RetailAlphaQueue's ApplyScratchRetention call sites passed the ENTRY
count as the SOURCE-count argument too (observedClip + observedAlpha
twice), so _sources/_sourceDrawOffsets never shrank toward the real source
count. Fixed to capture _sources.Count before Clear().

A5/A6/A7: WalkStaticStreamPopulatorTests.cs's stale "same viewer distance"
banner corrected; two off-by-one entry counts in the packet's section 10
sequences corrected (foundry-deep x10->x11, holtburg-doorway-still x5->x6);
WalkAlphaDepthTrace.cs's "new=" comment explains why IsNew is retained but
never compared (M4's finding makes a per-subset comparison meaningless at
acdream's per-instance granularity); RetailAlphaMeshRouterTests.cs's
IndependentReferenceRoute (never actually independently-shaped) renamed to
RestatedBranchTableRoute with an honest doc comment, and the unverified
"flipped in turn and failed every time" claim deleted.

A3 was resolved as a side effect of M1's SubmitToAlphaQueue doc-comment
rewrite (the wrong "0x02/0x03, 0x04/0x05, 0x08/0x09" enumeration no longer
exists); RetailAlphaMeshRouter.cs's own MaskFromTranslucencyKind comment
updated in the same spirit (M1's particle-site Opaque-reachability finding).

Mutation checks (each applied to a scratch-restored copy, confirmed
failing, then byte-exact reverted - diffed against a /tmp backup after
restore):

- A1 (RetailPViewRendererTests.DrawInside_NeverCallsFlushLandscapeAlphaDirectly):
  restoring the deleted "if (ctx.RootCell.IsOutdoorNode)
  passes.FlushLandscapeAlpha();" line reintroduces a direct
  RetailPViewPassExecutor.FlushLandscapeAlpha call in DrawInside's compiled
  body. Actual failure: "Assert.DoesNotContain() Failure: Filter matched in
  collection ... CompiledCall { ... Target = Void FlushLandscapeAlpha() }".

- A4 (RetailAlphaQueueTests.RetainedSourceCapacity_ConvergesToTheReal
  SourceCountNotTheEntryCount): reverting both ApplyScratchRetention calls
  to (observedClip + observedAlpha, observedClip + observedAlpha) - with
  100 distinct sources in the spike frame (so _sources.Capacity grows to
  128, past its initial 4) followed by three low-demand frames of 10
  entries via ONE repeated source - makes sourceTarget compute from 10
  (Math.Max(4,10*2)=20) instead of 1 (Math.Max(4,1*2)=4). Actual failure:
  "Expected the retained source-array capacity to converge toward the real
  source count (1), but it stayed at 20". (A single-source-only spike does
  NOT discriminate this bug - Math.Min(sourceTarget, _sources.Capacity)
  clamps both formulas to the same unchanged initial 4 - hence the
  100-source setup.)

- M5 valve (WalkFrameDriverTests.SortCellExit_ValveDrainsThroughReplayAt
  TheExactBoundary, 2250 case): flipping RetailAlphaQueue.Flush's no-op
  comparison from "<" to "<=" (S4-c1/c2's own boundary mutation) makes the
  2250-entries case a no-op instead of draining. Actual failure:
  "Assert.Equal() Failure: Values differ Expected: 0 Actual: 2250".

- M6 (EnvCellAlphaDrawSourceTests, both Facts): adding an immediate
  renderTransparentOrdered(new[]{cellId}) call inside
  EnvCellAlphaDrawSource.AddPendingCellId (simulating the M1/M3 "drew
  immediately instead of deferring" bug class) makes
  PendingCellToken_IsDrainedAtTheFlushAndNeverBeforeIt fail with
  "Assert.Empty() Failure: Collection was not empty Collection: [[4660]]"
  and ParticleAppendedBetweenTwoCellTokens_KeepsItsPositionInTheCombined
  Drain fail with 'Expected: string[] ["cell:256", "particle:7",
  "cell:512"] Actual: List<string> ["cell:256", "cell:512", "cell:256",
  "particle:7", "cell:512"]'.

- M1 (ParticleRendererRouteTests.OpaqueClassifiedMeshBatch_WithMaterialAlpha
  _RoutesToAlphaAppend): hardcoding materialHasAlpha to false inside
  RouteParticleSubmission makes the Opaque-mask+has-alpha case route
  Immediate instead of Append. Actual failure: "Assert.Equal() Failure:
  Values differ Expected: Append Actual: Immediate".

Gates (real output lines):

- dotnet build AcDream.slnx -c Release -> "Build succeeded. 0 Warning(s)
  0 Error(s)".
- Hermetic lane (--filter "Lane!=InstalledDat&Lane!=PreparedPackage&
  Lane!=Live&Lane!=Manual&Lane!=Timing&Lane!=Windows&Lane!=Linux&
  Lane!=SystemFont&Purpose!=Diagnostic&Status!=KnownFailure") ->
  "Passed! - Failed: 0, Passed: 6864, Skipped: 0, Total: 6864".
- InstalledDat lane (ACDREAM_RUN_INSTALLED_DAT_TESTS=1,
  ACDREAM_DAT_DIR="C:/Users/erikn/Documents/Asheron's Call",
  --filter "Lane=InstalledDat") -> "Failed: 10, Passed: 255, Skipped: 1,
  Total: 266" - the exact 4 pre-existing failures
  (TowerAscent_StaircaseStaysConeVisible_EveryStep,
  LayoutImporterMediaBearingChildSweepTests, LayoutImporterInvisibleSweep
  Tests, Oh_doorway_still_first_frame_diff) plus the six
  AlphaFlushCounts_* KnownFailure Facts, nothing else; all six
  AlphaFlushSites_* Facts pass inside this same lane (the whole
  WalkTraceConformanceTests partial class carries Lane=InstalledDat, so
  they cannot run hermetically).
- Shader classes (VulkanShaderDescriptorContractTests,
  VulkanShaderManifestTests, RenderPackSpirvValidatorTests) -> "Passed! -
  Failed: 0, Passed: 32, Skipped: 0, Total: 32".
- RetailAlphaQueueTests, RetailAlphaMeshRouterTests, RetailFrameWalkTests,
  WalkFrameDriverTests, ParticleRenderer*Tests, EnvCellRenderer*Tests
  (combined filter) -> "Passed! - Failed: 0, Passed: 120, Skipped: 0,
  Total: 120".
- Register collision grep: AP-238/AP-239/AP-240/AD-120 each count exactly
  1; ~~AP-34~~ count exactly 1; live totals AP=159, AD=92.

Not done / deferred: none - all M1-M8/A1-A8 items landed; A8 was a
no-action note.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
Erik 2026-09-04 07:30:25 +02:00
parent 89f1e2676f
commit 9ccb61a8ec
26 changed files with 1180 additions and 326 deletions
Download patch file Download diff file Expand all files Collapse all files

194
src/AcDream.App/Rendering/Wb/WbDrawDispatcher.cs
View file

@ -2445,8 +2445,7 @@ public sealed partial class WbDrawDispatcher : IDisposable
{
InstanceGroup group = entry.Group;
int i = entry.InstanceIndex;
int token = _deferredAlpha.Count;
_deferredAlpha.Add(new DeferredAlphaInstance(
var candidate = new DeferredAlphaInstance(
ToKey(group),
group.Matrices[i],
group.Slots[i],
@ -2454,8 +2453,9 @@ public sealed partial class WbDrawDispatcher : IDisposable
group.IndoorFlags[i],
group.DetailCategories[i],
group.Opacities[i],
group.SelectionLighting[i]));
SubmitToAlphaQueue(queue, group.Translucency, token);
group.SelectionLighting[i]);
SubmitToAlphaQueue(
queue, group.Translucency, in candidate, group.DetailCategories[i] == 1u, viewProjection);
}
}
@ -2466,40 +2466,71 @@ public sealed partial class WbDrawDispatcher : IDisposable
/// clip-map subsets are filtered out upstream by <c>IsOpaque</c> and
/// never reach <c>_translucentDraws</c>/this path at all — see
/// <see cref="RetailAlphaMeshRouter.MaskFromTranslucencyKind"/>'s own doc
/// comment). Neither call site ever draws during the Sky leaf or with a
/// building/environment detail surface installed (ordinary GfxObj/
/// particle paths never install one — OH1 contract §6), and
/// comment). Neither call site ever draws during the Sky leaf and
/// <c>MultiPassAlpha</c> stays false (no environment override — Must
/// Not). Under those fixed inputs and <see cref="RetailAlphaMeshRouter.DefaultDelayMask"/>,
/// every reachable mask (0x02/0x03, 0x04/0x05, 0x08/0x09) intersects the
/// delay mask, so <c>DrawMesh</c>'s row 3 always fires — rows 1, 2, 4,
/// and 5 are unreachable here and would indicate a real routing bug if
/// ever hit.
/// Not) — Row 2 is provably unreachable. Under
/// <see cref="RetailAlphaMeshRouter.DefaultDelayMask"/> the only
/// reachable mask here is 0x02 (alpha-family), which always intersects
/// the delay mask, so an ordinary (non-building-shell) instance always
/// takes Row 3 (Append).
///
/// <para>S4-c2 fix round 1 (M3): <paramref name="isBuildingShell"/> feeds
/// Row 1's <c>curr_detail_surface != null</c> gate — retail's
/// <c>DrawBuilding</c> @0x0059f2a0 installs the building detail surface
/// BEFORE its own shell subsets reach <c>DrawMesh</c>
/// (<c>0059f2eb curr_detail_surface = building_detail_surface</c>), so a
/// translucent building-shell instance takes Row 1 (immediate, WITH
/// detail) whenever building detail is on. This IS therefore a real,
/// data-driven outcome — not an invariant to throw on
/// (feedback_retail_dispatch_is_data_driven) — handled below by drawing
/// the instance immediately instead of appending it.</para>
/// </summary>
private void SubmitToAlphaQueue(
RetailAlphaQueue queue, TranslucencyKind kind, int token)
RetailAlphaQueue queue,
TranslucencyKind kind,
in DeferredAlphaInstance candidate,
bool isBuildingShell,
Matrix4x4 viewProjection)
{
byte mask = RetailAlphaMeshRouter.MaskFromTranslucencyKind(kind);
bool detailSurfaceActive = isBuildingShell
&& RetailDetailTextureContract.ShouldRender(_buildingDetailEnabled(), _buildingDetail);
RetailAlphaMeshDecision decision = RetailAlphaMeshRouter.Route(
currentlyDrawingSky: false,
delayMask: RetailAlphaMeshRouter.DefaultDelayMask,
detailSurfaceActive: false,
detailSurfaceActive: detailSurfaceActive,
multiPassAlpha: false,
subsetMask: mask,
materialHasAlpha: false);
if (decision.Action != RetailAlphaMeshAction.Append)
if (decision.Action == RetailAlphaMeshAction.Immediate)
{
throw new InvalidOperationException(
"Ordinary translucent GfxObj/particle submissions never install a detail "
+ "surface or draw during the Sky leaf, and MultiPassAlpha stays false — "
+ $"DrawMesh's row 1/2/4/5 branches are unreachable here; got {decision.Action}.");
// M3(b): row 1 — draw NOW, at this instance's own turn, and
// never touch _deferredAlpha/the queue at all (so a frame whose
// translucent content is ENTIRELY immediate — e.g. every visible
// shell drawing with building detail on — still leaves nothing
// for the queue to clear; only Append/AppendClipAndImmediate,
// below, ever grow _deferredAlpha).
DrawImmediateAlphaInstance(in candidate, viewProjection);
return;
}
int token = _deferredAlpha.Count;
_deferredAlpha.Add(candidate);
// Capacity overflow (spec §5): TryAppend returns false and the
// subset is DROPPED. The reserved _deferredAlpha token simply never
// gets prepared/drawn — no recovery, matching retail exactly.
queue.TryAppend(decision.List, _alphaSource, token, decision.OverrideClipmap);
if (decision.Action == RetailAlphaMeshAction.AppendClipAndImmediate)
{
// Row 2: provably unreachable here (MultiPassAlpha stays false),
// but handled in full rather than asserted against — exactly as
// spec §4 row 2 describes: append to CLIP AND ALSO draw
// immediately.
DrawImmediateAlphaInstance(in candidate, viewProjection);
}
}
private sealed class AlphaSubmissionOrderComparer :
@ -2518,6 +2549,59 @@ public sealed partial class WbDrawDispatcher : IDisposable
left.SubmissionOrder.CompareTo(right.SubmissionOrder);
}
/// <summary>
/// Writes ONE <see cref="DeferredAlphaInstance"/> into the CPU staging
/// arrays at <paramref name="slot"/> — the per-entry body
/// <see cref="PrepareDeferredAlphaDraws"/>'s drain loop and
/// <see cref="DrawImmediateAlphaInstance"/>'s single-instance immediate
/// path (S4-c2 fix round 1, M3) both share, so the two paths can never
/// disagree on how a <see cref="DeferredAlphaInstance"/> becomes GPU
/// data. Caller ensures capacity first.
/// </summary>
private void WriteDeferredAlphaEntrySlot(int slot, in DeferredAlphaInstance entry)
{
WriteMatrix(_instanceData, slot * 16, entry.Model);
_clipSlotData[slot] = entry.ClipSlot;
_indoorData[slot] = entry.Indoor;
_detailCategoryData[slot] = entry.DetailCategory;
_alphaData[slot] = entry.Opacity;
_selectionLightingData[slot] = entry.SelectionLighting;
int lightOffset = slot * LightManager.MaxLightsPerObject;
entry.Lights.CopyTo(_lightSetData, lightOffset);
GroupKey key = entry.Key;
_batchData[slot] = new BatchData
{
// Campaign V slice V2: table slot, not the raw handle.
TextureIndex = key.TextureSlot.Index,
TextureLayer = key.TextureLayer,
// DrawMesh invokes RenderMeshSubset with detail enabled for
// every built-mesh material subset while curr_detail_surface
// is installed. The per-instance category still rejects
// ordinary objects in mesh_detail. Review fix round 2 (F2):
// bit 0 (the #226 built-mesh marker) is unconditional here —
// every delayed-alpha entry IS a built-mesh alpha submission
// — but the previous hardcoded `1` silently dropped bits 1/2
// (Campaign VM VM6 foliage classification). A trunk instance
// promoted into the alpha-blend group mid-fade (translucency
// < 1 forces AlphaBlend even for an otherwise-Opaque trunk —
// see ClassifyBatches's #188 promotion) must keep swaying
// through the deferred-alpha replay instead of going rigid
// for the duration of its fade.
Flags = 1u | key.FoliageFlags,
};
_indirectCommands[slot] = new DrawElementsIndirectCommand
{
Count = (uint)key.IndexCount,
InstanceCount = 1,
FirstIndex = key.FirstIndex,
BaseVertex = key.BaseVertex,
BaseInstance = (uint)slot,
};
_drawCullModes[slot] = key.CullMode;
_deferredAlphaKinds[slot] = key.Translucency;
}
private void PrepareDeferredAlphaDraws(ReadOnlySpan<int> tokens)
{
if (tokens.Length == 0)
@ -2530,49 +2614,7 @@ public sealed partial class WbDrawDispatcher : IDisposable
int count = tokens.Length;
EnsureDeferredAlphaCapacity(count);
for (int i = 0; i < count; i++)
{
DeferredAlphaInstance entry = _deferredAlpha[tokens[i]];
WriteMatrix(_instanceData, i * 16, entry.Model);
_clipSlotData[i] = entry.ClipSlot;
_indoorData[i] = entry.Indoor;
_detailCategoryData[i] = entry.DetailCategory;
_alphaData[i] = entry.Opacity;
_selectionLightingData[i] = entry.SelectionLighting;
int lightOffset = i * LightManager.MaxLightsPerObject;
entry.Lights.CopyTo(_lightSetData, lightOffset);
GroupKey key = entry.Key;
_batchData[i] = new BatchData
{
// Campaign V slice V2: table slot, not the raw handle.
TextureIndex = key.TextureSlot.Index,
TextureLayer = key.TextureLayer,
// DrawMesh invokes RenderMeshSubset with detail enabled for
// every built-mesh material subset while curr_detail_surface
// is installed. The per-instance category still rejects
// ordinary objects in mesh_detail. Review fix round 2 (F2):
// bit 0 (the #226 built-mesh marker) is unconditional here —
// every delayed-alpha entry IS a built-mesh alpha submission
// — but the previous hardcoded `1` silently dropped bits 1/2
// (Campaign VM VM6 foliage classification). A trunk instance
// promoted into the alpha-blend group mid-fade (translucency
// < 1 forces AlphaBlend even for an otherwise-Opaque trunk —
// see ClassifyBatches's #188 promotion) must keep swaying
// through the deferred-alpha replay instead of going rigid
// for the duration of its fade.
Flags = 1u | key.FoliageFlags,
};
_indirectCommands[i] = new DrawElementsIndirectCommand
{
Count = (uint)key.IndexCount,
InstanceCount = 1,
FirstIndex = key.FirstIndex,
BaseVertex = key.BaseVertex,
BaseInstance = (uint)i,
};
_drawCullModes[i] = key.CullMode;
_deferredAlphaKinds[i] = key.Translucency;
}
WriteDeferredAlphaEntrySlot(i, _deferredAlpha[tokens[i]]);
// One upload per source per sorted alpha scope. RetailAlphaQueue later
// draws contiguous ranges from this immutable prepared payload; it must
@ -2584,6 +2626,34 @@ public sealed partial class WbDrawDispatcher : IDisposable
PrepareRhiAlphaSections(count);
}
/// <summary>
/// S4-c2 fix round 1 (M3b): <c>DrawMesh</c> row 1's "render immediately;
/// enqueue nothing" outcome for ONE translucent building-shell instance
/// — retail draws the subset in place inside the mesh; the walk's
/// opaque instances are stream-batched, so "in place" becomes "at the
/// entity's own stream mark" (a register row records this granularity
/// adaptation — see <c>SubmitToAlphaQueue</c>'s caller). Reuses
/// <see cref="WriteDeferredAlphaEntrySlot"/> and
/// <see cref="PrepareRhiAlphaSections"/> for slot 0, then
/// <see cref="DrawImmediateAlphaInstanceRhi"/> for the actual pipeline/
/// detail draw. Never touches <c>_deferredAlpha</c> or the queue — this
/// instance never enters a list — and never overlaps a real queue drain
/// in time (a drain only replays previously-APPENDED tokens at a LATER
/// flush site; this call happens at the instance's own submission,
/// strictly before any such flush).
/// </summary>
private void DrawImmediateAlphaInstance(in DeferredAlphaInstance entry, Matrix4x4 viewProjection)
{
GlobalMeshBuffer? global = _meshAdapter.MeshManager?.GlobalBuffer;
if (global is null || !MeshSourceReady())
return;
EnsureDeferredAlphaCapacity(1);
WriteDeferredAlphaEntrySlot(0, in entry);
PrepareRhiAlphaSections(1);
DrawImmediateAlphaInstanceRhi(global, entry.Key.Translucency, viewProjection);
}
private void DrawPreparedAlphaBatch(int firstPreparedDraw, int drawCount)
{
if (drawCount <= 0)