feat(physics): define deterministic flat collision assets
Add immutable indexed physics and containment BSP records, exact-bit polygon and Setup payloads, separated CellStruct/topology ownership, and iterative positive-before-negative flattening. Reject malformed graphs and ranges, and prove source identity over synthetic edge cases and installed retail DAT samples without cutting production traversal over.
This commit is contained in:
Erik
parent
16d182c2f0
commit
d9300c7854
11 changed files with 2094 additions and 21 deletions
|
|
@ -0,0 +1,330 @@
|
|||
using System.Numerics;
|
||||
using AcDream.Core.Physics;
|
||||
using AcDream.Core.Tests.Conformance;
|
||||
using DatReaderWriter;
|
||||
using DatReaderWriter.DBObjs;
|
||||
using DatReaderWriter.Options;
|
||||
using DatReaderWriter.Types;
|
||||
using Xunit.Abstractions;
|
||||
|
||||
namespace AcDream.Core.Tests.Physics;
|
||||
|
||||
public sealed class FlatCollisionInstalledDatTests
|
||||
{
|
||||
private readonly ITestOutputHelper _output;
|
||||
|
||||
public FlatCollisionInstalledDatTests(ITestOutputHelper output) =>
|
||||
_output = output;
|
||||
|
||||
[Fact]
|
||||
public void InstalledCells_FlattenVerbatimAndDeterministically()
|
||||
{
|
||||
string? datDir = ConformanceDats.ResolveDatDir();
|
||||
if (datDir is null)
|
||||
{
|
||||
_output.WriteLine("SKIP: installed retail DAT directory is unavailable.");
|
||||
return;
|
||||
}
|
||||
|
||||
using var dats = new DatCollection(datDir, DatAccessType.Read);
|
||||
foreach (uint cellId in new[]
|
||||
{
|
||||
0x8A02_016Eu, // Facility Hub corridor
|
||||
0x8A02_017Au, // asymmetric adjoining corridor
|
||||
0xA9B4_013Fu, // Holtburg cottage
|
||||
})
|
||||
{
|
||||
var cache = new PhysicsDataCache();
|
||||
ConformanceDats.LoadEnvCell(dats, cache, cellId);
|
||||
CellPhysics source = Assert.IsType<CellPhysics>(
|
||||
cache.GetCellStruct(cellId));
|
||||
|
||||
FlatCellCollisionAsset first =
|
||||
FlatCollisionAssetBuilder.FlattenCell(source);
|
||||
FlatCellCollisionAsset second =
|
||||
FlatCollisionAssetBuilder.FlattenCell(source);
|
||||
|
||||
AssertPhysicsSourceMatches(source.BSP?.Root, source.Resolved, first.Structure.PhysicsBsp);
|
||||
AssertContainmentSourceMatches(
|
||||
source.CellBSP?.Root,
|
||||
first.Structure.ContainmentBsp);
|
||||
FlatCollisionAssetBuilderTests.AssertFlatPhysicsEqual(
|
||||
first.Structure.PhysicsBsp,
|
||||
second.Structure.PhysicsBsp);
|
||||
Assert.Equal(
|
||||
first.Structure.ContainmentBsp.Nodes.AsEnumerable(),
|
||||
second.Structure.ContainmentBsp.Nodes.AsEnumerable());
|
||||
Assert.Equal(
|
||||
first.Topology.Portals.AsEnumerable(),
|
||||
second.Topology.Portals.AsEnumerable());
|
||||
Assert.Equal(
|
||||
first.Topology.VisibleCellIds.AsEnumerable(),
|
||||
second.Topology.VisibleCellIds.AsEnumerable());
|
||||
|
||||
_output.WriteLine(
|
||||
$"cell 0x{cellId:X8}: physicsNodes={first.Structure.PhysicsBsp.Nodes.Length}, " +
|
||||
$"physicsPolygons={first.Structure.PhysicsBsp.PolygonTable.Polygons.Length}, " +
|
||||
$"containmentNodes={first.Structure.ContainmentBsp.Nodes.Length}, " +
|
||||
$"portals={first.Topology.Portals.Length}");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void InstalledGfxObjsAndSetups_FlattenVerbatim()
|
||||
{
|
||||
string? datDir = ConformanceDats.ResolveDatDir();
|
||||
if (datDir is null)
|
||||
{
|
||||
_output.WriteLine("SKIP: installed retail DAT directory is unavailable.");
|
||||
return;
|
||||
}
|
||||
|
||||
using var dats = new DatCollection(datDir, DatAccessType.Read);
|
||||
var cache = new PhysicsDataCache();
|
||||
foreach (uint gfxObjId in new[]
|
||||
{
|
||||
0x0100_0A2Bu, // Holtburg cottage shell
|
||||
0x0100_0AC5u, // outdoor stair/ramp fixture
|
||||
0x0100_44B5u, // multipart door shell
|
||||
})
|
||||
{
|
||||
GfxObj gfxObj = Assert.IsType<GfxObj>(dats.Get<GfxObj>(gfxObjId));
|
||||
cache.CacheGfxObj(gfxObjId, gfxObj);
|
||||
GfxObjPhysics source = Assert.IsType<GfxObjPhysics>(
|
||||
cache.GetGfxObj(gfxObjId));
|
||||
|
||||
FlatGfxObjCollisionAsset flat =
|
||||
FlatCollisionAssetBuilder.FlattenGfxObj(
|
||||
source,
|
||||
cache.GetVisualBounds(gfxObjId));
|
||||
|
||||
AssertPhysicsSourceMatches(
|
||||
source.BSP.Root,
|
||||
source.Resolved,
|
||||
flat.PhysicsBsp);
|
||||
AssertNullableSphereBits(source.BoundingSphere, flat.BoundingSphere);
|
||||
Assert.NotNull(flat.VisualBounds);
|
||||
AssertVisualBoundsBits(
|
||||
Assert.IsType<GfxObjVisualBounds>(cache.GetVisualBounds(gfxObjId)),
|
||||
flat.VisualBounds!.Value);
|
||||
|
||||
_output.WriteLine(
|
||||
$"gfx 0x{gfxObjId:X8}: nodes={flat.PhysicsBsp.Nodes.Length}, " +
|
||||
$"polygons={flat.PhysicsBsp.PolygonTable.Polygons.Length}");
|
||||
}
|
||||
|
||||
foreach (uint setupId in new[]
|
||||
{
|
||||
0x0200_0001u, // player
|
||||
0x0200_19E3u, // wide low collision family
|
||||
0x0200_19FFu, // multipart door
|
||||
})
|
||||
{
|
||||
Setup setup = Assert.IsType<Setup>(dats.Get<Setup>(setupId));
|
||||
cache.CacheSetup(setupId, setup);
|
||||
SetupPhysics source = Assert.IsType<SetupPhysics>(
|
||||
cache.GetSetup(setupId));
|
||||
|
||||
FlatSetupCollision flat =
|
||||
FlatCollisionAssetBuilder.FlattenSetup(source);
|
||||
AssertSetupSourceMatches(source, flat);
|
||||
|
||||
_output.WriteLine(
|
||||
$"setup 0x{setupId:X8}: cylinders={flat.Cylinders.Length}, " +
|
||||
$"spheres={flat.Spheres.Length}");
|
||||
}
|
||||
}
|
||||
|
||||
private static void AssertPhysicsSourceMatches(
|
||||
PhysicsBSPNode? root,
|
||||
IReadOnlyDictionary<ushort, ResolvedPolygon> resolved,
|
||||
FlatPhysicsBsp flat)
|
||||
{
|
||||
if (root is null)
|
||||
{
|
||||
Assert.Equal(-1, flat.RootIndex);
|
||||
Assert.Empty(flat.Nodes);
|
||||
return;
|
||||
}
|
||||
|
||||
var ordered = new List<PhysicsBSPNode>();
|
||||
var indices = new Dictionary<PhysicsBSPNode, int>(
|
||||
ReferenceEqualityComparer.Instance);
|
||||
var stack = new Stack<PhysicsBSPNode>();
|
||||
stack.Push(root);
|
||||
while (stack.Count != 0)
|
||||
{
|
||||
PhysicsBSPNode source = stack.Pop();
|
||||
indices.Add(source, ordered.Count);
|
||||
ordered.Add(source);
|
||||
if (source.NegNode is not null)
|
||||
stack.Push(source.NegNode);
|
||||
if (source.PosNode is not null)
|
||||
stack.Push(source.PosNode);
|
||||
}
|
||||
|
||||
Assert.Equal(flat.Nodes.Length, ordered.Count);
|
||||
for (int flatIndex = 0; flatIndex < ordered.Count; flatIndex++)
|
||||
{
|
||||
PhysicsBSPNode source = ordered[flatIndex];
|
||||
FlatPhysicsBspNode row = flat.Nodes[flatIndex];
|
||||
Assert.Equal(source.Type, row.Type);
|
||||
FlatCollisionAssetBuilderTests.AssertPlaneBits(
|
||||
source.SplittingPlane,
|
||||
row.SplittingPlane);
|
||||
Assert.Equal(source.LeafIndex, row.LeafIndex);
|
||||
Assert.Equal(source.Solid, row.Solid);
|
||||
FlatCollisionAssetBuilderTests.AssertVectorBits(
|
||||
source.BoundingSphere.Origin,
|
||||
row.BoundingSphere.Origin);
|
||||
FlatCollisionAssetBuilderTests.AssertFloatBits(
|
||||
source.BoundingSphere.Radius,
|
||||
row.BoundingSphere.Radius);
|
||||
Assert.Equal(
|
||||
source.PosNode is null ? -1 : indices[source.PosNode],
|
||||
row.PositiveChildIndex);
|
||||
Assert.Equal(
|
||||
source.NegNode is null ? -1 : indices[source.NegNode],
|
||||
row.NegativeChildIndex);
|
||||
Assert.Equal(source.Polygons.Count, row.PolygonIndexRange.Count);
|
||||
|
||||
for (int i = 0; i < source.Polygons.Count; i++)
|
||||
{
|
||||
int streamIndex = row.PolygonIndexRange.Start + i;
|
||||
int polygonIndex = flat.PolygonIndexStream[streamIndex];
|
||||
Assert.Equal(
|
||||
source.Polygons[i],
|
||||
flat.PolygonTable.Polygons[polygonIndex].Id);
|
||||
}
|
||||
}
|
||||
|
||||
Assert.Equal(resolved.Count, flat.PolygonTable.Polygons.Length);
|
||||
foreach ((ushort id, ResolvedPolygon source) in resolved)
|
||||
{
|
||||
Assert.True(flat.PolygonTable.TryFindPolygonIndex(id, out int polygonIndex));
|
||||
FlatCollisionPolygon row = flat.PolygonTable.Polygons[polygonIndex];
|
||||
Assert.Equal(source.Id, row.Id);
|
||||
Assert.Equal(source.NumPoints, row.NumPoints);
|
||||
Assert.Equal(source.SidesType, row.SidesType);
|
||||
FlatCollisionAssetBuilderTests.AssertPlaneBits(source.Plane, row.Plane);
|
||||
for (int i = 0; i < source.Vertices.Length; i++)
|
||||
{
|
||||
FlatCollisionAssetBuilderTests.AssertVectorBits(
|
||||
source.Vertices[i],
|
||||
flat.PolygonTable.Vertices[row.VertexRange.Start + i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void AssertContainmentSourceMatches(
|
||||
CellBSPNode? root,
|
||||
FlatCellContainmentBsp flat)
|
||||
{
|
||||
if (root is null)
|
||||
{
|
||||
Assert.Equal(-1, flat.RootIndex);
|
||||
Assert.Empty(flat.Nodes);
|
||||
return;
|
||||
}
|
||||
|
||||
var ordered = new List<CellBSPNode>();
|
||||
var indices = new Dictionary<CellBSPNode, int>(
|
||||
ReferenceEqualityComparer.Instance);
|
||||
var stack = new Stack<CellBSPNode>();
|
||||
stack.Push(root);
|
||||
while (stack.Count != 0)
|
||||
{
|
||||
CellBSPNode source = stack.Pop();
|
||||
indices.Add(source, ordered.Count);
|
||||
ordered.Add(source);
|
||||
if (source.NegNode is not null)
|
||||
stack.Push(source.NegNode);
|
||||
if (source.PosNode is not null)
|
||||
stack.Push(source.PosNode);
|
||||
}
|
||||
|
||||
Assert.Equal(flat.Nodes.Length, ordered.Count);
|
||||
for (int flatIndex = 0; flatIndex < ordered.Count; flatIndex++)
|
||||
{
|
||||
CellBSPNode source = ordered[flatIndex];
|
||||
FlatCellBspNode row = flat.Nodes[flatIndex];
|
||||
Assert.Equal(source.Type, row.Type);
|
||||
Assert.Equal(source.LeafIndex, row.LeafIndex);
|
||||
FlatCollisionAssetBuilderTests.AssertPlaneBits(
|
||||
source.SplittingPlane,
|
||||
row.SplittingPlane);
|
||||
Assert.Equal(
|
||||
source.PosNode is null ? -1 : indices[source.PosNode],
|
||||
row.PositiveChildIndex);
|
||||
Assert.Equal(
|
||||
source.NegNode is null ? -1 : indices[source.NegNode],
|
||||
row.NegativeChildIndex);
|
||||
}
|
||||
}
|
||||
|
||||
private static void AssertSetupSourceMatches(
|
||||
SetupPhysics source,
|
||||
FlatSetupCollision flat)
|
||||
{
|
||||
Assert.Equal(source.CylSpheres.Count, flat.Cylinders.Length);
|
||||
Assert.Equal(source.Spheres.Count, flat.Spheres.Length);
|
||||
for (int i = 0; i < source.CylSpheres.Count; i++)
|
||||
{
|
||||
FlatCollisionAssetBuilderTests.AssertVectorBits(
|
||||
source.CylSpheres[i].Origin,
|
||||
flat.Cylinders[i].Origin);
|
||||
FlatCollisionAssetBuilderTests.AssertFloatBits(
|
||||
source.CylSpheres[i].Radius,
|
||||
flat.Cylinders[i].Radius);
|
||||
FlatCollisionAssetBuilderTests.AssertFloatBits(
|
||||
source.CylSpheres[i].Height,
|
||||
flat.Cylinders[i].Height);
|
||||
}
|
||||
for (int i = 0; i < source.Spheres.Count; i++)
|
||||
{
|
||||
FlatCollisionAssetBuilderTests.AssertVectorBits(
|
||||
source.Spheres[i].Origin,
|
||||
flat.Spheres[i].Origin);
|
||||
FlatCollisionAssetBuilderTests.AssertFloatBits(
|
||||
source.Spheres[i].Radius,
|
||||
flat.Spheres[i].Radius);
|
||||
}
|
||||
FlatCollisionAssetBuilderTests.AssertFloatBits(source.Height, flat.Height);
|
||||
FlatCollisionAssetBuilderTests.AssertFloatBits(source.Radius, flat.Radius);
|
||||
FlatCollisionAssetBuilderTests.AssertFloatBits(
|
||||
source.StepUpHeight,
|
||||
flat.StepUpHeight);
|
||||
FlatCollisionAssetBuilderTests.AssertFloatBits(
|
||||
source.StepDownHeight,
|
||||
flat.StepDownHeight);
|
||||
}
|
||||
|
||||
private static void AssertNullableSphereBits(
|
||||
Sphere? source,
|
||||
FlatCollisionSphere? flat)
|
||||
{
|
||||
Assert.Equal(source is null, flat is null);
|
||||
if (source is null || flat is null)
|
||||
return;
|
||||
|
||||
FlatCollisionAssetBuilderTests.AssertVectorBits(
|
||||
source.Origin,
|
||||
flat.Value.Origin);
|
||||
FlatCollisionAssetBuilderTests.AssertFloatBits(
|
||||
source.Radius,
|
||||
flat.Value.Radius);
|
||||
}
|
||||
|
||||
private static void AssertVisualBoundsBits(
|
||||
GfxObjVisualBounds source,
|
||||
FlatGfxObjVisualBounds flat)
|
||||
{
|
||||
FlatCollisionAssetBuilderTests.AssertVectorBits(source.Min, flat.Min);
|
||||
FlatCollisionAssetBuilderTests.AssertVectorBits(source.Max, flat.Max);
|
||||
FlatCollisionAssetBuilderTests.AssertVectorBits(source.Center, flat.Center);
|
||||
FlatCollisionAssetBuilderTests.AssertFloatBits(source.Radius, flat.Radius);
|
||||
FlatCollisionAssetBuilderTests.AssertVectorBits(
|
||||
source.HalfExtents,
|
||||
flat.HalfExtents);
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue