9aaf97e785
This reverts ceec3bc4. Two independent reasons, either sufficient.
The rendering regression. The slice deleted TextRenderGlStateScope, which
saved GL_MULTISAMPLE and GL_SAMPLE_ALPHA_TO_COVERAGE on entry, disabled them
for the text pass, and restored them on exit (TextRenderGlStateScope.cs:111-112
and 153-154 at the parent commit). Its replacement bakes that state into the
text pipeline but nothing restores it, and GlGpuPassEncoder.Dispose does not
either. Every world renderer is still raw GL at this point in the campaign, so
from the first UI frame onward the world drew with multisampling disabled.
The offline pixel gate caught it: 1,791 of 563,200 compared pixels differed,
0.318% against a 0.001 threshold. The commit message attributed this to
wall-clock-driven ambient animation shifting phase, and committed through the
failure. That explanation does not survive its own control: capturing twice at
the reverted-to commit differs by 19 pixels and twice at the slice's own commit
by 8, while base-versus-head differs by 1,791 - a 224x gap that no shared-noise
source explains. An amplified difference image settles it visually: the changed
pixels are the silhouette edges of every tree, building and rock, with terrain
interiors, water and the entire UI untouched. That is the signature of losing
edge antialiasing, not of animated sprites.
This is the exact failure mode two existing memory notes already warn about -
a mid-frame renderer must set every GL state it uses rather than inherit it,
and issue #52's lesson that a rendering migration must audit per-pass GL state
before declaring itself done.
The scope. The brief was three small leaf renderers plus additive frame-
lifecycle wiring, roughly ten files. The commit changed 334 files with 3,665
insertions and 3,845 deletions, including 323 public-to-internal visibility
conversions across the App assembly, 55 test files, two retired conformance
tests, and a self-described temporary escape hatch for bridging raw-GL viewport
textures. Even without the regression, that is not separable into the part
worth keeping and the part worth dropping.
Reverting rather than patching because the good work here - the RHI frame
lifecycle wiring and a genuine render-state-cache staleness fix - is small
enough to redo cleanly against a tightened spec, while untangling it from 300+
files of unrelated churn is not.
Post-revert: Release build clean, App suite back to 3,843 passed / 3 skipped,
offline pixel gate passing at 19 differing pixels.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
976 lines
36 KiB
C#
976 lines
36 KiB
C#
using System.Diagnostics;
|
|
using System.Numerics;
|
|
using AcDream.Core.Physics;
|
|
using AcDream.Core.World;
|
|
using AcDream.Runtime.Physics;
|
|
using DatReaderWriter.Types;
|
|
|
|
namespace AcDream.App.Streaming;
|
|
|
|
/// <summary>
|
|
/// Exact receipt for the two physics-owned stages of one accepted landblock
|
|
/// publication. The render publisher commits buildings and EnvCells between
|
|
/// these stages without recomputing the captured origin.
|
|
/// </summary>
|
|
public sealed class LandblockPhysicsPublication
|
|
{
|
|
internal LandblockPhysicsPublication(
|
|
object owner,
|
|
LandblockBuild build,
|
|
Vector3 origin,
|
|
uint currentCellId,
|
|
BuildingInfo[] buildings,
|
|
uint[] priorStaticOwnerIds,
|
|
RuntimeCollisionAdmission collisionAdmission)
|
|
{
|
|
Owner = owner;
|
|
Build = build;
|
|
Origin = origin;
|
|
CurrentCellId = currentCellId;
|
|
Buildings = buildings;
|
|
PriorStaticOwnerIds = priorStaticOwnerIds;
|
|
CollisionAdmission = collisionAdmission;
|
|
}
|
|
|
|
internal object Owner { get; }
|
|
internal LandblockBuild Build { get; }
|
|
internal uint CurrentCellId { get; }
|
|
internal BuildingInfo[] Buildings { get; }
|
|
internal uint[] PriorStaticOwnerIds { get; }
|
|
internal RuntimeCollisionAdmission CollisionAdmission { get; }
|
|
internal SortedSet<uint> GfxObjectIdSet { get; } = new();
|
|
internal uint[] GfxObjectIds { get; set; } = Array.Empty<uint>();
|
|
internal int PreparationCursor { get; set; }
|
|
internal bool PreparationCommitted { get; set; }
|
|
internal bool PriorCacheRemoved { get; set; }
|
|
internal TerrainSurface? TerrainSurface { get; set; }
|
|
internal List<CellSurface> CellSurfaces { get; } = new();
|
|
internal List<PortalPlane> PortalPlanes { get; } = new();
|
|
internal uint CellCursor { get; set; }
|
|
internal int BuildingCursor { get; set; }
|
|
internal bool BaseCommitted { get; set; }
|
|
internal int GfxCursor { get; set; }
|
|
internal uint[] SetupObjectIds { get; set; } = Array.Empty<uint>();
|
|
internal int SetupCursor { get; set; }
|
|
internal int PriorStaticCursor { get; set; }
|
|
internal int StaticCursor { get; set; }
|
|
internal int BspOwnerCount { get; set; }
|
|
internal int CylinderOwnerCount { get; set; }
|
|
internal int NoCollisionCount { get; set; }
|
|
internal int SceneryTried { get; set; }
|
|
internal uint[]? RefloodOwnerIds { get; set; }
|
|
internal int RefloodCursor { get; set; }
|
|
internal bool RefloodCommitted { get; set; }
|
|
internal bool BeginCommitted { get; set; }
|
|
internal bool CompletionCommitted { get; set; }
|
|
|
|
public uint LandblockId => Build.Landblock.LandblockId;
|
|
public Vector3 Origin { get; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cumulative update-thread diagnostics for physics publication and removal.
|
|
/// Durations are <see cref="Stopwatch"/> ticks.
|
|
/// </summary>
|
|
public readonly record struct LandblockPhysicsPublisherDiagnostics(
|
|
long BeginCount,
|
|
long CompleteCount,
|
|
long BasePublishTicks,
|
|
long GfxCacheTicks,
|
|
long CompletePublishTicks,
|
|
long CellSurfaceCount,
|
|
long PortalPlaneCount,
|
|
long BuildingCount,
|
|
long StaticBspOwnerCount,
|
|
long StaticCylinderOwnerCount,
|
|
long RefloodCount,
|
|
long DemotionCount,
|
|
long FullRemovalCount);
|
|
|
|
/// <summary>
|
|
/// Update-thread owner of streamed landblock physics publication. It consumes
|
|
/// only the immutable build payload: terrain, cells, portal planes, building
|
|
/// collision, cached GfxObj shapes, static BSP/cylinder registration, and the
|
|
/// final cross-cell reflood. It has no DAT reader or residency policy.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The order preserves retail <c>CObjCell::init_objects</c> (0x0052B420),
|
|
/// <c>CPhysicsObj::recalc_cross_cells</c> (0x00515A30),
|
|
/// <c>CBuildingObj::find_building_collisions</c> (0x006B5300), and
|
|
/// <c>CPhysicsObj::add_shadows_to_cells</c> (0x00514AE0). The BSP-or-Setup
|
|
/// collision gate follows <c>CPhysicsObj::FindObjCollisions</c> (0x0050F050).
|
|
/// Building shells use the per-landcell building channel; ordinary statics
|
|
/// use one multipart shadow owner or the mutually exclusive Setup
|
|
/// cylinder/sphere fallback.
|
|
/// </remarks>
|
|
public sealed class LandblockPhysicsPublisher
|
|
{
|
|
private readonly object _receiptOwner = new();
|
|
private readonly RuntimePhysicsState _physics;
|
|
private readonly PhysicsEngine _physicsEngine;
|
|
private readonly PhysicsDataCache _physicsDataCache;
|
|
private readonly float[] _heightTable;
|
|
|
|
private long _beginCount;
|
|
private long _completeCount;
|
|
private long _basePublishTicks;
|
|
private long _gfxCacheTicks;
|
|
private long _completePublishTicks;
|
|
private long _cellSurfaceCount;
|
|
private long _portalPlaneCount;
|
|
private long _buildingCount;
|
|
private long _staticBspOwnerCount;
|
|
private long _staticCylinderOwnerCount;
|
|
private long _refloodCount;
|
|
private long _demotionCount;
|
|
private long _fullRemovalCount;
|
|
|
|
public LandblockPhysicsPublisher(
|
|
RuntimePhysicsState physics,
|
|
float[] heightTable)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(physics);
|
|
ArgumentNullException.ThrowIfNull(heightTable);
|
|
if (heightTable.Length < 256)
|
|
throw new ArgumentException(
|
|
"The retail terrain height table must contain at least 256 entries.",
|
|
nameof(heightTable));
|
|
|
|
_physics = physics;
|
|
_physicsEngine = physics.Engine;
|
|
_physicsDataCache = physics.DataCache;
|
|
_heightTable = (float[])heightTable.Clone();
|
|
}
|
|
|
|
public LandblockPhysicsPublisherDiagnostics Diagnostics => new(
|
|
_beginCount,
|
|
_completeCount,
|
|
_basePublishTicks,
|
|
_gfxCacheTicks,
|
|
_completePublishTicks,
|
|
_cellSurfaceCount,
|
|
_portalPlaneCount,
|
|
_buildingCount,
|
|
_staticBspOwnerCount,
|
|
_staticCylinderOwnerCount,
|
|
_refloodCount,
|
|
_demotionCount,
|
|
_fullRemovalCount);
|
|
|
|
/// <summary>
|
|
/// Publishes terrain, EnvCell physics, portal planes, and building shells.
|
|
/// The render publisher completes its building/EnvCell transaction before
|
|
/// <see cref="CompletePublication"/> publishes ordinary static collision.
|
|
/// </summary>
|
|
public LandblockPhysicsPublication BeginPublication(
|
|
LandblockRenderPublication renderPublication)
|
|
{
|
|
LandblockPhysicsPublication publication = PreparePublication(
|
|
renderPublication);
|
|
BeginPublication(publication);
|
|
return publication;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Captures the exact render receipt before physics mutation begins. The
|
|
/// coordinator retains this receipt and can retry the idempotent exact
|
|
/// replacement when a cache/backend operation fails.
|
|
/// </summary>
|
|
public LandblockPhysicsPublication PreparePublication(
|
|
LandblockRenderPublication renderPublication)
|
|
{
|
|
LandblockPhysicsPublication publication =
|
|
CreatePublication(renderPublication);
|
|
while (!AdvancePreparationOne(publication))
|
|
{
|
|
}
|
|
return publication;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Captures the immutable physics root without walking the entity suffix.
|
|
/// The concrete pipeline advances that walk under its frame meter.
|
|
/// </summary>
|
|
internal LandblockPhysicsPublication CreatePublication(
|
|
LandblockRenderPublication renderPublication)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(renderPublication);
|
|
LandblockBuild build = renderPublication.Build;
|
|
Vector3 origin = renderPublication.Origin;
|
|
if (!IsFinite(origin))
|
|
throw new ArgumentOutOfRangeException(nameof(renderPublication));
|
|
|
|
PhysicsDatBundle datBundle =
|
|
build.Landblock.PhysicsDats ?? PhysicsDatBundle.Empty;
|
|
BuildingInfo[] buildings = datBundle.Info?.Buildings.ToArray()
|
|
?? Array.Empty<BuildingInfo>();
|
|
var publication = new LandblockPhysicsPublication(
|
|
_receiptOwner,
|
|
build,
|
|
origin,
|
|
_physicsDataCache.CellGraph.CurrCell?.Id ?? 0u,
|
|
buildings,
|
|
_physicsEngine.ShadowObjects.CaptureStaticOwnersForLandblock(
|
|
build.Landblock.LandblockId),
|
|
_physics.BeginCollisionAdmission(
|
|
build.Landblock.LandblockId));
|
|
publication.SetupObjectIds = build.Collisions is { } collisions
|
|
? [.. collisions.SetupIds]
|
|
: datBundle.Setups.Keys.Order().ToArray();
|
|
return publication;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Advances one entity's stable GfxObj-index preparation. No external
|
|
/// physics state is mutated until this cursor and the static-validation
|
|
/// cursor both complete.
|
|
/// </summary>
|
|
internal bool AdvancePreparationOne(
|
|
LandblockPhysicsPublication publication)
|
|
{
|
|
ValidateReceipt(publication);
|
|
if (publication.PreparationCommitted)
|
|
return true;
|
|
|
|
IReadOnlyList<WorldEntity> entities =
|
|
publication.Build.Landblock.Entities;
|
|
if (publication.Build.Collisions is { } collisions)
|
|
{
|
|
publication.GfxObjectIds = [.. collisions.GfxObjIds];
|
|
publication.PreparationCursor = entities.Count;
|
|
publication.PreparationCommitted = true;
|
|
return true;
|
|
}
|
|
|
|
if (publication.PreparationCursor < entities.Count)
|
|
{
|
|
WorldEntity entity = entities[publication.PreparationCursor];
|
|
for (int i = 0; i < entity.MeshRefs.Count; i++)
|
|
{
|
|
uint id = entity.MeshRefs[i].GfxObjId;
|
|
if ((id & 0xFF000000u) == 0x01000000u)
|
|
publication.GfxObjectIdSet.Add(id);
|
|
}
|
|
publication.PreparationCursor++;
|
|
return false;
|
|
}
|
|
|
|
publication.GfxObjectIds = publication.GfxObjectIdSet.ToArray();
|
|
publication.PreparationCommitted = true;
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Advances the exact terrain/cell/building physics replacement from a
|
|
/// retained receipt.
|
|
/// </summary>
|
|
public void BeginPublication(LandblockPhysicsPublication publication)
|
|
{
|
|
ValidateReceipt(publication);
|
|
if (!publication.PreparationCommitted)
|
|
throw new InvalidOperationException(
|
|
"Physics publication cannot begin before preparation commits.");
|
|
while (!AdvanceBeginOne(publication))
|
|
{
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Advances one exact physics-prefix operation: prior-cache withdrawal,
|
|
/// terrain construction, one EnvCell, one building, or the final canonical
|
|
/// physics-engine replacement. All arrays and cursors live on the receipt.
|
|
/// </summary>
|
|
internal bool AdvanceBeginOne(LandblockPhysicsPublication publication)
|
|
{
|
|
ValidateReceipt(publication);
|
|
if (publication.BeginCommitted)
|
|
return true;
|
|
|
|
long started = Stopwatch.GetTimestamp();
|
|
LandblockBuild build = publication.Build;
|
|
Vector3 origin = publication.Origin;
|
|
LoadedLandblock landblock = build.Landblock;
|
|
PhysicsDatBundle datBundle =
|
|
landblock.PhysicsDats ?? PhysicsDatBundle.Empty;
|
|
DatReaderWriter.DBObjs.LandBlockInfo? landblockInfo = datBundle.Info;
|
|
|
|
if (!publication.PriorCacheRemoved)
|
|
{
|
|
// CacheCellStruct/CacheBuilding use first-wins semantics within one
|
|
// publication, so the replacement pass starts with one exact
|
|
// landblock-scoped withdrawal.
|
|
_physicsDataCache.RemoveCellsForLandblock(landblock.LandblockId);
|
|
_physicsDataCache.RemoveBuildingsForLandblock(landblock.LandblockId);
|
|
_physicsDataCache.CellGraph.RemoveEnvCellsForLandblock(
|
|
landblock.LandblockId);
|
|
publication.PriorCacheRemoved = true;
|
|
}
|
|
else if (publication.TerrainSurface is null)
|
|
{
|
|
uint landblockX = (landblock.LandblockId >> 24) & 0xFFu;
|
|
uint landblockY = (landblock.LandblockId >> 16) & 0xFFu;
|
|
var terrainBytes = new byte[81];
|
|
for (int i = 0; i < terrainBytes.Length; i++)
|
|
terrainBytes[i] = (byte)(ushort)landblock.Heightmap.Terrain[i];
|
|
publication.TerrainSurface = new TerrainSurface(
|
|
landblock.Heightmap.Height,
|
|
_heightTable,
|
|
landblockX,
|
|
landblockY,
|
|
terrainBytes);
|
|
}
|
|
else if (landblockInfo is not null
|
|
&& publication.CellCursor < landblockInfo.NumCells)
|
|
{
|
|
PublishCell(publication, datBundle, publication.CellCursor);
|
|
publication.CellCursor++;
|
|
}
|
|
else if (publication.BuildingCursor < publication.Buildings.Length)
|
|
{
|
|
PublishBuilding(
|
|
landblock,
|
|
datBundle,
|
|
publication.TerrainSurface,
|
|
origin,
|
|
publication.Buildings[publication.BuildingCursor]);
|
|
publication.BuildingCursor++;
|
|
}
|
|
else if (!publication.BaseCommitted)
|
|
{
|
|
_physics.AdmitCollisionAssets(
|
|
publication.CollisionAdmission,
|
|
new RuntimeLandblockCollisionAssets(
|
|
landblock.LandblockId,
|
|
publication.TerrainSurface,
|
|
publication.CellSurfaces.ToArray(),
|
|
publication.PortalPlanes.ToArray(),
|
|
origin.X,
|
|
origin.Y,
|
|
publication.CurrentCellId));
|
|
publication.BaseCommitted = true;
|
|
}
|
|
else
|
|
{
|
|
_cellSurfaceCount += publication.CellSurfaces.Count;
|
|
_portalPlaneCount += publication.PortalPlanes.Count;
|
|
_buildingCount += publication.Buildings.Length;
|
|
publication.BeginCommitted = true;
|
|
_beginCount++;
|
|
}
|
|
|
|
_basePublishTicks += Stopwatch.GetTimestamp() - started;
|
|
return publication.BeginCommitted;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Publishes ordinary static collision and refloods after the caller has
|
|
/// completed the render-owned building/EnvCell suffix. The concrete
|
|
/// presentation pipeline supplies the static-presentation owner callback
|
|
/// that preserves per-entity light-before-collision order.
|
|
/// </summary>
|
|
public void CompletePublication(
|
|
LandblockPhysicsPublication publication,
|
|
Action<WorldEntity>? beforeStaticCollision = null)
|
|
{
|
|
ValidateReceipt(publication);
|
|
if (!publication.BeginCommitted)
|
|
throw new InvalidOperationException(
|
|
"Physics publication cannot complete before its prefix commits.");
|
|
while (!AdvanceCompleteOne(publication, beforeStaticCollision))
|
|
{
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Advances one exact physics-suffix operation: one GfxObj cache entry,
|
|
/// prior static withdrawal, one static light/collision entity, or reflood.
|
|
/// </summary>
|
|
internal bool AdvanceCompleteOne(
|
|
LandblockPhysicsPublication publication,
|
|
Action<WorldEntity>? beforeStaticCollision = null)
|
|
{
|
|
ValidateReceipt(publication);
|
|
if (!publication.BeginCommitted)
|
|
throw new InvalidOperationException(
|
|
"Physics publication cannot complete before its prefix commits.");
|
|
if (publication.CompletionCommitted)
|
|
return true;
|
|
|
|
long started = Stopwatch.GetTimestamp();
|
|
LoadedLandblock landblock = publication.Build.Landblock;
|
|
PhysicsDatBundle datBundle =
|
|
landblock.PhysicsDats ?? PhysicsDatBundle.Empty;
|
|
|
|
if (publication.GfxCursor < publication.GfxObjectIds.Length)
|
|
{
|
|
long cacheStarted = Stopwatch.GetTimestamp();
|
|
uint gfxObjectId = publication.GfxObjectIds[publication.GfxCursor];
|
|
if (publication.Build.Collisions?.GfxObjs.TryGetValue(
|
|
gfxObjectId,
|
|
out FlatGfxObjCollisionAsset? prepared) == true)
|
|
{
|
|
_physicsDataCache.CacheGfxObj(gfxObjectId, prepared);
|
|
}
|
|
else if (datBundle.GfxObjs.TryGetValue(
|
|
gfxObjectId,
|
|
out var source))
|
|
{
|
|
// Graph-oracle fixture seam. Production near builds always
|
|
// carry the strict prepared closure.
|
|
_physicsDataCache.CacheGfxObj(gfxObjectId, source);
|
|
}
|
|
publication.GfxCursor++;
|
|
_gfxCacheTicks += Stopwatch.GetTimestamp() - cacheStarted;
|
|
}
|
|
else if (publication.SetupCursor < publication.SetupObjectIds.Length)
|
|
{
|
|
uint setupId =
|
|
publication.SetupObjectIds[publication.SetupCursor];
|
|
if (publication.Build.Collisions?.Setups.TryGetValue(
|
|
setupId,
|
|
out FlatSetupCollision? prepared) == true)
|
|
{
|
|
_physicsDataCache.CacheSetup(setupId, prepared);
|
|
}
|
|
else if (datBundle.Setups.TryGetValue(setupId, out var source))
|
|
{
|
|
// Graph-oracle fixture seam only.
|
|
_physicsDataCache.CacheSetup(setupId, source);
|
|
}
|
|
publication.SetupCursor++;
|
|
}
|
|
else if (publication.PriorStaticCursor
|
|
< publication.PriorStaticOwnerIds.Length)
|
|
{
|
|
_physicsEngine.ShadowObjects.DeregisterStaticOwnerForLandblock(
|
|
publication.PriorStaticOwnerIds[
|
|
publication.PriorStaticCursor],
|
|
landblock.LandblockId);
|
|
publication.PriorStaticCursor++;
|
|
}
|
|
else if (publication.StaticCursor < landblock.Entities.Count)
|
|
{
|
|
WorldEntity entity = landblock.Entities[publication.StaticCursor];
|
|
beforeStaticCollision?.Invoke(entity);
|
|
PublishStaticEntity(publication, entity);
|
|
publication.StaticCursor++;
|
|
}
|
|
else if (publication.RefloodOwnerIds is null)
|
|
{
|
|
publication.RefloodOwnerIds =
|
|
_physicsEngine.ShadowObjects
|
|
.CaptureRefloodOwnersForLandblock(landblock.LandblockId);
|
|
}
|
|
else if (publication.RefloodCursor
|
|
< publication.RefloodOwnerIds.Length)
|
|
{
|
|
_physicsEngine.ShadowObjects.RefloodOwnerForLandblock(
|
|
publication.RefloodOwnerIds[publication.RefloodCursor],
|
|
landblock.LandblockId);
|
|
publication.RefloodCursor++;
|
|
}
|
|
else if (!publication.RefloodCommitted)
|
|
{
|
|
if (PhysicsDiagnostics.ProbeBuildingEnabled
|
|
&& publication.SceneryTried > 0)
|
|
{
|
|
Console.WriteLine(
|
|
$"lb 0x{landblock.LandblockId:X8}: scenery tried={publication.SceneryTried} " +
|
|
$"(outdoorNone={publication.NoCollisionCount})");
|
|
}
|
|
LogMissingSceneryBounds(landblock);
|
|
_refloodCount++;
|
|
publication.RefloodCommitted = true;
|
|
}
|
|
else
|
|
{
|
|
_physics.CompleteCollisionAdmission(
|
|
publication.CollisionAdmission);
|
|
_staticBspOwnerCount += publication.BspOwnerCount;
|
|
_staticCylinderOwnerCount += publication.CylinderOwnerCount;
|
|
publication.CompletionCommitted = true;
|
|
_completeCount++;
|
|
}
|
|
|
|
_completePublishTicks += Stopwatch.GetTimestamp() - started;
|
|
return publication.CompletionCommitted;
|
|
}
|
|
|
|
public void DemoteToTerrain(uint landblockId)
|
|
{
|
|
_physics.DemoteCollisionToTerrain(landblockId);
|
|
_demotionCount++;
|
|
}
|
|
|
|
public void RemoveLandblock(uint landblockId)
|
|
{
|
|
_physics.WithdrawCollision(landblockId);
|
|
_fullRemovalCount++;
|
|
}
|
|
|
|
private void PublishCell(
|
|
LandblockPhysicsPublication publication,
|
|
PhysicsDatBundle datBundle,
|
|
uint offset)
|
|
{
|
|
LoadedLandblock landblock = publication.Build.Landblock;
|
|
uint envCellId =
|
|
(landblock.LandblockId & 0xFFFF0000u) | (0x0100u + offset);
|
|
if (!datBundle.EnvCells.TryGetValue(envCellId, out var envCell))
|
|
return;
|
|
|
|
if (publication.Build.Collisions is not { } collisions)
|
|
{
|
|
PublishGraphFixtureCell(
|
|
publication,
|
|
datBundle,
|
|
envCellId,
|
|
envCell);
|
|
return;
|
|
}
|
|
|
|
if (!collisions.CellStructures.TryGetValue(
|
|
envCellId,
|
|
out FlatCellStructureCollisionAsset? preparedStructure)
|
|
|| !collisions.EnvCells.TryGetValue(
|
|
envCellId,
|
|
out FlatEnvCellTopology? preparedTopology))
|
|
{
|
|
return;
|
|
}
|
|
|
|
Quaternion rotation = envCell.Position.Orientation;
|
|
Vector3 cellOriginWorld = envCell.Position.Origin + publication.Origin;
|
|
Matrix4x4 physicsCellTransform =
|
|
Matrix4x4.CreateFromQuaternion(rotation)
|
|
* Matrix4x4.CreateTranslation(cellOriginWorld);
|
|
|
|
_physicsDataCache.CacheCellStruct(
|
|
envCellId,
|
|
envCell,
|
|
physicsCellTransform,
|
|
preparedStructure,
|
|
preparedTopology);
|
|
|
|
FlatPolygonTable physicsPolygons =
|
|
preparedStructure.PhysicsBsp.PolygonTable;
|
|
|
|
var portalPlanes = new List<PortalPlane>();
|
|
FlatPolygonTable portalPolygons = preparedStructure.PortalPolygons;
|
|
for (int portalIndex = 0;
|
|
portalIndex < preparedTopology.Portals.Length;
|
|
portalIndex++)
|
|
{
|
|
FlatEnvCellPortal portal = preparedTopology.Portals[portalIndex];
|
|
if ((uint)portal.PolygonIndex
|
|
>= (uint)portalPolygons.Polygons.Length)
|
|
{
|
|
continue;
|
|
}
|
|
FlatCollisionPolygon polygon =
|
|
portalPolygons.Polygons[portal.PolygonIndex];
|
|
if (polygon.VertexRange.Count < 3)
|
|
continue;
|
|
var portalVertices = new Vector3[polygon.VertexRange.Count];
|
|
for (int index = 0; index < portalVertices.Length; index++)
|
|
{
|
|
Vector3 local = portalPolygons.Vertices[
|
|
polygon.VertexRange.Start + index];
|
|
portalVertices[index] =
|
|
Vector3.Transform(local, rotation) + cellOriginWorld;
|
|
}
|
|
|
|
portalPlanes.Add(PortalPlane.FromVertices(
|
|
portalVertices.AsSpan(),
|
|
portal.OtherCellId,
|
|
envCellId & 0xFFFFu,
|
|
(ushort)portal.Flags));
|
|
}
|
|
|
|
publication.CellSurfaces.Add(new CellSurface(
|
|
envCellId,
|
|
physicsPolygons,
|
|
rotation,
|
|
cellOriginWorld));
|
|
publication.PortalPlanes.AddRange(portalPlanes);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parsed-graph publication is retained only for unit/conformance fixtures
|
|
/// constructed without a prepared collision closure. Production cannot
|
|
/// reach this branch because near-build admission requires that closure.
|
|
/// </summary>
|
|
private void PublishGraphFixtureCell(
|
|
LandblockPhysicsPublication publication,
|
|
PhysicsDatBundle datBundle,
|
|
uint envCellId,
|
|
DatReaderWriter.DBObjs.EnvCell envCell)
|
|
{
|
|
if (envCell.EnvironmentId == 0
|
|
|| !datBundle.Environments.TryGetValue(
|
|
0x0D000000u | envCell.EnvironmentId,
|
|
out var environment)
|
|
|| !environment.Cells.TryGetValue(
|
|
envCell.CellStructure,
|
|
out var cellStruct))
|
|
{
|
|
return;
|
|
}
|
|
|
|
Quaternion rotation = envCell.Position.Orientation;
|
|
Vector3 cellOriginWorld =
|
|
envCell.Position.Origin + publication.Origin;
|
|
Matrix4x4 physicsCellTransform =
|
|
Matrix4x4.CreateFromQuaternion(rotation)
|
|
* Matrix4x4.CreateTranslation(cellOriginWorld);
|
|
_physicsDataCache.CacheCellStruct(
|
|
envCellId,
|
|
envCell,
|
|
cellStruct,
|
|
physicsCellTransform);
|
|
|
|
var worldVertices = new Dictionary<ushort, Vector3>(
|
|
cellStruct.VertexArray.Vertices.Count);
|
|
foreach ((ushort vertexId, var vertex) in
|
|
cellStruct.VertexArray.Vertices)
|
|
{
|
|
worldVertices[vertexId] =
|
|
Vector3.Transform(vertex.Origin, rotation)
|
|
+ cellOriginWorld;
|
|
}
|
|
|
|
var polygonVertexIds = new List<List<short>>(
|
|
cellStruct.PhysicsPolygons.Count);
|
|
foreach (var polygon in cellStruct.PhysicsPolygons.Values)
|
|
polygonVertexIds.Add([.. polygon.VertexIds]);
|
|
|
|
var portalPlanes = new List<PortalPlane>();
|
|
foreach (var portal in envCell.CellPortals)
|
|
{
|
|
if (!cellStruct.Polygons.TryGetValue(
|
|
portal.PolygonId,
|
|
out var polygon)
|
|
|| polygon.VertexIds.Count < 3)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var portalVertices = new Vector3[polygon.VertexIds.Count];
|
|
bool allFound = true;
|
|
for (int index = 0; index < polygon.VertexIds.Count; index++)
|
|
{
|
|
if (!worldVertices.TryGetValue(
|
|
(ushort)polygon.VertexIds[index],
|
|
out portalVertices[index]))
|
|
{
|
|
allFound = false;
|
|
break;
|
|
}
|
|
}
|
|
if (!allFound)
|
|
continue;
|
|
|
|
portalPlanes.Add(PortalPlane.FromVertices(
|
|
portalVertices,
|
|
portal.OtherCellId,
|
|
envCellId & 0xFFFFu,
|
|
(ushort)portal.Flags));
|
|
}
|
|
|
|
publication.CellSurfaces.Add(new CellSurface(
|
|
envCellId,
|
|
worldVertices,
|
|
polygonVertexIds));
|
|
publication.PortalPlanes.AddRange(portalPlanes);
|
|
}
|
|
|
|
private void PublishBuilding(
|
|
LoadedLandblock landblock,
|
|
PhysicsDatBundle datBundle,
|
|
TerrainSurface terrainSurface,
|
|
Vector3 origin,
|
|
BuildingInfo building)
|
|
{
|
|
uint landblockPrefix = landblock.LandblockId & 0xFFFF0000u;
|
|
var portals = new List<BldPortalInfo>(building.Portals.Count);
|
|
foreach (var portal in building.Portals)
|
|
{
|
|
portals.Add(new BldPortalInfo(
|
|
otherCellId: landblockPrefix | (uint)portal.OtherCellId,
|
|
otherPortalId: unchecked((short)portal.OtherPortalId),
|
|
flags: (ushort)portal.Flags));
|
|
}
|
|
|
|
Vector3 buildingOrigin = building.Frame.Origin + origin;
|
|
Matrix4x4 buildingTransform =
|
|
Matrix4x4.CreateFromQuaternion(building.Frame.Orientation)
|
|
* Matrix4x4.CreateTranslation(buildingOrigin);
|
|
uint landcellLow = terrainSurface.ComputeOutdoorCellId(
|
|
building.Frame.Origin.X,
|
|
building.Frame.Origin.Y);
|
|
uint landcellId = landblockPrefix | landcellLow;
|
|
|
|
uint shellPartZero = building.ModelId;
|
|
if ((shellPartZero & 0xFF000000u) == 0x02000000u)
|
|
{
|
|
datBundle.Setups.TryGetValue(
|
|
building.ModelId,
|
|
out var setup);
|
|
shellPartZero = setup is not null && setup.Parts.Count > 0
|
|
? setup.Parts[0]
|
|
: 0u;
|
|
}
|
|
_physicsDataCache.CacheBuilding(
|
|
landcellId,
|
|
portals,
|
|
buildingTransform,
|
|
modelId: shellPartZero);
|
|
}
|
|
|
|
private void PublishStaticEntity(
|
|
LandblockPhysicsPublication publication,
|
|
WorldEntity entity)
|
|
{
|
|
LoadedLandblock landblock = publication.Build.Landblock;
|
|
// Retail building shells collide exclusively through the per-landcell
|
|
// building channel. They never become ordinary shadow objects.
|
|
if (entity.IsBuildingShell)
|
|
return;
|
|
|
|
int entityBspCount = 0;
|
|
int entityCylinderCount = 0;
|
|
uint sourcePrefix = entity.SourceGfxObjOrSetupId & 0xFF000000u;
|
|
bool isOutdoorMesh =
|
|
(entity.Id & 0x80000000u) != 0
|
|
|| (entity.Id < 0x40000000u
|
|
&& (sourcePrefix == 0x01000000u
|
|
|| sourcePrefix == 0x02000000u));
|
|
if (isOutdoorMesh)
|
|
publication.SceneryTried++;
|
|
|
|
IReadOnlyList<ShadowShape> bspShapes =
|
|
ShadowShapeBuilder.FromLandblockBspParts(
|
|
entity.MeshRefs,
|
|
entity.IsBuildingShell,
|
|
_physicsDataCache.GetGfxObj);
|
|
entityBspCount = bspShapes.Count;
|
|
if (entityBspCount > 0)
|
|
{
|
|
_physicsEngine.ShadowObjects.RegisterMultiPart(
|
|
entity.Id,
|
|
entity.Position,
|
|
entity.Rotation,
|
|
bspShapes,
|
|
0u,
|
|
EntityCollisionFlags.None,
|
|
publication.Origin.X,
|
|
publication.Origin.Y,
|
|
landblock.LandblockId,
|
|
seedCellId: entity.ParentCellId ?? 0u,
|
|
isStatic: true);
|
|
LogMultipartRegistration(landblock, entity, bspShapes);
|
|
}
|
|
|
|
FlatSetupCollision? setup =
|
|
_physicsDataCache.GetFlatSetup(entity.SourceGfxObjOrSetupId);
|
|
if (setup is null
|
|
&& _physicsDataCache.GetSetup(
|
|
entity.SourceGfxObjOrSetupId) is { } graphSetup)
|
|
{
|
|
// Graph-oracle fixture seam only. Production Setup publication is
|
|
// already package-flat and never allocates this conversion.
|
|
setup = FlatCollisionAssetBuilder.FlattenSetup(graphSetup);
|
|
}
|
|
if (setup is not null && entityBspCount == 0)
|
|
{
|
|
float scale = entity.Scale > 0f ? entity.Scale : 1f;
|
|
var setupShapes = new List<ShadowShape>();
|
|
for (int cylinderIndex = 0;
|
|
cylinderIndex < setup.Cylinders.Length;
|
|
cylinderIndex++)
|
|
{
|
|
FlatCollisionCylinder cylinder =
|
|
setup.Cylinders[cylinderIndex];
|
|
float radius = cylinder.Radius * scale;
|
|
float baseHeight = cylinder.Height > 0f
|
|
? cylinder.Height
|
|
: cylinder.Radius * 4f;
|
|
float height = baseHeight * scale;
|
|
if (radius <= 0f)
|
|
continue;
|
|
|
|
Vector3 localOffset = cylinder.Origin * scale;
|
|
setupShapes.Add(new ShadowShape(
|
|
GfxObjId: entity.SourceGfxObjOrSetupId,
|
|
LocalPosition: localOffset,
|
|
LocalRotation: Quaternion.Identity,
|
|
Scale: scale,
|
|
CollisionType: ShadowCollisionType.Cylinder,
|
|
Radius: radius,
|
|
CylHeight: height));
|
|
}
|
|
|
|
if (setup.Cylinders.Length == 0)
|
|
{
|
|
for (int sphereIndex = 0;
|
|
sphereIndex < setup.Spheres.Length;
|
|
sphereIndex++)
|
|
{
|
|
FlatCollisionSphere sphere =
|
|
setup.Spheres[sphereIndex];
|
|
if (sphere.Radius <= 0f)
|
|
continue;
|
|
|
|
float radius = sphere.Radius * scale;
|
|
Vector3 localOffset = sphere.Origin * scale;
|
|
Vector3 localBaseOffset = localOffset
|
|
+ Vector3.Transform(
|
|
-Vector3.UnitZ * radius,
|
|
Quaternion.Inverse(entity.Rotation));
|
|
setupShapes.Add(new ShadowShape(
|
|
GfxObjId: entity.SourceGfxObjOrSetupId,
|
|
LocalPosition: localBaseOffset,
|
|
LocalRotation: Quaternion.Identity,
|
|
Scale: scale,
|
|
CollisionType: ShadowCollisionType.Cylinder,
|
|
Radius: radius,
|
|
CylHeight: radius * 2f));
|
|
}
|
|
}
|
|
|
|
if (setup.Cylinders.Length == 0
|
|
&& setup.Spheres.Length == 0
|
|
&& setup.Radius > 0f)
|
|
{
|
|
float radius = setup.Radius * scale;
|
|
float height = (setup.Height > 0f
|
|
? setup.Height
|
|
: setup.Radius * 2f) * scale;
|
|
setupShapes.Add(new ShadowShape(
|
|
GfxObjId: entity.SourceGfxObjOrSetupId,
|
|
LocalPosition: Vector3.Zero,
|
|
LocalRotation: Quaternion.Identity,
|
|
Scale: scale,
|
|
CollisionType: ShadowCollisionType.Cylinder,
|
|
Radius: radius,
|
|
CylHeight: height));
|
|
}
|
|
|
|
if (setupShapes.Count > 0)
|
|
{
|
|
_physicsEngine.ShadowObjects.RegisterMultiPart(
|
|
entity.Id,
|
|
entity.Position,
|
|
entity.Rotation,
|
|
setupShapes,
|
|
0u,
|
|
EntityCollisionFlags.None,
|
|
publication.Origin.X,
|
|
publication.Origin.Y,
|
|
landblock.LandblockId,
|
|
seedCellId: entity.ParentCellId ?? 0u,
|
|
isStatic: true);
|
|
LogSetupRegistration(landblock, entity, setupShapes);
|
|
entityCylinderCount = setupShapes.Count;
|
|
}
|
|
}
|
|
|
|
if (entityBspCount > 0)
|
|
publication.BspOwnerCount++;
|
|
if (entityCylinderCount > 0)
|
|
publication.CylinderOwnerCount++;
|
|
if (entityBspCount == 0 && entityCylinderCount == 0
|
|
&& (sourcePrefix == 0x01000000u
|
|
|| sourcePrefix == 0x02000000u))
|
|
{
|
|
publication.NoCollisionCount++;
|
|
}
|
|
}
|
|
|
|
private static void LogSetupRegistration(
|
|
LoadedLandblock landblock,
|
|
WorldEntity entity,
|
|
IReadOnlyList<ShadowShape> shapes)
|
|
{
|
|
if (!PhysicsDiagnostics.ProbeBuildingEnabled)
|
|
return;
|
|
|
|
for (int index = 0; index < shapes.Count; index++)
|
|
{
|
|
Console.WriteLine(FormattableString.Invariant(
|
|
$"[entity-source] id=0x{entity.Id:X8} entityId=0x{entity.Id:X8} src=0x{entity.SourceGfxObjOrSetupId:X8} gfxObj=0x{shapes[index].GfxObjId:X8} lb=0x{landblock.LandblockId:X8} type=Cylinder note=setup-part{index} state=0x{0u:X8} flags={EntityCollisionFlags.None}"));
|
|
}
|
|
}
|
|
|
|
private static void LogMultipartRegistration(
|
|
LoadedLandblock landblock,
|
|
WorldEntity entity,
|
|
IReadOnlyList<ShadowShape> shapes)
|
|
{
|
|
if (!PhysicsDiagnostics.ProbeBuildingEnabled)
|
|
return;
|
|
|
|
for (int index = 0; index < shapes.Count; index++)
|
|
{
|
|
Console.WriteLine(FormattableString.Invariant(
|
|
$"[entity-source] id=0x{entity.Id:X8} entityId=0x{entity.Id:X8} src=0x{entity.SourceGfxObjOrSetupId:X8} gfxObj=0x{shapes[index].GfxObjId:X8} lb=0x{landblock.LandblockId:X8} type=BSP note=multipart-part{index} hasPhys=true state=0x{0u:X8} flags={EntityCollisionFlags.None}"));
|
|
}
|
|
}
|
|
|
|
private void LogMissingSceneryBounds(LoadedLandblock landblock)
|
|
{
|
|
if (!PhysicsDiagnostics.ProbeBuildingEnabled)
|
|
return;
|
|
|
|
int missingCount = 0;
|
|
var samples = new List<uint>();
|
|
foreach (WorldEntity entity in landblock.Entities)
|
|
{
|
|
if ((entity.Id & 0x80000000u) == 0)
|
|
continue;
|
|
|
|
bool hasBounds = false;
|
|
foreach (MeshRef meshRef in entity.MeshRefs)
|
|
{
|
|
GfxObjVisualBounds? bounds =
|
|
_physicsDataCache.GetVisualBounds(meshRef.GfxObjId);
|
|
if (bounds is not null && bounds.Radius > 0f)
|
|
{
|
|
hasBounds = true;
|
|
break;
|
|
}
|
|
}
|
|
if (hasBounds)
|
|
continue;
|
|
|
|
missingCount++;
|
|
if (samples.Count < 3)
|
|
samples.Add(entity.SourceGfxObjOrSetupId);
|
|
}
|
|
|
|
if (missingCount > 0)
|
|
{
|
|
string sampleText = string.Join(",", samples.Select(
|
|
value => $"0x{value:X8}"));
|
|
Console.WriteLine(
|
|
$" → {missingCount} scenery entities had no visual bounds cached. " +
|
|
$"Samples: {sampleText}");
|
|
}
|
|
}
|
|
|
|
private static bool IsFinite(Vector3 value) =>
|
|
float.IsFinite(value.X)
|
|
&& float.IsFinite(value.Y)
|
|
&& float.IsFinite(value.Z);
|
|
|
|
private void ValidateReceipt(LandblockPhysicsPublication publication)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(publication);
|
|
if (!ReferenceEquals(publication.Owner, _receiptOwner))
|
|
{
|
|
throw new ArgumentException(
|
|
"The physics publication receipt belongs to another publisher.",
|
|
nameof(publication));
|
|
}
|
|
}
|
|
}
|