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

feat(render): Phase A8 — indoor visibility + streaming fixes batch

Browse source 
Lands the working A8 indoor-rendering and streaming fixes accumulated this
session. User has verified these visually to some degree (e.g. lifestone /
translucent meshes confirmed fine under the FrontFace flip; bridge / wall /
collision regressions confirmed fixed after travel); not every path has been
exhaustively gated. The cellar-flap defect remains OPEN and will be solved
the retail-faithful way via a dedicated brainstorm (see handoff docs).

Rendering core (reviewed, high confidence):
- EnvCellRenderer SSBO stride fix: upload packed Matrix4x4[] (64B) instead of
  the 80B CPU InstanceData struct the shader never expected — fixes the
  transform/texture "explosion" for any draw with >1 instance (cells that
  dedupe to a shared cellGeomId). Real root cause.
- WB-style global FrontFace(CW) + per-batch CullMode carried through the MDI
  layout (GroupKey + BuildIndirectArrays + DrawIndirectRange split into
  same-cull runs with absolute uDrawIDOffset per run).
- EntitySet partitioning (IndoorPass / OutdoorScenery / LiveDynamic) +
  WorldEntity.BuildingShellAnchorCellId so building shells scope to their
  dat-derived building cell instead of rendering everywhere.
- RenderOutsideInAcdream (look into buildings from outside) +
  CollectVisiblePortalBuildings frustum cull of portal bounds.
- Sky-when-inside-building + per-cell audit probe + GL-state probe.

Streaming / perf (test-covered; not independently code-reviewed this session):
- Near/far priority queues so near work wins over far; PromoteToNear carries
  full landblock + mesh data; LandblockEntriesWithoutAnimatedIndex avoids
  rebuilding the animated-lookup dict in the hot draw path. Fixes the
  bridge-not-appearing / missing-walls / broken-collision-after-travel
  regressions and improves post-transition FPS.

Tooling + docs:
- tools/A8CellAudit: offline dat cell/portal/building dumper (portals +
  buildings modes) — reproduces the cellar-flap investigation with no launch.
- docs/research cellar-flap root-cause + option-2 handoff (the didInsideStencil
  double-duty finding + the WB-recursive design decision + brainstorm prompt),
  entity-taxonomy, replan, issue-78 visibility investigation.

Diagnostics retained on purpose: ACDREAM_A8_DIAG_* gates, portal_stencil.vert
provisional pos.w clamp, and the probe families are kept (env-var gated, zero
cost when off) because the pending option-2 cellar-flap brainstorm needs them.
Strip in the option-2 ship commit.

Indoor branch stays behind ACDREAM_A8_INDOOR_BRANCH=1 (default off = pre-A8
visual). Build green; App tests + Core (streaming/dispatcher/loader) tests pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Erik 2026-05-29 10:14:50 +02:00
parent e415bb3863
commit 5dc4140c11
38 changed files with 3965 additions and 277 deletions
Download patch file Download diff file Expand all files Collapse all files

46
tests/AcDream.Core.Tests/Rendering/Wb/LandblockSpawnAdapterTests.cs
View file

@ -101,8 +101,7 @@ public sealed class LandblockSpawnAdapterTests
public void OnLandblockLoaded_SameLandblockTwice_DedupesAtTheLandblockLevel()
{
// If a landblock load fires twice (e.g. a streaming-controller bug),
// we should not double-register. Second load is treated as a no-op
// for ref-counting purposes.
// we should not double-register ids that were already seen.
var captured = new CapturingAdapterMock();
var adapter = new LandblockSpawnAdapter(captured);
@ -118,6 +117,49 @@ public sealed class LandblockSpawnAdapterTests
Assert.Single(captured.IncrementCalls);
}
[Fact]
public void OnLandblockLoaded_FarEmptyThenNearPromotion_RegistersPromotedIds()
{
var captured = new CapturingAdapterMock();
var adapter = new LandblockSpawnAdapter(captured);
var far = MakeLandblock(
landblockId: 0x12340000u,
entities: System.Array.Empty<WorldEntity>());
var promoted = MakeLandblock(landblockId: 0x12340000u, entities: new[]
{
MakeAtlasEntity(id: 1, gfxObjIds: new[] { 0x01000010u, 0x01000020u }),
});
adapter.OnLandblockLoaded(far);
adapter.OnLandblockLoaded(promoted);
Assert.Equal(2, captured.IncrementCalls.Count);
Assert.Contains(0x01000010ul, captured.IncrementCalls);
Assert.Contains(0x01000020ul, captured.IncrementCalls);
}
[Fact]
public void OnLandblockLoaded_PromotionWithPartiallyRegisteredIds_RegistersOnlyNewIds()
{
var captured = new CapturingAdapterMock();
var adapter = new LandblockSpawnAdapter(captured);
var initial = MakeLandblock(landblockId: 0x12340000u, entities: new[]
{
MakeAtlasEntity(id: 1, gfxObjIds: new[] { 0x01000010u }),
});
var promoted = MakeLandblock(landblockId: 0x12340000u, entities: new[]
{
MakeAtlasEntity(id: 1, gfxObjIds: new[] { 0x01000010u, 0x01000020u }),
});
adapter.OnLandblockLoaded(initial);
adapter.OnLandblockLoaded(promoted);
Assert.Equal(new[] { 0x01000010ul, 0x01000020ul }, captured.IncrementCalls);
}
// ── Test helpers ──────────────────────────────────────────────────────
private sealed class CapturingAdapterMock : IWbMeshAdapter

18
tests/AcDream.Core.Tests/Rendering/Wb/WbDrawDispatcherCellIdsOverloadTests.cs
View file

@ -2,7 +2,8 @@
// the pure-data companion to the new Draw(cellIds:) production overload.
//
// Semantics: indoor entities (ParentCellId.HasValue) are gated by explicit
// membership in cellIds. Building shells (IsBuildingShell) always pass.
// membership in cellIds. Building shells (IsBuildingShell) pass only when their
// BuildingShellAnchorCellId belongs to the same cell set.
// Outdoor scenery (no ParentCellId, not a shell) is excluded by EntitySet.IndoorPass.
using System.Collections.Generic;
@ -36,12 +37,13 @@ public class WbDrawDispatcherCellIdsOverloadTests
Rotation = Quaternion.Identity,
};
private static WorldEntity BuildingShell(uint id) => new()
private static WorldEntity BuildingShell(uint id, uint? anchorCellId) => new()
{
Id = id,
SourceGfxObjOrSetupId = 0x02000001u,
ParentCellId = null,
IsBuildingShell = true,
BuildingShellAnchorCellId = anchorCellId,
MeshRefs = new List<MeshRef> { new(0x01000001u, Matrix4x4.Identity) },
Position = Vector3.Zero,
Rotation = Quaternion.Identity,
@ -55,7 +57,8 @@ public class WbDrawDispatcherCellIdsOverloadTests
CellEnt(0x40000001u, 0xA9B40150u), // in listed cells
CellEnt(0x40000002u, 0xA9B40151u), // in listed cells
CellEnt(0x40000003u, 0xA9B40999u), // OUT — not in list
BuildingShell(0xC0000001u), // always included (IsBuildingShell)
BuildingShell(0xC0000001u, 0xA9B40150u), // in listed building cells
BuildingShell(0xC0000003u, 0xA9B40999u), // OUT — another building shell
OutdoorScenery(0xC0000002u), // OUT — not a shell, not in cell list
};
var cellIds = new HashSet<uint> { 0xA9B40150u, 0xA9B40151u };
@ -68,23 +71,22 @@ public class WbDrawDispatcherCellIdsOverloadTests
Assert.Contains(0x40000002u, result);
Assert.Contains(0xC0000001u, result);
Assert.DoesNotContain(0x40000003u, result);
Assert.DoesNotContain(0xC0000003u, result);
Assert.DoesNotContain(0xC0000002u, result);
}
[Fact]
public void WalkEntitiesByCellIds_EmptyCellList_StillIncludesBuildingShells()
public void WalkEntitiesByCellIds_EmptyCellList_ExcludesBuildingShells()
{
var entities = new List<WorldEntity>
{
CellEnt(0x40000001u, 0xA9B40150u),
BuildingShell(0xC0000001u),
BuildingShell(0xC0000001u, 0xA9B40150u),
};
var result = WbDrawDispatcher.WalkEntitiesForTestByCellIds(
entities, new HashSet<uint>(), set: WbDrawDispatcher.EntitySet.IndoorPass);
// Cell entity dropped (no cells in list); building shell still passes.
Assert.Single(result);
Assert.Contains(0xC0000001u, result);
Assert.Empty(result);
}
}

88
tests/AcDream.Core.Tests/Rendering/Wb/WbDrawDispatcherEntitySetTests.cs
View file

@ -5,10 +5,12 @@
//
// EntitySet.IndoorPass — ParentCellId.HasValue OR IsBuildingShell,
// and NOT live-dynamic (ServerGuid == 0).
// Building shells render unconditionally indoors;
// Building shells are gated by their dat anchor;
// live-dynamic flows through LiveDynamic instead.
// EntitySet.OutdoorScenery — ParentCellId == null AND !IsBuildingShell
// AND not live-dynamic.
// EntitySet.OutdoorScenery — ParentCellId == null AND not live-dynamic.
// Includes building shells for exterior/depth repair passes.
// EntitySet.BuildingShells — IsBuildingShell only, gated by dat anchor when
// visibleCellIds are supplied.
// EntitySet.LiveDynamic — ServerGuid != 0 (player, NPCs, dropped items,
// idle doors after animation). Drawn last with
// stencil disabled.
@ -46,12 +48,13 @@ public class WbDrawDispatcherEntitySetTests
Rotation = Quaternion.Identity,
};
private static WorldEntity BuildingShell(uint id) => new()
private static WorldEntity BuildingShell(uint id, uint? anchorCellId = null) => new()
{
Id = id,
SourceGfxObjOrSetupId = 0x02000001u,
ParentCellId = null,
IsBuildingShell = true,
BuildingShellAnchorCellId = anchorCellId,
MeshRefs = new List<MeshRef> { new() { GfxObjId = 0x01000001u } },
Position = Vector3.Zero,
Rotation = Quaternion.Identity,
@ -90,11 +93,11 @@ public class WbDrawDispatcherEntitySetTests
}
[Fact]
public void IndoorPass_IncludesBuildingShells_EvenWithNullParentCellId()
public void IndoorPass_IncludesBuildingShells_WhenAnchorCellIsVisible()
{
var entities = new List<WorldEntity>
{
BuildingShell(0xC0000001), // cottage wall
BuildingShell(0xC0000001, 0xA9B40143u), // cottage wall
OutdoorScenery(0xC0000002), // tree
CellEnt(0x40000001, 0xA9B40143),
};
@ -109,6 +112,47 @@ public class WbDrawDispatcherEntitySetTests
Assert.DoesNotContain(0xC0000002u, result); // tree excluded
}
[Fact]
public void IndoorPass_WithNullCellFilter_UsesEntitySetOnly()
{
var entities = new List<WorldEntity>
{
BuildingShell(0xC0000001, 0xA9B40143u),
CellEnt(0x40000001, 0xA9B40143),
CellEnt(0x40000002, 0xA9B40199),
OutdoorScenery(0xC0000002),
LiveDynamic(0x10000001, serverGuid: 0x50000123u),
};
var result = WbDrawDispatcher.WalkEntitiesForTest(
entities, visibleCellIds: null, set: WbDrawDispatcher.EntitySet.IndoorPass);
Assert.Equal(3, result.Count);
Assert.Contains(0xC0000001u, result);
Assert.Contains(0x40000001u, result);
Assert.Contains(0x40000002u, result);
Assert.DoesNotContain(0xC0000002u, result);
Assert.DoesNotContain(0x10000001u, result);
}
[Fact]
public void IndoorPass_ExcludesBuildingShells_WhenAnchorCellIsNotVisible()
{
var entities = new List<WorldEntity>
{
BuildingShell(0xC0000001, 0xA9B40150u),
CellEnt(0x40000001, 0xA9B40143),
};
var visible = new HashSet<uint> { 0xA9B40143u };
var result = WbDrawDispatcher.WalkEntitiesForTest(
entities, visibleCellIds: visible, set: WbDrawDispatcher.EntitySet.IndoorPass);
Assert.Single(result);
Assert.Contains(0x40000001u, result);
Assert.DoesNotContain(0xC0000001u, result);
}
[Fact]
public void IndoorPass_ExcludesLiveDynamic()
{
@ -128,11 +172,11 @@ public class WbDrawDispatcherEntitySetTests
}
[Fact]
public void OutdoorScenery_ExcludesBuildingShells()
public void OutdoorScenery_IncludesBuildingShells()
{
var entities = new List<WorldEntity>
{
BuildingShell(0xC0000001), // cottage wall — excluded
BuildingShell(0xC0000001), // cottage wall — included
OutdoorScenery(0xC0000002), // tree — included
CellEnt(0x40000001, 0xA9B40143), // cell — excluded
};
@ -140,9 +184,9 @@ public class WbDrawDispatcherEntitySetTests
var result = WbDrawDispatcher.WalkEntitiesForTest(
entities, visibleCellIds: null, set: WbDrawDispatcher.EntitySet.OutdoorScenery);
Assert.Single(result);
Assert.Equal(2, result.Count);
Assert.Contains(0xC0000002u, result);
Assert.DoesNotContain(0xC0000001u, result);
Assert.Contains(0xC0000001u, result);
Assert.DoesNotContain(0x40000001u, result);
}
@ -163,6 +207,30 @@ public class WbDrawDispatcherEntitySetTests
Assert.DoesNotContain(0x10000001u, result);
}
[Fact]
public void BuildingShells_IncludesOnlyAnchoredShells()
{
var entities = new List<WorldEntity>
{
BuildingShell(0xC0000001, 0xA9B40143u),
BuildingShell(0xC0000002, 0xA9B40999u),
OutdoorScenery(0xC0000003),
CellEnt(0x40000001, 0xA9B40143),
LiveDynamic(0x10000001, serverGuid: 0x50000123u),
};
var visible = new HashSet<uint> { 0xA9B40143u };
var result = WbDrawDispatcher.WalkEntitiesForTest(
entities, visibleCellIds: visible, set: WbDrawDispatcher.EntitySet.BuildingShells);
Assert.Single(result);
Assert.Contains(0xC0000001u, result);
Assert.DoesNotContain(0xC0000002u, result);
Assert.DoesNotContain(0xC0000003u, result);
Assert.DoesNotContain(0x40000001u, result);
Assert.DoesNotContain(0x10000001u, result);
}
[Fact]
public void LiveDynamic_IncludesOnlyServerSpawned()
{

34
tests/AcDream.Core.Tests/Rendering/Wb/WbDrawDispatcherIndirectBuilderTests.cs
View file

@ -1,6 +1,7 @@
using System.Numerics;
using AcDream.App.Rendering.Wb;
using AcDream.Core.Meshing;
using DatReaderWriter.Enums;
using Xunit;
namespace AcDream.Core.Tests.Rendering.Wb;
@ -26,9 +27,10 @@ public sealed class WbDrawDispatcherIndirectBuilderTests
var indirect = new DrawElementsIndirectCommand[16];
var batch = new WbDrawDispatcher.BatchDataPublic[16];
var cull = new CullMode[16];
// Act
var result = WbDrawDispatcher.BuildIndirectArrays(groups, indirect, batch);
var result = WbDrawDispatcher.BuildIndirectArrays(groups, indirect, batch, cull);
// Assert layout
Assert.Equal(2, result.OpaqueCount);
@ -58,6 +60,36 @@ public sealed class WbDrawDispatcherIndirectBuilderTests
Assert.Equal(0xAAul, batch[0].TextureHandle);
Assert.Equal(0xCCul, batch[1].TextureHandle);
Assert.Equal(0xBBul, batch[2].TextureHandle);
Assert.Equal(CullMode.CounterClockwise, cull[0]);
Assert.Equal(CullMode.CounterClockwise, cull[1]);
Assert.Equal(CullMode.CounterClockwise, cull[2]);
}
[Fact]
public void CullModes_FollowOpaqueTransparentLayout()
{
var groups = new List<WbDrawDispatcher.IndirectGroupInput>
{
new(IndexCount: 10, FirstIndex: 0, BaseVertex: 0, InstanceCount: 1, FirstInstance: 0,
TextureHandle: 0x1, TextureLayer: 0, Translucency: TranslucencyKind.Opaque,
CullMode: CullMode.Clockwise),
new(IndexCount: 20, FirstIndex: 10, BaseVertex: 0, InstanceCount: 1, FirstInstance: 1,
TextureHandle: 0x2, TextureLayer: 0, Translucency: TranslucencyKind.AlphaBlend,
CullMode: CullMode.None),
new(IndexCount: 30, FirstIndex: 30, BaseVertex: 0, InstanceCount: 1, FirstInstance: 2,
TextureHandle: 0x3, TextureLayer: 0, Translucency: TranslucencyKind.ClipMap,
CullMode: CullMode.Landblock),
};
var indirect = new DrawElementsIndirectCommand[4];
var batch = new WbDrawDispatcher.BatchDataPublic[4];
var cull = new CullMode[4];
var result = WbDrawDispatcher.BuildIndirectArrays(groups, indirect, batch, cull);
Assert.Equal(2, result.OpaqueCount);
Assert.Equal(CullMode.Clockwise, cull[0]);
Assert.Equal(CullMode.Landblock, cull[1]);
Assert.Equal(CullMode.None, cull[2]);
}
[Fact]

30
tests/AcDream.Core.Tests/Streaming/GpuWorldStateTwoTierTests.cs
View file

@ -74,6 +74,36 @@ public class GpuWorldStateTwoTierTests
Assert.Equal(2, state.Entities.Count);
}
[Fact]
public void LandblockEntriesWithoutAnimatedIndex_LeavesAnimatedLookupNull()
{
var state = new GpuWorldState();
state.AddLandblock(MakeStubLandblock(0xAAAAFFFFu,
MakeStubEntity(1),
MakeStubEntity(2)));
var staticEntry = Assert.Single(state.LandblockEntriesWithoutAnimatedIndex);
Assert.Null(staticEntry.AnimatedById);
var liveEntry = Assert.Single(state.LandblockEntries);
Assert.NotNull(liveEntry.AnimatedById);
Assert.True(liveEntry.AnimatedById!.ContainsKey(1));
Assert.True(liveEntry.AnimatedById.ContainsKey(2));
}
[Fact]
public void LandblockBounds_EnumeratesWithoutEntityPayload()
{
var state = new GpuWorldState();
state.AddLandblock(MakeStubLandblock(0xAAAAFFFFu,
MakeStubEntity(1),
MakeStubEntity(2)));
var bounds = Assert.Single(state.LandblockBounds);
Assert.Equal(0xAAAAFFFFu, bounds.LandblockId);
}
/// <summary>
/// Phase Post-A.5 #53 (Task 12): the optional <c>onLandblockUnloaded</c>
/// callback fires once when <see cref="GpuWorldState.RemoveEntitiesFromLandblock"/>

103
tests/AcDream.Core.Tests/Streaming/LandblockStreamerTests.cs
View file

@ -45,6 +45,97 @@ public class LandblockStreamerTests
Assert.Same(stubLandblock, loaded.Landblock);
}
[Fact]
public async Task LoadNear_OvertakesQueuedFarLoads()
{
var callOrder = new System.Collections.Generic.List<(uint Id, LandblockStreamJobKind Kind)>();
var stubMesh = new AcDream.Core.Terrain.LandblockMeshData(
System.Array.Empty<AcDream.Core.Terrain.TerrainVertex>(),
System.Array.Empty<uint>());
using var streamer = new LandblockStreamer(
loadLandblock: (id, kind) =>
{
callOrder.Add((id, kind));
return new LoadedLandblock(id, new LandBlock(), System.Array.Empty<WorldEntity>());
},
buildMeshOrNull: (_, _) => stubMesh);
streamer.EnqueueLoad(0xAAAAFFFFu, LandblockStreamJobKind.LoadFar);
streamer.EnqueueLoad(0xBBBBFFFFu, LandblockStreamJobKind.LoadFar);
streamer.EnqueueLoad(0xCCCCFFFFu, LandblockStreamJobKind.LoadFar);
streamer.EnqueueLoad(0xDDDDFFFFu, LandblockStreamJobKind.LoadNear);
streamer.Start();
var result = await DrainFirstAsync(streamer);
var loaded = Assert.IsType<LandblockStreamResult.Loaded>(result);
Assert.Equal(0xDDDDFFFFu, loaded.LandblockId);
Assert.Equal((0xDDDDFFFFu, LandblockStreamJobKind.LoadNear), callOrder[0]);
}
[Fact]
public async Task PromoteToNear_ProducesPromotedWithMeshData()
{
int meshBuildCalls = 0;
var entity = new WorldEntity
{
Id = 7,
SourceGfxObjOrSetupId = 0,
Position = System.Numerics.Vector3.Zero,
Rotation = System.Numerics.Quaternion.Identity,
MeshRefs = System.Array.Empty<MeshRef>()
};
using var streamer = new LandblockStreamer(
loadLandblock: (id, kind) => new LoadedLandblock(id, new LandBlock(), new[] { entity }),
buildMeshOrNull: (_, _) =>
{
meshBuildCalls++;
return new AcDream.Core.Terrain.LandblockMeshData(
System.Array.Empty<AcDream.Core.Terrain.TerrainVertex>(),
System.Array.Empty<uint>());
});
streamer.EnqueueLoad(0xA9B4FFFFu, LandblockStreamJobKind.PromoteToNear);
streamer.Start();
var result = await DrainFirstAsync(streamer);
var promoted = Assert.IsType<LandblockStreamResult.Promoted>(result);
Assert.Equal(0xA9B4FFFFu, promoted.LandblockId);
Assert.Same(entity, promoted.Entities[0]);
Assert.NotNull(promoted.MeshData);
Assert.Equal(1, meshBuildCalls);
}
[Fact]
public async Task PromoteToNear_OvertakesAndSupersedesQueuedFarLoadForSameLandblock()
{
var callOrder = new System.Collections.Generic.List<(uint Id, LandblockStreamJobKind Kind)>();
var stubMesh = new AcDream.Core.Terrain.LandblockMeshData(
System.Array.Empty<AcDream.Core.Terrain.TerrainVertex>(),
System.Array.Empty<uint>());
using var streamer = new LandblockStreamer(
loadLandblock: (id, kind) =>
{
callOrder.Add((id, kind));
return new LoadedLandblock(id, new LandBlock(), System.Array.Empty<WorldEntity>());
},
buildMeshOrNull: (_, _) => stubMesh);
streamer.EnqueueLoad(0xA9B4FFFFu, LandblockStreamJobKind.LoadFar);
streamer.EnqueueLoad(0xA9B4FFFFu, LandblockStreamJobKind.PromoteToNear);
streamer.Start();
var result = await DrainFirstAsync(streamer);
var promoted = Assert.IsType<LandblockStreamResult.Promoted>(result);
Assert.Equal(0xA9B4FFFFu, promoted.LandblockId);
Assert.Equal((0xA9B4FFFFu, LandblockStreamJobKind.PromoteToNear), callOrder[0]);
}
[Fact]
public async Task Load_WhenLoaderReturnsNull_ReportsFailed()
{
@ -183,4 +274,16 @@ public class LandblockStreamerTests
Assert.NotNull(loaderThreadId);
Assert.NotEqual(testThreadId, loaderThreadId.Value);
}
private static async Task<LandblockStreamResult> DrainFirstAsync(LandblockStreamer streamer)
{
for (int i = 0; i < SpinMaxIterations; i++)
{
var drained = streamer.DrainCompletions(maxBatchSize: LandblockStreamer.DefaultDrainBatchSize);
if (drained.Count > 0) return drained[0];
await Task.Delay(SpinStepMs);
}
throw new Xunit.Sdk.XunitException("Timed out waiting for streamer completion.");
}
}

23
tests/AcDream.Core.Tests/Streaming/StreamingControllerTwoTierTests.cs
View file

@ -99,16 +99,25 @@ public class StreamingControllerTwoTierTests
state.AddLandblock(lb);
Assert.Empty(state.Entities);
// Streamer pushes a Promoted result carrying the entity layer.
var promoted = new LandblockStreamResult.Promoted(
// Streamer pushes a Promoted result carrying the full near landblock.
var promotedLb = new LoadedLandblock(
lbId,
new[] { new WorldEntity {
Heightmap: null!,
Entities: new[] { new WorldEntity {
Id = 7, SourceGfxObjOrSetupId = 0,
Position = System.Numerics.Vector3.Zero,
Rotation = System.Numerics.Quaternion.Identity,
MeshRefs = System.Array.Empty<MeshRef>() } });
var promotedMesh = new LandblockMeshData(
System.Array.Empty<TerrainVertex>(),
System.Array.Empty<uint>());
var promoted = new LandblockStreamResult.Promoted(
lbId,
promotedLb,
promotedMesh);
var queue = new Queue<LandblockStreamResult>();
queue.Enqueue(promoted);
int applyPromotedCount = 0;
var ctrl = new StreamingController(
enqueueLoad: (id, kind) => loads.Add((id, kind)),
@ -119,7 +128,12 @@ public class StreamingControllerTwoTierTests
while (batch.Count < max && queue.Count > 0) batch.Add(queue.Dequeue());
return batch;
},
applyTerrain: (_, _) => { },
applyTerrain: (appliedLb, appliedMesh) =>
{
applyPromotedCount++;
Assert.Same(promotedLb, appliedLb);
Assert.Same(promotedMesh, appliedMesh);
},
state: state,
nearRadius: 2,
farRadius: 2);
@ -128,6 +142,7 @@ public class StreamingControllerTwoTierTests
// Promoted routes to AddEntitiesToExistingLandblock — the entity is now
// merged into the existing LB record.
Assert.Equal(1, applyPromotedCount);
Assert.Equal(1, state.Entities.Count);
Assert.Equal(7u, state.Entities[0].Id);
}

12
tests/AcDream.Core.Tests/World/LandblockLoaderTests.cs
View file

@ -178,14 +178,24 @@ public class LandblockLoaderTests
Origin = new Vector3(10f, 20f, 30f),
Orientation = Quaternion.Identity,
},
Portals =
{
new BuildingPortal
{
OtherCellId = 0x013F,
OtherPortalId = 0,
Flags = 0,
},
},
},
},
};
var entities = LandblockLoader.BuildEntitiesFromInfo(info);
var entities = LandblockLoader.BuildEntitiesFromInfo(info, landblockId: 0xA9B40000u);
Assert.Single(entities);
Assert.True(entities[0].IsBuildingShell);
Assert.Equal(0xA9B4013Fu, entities[0].BuildingShellAnchorCellId);
}
[Fact]