9cd42417a8
Append strict collision/topology payloads to the existing prepared package so later physics cutover can drop parsed DAT graphs without adding a second mapping or changing traversal behavior. The full 2,232,170-key catalog is deterministic across worker counts, exact-byte aliased, corruption-isolated, and cancellation-safe.
715 lines
24 KiB
C#
715 lines
24 KiB
C#
using System.Buffers;
|
|
using System.Buffers.Binary;
|
|
using System.Collections.Immutable;
|
|
using System.Numerics;
|
|
using AcDream.Core.Physics;
|
|
using DatReaderWriter.Enums;
|
|
|
|
namespace AcDream.Content;
|
|
|
|
/// <summary>
|
|
/// Strict little-endian package codec for immutable flat collision assets.
|
|
/// Every float is persisted through its exact IEEE-754 bit pattern. Readers
|
|
/// reject invalid counts, invalid enum/range/tree contracts, wrong payload
|
|
/// kinds, non-zero reserved bytes, truncation, and trailing bytes.
|
|
/// </summary>
|
|
public static class FlatCollisionAssetSerializer
|
|
{
|
|
private const uint Magic = 0x4C_43_43_41u; // "ACCL" little-endian
|
|
private const byte SchemaVersion = 1;
|
|
private const int MaximumRows = 16_777_216;
|
|
|
|
public static byte[] Serialize(
|
|
FlatGfxObjCollisionAsset asset,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(asset);
|
|
var writer = new CollisionWriter();
|
|
writer.WriteHeader(CollisionPayloadKind.GfxObj);
|
|
WritePhysicsBsp(writer, asset.PhysicsBsp, cancellationToken);
|
|
writer.WriteOptionalSphere(asset.BoundingSphere);
|
|
writer.WriteBoolean(asset.VisualBounds.HasValue);
|
|
if (asset.VisualBounds is FlatGfxObjVisualBounds visual)
|
|
{
|
|
writer.WriteVector3(visual.Min);
|
|
writer.WriteVector3(visual.Max);
|
|
writer.WriteVector3(visual.Center);
|
|
writer.WriteSingle(visual.Radius);
|
|
writer.WriteVector3(visual.HalfExtents);
|
|
}
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
return writer.ToArray();
|
|
}
|
|
|
|
public static byte[] Serialize(
|
|
FlatSetupCollision asset,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(asset);
|
|
var writer = new CollisionWriter();
|
|
writer.WriteHeader(CollisionPayloadKind.Setup);
|
|
writer.WriteCount(asset.Cylinders.Length, "Setup cylinder");
|
|
writer.WriteCount(asset.Spheres.Length, "Setup sphere");
|
|
writer.WriteSingle(asset.Height);
|
|
writer.WriteSingle(asset.Radius);
|
|
writer.WriteSingle(asset.StepUpHeight);
|
|
writer.WriteSingle(asset.StepDownHeight);
|
|
|
|
for (int i = 0; i < asset.Cylinders.Length; i++)
|
|
{
|
|
CheckCancellation(cancellationToken, i);
|
|
FlatCollisionCylinder cylinder = asset.Cylinders[i];
|
|
writer.WriteVector3(cylinder.Origin);
|
|
writer.WriteSingle(cylinder.Radius);
|
|
writer.WriteSingle(cylinder.Height);
|
|
}
|
|
for (int i = 0; i < asset.Spheres.Length; i++)
|
|
{
|
|
CheckCancellation(cancellationToken, i);
|
|
writer.WriteSphere(asset.Spheres[i]);
|
|
}
|
|
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
return writer.ToArray();
|
|
}
|
|
|
|
public static byte[] Serialize(
|
|
FlatCellStructureCollisionAsset asset,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(asset);
|
|
var writer = new CollisionWriter();
|
|
writer.WriteHeader(CollisionPayloadKind.CellStructure);
|
|
WritePhysicsBsp(writer, asset.PhysicsBsp, cancellationToken);
|
|
WriteContainmentBsp(writer, asset.ContainmentBsp, cancellationToken);
|
|
WritePolygonTable(writer, asset.PortalPolygons, cancellationToken);
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
return writer.ToArray();
|
|
}
|
|
|
|
public static byte[] Serialize(
|
|
FlatEnvCellTopology asset,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(asset);
|
|
var writer = new CollisionWriter();
|
|
writer.WriteHeader(CollisionPayloadKind.EnvCellTopology);
|
|
writer.WriteCount(asset.Portals.Length, "EnvCell portal");
|
|
writer.WriteCount(asset.VisibleCellIds.Length, "visible-cell");
|
|
writer.WriteBoolean(asset.SeenOutside);
|
|
|
|
for (int i = 0; i < asset.Portals.Length; i++)
|
|
{
|
|
CheckCancellation(cancellationToken, i);
|
|
FlatEnvCellPortal portal = asset.Portals[i];
|
|
writer.WriteUInt16(portal.OtherCellId);
|
|
writer.WriteUInt16(portal.PolygonId);
|
|
writer.WriteUInt16(portal.Flags);
|
|
writer.WriteInt32(portal.PolygonIndex);
|
|
}
|
|
for (int i = 0; i < asset.VisibleCellIds.Length; i++)
|
|
{
|
|
CheckCancellation(cancellationToken, i);
|
|
writer.WriteUInt32(asset.VisibleCellIds[i]);
|
|
}
|
|
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
return writer.ToArray();
|
|
}
|
|
|
|
public static FlatGfxObjCollisionAsset DeserializeGfxObj(
|
|
ReadOnlySpan<byte> bytes,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
var reader = new CollisionReader(bytes, cancellationToken);
|
|
reader.ReadHeader(CollisionPayloadKind.GfxObj);
|
|
FlatPhysicsBsp physicsBsp = ReadPhysicsBsp(ref reader);
|
|
FlatCollisionSphere? boundingSphere = reader.ReadOptionalSphere();
|
|
FlatGfxObjVisualBounds? visualBounds = null;
|
|
if (reader.ReadBoolean())
|
|
{
|
|
visualBounds = new FlatGfxObjVisualBounds(
|
|
reader.ReadVector3(),
|
|
reader.ReadVector3(),
|
|
reader.ReadVector3(),
|
|
reader.ReadSingle(),
|
|
reader.ReadVector3());
|
|
}
|
|
reader.RequireEnd();
|
|
return new FlatGfxObjCollisionAsset(
|
|
physicsBsp,
|
|
boundingSphere,
|
|
visualBounds);
|
|
}
|
|
|
|
public static FlatSetupCollision DeserializeSetup(
|
|
ReadOnlySpan<byte> bytes,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
var reader = new CollisionReader(bytes, cancellationToken);
|
|
reader.ReadHeader(CollisionPayloadKind.Setup);
|
|
int cylinderCount = reader.ReadCount(
|
|
"Setup cylinder",
|
|
bytesPerItem: 20);
|
|
int sphereCount = reader.ReadCount(
|
|
"Setup sphere",
|
|
bytesPerItem: 16);
|
|
reader.RequireRemaining(
|
|
checked(16L + (20L * cylinderCount) + (16L * sphereCount)),
|
|
"Setup collision rows");
|
|
float height = reader.ReadSingle();
|
|
float radius = reader.ReadSingle();
|
|
float stepUpHeight = reader.ReadSingle();
|
|
float stepDownHeight = reader.ReadSingle();
|
|
|
|
var cylinders =
|
|
ImmutableArray.CreateBuilder<FlatCollisionCylinder>(cylinderCount);
|
|
for (int i = 0; i < cylinderCount; i++)
|
|
{
|
|
reader.CheckCancellation(i);
|
|
cylinders.Add(new FlatCollisionCylinder(
|
|
reader.ReadVector3(),
|
|
reader.ReadSingle(),
|
|
reader.ReadSingle()));
|
|
}
|
|
|
|
var spheres =
|
|
ImmutableArray.CreateBuilder<FlatCollisionSphere>(sphereCount);
|
|
for (int i = 0; i < sphereCount; i++)
|
|
{
|
|
reader.CheckCancellation(i);
|
|
spheres.Add(reader.ReadSphere());
|
|
}
|
|
|
|
reader.RequireEnd();
|
|
return new FlatSetupCollision(
|
|
cylinders.MoveToImmutable(),
|
|
spheres.MoveToImmutable(),
|
|
height,
|
|
radius,
|
|
stepUpHeight,
|
|
stepDownHeight);
|
|
}
|
|
|
|
public static FlatCellStructureCollisionAsset DeserializeCellStructure(
|
|
ReadOnlySpan<byte> bytes,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
var reader = new CollisionReader(bytes, cancellationToken);
|
|
reader.ReadHeader(CollisionPayloadKind.CellStructure);
|
|
FlatPhysicsBsp physicsBsp = ReadPhysicsBsp(ref reader);
|
|
FlatCellContainmentBsp containmentBsp = ReadContainmentBsp(ref reader);
|
|
FlatPolygonTable portalPolygons = ReadPolygonTable(ref reader);
|
|
reader.RequireEnd();
|
|
return new FlatCellStructureCollisionAsset(
|
|
physicsBsp,
|
|
containmentBsp,
|
|
portalPolygons);
|
|
}
|
|
|
|
public static FlatEnvCellTopology DeserializeEnvCellTopology(
|
|
ReadOnlySpan<byte> bytes,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
var reader = new CollisionReader(bytes, cancellationToken);
|
|
reader.ReadHeader(CollisionPayloadKind.EnvCellTopology);
|
|
int portalCount = reader.ReadCount(
|
|
"EnvCell portal",
|
|
bytesPerItem: 10);
|
|
int visibleCount = reader.ReadCount(
|
|
"visible-cell",
|
|
bytesPerItem: 4);
|
|
reader.RequireRemaining(
|
|
checked(1L + (10L * portalCount) + (4L * visibleCount)),
|
|
"EnvCell topology rows");
|
|
bool seenOutside = reader.ReadBoolean();
|
|
|
|
var portals =
|
|
ImmutableArray.CreateBuilder<FlatEnvCellPortal>(portalCount);
|
|
for (int i = 0; i < portalCount; i++)
|
|
{
|
|
reader.CheckCancellation(i);
|
|
portals.Add(new FlatEnvCellPortal(
|
|
reader.ReadUInt16(),
|
|
reader.ReadUInt16(),
|
|
reader.ReadUInt16(),
|
|
reader.ReadInt32()));
|
|
}
|
|
|
|
var visible =
|
|
ImmutableArray.CreateBuilder<uint>(visibleCount);
|
|
for (int i = 0; i < visibleCount; i++)
|
|
{
|
|
reader.CheckCancellation(i);
|
|
visible.Add(reader.ReadUInt32());
|
|
}
|
|
|
|
reader.RequireEnd();
|
|
return new FlatEnvCellTopology(
|
|
portals.MoveToImmutable(),
|
|
visible.MoveToImmutable(),
|
|
seenOutside);
|
|
}
|
|
|
|
private static void WritePhysicsBsp(
|
|
CollisionWriter writer,
|
|
FlatPhysicsBsp bsp,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(bsp);
|
|
writer.WriteInt32(bsp.RootIndex);
|
|
writer.WriteCount(bsp.Nodes.Length, "physics BSP node");
|
|
writer.WriteCount(
|
|
bsp.PolygonIndexStream.Length,
|
|
"physics BSP polygon-index");
|
|
|
|
for (int i = 0; i < bsp.Nodes.Length; i++)
|
|
{
|
|
CheckCancellation(cancellationToken, i);
|
|
FlatPhysicsBspNode node = bsp.Nodes[i];
|
|
writer.WriteUInt32((uint)node.Type);
|
|
writer.WritePlane(node.SplittingPlane);
|
|
writer.WriteInt32(node.PositiveChildIndex);
|
|
writer.WriteInt32(node.NegativeChildIndex);
|
|
writer.WriteInt32(node.LeafIndex);
|
|
writer.WriteInt32(node.Solid);
|
|
writer.WriteSphere(node.BoundingSphere);
|
|
writer.WriteRange(node.PolygonIndexRange);
|
|
}
|
|
|
|
for (int i = 0; i < bsp.PolygonIndexStream.Length; i++)
|
|
{
|
|
CheckCancellation(cancellationToken, i);
|
|
writer.WriteInt32(bsp.PolygonIndexStream[i]);
|
|
}
|
|
WritePolygonTable(writer, bsp.PolygonTable, cancellationToken);
|
|
}
|
|
|
|
private static FlatPhysicsBsp ReadPhysicsBsp(
|
|
ref CollisionReader reader)
|
|
{
|
|
int rootIndex = reader.ReadInt32();
|
|
int nodeCount = reader.ReadCount(
|
|
"physics BSP node",
|
|
bytesPerItem: 60);
|
|
int polygonIndexCount = reader.ReadCount(
|
|
"physics BSP polygon-index",
|
|
bytesPerItem: 4);
|
|
reader.RequireRemaining(
|
|
checked((60L * nodeCount) + (4L * polygonIndexCount) + 8L),
|
|
"physics BSP rows");
|
|
|
|
var nodes =
|
|
ImmutableArray.CreateBuilder<FlatPhysicsBspNode>(nodeCount);
|
|
for (int i = 0; i < nodeCount; i++)
|
|
{
|
|
reader.CheckCancellation(i);
|
|
nodes.Add(new FlatPhysicsBspNode(
|
|
(BSPNodeType)reader.ReadUInt32(),
|
|
reader.ReadPlane(),
|
|
reader.ReadInt32(),
|
|
reader.ReadInt32(),
|
|
reader.ReadInt32(),
|
|
reader.ReadInt32(),
|
|
reader.ReadSphere(),
|
|
reader.ReadRange()));
|
|
}
|
|
|
|
var polygonIndices =
|
|
ImmutableArray.CreateBuilder<int>(polygonIndexCount);
|
|
for (int i = 0; i < polygonIndexCount; i++)
|
|
{
|
|
reader.CheckCancellation(i);
|
|
polygonIndices.Add(reader.ReadInt32());
|
|
}
|
|
|
|
FlatPolygonTable polygons = ReadPolygonTable(ref reader);
|
|
return new FlatPhysicsBsp(
|
|
rootIndex,
|
|
nodes.MoveToImmutable(),
|
|
polygonIndices.MoveToImmutable(),
|
|
polygons);
|
|
}
|
|
|
|
private static void WriteContainmentBsp(
|
|
CollisionWriter writer,
|
|
FlatCellContainmentBsp bsp,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(bsp);
|
|
writer.WriteInt32(bsp.RootIndex);
|
|
writer.WriteCount(bsp.Nodes.Length, "cell-containment BSP node");
|
|
for (int i = 0; i < bsp.Nodes.Length; i++)
|
|
{
|
|
CheckCancellation(cancellationToken, i);
|
|
FlatCellBspNode node = bsp.Nodes[i];
|
|
writer.WriteUInt32((uint)node.Type);
|
|
writer.WritePlane(node.SplittingPlane);
|
|
writer.WriteInt32(node.PositiveChildIndex);
|
|
writer.WriteInt32(node.NegativeChildIndex);
|
|
writer.WriteInt32(node.LeafIndex);
|
|
}
|
|
}
|
|
|
|
private static FlatCellContainmentBsp ReadContainmentBsp(
|
|
ref CollisionReader reader)
|
|
{
|
|
int rootIndex = reader.ReadInt32();
|
|
int nodeCount = reader.ReadCount(
|
|
"cell-containment BSP node",
|
|
bytesPerItem: 32);
|
|
var nodes =
|
|
ImmutableArray.CreateBuilder<FlatCellBspNode>(nodeCount);
|
|
for (int i = 0; i < nodeCount; i++)
|
|
{
|
|
reader.CheckCancellation(i);
|
|
nodes.Add(new FlatCellBspNode(
|
|
(BSPNodeType)reader.ReadUInt32(),
|
|
reader.ReadPlane(),
|
|
reader.ReadInt32(),
|
|
reader.ReadInt32(),
|
|
reader.ReadInt32()));
|
|
}
|
|
return new FlatCellContainmentBsp(
|
|
rootIndex,
|
|
nodes.MoveToImmutable());
|
|
}
|
|
|
|
private static void WritePolygonTable(
|
|
CollisionWriter writer,
|
|
FlatPolygonTable table,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(table);
|
|
writer.WriteCount(table.Polygons.Length, "polygon");
|
|
writer.WriteCount(table.Vertices.Length, "polygon vertex");
|
|
for (int i = 0; i < table.Polygons.Length; i++)
|
|
{
|
|
CheckCancellation(cancellationToken, i);
|
|
FlatCollisionPolygon polygon = table.Polygons[i];
|
|
writer.WriteUInt16(polygon.Id);
|
|
writer.WriteUInt32((uint)polygon.SidesType);
|
|
writer.WriteInt32(polygon.NumPoints);
|
|
writer.WriteRange(polygon.VertexRange);
|
|
writer.WritePlane(polygon.Plane);
|
|
}
|
|
for (int i = 0; i < table.Vertices.Length; i++)
|
|
{
|
|
CheckCancellation(cancellationToken, i);
|
|
writer.WriteVector3(table.Vertices[i]);
|
|
}
|
|
}
|
|
|
|
private static FlatPolygonTable ReadPolygonTable(
|
|
ref CollisionReader reader)
|
|
{
|
|
int polygonCount = reader.ReadCount(
|
|
"polygon",
|
|
bytesPerItem: 34);
|
|
int vertexCount = reader.ReadCount(
|
|
"polygon vertex",
|
|
bytesPerItem: 12);
|
|
reader.RequireRemaining(
|
|
checked((34L * polygonCount) + (12L * vertexCount)),
|
|
"polygon-table rows");
|
|
var polygons =
|
|
ImmutableArray.CreateBuilder<FlatCollisionPolygon>(polygonCount);
|
|
for (int i = 0; i < polygonCount; i++)
|
|
{
|
|
reader.CheckCancellation(i);
|
|
polygons.Add(new FlatCollisionPolygon(
|
|
reader.ReadUInt16(),
|
|
reader.ReadPlaneAfterMetadata(out CullMode sides, out int count,
|
|
out FlatIndexRange range),
|
|
sides,
|
|
count,
|
|
range));
|
|
}
|
|
|
|
var vertices = ImmutableArray.CreateBuilder<Vector3>(vertexCount);
|
|
for (int i = 0; i < vertexCount; i++)
|
|
{
|
|
reader.CheckCancellation(i);
|
|
vertices.Add(reader.ReadVector3());
|
|
}
|
|
return new FlatPolygonTable(
|
|
polygons.MoveToImmutable(),
|
|
vertices.MoveToImmutable());
|
|
}
|
|
|
|
private static void CheckCancellation(
|
|
CancellationToken cancellationToken,
|
|
int index)
|
|
{
|
|
if ((index & 0xFF) == 0)
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
}
|
|
|
|
private enum CollisionPayloadKind : byte
|
|
{
|
|
GfxObj = 1,
|
|
Setup = 2,
|
|
CellStructure = 3,
|
|
EnvCellTopology = 4,
|
|
}
|
|
|
|
private sealed class CollisionWriter
|
|
{
|
|
private readonly ArrayBufferWriter<byte> _buffer = new(256);
|
|
|
|
public void WriteHeader(CollisionPayloadKind kind)
|
|
{
|
|
WriteUInt32(Magic);
|
|
WriteByte((byte)kind);
|
|
WriteByte(SchemaVersion);
|
|
WriteUInt16(0);
|
|
}
|
|
|
|
public void WriteCount(int value, string name)
|
|
{
|
|
if ((uint)value > MaximumRows)
|
|
{
|
|
throw new InvalidDataException(
|
|
$"{name} count {value} exceeds {MaximumRows}.");
|
|
}
|
|
WriteInt32(value);
|
|
}
|
|
|
|
public void WriteOptionalSphere(FlatCollisionSphere? sphere)
|
|
{
|
|
WriteBoolean(sphere.HasValue);
|
|
if (sphere.HasValue)
|
|
WriteSphere(sphere.Value);
|
|
}
|
|
|
|
public void WriteBoolean(bool value) => WriteByte(value ? (byte)1 : (byte)0);
|
|
|
|
public void WriteSphere(FlatCollisionSphere sphere)
|
|
{
|
|
WriteVector3(sphere.Origin);
|
|
WriteSingle(sphere.Radius);
|
|
}
|
|
|
|
public void WriteRange(FlatIndexRange range)
|
|
{
|
|
WriteInt32(range.Start);
|
|
WriteInt32(range.Count);
|
|
}
|
|
|
|
public void WritePlane(Plane plane)
|
|
{
|
|
WriteVector3(plane.Normal);
|
|
WriteSingle(plane.D);
|
|
}
|
|
|
|
public void WriteVector3(Vector3 vector)
|
|
{
|
|
WriteSingle(vector.X);
|
|
WriteSingle(vector.Y);
|
|
WriteSingle(vector.Z);
|
|
}
|
|
|
|
public void WriteSingle(float value) =>
|
|
WriteInt32(BitConverter.SingleToInt32Bits(value));
|
|
|
|
public void WriteByte(byte value)
|
|
{
|
|
Span<byte> span = _buffer.GetSpan(1);
|
|
span[0] = value;
|
|
_buffer.Advance(1);
|
|
}
|
|
|
|
public void WriteUInt16(ushort value)
|
|
{
|
|
Span<byte> span = _buffer.GetSpan(sizeof(ushort));
|
|
BinaryPrimitives.WriteUInt16LittleEndian(span, value);
|
|
_buffer.Advance(sizeof(ushort));
|
|
}
|
|
|
|
public void WriteInt32(int value)
|
|
{
|
|
Span<byte> span = _buffer.GetSpan(sizeof(int));
|
|
BinaryPrimitives.WriteInt32LittleEndian(span, value);
|
|
_buffer.Advance(sizeof(int));
|
|
}
|
|
|
|
public void WriteUInt32(uint value)
|
|
{
|
|
Span<byte> span = _buffer.GetSpan(sizeof(uint));
|
|
BinaryPrimitives.WriteUInt32LittleEndian(span, value);
|
|
_buffer.Advance(sizeof(uint));
|
|
}
|
|
|
|
public byte[] ToArray() => _buffer.WrittenSpan.ToArray();
|
|
}
|
|
|
|
private ref struct CollisionReader
|
|
{
|
|
private readonly ReadOnlySpan<byte> _bytes;
|
|
private readonly CancellationToken _cancellationToken;
|
|
private int _offset;
|
|
|
|
public CollisionReader(
|
|
ReadOnlySpan<byte> bytes,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
_bytes = bytes;
|
|
_cancellationToken = cancellationToken;
|
|
_offset = 0;
|
|
_cancellationToken.ThrowIfCancellationRequested();
|
|
}
|
|
|
|
private int Remaining => _bytes.Length - _offset;
|
|
|
|
public void ReadHeader(CollisionPayloadKind expectedKind)
|
|
{
|
|
uint magic = ReadUInt32();
|
|
byte kind = ReadByte();
|
|
byte version = ReadByte();
|
|
ushort reserved = ReadUInt16();
|
|
if (magic != Magic)
|
|
{
|
|
throw new InvalidDataException(
|
|
$"collision payload magic 0x{magic:X8} does not match " +
|
|
$"0x{Magic:X8}.");
|
|
}
|
|
if (kind != (byte)expectedKind)
|
|
{
|
|
throw new InvalidDataException(
|
|
$"collision payload kind {kind} does not match " +
|
|
$"{(byte)expectedKind}.");
|
|
}
|
|
if (version != SchemaVersion)
|
|
{
|
|
throw new InvalidDataException(
|
|
$"collision payload schema {version} is unsupported.");
|
|
}
|
|
if (reserved != 0)
|
|
{
|
|
throw new InvalidDataException(
|
|
"collision payload reserved header bits are non-zero.");
|
|
}
|
|
}
|
|
|
|
public int ReadCount(string name, int bytesPerItem)
|
|
{
|
|
int count = ReadInt32();
|
|
if (count < 0 || count > MaximumRows)
|
|
{
|
|
throw new InvalidDataException(
|
|
$"{name} count {count} is outside [0,{MaximumRows}].");
|
|
}
|
|
if (bytesPerItem <= 0 || count > Remaining / bytesPerItem)
|
|
{
|
|
throw new InvalidDataException(
|
|
$"{name} count {count} exceeds the remaining payload.");
|
|
}
|
|
return count;
|
|
}
|
|
|
|
public FlatCollisionSphere? ReadOptionalSphere() =>
|
|
ReadBoolean() ? ReadSphere() : null;
|
|
|
|
public bool ReadBoolean()
|
|
{
|
|
byte value = ReadByte();
|
|
return value switch
|
|
{
|
|
0 => false,
|
|
1 => true,
|
|
_ => throw new InvalidDataException(
|
|
$"invalid collision boolean value {value}."),
|
|
};
|
|
}
|
|
|
|
public FlatCollisionSphere ReadSphere() =>
|
|
new(ReadVector3(), ReadSingle());
|
|
|
|
public FlatIndexRange ReadRange() =>
|
|
new(ReadInt32(), ReadInt32());
|
|
|
|
public Plane ReadPlane() =>
|
|
new(ReadVector3(), ReadSingle());
|
|
|
|
public Plane ReadPlaneAfterMetadata(
|
|
out CullMode sides,
|
|
out int numPoints,
|
|
out FlatIndexRange range)
|
|
{
|
|
sides = (CullMode)ReadUInt32();
|
|
numPoints = ReadInt32();
|
|
range = ReadRange();
|
|
return ReadPlane();
|
|
}
|
|
|
|
public Vector3 ReadVector3() =>
|
|
new(ReadSingle(), ReadSingle(), ReadSingle());
|
|
|
|
public float ReadSingle() =>
|
|
BitConverter.Int32BitsToSingle(ReadInt32());
|
|
|
|
public byte ReadByte()
|
|
{
|
|
Require(sizeof(byte));
|
|
return _bytes[_offset++];
|
|
}
|
|
|
|
public ushort ReadUInt16()
|
|
{
|
|
ReadOnlySpan<byte> span = Take(sizeof(ushort));
|
|
return BinaryPrimitives.ReadUInt16LittleEndian(span);
|
|
}
|
|
|
|
public int ReadInt32()
|
|
{
|
|
ReadOnlySpan<byte> span = Take(sizeof(int));
|
|
return BinaryPrimitives.ReadInt32LittleEndian(span);
|
|
}
|
|
|
|
public uint ReadUInt32()
|
|
{
|
|
ReadOnlySpan<byte> span = Take(sizeof(uint));
|
|
return BinaryPrimitives.ReadUInt32LittleEndian(span);
|
|
}
|
|
|
|
public void CheckCancellation(int index)
|
|
{
|
|
if ((index & 0xFF) == 0)
|
|
_cancellationToken.ThrowIfCancellationRequested();
|
|
}
|
|
|
|
public void RequireEnd()
|
|
{
|
|
_cancellationToken.ThrowIfCancellationRequested();
|
|
if (_offset != _bytes.Length)
|
|
{
|
|
throw new InvalidDataException(
|
|
$"collision payload contains {_bytes.Length - _offset} " +
|
|
"trailing byte(s).");
|
|
}
|
|
}
|
|
|
|
public void RequireRemaining(long required, string name)
|
|
{
|
|
if (required < 0 || required > Remaining)
|
|
{
|
|
throw new InvalidDataException(
|
|
$"{name} require {required} bytes but only {Remaining} remain.");
|
|
}
|
|
}
|
|
|
|
private ReadOnlySpan<byte> Take(int length)
|
|
{
|
|
Require(length);
|
|
ReadOnlySpan<byte> result = _bytes.Slice(_offset, length);
|
|
_offset += length;
|
|
return result;
|
|
}
|
|
|
|
private void Require(int length)
|
|
{
|
|
if (length < 0 || length > Remaining)
|
|
throw new EndOfStreamException("collision payload is truncated.");
|
|
}
|
|
}
|
|
}
|