feat(render) Campaign FW3.2a: the walk-to-draw population layer
The piece that turns walk-visited static content into draws, with no production frame wiring (FW3.2b roots the frame): - TryClassifyBatch: ONE shared per-batch classify core (the #426 untextured gate, #188 opacity promotion, texture resolve, foliage classification, in the exact original order) extracted from ClassifyBatches; the classic and packed classifiers now call it - behavior-identical, proven by the full hermetic + InstalledDat + Core Wb suites. - ClassifyEntityForWalk / WalkClassifiedBatch: the per-entity seam yielding per-batch keys + instance data WITHOUT InstanceGroup bucketing, plus the per-part selection data (picking stays alive on the walk path - the survey's unlisted-consumer fix). - WalkStaticStreamPopulator: per-entity walk-ordered opaque appends (under depth Less, opaque order is pixel-relevant only for coplanar surfaces, which retail resolves first-drawn-wins in ITS order - never material-grouped), translucent instances to the SAME RetailAlphaQueue via SubmitWalkAlphaInstance (identical viewer distances; walk-order submission improves retail's tie fidelity), selection parts published per entity. - SubmitOrderedStream now owns _orderedDrawCullModes, retiring the FW2-recorded alpha-scope interleaving constraint; DrawIndirectRangeRhi takes an optional cull array (all existing call sites unchanged). The referee test was verified to FAIL against the old shared-scratch behavior. - WalkDrawStage.OutdoorStatic added for the landscape turn. Suites: full Release build 0 warnings; Walk lane 195/1 skip; hermetic 6,747/0 (the two failures the implementation round reported were transient - both pass in isolation and in the full run). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Erik
parent
b10ad662b0
commit
81c6531727
9 changed files with 1264 additions and 116 deletions
|
|
@ -70,6 +70,47 @@ internal readonly record struct RenderInstanceCandidate(
|
|||
TupleLandblockId: tupleLandblockId);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Campaign FW stage FW3.2a: builds a candidate straight from a
|
||||
/// <see cref="RenderProjectionRecord"/>, without the packed route's
|
||||
/// <see cref="RenderFrameEntityCandidate"/>/frame-arena mesh-part
|
||||
/// flattening. The walk populator reads <see cref="RenderSceneQuery"/>
|
||||
/// records directly (<c>CopyCellStaticsTo</c> / <c>CopyIndexTo</c>), so it
|
||||
/// has no frame arena to look the source candidate up in — every field
|
||||
/// this needs already lives on the record's own <see cref="RenderSourceMetadata"/>
|
||||
/// and <see cref="RenderEntityPayload"/>.
|
||||
///
|
||||
/// <para><paramref name="animated"/> defaults to false: the walk's static
|
||||
/// routes (<c>RenderProjectionClass.OutdoorStatic</c> /
|
||||
/// <c>IndoorCellStatic</c>) never carry retail's per-part
|
||||
/// <c>TransparentPartHook</c> animation — that mechanic keys off a live
|
||||
/// entity's ServerGuid, not a world static's. A future dynamic walk route
|
||||
/// passes true explicitly.</para>
|
||||
/// </summary>
|
||||
internal static RenderInstanceCandidate FromProjection(
|
||||
in RenderProjectionRecord projection,
|
||||
uint tupleLandblockId,
|
||||
bool animated = false)
|
||||
{
|
||||
RenderEntityPayload payload = projection.EntityPayload;
|
||||
return new RenderInstanceCandidate(
|
||||
ProjectionId: projection.Id,
|
||||
LocalEntityId: projection.Source.LocalEntityId,
|
||||
ServerGuid: projection.Source.ServerGuid,
|
||||
SourceId: projection.Source.SourceId,
|
||||
ParentCellId: projection.Source.ParentCellId,
|
||||
RootWorld: projection.Transform.LocalToWorld,
|
||||
Position: projection.Transform.Position,
|
||||
Rotation: projection.Transform.Rotation,
|
||||
Scale: projection.Transform.UniformScale,
|
||||
Bounds: projection.Bounds,
|
||||
PaletteOverride: payload.PaletteOverride,
|
||||
IsBuildingShell: payload.IsBuildingShell,
|
||||
Animated: animated,
|
||||
MeshPartCount: payload.MeshRefs?.Count ?? 0,
|
||||
TupleLandblockId: tupleLandblockId);
|
||||
}
|
||||
|
||||
internal static RenderInstanceCandidate FromFrame(
|
||||
in RenderFrameEntityCandidate source,
|
||||
uint tupleLandblockId)
|
||||
|
|
|
|||
|
|
@ -22,6 +22,20 @@ internal enum WalkDrawStage : byte
|
|||
/// <c>LScape::grab_visible_cells</c> @0x00504EC0 — outdoor terrain.</summary>
|
||||
Terrain,
|
||||
|
||||
/// <summary>
|
||||
/// Campaign FW stage FW3.2a: the outdoor static objects (scenery,
|
||||
/// buildings-as-decor, landblock statics —
|
||||
/// <c>RenderProjectionClass.OutdoorStatic</c>) <c>LScape::draw</c> visits
|
||||
/// for each landblock alongside its terrain mesh — retail's landscape
|
||||
/// walk draws a landblock's ground and its static content in the same
|
||||
/// pass, distinct from the ground mesh itself (<see cref="Terrain"/>) and
|
||||
/// from a building's own exterior shell (<see cref="BuildingShell"/>).
|
||||
/// The packed route's analogue is
|
||||
/// <c>RenderFrameCandidateRoute.LandscapeOutdoorStatic</c>
|
||||
/// (<c>WbDrawDispatcher.PackedOracle.cs</c>).
|
||||
/// </summary>
|
||||
OutdoorStatic,
|
||||
|
||||
/// <summary>An indoor <c>PView::DrawCells</c> @0x005A4840 flood's static
|
||||
/// geometry: EnvCell shells plus the static meshes they contain.</summary>
|
||||
CellStatic,
|
||||
|
|
|
|||
137
src/AcDream.App/Rendering/Walk/WalkStaticStreamPopulator.cs
Normal file
137
src/AcDream.App/Rendering/Walk/WalkStaticStreamPopulator.cs
Normal file
|
|
@ -0,0 +1,137 @@
|
|||
using System.Numerics;
|
||||
using AcDream.App.Rendering.Scene;
|
||||
using AcDream.App.Rendering.Wb;
|
||||
|
||||
namespace AcDream.App.Rendering.Walk;
|
||||
|
||||
/// <summary>
|
||||
/// Campaign FW stage FW3.2a: the walk→draw population layer. Turns one
|
||||
/// cell's already-classified static content into <see cref="OrderedDrawCommand"/>
|
||||
/// appends (opaque, walk order), per-instance deferred-alpha submissions
|
||||
/// (translucent), and selection-scene publications (picking) — WITHOUT any
|
||||
/// production frame wiring. <c>WorldSceneRenderer</c> does not call this
|
||||
/// class yet; FW3.2b roots it into the real frame.
|
||||
///
|
||||
/// <para><b>Why per-entity append instead of the classic material grouping</b>:
|
||||
/// under <see cref="WorldDepthContract"/>'s depth-compare Less, opaque draw
|
||||
/// order is pixel-relevant ONLY for coplanar surfaces (a rug on a floor, a
|
||||
/// shell over terrain) — and retail resolves those by first-drawn-wins in
|
||||
/// ITS walk/cell-content order, not by any texture/material grouping. So
|
||||
/// this populator appends one <see cref="OrderedDrawCommand"/> per (entity,
|
||||
/// opaque batch) in the SAME order the caller's <c>records</c> span presents
|
||||
/// them — never material-grouped, never re-sorted. Translucent batches go to
|
||||
/// the SAME <see cref="RetailAlphaQueue"/> the classic/packed paths already
|
||||
/// use (global far→near re-sort still applies; walk-order submission only
|
||||
/// improves retail's submission-order tie-break fidelity for coincident
|
||||
/// distances — <c>WbDrawDispatcher.DeferTransparentGroups</c>'s own doc
|
||||
/// comment cites the same <c>CShadowPart::insertion_sort</c> stability this
|
||||
/// preserves).</para>
|
||||
///
|
||||
/// <para>Reads no retained scene state itself: every method takes the target
|
||||
/// <see cref="OrderedDrawStream"/> and a caller-supplied span of already
|
||||
/// -queried <see cref="RenderProjectionRecord"/>s (from
|
||||
/// <c>RenderSceneQuery.CopyCellStaticsTo</c> / <c>CopyIndexTo</c>). Owns only
|
||||
/// two small per-call scratch lists — the classify seam's per-entity output
|
||||
/// — reused across records to keep this hot path allocation-free after
|
||||
/// warmup.</para>
|
||||
/// </summary>
|
||||
internal sealed class WalkStaticStreamPopulator
|
||||
{
|
||||
private readonly WbDrawDispatcher _dispatcher;
|
||||
private readonly List<WbDrawDispatcher.WalkClassifiedBatch> _batchScratch = new();
|
||||
private readonly List<WbDrawDispatcher.WalkClassifiedSelectionPart> _selectionScratch = new();
|
||||
|
||||
internal WalkStaticStreamPopulator(WbDrawDispatcher dispatcher)
|
||||
{
|
||||
_dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Populates <paramref name="stream"/> from one indoor cell's static
|
||||
/// content (<c>RenderProjectionClass.IndoorCellStatic</c> —
|
||||
/// <c>RenderSceneQuery.CopyCellStaticsTo</c>). <paramref name="stage"/>
|
||||
/// is caller-selected per the walk turn this cell's content belongs to
|
||||
/// — <see cref="WalkDrawStage.CellStatic"/> for an ordinary
|
||||
/// <c>PView::DrawCells</c> flood, <see cref="WalkDrawStage.LookInStatic"/>
|
||||
/// for a <c>ConstructView(CBldPortal)</c> look-in, or
|
||||
/// <see cref="WalkDrawStage.BuildingShell"/> for a building's own
|
||||
/// exterior shell content.
|
||||
/// </summary>
|
||||
internal void PopulateCell(
|
||||
OrderedDrawStream stream,
|
||||
WalkDrawStage stage,
|
||||
uint cellId,
|
||||
ReadOnlySpan<RenderProjectionRecord> records,
|
||||
uint tupleLandblockId,
|
||||
Vector3 cameraWorldPosition,
|
||||
Matrix4x4 viewProjection)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(stream);
|
||||
for (int i = 0; i < records.Length; i++)
|
||||
{
|
||||
ClassifyAndAppend(
|
||||
stream, stage, cellId, in records[i], tupleLandblockId,
|
||||
cameraWorldPosition, viewProjection);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The landscape entry point: outdoor static content
|
||||
/// (<c>RenderProjectionClass.OutdoorStatic</c> —
|
||||
/// <c>RenderSceneQuery.CopyIndexTo(RenderSceneIndex.OutdoorStatic, ...)</c>)
|
||||
/// at <see cref="WalkDrawStage.OutdoorStatic"/>, the terrain-adjacent
|
||||
/// stage <c>LScape::draw</c> visits a landblock's static objects at
|
||||
/// alongside its ground mesh (see that stage value's own doc comment).
|
||||
/// <paramref name="cellId"/> is the OUTDOOR landblock id — outdoor
|
||||
/// statics have no EnvCell of their own, so this is walk-order
|
||||
/// provenance only, not a clip-slot key.
|
||||
/// </summary>
|
||||
internal void PopulateOutdoorStatics(
|
||||
OrderedDrawStream stream,
|
||||
uint cellId,
|
||||
ReadOnlySpan<RenderProjectionRecord> records,
|
||||
uint tupleLandblockId,
|
||||
Vector3 cameraWorldPosition,
|
||||
Matrix4x4 viewProjection) =>
|
||||
PopulateCell(
|
||||
stream, WalkDrawStage.OutdoorStatic, cellId, records,
|
||||
tupleLandblockId, cameraWorldPosition, viewProjection);
|
||||
|
||||
private void ClassifyAndAppend(
|
||||
OrderedDrawStream stream,
|
||||
WalkDrawStage stage,
|
||||
uint cellId,
|
||||
in RenderProjectionRecord record,
|
||||
uint tupleLandblockId,
|
||||
Vector3 cameraWorldPosition,
|
||||
Matrix4x4 viewProjection)
|
||||
{
|
||||
_batchScratch.Clear();
|
||||
_selectionScratch.Clear();
|
||||
_dispatcher.ClassifyEntityForWalk(
|
||||
in record, tupleLandblockId, _batchScratch, _selectionScratch);
|
||||
|
||||
for (int i = 0; i < _batchScratch.Count; i++)
|
||||
{
|
||||
WbDrawDispatcher.WalkClassifiedBatch batch = _batchScratch[i];
|
||||
if (batch.IsOpaque)
|
||||
{
|
||||
stream.Append(new OrderedDrawCommand(
|
||||
batch.Key, batch.Transform, stage, cellId, batch.ClipSlot,
|
||||
batch.Lights, batch.IndoorFlag, batch.Alpha,
|
||||
batch.SelectionLighting, batch.DetailCategory));
|
||||
}
|
||||
else
|
||||
{
|
||||
_dispatcher.SubmitWalkAlphaInstance(
|
||||
in batch, cameraWorldPosition, viewProjection);
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < _selectionScratch.Count; i++)
|
||||
{
|
||||
WbDrawDispatcher.WalkClassifiedSelectionPart part = _selectionScratch[i];
|
||||
_dispatcher.PublishWalkSelectionPart(in part);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -253,14 +253,14 @@ public sealed unsafe partial class WbDrawDispatcher
|
|||
|
||||
// Per-instance-first emission — the PrepareDeferredAlphaDraws shape,
|
||||
// into the SAME per-frame scratch arrays PrepareDeferredAlphaDraws/
|
||||
// SubmitRhi write. Most are consumed immediately by the ring uploads
|
||||
// below, but _drawCullModes is NOT write-then-consume: the deferred-
|
||||
// alpha path reads it at FLUSH time (DrawIndirectRangeRhi's internal
|
||||
// cull split), so an ordered submission may never interleave between
|
||||
// RetailAlphaQueue prepare and flush. FW2 has no production caller;
|
||||
// the FW3 wiring must either sequence around the alpha scope or give
|
||||
// this path its own cull scratch.
|
||||
// SubmitRhi write, EXCEPT cull modes: this stage (FW3.2a) gives the
|
||||
// ordered path its own _orderedDrawCullModes scratch (see
|
||||
// DrawIndirectRangeRhi's doc comment) precisely so this loop and its
|
||||
// draws below can freely interleave with a mid-flight
|
||||
// RetailAlphaQueue scope without corrupting — or being corrupted by
|
||||
// — the alpha path's _drawCullModes.
|
||||
EnsureDeferredAlphaCapacity(count);
|
||||
EnsureOrderedCullModeCapacity(count);
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
GroupKey key = stream.Keys[i];
|
||||
|
|
@ -286,7 +286,7 @@ public sealed unsafe partial class WbDrawDispatcher
|
|||
BaseVertex = key.BaseVertex,
|
||||
BaseInstance = (uint)i,
|
||||
};
|
||||
_drawCullModes[i] = key.CullMode;
|
||||
_orderedDrawCullModes[i] = key.CullMode;
|
||||
}
|
||||
|
||||
// Write every section ONCE — the PrepareRhiAlphaSections shape, but
|
||||
|
|
@ -350,10 +350,10 @@ public sealed unsafe partial class WbDrawDispatcher
|
|||
|
||||
// One in-order pass over the pre-built merge runs: bind the run's
|
||||
// pipeline, set RenderPass, draw. DrawIndirectRangeRhi still splits
|
||||
// internally on _drawCullModes (issue #52's absolute DrawIdOffset per
|
||||
// sub-call) — every run here already shares one cull mode by
|
||||
// construction, so that inner split is a no-op here, never a second
|
||||
// boundary this loop failed to expect.
|
||||
// internally on _orderedDrawCullModes (issue #52's absolute
|
||||
// DrawIdOffset per sub-call) — every run here already shares one
|
||||
// cull mode by construction, so that inner split is a no-op here,
|
||||
// never a second boundary this loop failed to expect.
|
||||
foreach (OrderedMergeRun run in runs)
|
||||
{
|
||||
ValidateMergeRun(stream, run);
|
||||
|
|
@ -365,7 +365,20 @@ public sealed unsafe partial class WbDrawDispatcher
|
|||
BindPipelineWithMesh(encoder, pipeline, global);
|
||||
DrawIndirectRangeRhi(
|
||||
encoder, ref pushConstants, commandBuffer, commandBase,
|
||||
run.FirstCommand, run.CommandCount);
|
||||
run.FirstCommand, run.CommandCount, _orderedDrawCullModes);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Grows <see cref="_orderedDrawCullModes"/> to at least
|
||||
/// <paramref name="count"/> — the same growth shape
|
||||
/// <c>EnsureDeferredAlphaCapacity</c> uses for <see cref="_drawCullModes"/>,
|
||||
/// kept as its own method because this scratch array is not part of that
|
||||
/// method's shared per-instance group (see this file's type doc comment).
|
||||
/// </summary>
|
||||
private void EnsureOrderedCullModeCapacity(int count)
|
||||
{
|
||||
if (_orderedDrawCullModes.Length < count)
|
||||
_orderedDrawCullModes = new CullMode[count + 64];
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -635,56 +635,22 @@ public sealed unsafe partial class WbDrawDispatcher
|
|||
batchIndex < renderData.Batches.Count;
|
||||
batchIndex++)
|
||||
{
|
||||
ObjectRenderBatch batch =
|
||||
renderData.Batches[batchIndex];
|
||||
|
||||
// #426: mirrors the classic ClassifyBatches gate exactly — see
|
||||
// RetailUntexturedSubsetPolicy for the retail citation. ONE
|
||||
// shared predicate so the classic and packed classifiers cannot
|
||||
// drift (Campaign VM VM6).
|
||||
if (!RetailUntexturedSubsetPolicy.Draws(entity.IsBuildingShell, batch.Key.IsSolid))
|
||||
continue;
|
||||
|
||||
TranslucencyKind translucency = batch.Translucency;
|
||||
if (opacity < 1f && IsOpaque(translucency))
|
||||
translucency = TranslucencyKind.AlphaBlend;
|
||||
|
||||
ResolvedTexture texture = ResolveTexture(
|
||||
in entity,
|
||||
meshRef,
|
||||
batch,
|
||||
paletteIdentity,
|
||||
out bool compositePending);
|
||||
// Campaign FW stage FW3.2a: mirrors the classic ClassifyBatches
|
||||
// gate/promotion/resolve/foliage-classify sequence exactly — see
|
||||
// the one shared core (WbDrawDispatcher.WalkClassify.cs's
|
||||
// TryClassifyBatch) also used by ClassifyBatches and the walk
|
||||
// classifier, so the classic and packed classifiers cannot drift
|
||||
// (Campaign VM VM6). `survives=false` still applies
|
||||
// compositePending exactly as before this extraction.
|
||||
bool survives = TryClassifyBatch(
|
||||
renderData, batchIndex, in entity, meshRef, paletteIdentity,
|
||||
opacity, entityHasCutoutSubset,
|
||||
out GroupKey key, out bool compositePending);
|
||||
if (compositePending)
|
||||
reusableAcrossFrames = false;
|
||||
if (!texture.Slot.IsAssigned)
|
||||
if (!survives)
|
||||
continue;
|
||||
|
||||
// Campaign VM VM6 review fix round 2 (F1 BLOCKER): the packed
|
||||
// production classifier never computed FoliageFlags, so the
|
||||
// production BatchData.flags word was always 0 for every
|
||||
// scenery entity — the world geometry never swayed even though
|
||||
// the independently-classified shadow caster did. Classify
|
||||
// BEFORE constructing the key, from the RAW (pre-#188-
|
||||
// promotion) batch.Translucency, exactly as the classic
|
||||
// ClassifyBatches does — see that method's own comment for why
|
||||
// raw translucency is used for classification but the (possibly
|
||||
// promoted) local `translucency` is still what the key/group
|
||||
// partitions draws by.
|
||||
uint foliageFlags = FoliageWindClassification.Classify(
|
||||
entity.LocalEntityId,
|
||||
FoliageWindExclusions.Contains(meshRef.GfxObjId),
|
||||
batch.Translucency,
|
||||
entityHasCutoutSubset);
|
||||
var key = new GroupKey(
|
||||
batch.FirstIndex,
|
||||
(int)batch.BaseVertex,
|
||||
batch.IndexCount,
|
||||
texture.Slot,
|
||||
texture.Layer,
|
||||
translucency,
|
||||
FoliageFlags: foliageFlags,
|
||||
CullMode: batch.CullMode);
|
||||
var classified = new PackedClassifiedBatch(
|
||||
key,
|
||||
restPose,
|
||||
|
|
|
|||
|
|
@ -796,23 +796,40 @@ public sealed unsafe partial class WbDrawDispatcher
|
|||
_ => pipelines.AlphaBlend,
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// Reads cull modes from <paramref name="cullModes"/> when the caller
|
||||
/// supplies one, or from the shared <see cref="_drawCullModes"/> scratch
|
||||
/// otherwise (every pre-FW3.2a call site). Campaign FW stage FW3.2a:
|
||||
/// <see cref="SubmitOrderedStream"/> passes its OWN scratch
|
||||
/// (<see cref="_orderedDrawCullModes"/>) so a walk-ordered submission can
|
||||
/// interleave with a mid-flight <see cref="RetailAlphaQueue"/> scope —
|
||||
/// <c>_drawCullModes</c> is written fresh by
|
||||
/// <c>PrepareDeferredAlphaDraws</c> at every alpha flush and read right
|
||||
/// back by this method for that draw; an ordered submission sharing the
|
||||
/// same array between those two steps could silently draw the alpha
|
||||
/// content's faces with the ordered content's cull mode, or vice
|
||||
/// versa (the FW2 caveat this stage retires — see
|
||||
/// <c>WbDrawDispatcher.OrderedStream.cs</c>).
|
||||
/// </summary>
|
||||
private void DrawIndirectRangeRhi(
|
||||
IGpuPassEncoder encoder,
|
||||
ref GpuPushConstants pushConstants,
|
||||
IGpuBuffer commandBuffer,
|
||||
uint commandBaseOffsetBytes,
|
||||
int startCommand,
|
||||
int commandCount)
|
||||
int commandCount,
|
||||
CullMode[]? cullModes = null)
|
||||
{
|
||||
CullMode[] modes = cullModes ?? _drawCullModes;
|
||||
int end = startCommand + commandCount;
|
||||
int command = startCommand;
|
||||
while (command < end)
|
||||
{
|
||||
CullMode cullMode = _drawCullModes[command];
|
||||
CullMode cullMode = modes[command];
|
||||
ApplyCullModeRhi(encoder, cullMode);
|
||||
|
||||
int runCount = 1;
|
||||
while (command + runCount < end && _drawCullModes[command + runCount] == cullMode)
|
||||
while (command + runCount < end && modes[command + runCount] == cullMode)
|
||||
runCount++;
|
||||
|
||||
// Each multi-draw-indirect call restarts gl_DrawID at 0, so a run
|
||||
|
|
|
|||
355
src/AcDream.App/Rendering/Wb/WbDrawDispatcher.WalkClassify.cs
Normal file
355
src/AcDream.App/Rendering/Wb/WbDrawDispatcher.WalkClassify.cs
Normal file
|
|
@ -0,0 +1,355 @@
|
|||
using System.Numerics;
|
||||
using AcDream.App.Rendering.Scene;
|
||||
using AcDream.App.Rendering.Selection;
|
||||
using AcDream.Core.Meshing;
|
||||
using AcDream.Core.World;
|
||||
using DatReaderWriter.Enums;
|
||||
|
||||
namespace AcDream.App.Rendering.Wb;
|
||||
|
||||
/// <summary>
|
||||
/// Campaign FW stage FW3.2a: the walk-order population layer. This partial
|
||||
/// holds two things.
|
||||
///
|
||||
/// <para><b>The shared per-batch classify core</b> (<see cref="TryClassifyBatch"/>):
|
||||
/// extracted from <c>ClassifyBatches</c> (this file's sibling
|
||||
/// <c>WbDrawDispatcher.cs</c>) and <c>ClassifyPackedBatches</c>
|
||||
/// (<c>WbDrawDispatcher.PackedOracle.cs</c>), which carried byte-identical
|
||||
/// per-batch logic (the #426 untextured-subset gate, the #188 opacity
|
||||
/// promotion, texture resolution, Campaign VM foliage classification, the
|
||||
/// <see cref="GroupKey"/> construction) with only their SURROUNDING
|
||||
/// bookkeeping differing (classic appends to an <see cref="InstanceGroup"/>
|
||||
/// via caller-scoped instance fields; packed appends via explicit
|
||||
/// parameters). Both call sites now call this one method per batch and keep
|
||||
/// their own append logic — the classic and packed paths are unchanged in
|
||||
/// every observable way (same hermetic + <c>Lane=InstalledDat</c> suites
|
||||
/// stay the referee); this stage's OWN new walk classifier
|
||||
/// (<see cref="ClassifyEntityForWalk"/>) is the third caller.</para>
|
||||
///
|
||||
/// <para><b>The per-entity walk classify seam</b>
|
||||
/// (<see cref="ClassifyEntityForWalk"/>): given ONE <see cref="RenderProjectionRecord"/>
|
||||
/// — the same shape <c>ClassifyPackedEntity</c> consumes, but read straight
|
||||
/// off the record's own <see cref="RenderEntityPayload"/> via
|
||||
/// <c>RenderInstanceCandidate.FromProjection</c> rather than the packed
|
||||
/// route's frame-arena mesh-part flattening — yields one
|
||||
/// <see cref="WalkClassifiedBatch"/> per surviving (part, batch) pair WITHOUT
|
||||
/// touching any <see cref="InstanceGroup"/>, plus the per-part selection
|
||||
/// data <c>AddPackedSelectionPart</c> would have published, for
|
||||
/// <c>WalkStaticStreamPopulator</c> to publish itself (deliverable
|
||||
/// 1 leaves the publish decision — timing, stage/cell provenance — to the
|
||||
/// caller; see <see cref="PublishWalkSelectionPart"/>, the thin internal seam
|
||||
/// that keeps <c>_selectionSink</c> encapsulated).</para>
|
||||
///
|
||||
/// <para>Scope: this stage classifies static content only (no production
|
||||
/// frame wiring — see plan §FW3.2a). Per-part translucency-fade
|
||||
/// (<c>TranslucencyFadeManager</c>/<c>EntityOpacity</c>) is NOT threaded
|
||||
/// through: that mechanic is <c>TransparentPartHook</c>, a retail LIVE-entity
|
||||
/// behavior keyed by ServerGuid, not something world statics undergo — every
|
||||
/// classified batch here carries <c>Alpha = 1f</c>. Likewise the async
|
||||
/// mesh-miss self-heal request (<c>_missRequested</c>/<c>EnsureLoaded</c>,
|
||||
/// frame-scoped state cleared by <c>BeginEntityDispatch</c>) is not fired
|
||||
/// here — this seam has no production frame to be scoped to yet; a missing
|
||||
/// mesh is simply skipped, matching every other unwired FW2/FW3.2a path.</para>
|
||||
/// </summary>
|
||||
public sealed partial class WbDrawDispatcher
|
||||
{
|
||||
/// <summary>
|
||||
/// One walk-classified (entity, part, batch) draw candidate — exactly
|
||||
/// <c>OrderedDrawCommand</c>'s per-instance field set (minus
|
||||
/// the walk-provenance <c>Stage</c>/<c>CellId</c> fields, which the
|
||||
/// populator stamps on since the classifier has no notion of either)
|
||||
/// plus two fields an opaque command has no use for but a translucent
|
||||
/// one needs to reach the alpha queue: <see cref="IsOpaque"/> (so the
|
||||
/// populator can route without re-deriving it from
|
||||
/// <see cref="GroupKey.Translucency"/>) and <see cref="LocalSortCenter"/>
|
||||
/// (the authored GfxObj sort center <c>RetailAlphaOrdering.ComputeViewerDistance</c>
|
||||
/// transforms through <see cref="Transform"/> — the same value
|
||||
/// <c>InstanceGroup.LocalSortCenters</c> carries per instance today).
|
||||
/// </summary>
|
||||
internal readonly record struct WalkClassifiedBatch(
|
||||
GroupKey Key,
|
||||
Matrix4x4 Transform,
|
||||
uint ClipSlot,
|
||||
InstanceLightSet Lights,
|
||||
uint IndoorFlag,
|
||||
float Alpha,
|
||||
Vector2 SelectionLighting,
|
||||
uint DetailCategory,
|
||||
bool IsOpaque,
|
||||
Vector3 LocalSortCenter);
|
||||
|
||||
/// <summary>
|
||||
/// One retail-picking part surfaced by <see cref="ClassifyEntityForWalk"/>
|
||||
/// — the exact argument tuple <c>AddPackedSelectionPart</c>'s
|
||||
/// <c>publishSelection: true</c> branch passes to
|
||||
/// <c>IRetailSelectionRenderSink.AddVisiblePart</c>. The classify seam
|
||||
/// surfaces this; <see cref="PublishWalkSelectionPart"/> is the caller's
|
||||
/// publish call.
|
||||
/// </summary>
|
||||
internal readonly record struct WalkClassifiedSelectionPart(
|
||||
uint ServerGuid,
|
||||
uint LocalEntityId,
|
||||
int PartIndex,
|
||||
uint GfxObjId,
|
||||
Matrix4x4 LocalToWorld);
|
||||
|
||||
/// <summary>
|
||||
/// The shared per-batch classify core. Given one already-resolved
|
||||
/// <paramref name="renderData"/> and the batch at <paramref name="batchIndex"/>,
|
||||
/// applies — in this exact order, matching both <c>ClassifyBatches</c> and
|
||||
/// <c>ClassifyPackedBatches</c> before this extraction — the #426
|
||||
/// untextured-subset-on-a-shell-only gate, the #188 mid-fade-forces-
|
||||
/// AlphaBlend promotion, texture resolution, and Campaign VM foliage
|
||||
/// classification, then builds the surviving batch's <see cref="GroupKey"/>.
|
||||
///
|
||||
/// <para>Returns false when the batch does not survive — either the
|
||||
/// untextured-subset gate rejected it (in which case
|
||||
/// <paramref name="compositePending"/> is always false: <c>ResolveTexture</c>
|
||||
/// is never called) or its resolved texture slot is unassigned (in which
|
||||
/// case <paramref name="compositePending"/> still reflects whatever
|
||||
/// <c>ResolveTexture</c> reported — a caller must apply it to its own
|
||||
/// reusability/readiness tracking regardless of the false return, exactly
|
||||
/// as both existing callers did before this extraction).</para>
|
||||
/// </summary>
|
||||
private bool TryClassifyBatch(
|
||||
ObjectRenderData renderData,
|
||||
int batchIndex,
|
||||
in RenderInstanceCandidate entity,
|
||||
MeshRef meshRef,
|
||||
PaletteCompositeIdentity paletteIdentity,
|
||||
float opacityMultiplier,
|
||||
bool entityHasCutoutSubset,
|
||||
out GroupKey key,
|
||||
out bool compositePending)
|
||||
{
|
||||
key = default;
|
||||
compositePending = false;
|
||||
ObjectRenderBatch batch = renderData.Batches[batchIndex];
|
||||
|
||||
// #426 — see RetailUntexturedSubsetPolicy for the retail citation.
|
||||
// ONE shared predicate for every classifier so they cannot drift.
|
||||
if (!RetailUntexturedSubsetPolicy.Draws(entity.IsBuildingShell, batch.Key.IsSolid))
|
||||
return false;
|
||||
|
||||
TranslucencyKind translucency = batch.Translucency;
|
||||
|
||||
// #188: a mid-fade instance whose surface is otherwise Opaque/ClipMap
|
||||
// must route through the alpha-blend pass so mesh_modern.frag's
|
||||
// (blend-enabled) shader actually composites the reduced alpha — the
|
||||
// no-blend opaque pass would ignore it.
|
||||
if (opacityMultiplier < 1.0f && IsOpaque(translucency))
|
||||
translucency = TranslucencyKind.AlphaBlend;
|
||||
|
||||
ResolvedTexture texture = ResolveTexture(
|
||||
in entity, meshRef, batch, paletteIdentity, out compositePending);
|
||||
if (!texture.Slot.IsAssigned)
|
||||
return false;
|
||||
|
||||
// Classify from the RAW (pre-#188-promotion) batch.Translucency — a
|
||||
// mid-fade trunk is still a trunk, it just landed in the alpha-blend
|
||||
// group instead of opaque (Campaign VM VM6 review fix round).
|
||||
uint foliageFlags = FoliageWindClassification.Classify(
|
||||
entity.LocalEntityId,
|
||||
FoliageWindExclusions.Contains(meshRef.GfxObjId),
|
||||
batch.Translucency,
|
||||
entityHasCutoutSubset);
|
||||
key = new GroupKey(
|
||||
batch.FirstIndex, (int)batch.BaseVertex,
|
||||
batch.IndexCount, texture.Slot, texture.Layer, translucency,
|
||||
FoliageFlags: foliageFlags,
|
||||
CullMode: batch.CullMode);
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Classifies one static entity for the walk populator: resolves its clip
|
||||
/// slot / light set / selection lighting exactly as
|
||||
/// <c>ClassifyPackedEntity</c> does (via the shared
|
||||
/// <see cref="ResolveSlotForFrame"/> / <c>ResolvePackedLightSet</c>
|
||||
/// helpers), walks its Setup parts or single mesh (mirroring
|
||||
/// <c>ClassifyPackedEntity</c>'s own shape), and appends one
|
||||
/// <see cref="WalkClassifiedBatch"/> per surviving batch to
|
||||
/// <paramref name="batches"/> plus one <see cref="WalkClassifiedSelectionPart"/>
|
||||
/// per part to <paramref name="selectionParts"/> — WITHOUT touching
|
||||
/// <c>_groups</c>/<c>_packedGroups</c> or publishing selection itself (see
|
||||
/// this file's type doc comment).
|
||||
///
|
||||
/// <para>A culled entity (<see cref="ResolveSlotForFrame"/> returns
|
||||
/// <c>Culled: true</c> — not visible through the active clip route)
|
||||
/// contributes nothing, matching every other classifier's cull gate.</para>
|
||||
/// </summary>
|
||||
internal void ClassifyEntityForWalk(
|
||||
in RenderProjectionRecord projection,
|
||||
uint tupleLandblockId,
|
||||
List<WalkClassifiedBatch> batches,
|
||||
List<WalkClassifiedSelectionPart> selectionParts)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(batches);
|
||||
ArgumentNullException.ThrowIfNull(selectionParts);
|
||||
|
||||
RenderInstanceCandidate entity =
|
||||
RenderInstanceCandidate.FromProjection(in projection, tupleLandblockId);
|
||||
|
||||
(uint slot, bool culled) = ResolveSlotForFrame(
|
||||
_clipRoutingActive, entity.ServerGuid, entity.ParentCell,
|
||||
_cellIdToSlot, _outdoorSlot, _outdoorVisible);
|
||||
if (culled)
|
||||
return;
|
||||
|
||||
ResolvePackedLightSet(in entity, out InstanceLightSet lights, out bool indoor);
|
||||
Vector2 selectionLighting =
|
||||
_selectionLighting?.TryGetLighting(
|
||||
entity.ServerGuid, entity.LocalEntityId, out RetailSelectionLighting lighting) == true
|
||||
? new Vector2(lighting.Luminosity, lighting.Diffuse)
|
||||
: new Vector2(0f, 1f);
|
||||
uint detailCategory = entity.IsBuildingShell ? 1u : 0u;
|
||||
|
||||
PaletteCompositeIdentity paletteIdentity = default;
|
||||
if (entity.PaletteOverride is not null)
|
||||
paletteIdentity = TextureCache.GetPaletteIdentity(entity.PaletteOverride);
|
||||
|
||||
IReadOnlyList<MeshRef>? meshRefs = projection.EntityPayload.MeshRefs;
|
||||
if (meshRefs is null)
|
||||
return;
|
||||
|
||||
for (int partIndex = 0; partIndex < meshRefs.Count; partIndex++)
|
||||
{
|
||||
MeshRef meshRef = meshRefs[partIndex];
|
||||
ObjectRenderData? renderData = _meshAdapter.TryGetRenderData(meshRef.GfxObjId);
|
||||
if (renderData is null)
|
||||
continue;
|
||||
|
||||
if (renderData.IsSetup && renderData.SetupParts.Count > 0)
|
||||
{
|
||||
// Same entity-scoped OR the classic/packed classifiers compute
|
||||
// — a Setup composite's parts are separate GfxObjs with their
|
||||
// own independently cached HasCutoutSubset (Campaign VM VM6
|
||||
// review fix round A4/F1).
|
||||
bool entityHasCutoutSubset = FoliageWindClassification.ComputeEntityHasCutoutSubset(
|
||||
renderData.SetupParts,
|
||||
_meshAdapter,
|
||||
static (adapter, part) => adapter.TryGetRenderData(part.GfxObjId)
|
||||
is { HasCutoutSubset: true });
|
||||
|
||||
for (int setupPartIndex = 0; setupPartIndex < renderData.SetupParts.Count; setupPartIndex++)
|
||||
{
|
||||
(ulong gfxObjId, Matrix4x4 partTransform) = renderData.SetupParts[setupPartIndex];
|
||||
ObjectRenderData? partData = _meshAdapter.TryGetRenderData(gfxObjId);
|
||||
if (partData is null)
|
||||
continue;
|
||||
|
||||
Matrix4x4 restPose = partTransform * meshRef.PartTransform;
|
||||
Matrix4x4 model = restPose * entity.RootWorld;
|
||||
int selectionPartIndex = unchecked((partIndex << 16) | (setupPartIndex & 0xFFFF));
|
||||
|
||||
EmitClassifiedBatches(
|
||||
partData, model, in entity, meshRef, paletteIdentity,
|
||||
entityHasCutoutSubset, slot, lights, indoor, selectionLighting,
|
||||
detailCategory, batches);
|
||||
selectionParts.Add(new WalkClassifiedSelectionPart(
|
||||
entity.ServerGuid, entity.LocalEntityId, selectionPartIndex,
|
||||
(uint)gfxObjId, model));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Matrix4x4 model = meshRef.PartTransform * entity.RootWorld;
|
||||
EmitClassifiedBatches(
|
||||
renderData, model, in entity, meshRef, paletteIdentity,
|
||||
entityHasCutoutSubsetOverride: null, slot, lights, indoor,
|
||||
selectionLighting, detailCategory, batches);
|
||||
selectionParts.Add(new WalkClassifiedSelectionPart(
|
||||
entity.ServerGuid, entity.LocalEntityId, partIndex,
|
||||
(uint)meshRef.GfxObjId, model));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Walks one resolved mesh's batches through <see cref="TryClassifyBatch"/>
|
||||
/// and appends every surviving one to <paramref name="sink"/> at
|
||||
/// <c>Alpha = 1f</c> (see this file's type doc comment for why statics
|
||||
/// never carry a per-part opacity multiplier here).
|
||||
/// </summary>
|
||||
private void EmitClassifiedBatches(
|
||||
ObjectRenderData renderData,
|
||||
Matrix4x4 model,
|
||||
in RenderInstanceCandidate entity,
|
||||
MeshRef meshRef,
|
||||
PaletteCompositeIdentity paletteIdentity,
|
||||
bool? entityHasCutoutSubsetOverride,
|
||||
uint slot,
|
||||
InstanceLightSet lights,
|
||||
bool indoor,
|
||||
Vector2 selectionLighting,
|
||||
uint detailCategory,
|
||||
List<WalkClassifiedBatch> sink)
|
||||
{
|
||||
bool entityHasCutoutSubset = entityHasCutoutSubsetOverride ?? renderData.HasCutoutSubset;
|
||||
for (int batchIdx = 0; batchIdx < renderData.Batches.Count; batchIdx++)
|
||||
{
|
||||
bool survives = TryClassifyBatch(
|
||||
renderData, batchIdx, in entity, meshRef, paletteIdentity,
|
||||
opacityMultiplier: 1.0f, entityHasCutoutSubset,
|
||||
out GroupKey key, out _);
|
||||
if (!survives)
|
||||
continue;
|
||||
|
||||
sink.Add(new WalkClassifiedBatch(
|
||||
key, model, slot, lights, indoor ? 1u : 0u, Alpha: 1f,
|
||||
selectionLighting, detailCategory, IsOpaque: IsOpaque(key.Translucency),
|
||||
LocalSortCenter: renderData.SortCenter));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The thin internal publish seam <c>WalkStaticStreamPopulator</c>
|
||||
/// calls for every <see cref="WalkClassifiedSelectionPart"/>
|
||||
/// <see cref="ClassifyEntityForWalk"/> surfaced — same call shape as
|
||||
/// <c>AddPackedSelectionPart</c>'s <c>publishSelection: true</c> branch.
|
||||
/// Keeps <c>_selectionSink</c> encapsulated: the populator lives outside
|
||||
/// the dispatcher and must not reach the field directly.
|
||||
/// </summary>
|
||||
internal void PublishWalkSelectionPart(in WalkClassifiedSelectionPart part) =>
|
||||
_selectionSink?.AddVisiblePart(
|
||||
part.ServerGuid, part.LocalEntityId, part.PartIndex, part.GfxObjId, part.LocalToWorld);
|
||||
|
||||
/// <summary>
|
||||
/// The walk populator's per-instance sibling of <c>DeferTransparentGroups</c>
|
||||
/// (see that method for the retail citations this mirrors): submits ONE
|
||||
/// translucent <see cref="WalkClassifiedBatch"/> into the same
|
||||
/// <c>_deferredAlpha</c>/<see cref="RetailAlphaQueue"/> machinery the
|
||||
/// classic material-grouped path uses, so scenery, particles, and walk
|
||||
/// content share retail's one stable far-to-near stream. Same
|
||||
/// view-projection consistency check, same
|
||||
/// <see cref="RetailAlphaOrdering.ComputeViewerDistance"/> call, same
|
||||
/// <c>queue.Submit</c> contract — the walk path denormalizes to one
|
||||
/// instance per call instead of flattening a material group.
|
||||
/// </summary>
|
||||
internal void SubmitWalkAlphaInstance(
|
||||
in WalkClassifiedBatch batch,
|
||||
Vector3 cameraWorldPosition,
|
||||
Matrix4x4 viewProjection)
|
||||
{
|
||||
RetailAlphaQueue queue = _alphaQueue
|
||||
?? throw new InvalidOperationException(
|
||||
"SubmitWalkAlphaInstance requires an active RetailAlphaQueue.");
|
||||
|
||||
if (_deferredAlpha.Count == 0)
|
||||
_deferredAlphaViewProjection = viewProjection;
|
||||
else if (_deferredAlphaViewProjection != viewProjection)
|
||||
throw new InvalidOperationException(
|
||||
"One retail alpha scope cannot combine different view-projection matrices.");
|
||||
|
||||
float viewerDistance = RetailAlphaOrdering.ComputeViewerDistance(
|
||||
batch.LocalSortCenter, batch.Transform, cameraWorldPosition);
|
||||
if (!float.IsFinite(viewerDistance) || viewerDistance <= 0f)
|
||||
viewerDistance = 0f;
|
||||
|
||||
int token = _deferredAlpha.Count;
|
||||
_deferredAlpha.Add(new DeferredAlphaInstance(
|
||||
batch.Key, batch.Transform, batch.ClipSlot, batch.Lights,
|
||||
batch.IndoorFlag, batch.DetailCategory, batch.Alpha, batch.SelectionLighting));
|
||||
queue.Submit(_alphaSource, token, viewerDistance);
|
||||
}
|
||||
}
|
||||
|
|
@ -598,6 +598,12 @@ public sealed partial class WbDrawDispatcher : IDisposable
|
|||
private BatchData[] _batchData = new BatchData[256];
|
||||
private DrawElementsIndirectCommand[] _indirectCommands = new DrawElementsIndirectCommand[256];
|
||||
private CullMode[] _drawCullModes = new CullMode[256];
|
||||
|
||||
// Campaign FW stage FW3.2a: SubmitOrderedStream's OWN cull-mode scratch,
|
||||
// separate from _drawCullModes above. See DrawIndirectRangeRhi's doc
|
||||
// comment for why sharing the array made an ordered submission unsafe to
|
||||
// interleave with a mid-flight RetailAlphaQueue scope.
|
||||
private CullMode[] _orderedDrawCullModes = new CullMode[256];
|
||||
private BatchDataPublic[] _batchPublicScratch = new BatchDataPublic[256];
|
||||
private readonly List<IndirectGroupInput> _groupInputScratch = new(256);
|
||||
private readonly List<GroupKey> _retiredGroupKeys = new();
|
||||
|
|
@ -3312,62 +3318,25 @@ public sealed partial class WbDrawDispatcher : IDisposable
|
|||
bool allTexturesReady = true;
|
||||
for (int batchIdx = 0; batchIdx < renderData.Batches.Count; batchIdx++)
|
||||
{
|
||||
var batch = renderData.Batches[batchIdx];
|
||||
|
||||
// #426: retail's D3DPolyRender::DrawMesh skips an UNTEXTURED
|
||||
// (solid-colour) subset only on a BUILDING SHELL
|
||||
// (RenderDeviceD3D::DrawBuilding sets ObjBuildingOrBuildingPart);
|
||||
// ordinary statics/scenery/creatures/items draw it same as any
|
||||
// textured subset. ONE shared predicate with ClassifyPackedBatches
|
||||
// and AddDirectionalShadowBatches — see RetailUntexturedSubsetPolicy.
|
||||
if (!RetailUntexturedSubsetPolicy.Draws(entity.IsBuildingShell, batch.Key.IsSolid))
|
||||
continue;
|
||||
|
||||
TranslucencyKind translucency = batch.Translucency;
|
||||
|
||||
// #188: a mid-fade instance whose surface is otherwise Opaque/ClipMap
|
||||
// must route through the alpha-blend pass so mesh_modern.frag's
|
||||
// (blend-enabled) shader actually composites the reduced alpha —
|
||||
// the no-blend opaque pass would ignore it.
|
||||
if (opacityMultiplier < 1.0f && IsOpaque(translucency))
|
||||
translucency = TranslucencyKind.AlphaBlend;
|
||||
|
||||
ResolvedTexture texture = ResolveTexture(
|
||||
in entity,
|
||||
meshRef,
|
||||
batch,
|
||||
paletteIdentity,
|
||||
out bool compositePending);
|
||||
// Campaign FW stage FW3.2a: the untextured-subset gate, the #188
|
||||
// opacity promotion, texture resolution, and Campaign VM foliage
|
||||
// classification now live in the one shared core
|
||||
// (WbDrawDispatcher.WalkClassify.cs) also used by
|
||||
// ClassifyPackedBatches and the walk classifier — see
|
||||
// TryClassifyBatch's doc comment. `survives=false` still applies
|
||||
// compositePending exactly as before this extraction (a batch
|
||||
// that fails the untextured-subset gate never touched
|
||||
// ResolveTexture, so compositePending is always false there; a
|
||||
// batch with an unresolved texture slot still reports it).
|
||||
bool survives = TryClassifyBatch(
|
||||
renderData, batchIdx, in entity, meshRef, paletteIdentity,
|
||||
opacityMultiplier, entityHasCutoutSubset,
|
||||
out GroupKey key, out bool compositePending);
|
||||
if (compositePending)
|
||||
allTexturesReady = false;
|
||||
// Campaign V slice V4t: an unassigned slot is the "no texture yet"
|
||||
// case a zero handle used to signal. It is a real sentinel
|
||||
// (GpuTextureSlot.Unassigned == ACDREAM_TEXTURE_NONE), not the
|
||||
// default value, so nothing here can silently resolve to slot 0.
|
||||
if (!texture.Slot.IsAssigned) continue;
|
||||
GpuTextureSlot texSlot = texture.Slot;
|
||||
uint texLayer = texture.Layer;
|
||||
|
||||
// Campaign VM VM6 review fix round: classify BEFORE constructing
|
||||
// the key and fold the result INTO the key (rather than
|
||||
// stamping it onto whatever group the key already resolves to).
|
||||
// Classification is from the RAW (pre-#188-promotion)
|
||||
// batch.Translucency — a mid-fade trunk is still a trunk, it
|
||||
// just landed in the alpha-blend group instead of opaque. This
|
||||
// is what keeps a scenery instance and a non-scenery instance
|
||||
// of the identical mesh subset in two SEPARATE groups instead of
|
||||
// coalescing into one group whose classification depends on
|
||||
// whichever entity classified it last.
|
||||
uint foliageFlags = FoliageWindClassification.Classify(
|
||||
entity.LocalEntityId,
|
||||
FoliageWindExclusions.Contains(meshRef.GfxObjId),
|
||||
batch.Translucency,
|
||||
entityHasCutoutSubset);
|
||||
var key = new GroupKey(
|
||||
batch.FirstIndex, (int)batch.BaseVertex,
|
||||
batch.IndexCount, texSlot, texLayer, translucency,
|
||||
FoliageFlags: foliageFlags,
|
||||
CullMode: batch.CullMode);
|
||||
if (!survives)
|
||||
continue;
|
||||
GpuTextureSlot texSlot = key.TextureSlot;
|
||||
|
||||
InstanceGroup grp = GetOrCreateInstanceGroup(key);
|
||||
grp.Matrices.Add(model);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue