Aetheria/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonSoaFramePublisher.cs
2026-07-19 09:47:22 +01:00

930 lines
45 KiB
C#

using System;
using System.Buffers.Binary;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using GameCult.Caching;
using GameCult.Eve.Surface;
using GameCult.Mesh;
#nullable enable
namespace GameCult.Aetheria.State.Verse
{
public sealed class AetheriaRuntimeDaemonSoaFrame : IDisposable
{
private CultMeshFrameBodyWriteLease? _write;
public AetheriaRuntimeDaemonSoaFrame(
AetheriaRuntimeDaemonSoaViewDocument view,
CultMeshFrameBodyWriteLease write,
int byteLength,
bool publishSharedMemory,
bool publishNetwork)
{
View = view ?? throw new ArgumentNullException(nameof(view));
_write = write ?? throw new ArgumentNullException(nameof(write));
ByteLength = byteLength;
PublishSharedMemory = publishSharedMemory;
PublishNetwork = publishNetwork;
}
public AetheriaRuntimeDaemonSoaViewDocument View { get; }
public int ByteLength { get; }
public bool PublishSharedMemory { get; }
public bool PublishNetwork { get; }
public ReadOnlySpan<byte> Span => (_write ?? throw new ObjectDisposedException(nameof(AetheriaRuntimeDaemonSoaFrame))).Span[..ByteLength];
public CultMeshBodyDescriptor Commit(DateTimeOffset nowUtc)
{
var write = _write ?? throw new ObjectDisposedException(nameof(AetheriaRuntimeDaemonSoaFrame));
var descriptor = write.Commit(ByteLength, nowUtc);
_write = null;
return descriptor;
}
public void Dispose()
{
_write?.Dispose();
_write = null;
}
}
public sealed class AetheriaRuntimeDaemonSoaPublication
{
public AetheriaRuntimeDaemonSoaPublication(
CultMeshBodyPublicationDocument body,
EveEntitySoaViewDocument view)
{
Body = body ?? throw new ArgumentNullException(nameof(body));
View = view ?? throw new ArgumentNullException(nameof(view));
}
public CultMeshBodyPublicationDocument Body { get; }
public EveEntitySoaViewDocument View { get; }
}
public sealed class AetheriaRuntimeDaemonSoaFramePublisher : IDisposable
{
public const string BodyId = "eve:entity-soa:aetheria.daemon:pilot";
public const string ProducerId = "aetheria.daemon";
public const string BodySchemaId = "gamecult.eve.entity_soa.body.v2";
public const int LayoutVersion = 3;
private const int Capacity = 4096;
private const int EntityRenderGroupId = 1;
private const int FloatStride = 4;
private const int Float3Stride = 12;
private const int IntStride = 4;
private const int ByteStride = 1;
private const string EntityProxyMeshAssetKey = "daemon.entity_proxy.mesh";
private const string EntityProxyMaterialAssetKey = "daemon.entity_proxy.material";
private const string EntityProxyMeshUri = "cultmesh://aetheria/assets/daemon/entity_proxy/mesh";
private const string EntityProxyMaterialUri = "cultmesh://aetheria/assets/daemon/entity_proxy/material";
private readonly CultMeshFrameBodyPublisher _localPublisher;
private readonly CultMeshNetworkBodyPublisher _networkPublisher;
private readonly CultMeshBodyDemandTracker? _demand;
private readonly Dictionary<string, int> _syntheticEntityIndices =
new Dictionary<string, int>(StringComparer.Ordinal);
private int _nextSyntheticEntityIndex = -2;
public AetheriaRuntimeDaemonSoaFramePublisher(
CultCache cache,
long producerEpoch,
CultMeshBodyDemandTracker? demand = null)
{
if (cache == null) throw new ArgumentNullException(nameof(cache));
_localPublisher = new CultMeshFrameBodyPublisher(
BodyId, BodySchemaId, LayoutVersion, Capacity, producerEpoch,
checked((int)EntityHotSlabLayout.Create(Capacity).TotalByteLength),
TimeSpan.FromSeconds(30));
_networkPublisher = new CultMeshNetworkBodyPublisher(
cache,
generation => string.Equals(generation.ProducerId, ProducerId, StringComparison.Ordinal));
_demand = demand;
}
public AetheriaRuntimeDaemonSoaFrame? BuildCurrentZoneEntities(
AetheriaRuntimeDaemonFrameDocument frame,
AetheriaRuntimeCatalogSnapshot? catalog = null)
{
if (frame == null)
throw new ArgumentNullException(nameof(frame));
var demand = _demand?.Plan(BodyId);
if (demand != null && !demand.HasConsumers)
return null;
var publishSharedMemory = demand?.RequiresSharedMemory ?? true;
var publishNetwork = demand?.RequiresNetwork ?? true;
var run = frame.Run ?? new AetheriaRuntimeRunCheckpointCommit();
var zone = (run.Zones ?? Array.Empty<AetheriaRuntimeZoneSnapshotCommit>())
.FirstOrDefault(candidate => candidate != null && candidate.ZoneIndex == run.CurrentZoneIndex);
AetheriaRuntimeRunCheckpointCommit.TryParseEntityKey(
run.CurrentEntityKey,
out var controlledZoneIndex,
out var controlledEntityIndex);
var controlled = controlledZoneIndex == run.CurrentZoneIndex
? (zone?.Entities ?? Array.Empty<AetheriaRuntimeEntitySnapshotCommit>())
.FirstOrDefault(entity => entity != null && entity.EntityIndex == controlledEntityIndex)
: null;
var dockParent = (zone?.Entities ?? Array.Empty<AetheriaRuntimeEntitySnapshotCommit>())
.FirstOrDefault(entity => entity != null && controlled != null &&
(entity.DockingBayAssignments ?? Array.Empty<int>()).Contains(controlled.EntityIndex));
var visibleEntityIndices = AetheriaRuntimeDaemonRenderQueries
.QueryEffectiveContacts(zone, controlled?.EntityIndex ?? -1)
.Where(contact => contact.Contact.Visible)
.Select(contact => contact.Contact.TargetEntityIndex)
.Append(controlled?.EntityIndex ?? -1)
.ToHashSet();
if (dockParent != null)
visibleEntityIndices.Add(dockParent.EntityIndex);
var entities = (zone?.Entities ?? Array.Empty<AetheriaRuntimeEntitySnapshotCommit>())
.Where(entity => entity != null && visibleEntityIndices.Contains(entity.EntityIndex))
.OrderBy(entity => entity.EntityIndex)
.ToArray();
var pickups = (zone?.DroppedPickups ?? Array.Empty<AetheriaRuntimeDroppedPickupCommit>())
.Where(pickup => pickup != null)
.OrderBy(pickup => pickup.PickupIndex)
.ToArray();
var payloads = (zone?.PhysicalPayloads ?? Array.Empty<AetheriaRuntimePhysicalPayloadCommit>())
.Where(payload => payload != null && payload.Active)
.OrderBy(payload => payload.PayloadId, StringComparer.Ordinal)
.ToArray();
var celestialBodies = BuildCelestialBodies(frame, zone);
var asteroidInstances = BuildAsteroidInstances(frame, zone);
var unsupportedPayload = payloads.FirstOrDefault(payload =>
!string.Equals(payload.PayloadKind, "mine", StringComparison.Ordinal));
if (unsupportedPayload != null)
throw new InvalidOperationException(
$"Physical payload '{unsupportedPayload.PayloadId}' uses unsupported provider asset kind '{unsupportedPayload.PayloadKind}'.");
var pickupEntityIds = pickups
.Select(pickup => $"pickup:{run.CurrentZoneIndex}:{pickup.PickupIndex}")
.ToArray();
var payloadEntityIds = payloads
.Select(payload => $"{run.RunId}:zone:{run.CurrentZoneIndex}:physical-payload:{payload.PayloadId}")
.ToArray();
var syntheticEntityIds = pickupEntityIds
.Concat(payloadEntityIds)
.Concat(celestialBodies.Select(value => value.EntityId))
.Concat(asteroidInstances.Select(value => value.EntityId))
.ToArray();
if (syntheticEntityIds.Distinct(StringComparer.Ordinal).Count() != syntheticEntityIds.Length)
throw new InvalidOperationException("Current-zone synthetic SoA entity identities are not unique.");
var syntheticEntityIndices = syntheticEntityIds.ToDictionary(
entityId => entityId,
GetOrAllocateSyntheticEntityIndex,
StringComparer.Ordinal);
var count = entities.Length + pickups.Length + payloads.Length +
celestialBodies.Count + asteroidInstances.Count;
if (count > Capacity)
throw new InvalidOperationException($"Aetheria entity SoA capacity {Capacity} was exceeded by {count} rows.");
var generation = Math.Max(frame.FrameId, 0);
// LayoutVersion owns byte interpretation. Keep offsets and body extent fixed for the
// publisher capacity so a mapped frame may advance before reactive row metadata
// without causing the same layout version to reinterpret its bytes.
var layout = EntityHotSlabLayout.Create(Capacity);
if (!_localPublisher.TryAcquireWrite(out var write))
throw new InvalidOperationException("CultMesh has no unleased frame slot for the Aetheria SoA generation.");
try
{
var bytes = write.Span[..checked((int)layout.TotalByteLength)];
bytes.Clear();
WriteEntities(bytes, layout, entities);
WritePickups(bytes, layout, pickups, pickupEntityIds, syntheticEntityIndices, entities.Length);
WritePayloads(bytes, layout, payloads, payloadEntityIds, syntheticEntityIndices, entities.Length + pickups.Length);
WriteCelestialBodies(
bytes,
layout,
celestialBodies,
syntheticEntityIndices,
entities.Length + pickups.Length + payloads.Length);
WriteAsteroidInstances(
bytes,
layout,
asteroidInstances,
syntheticEntityIndices,
entities.Length + pickups.Length + payloads.Length + celestialBodies.Count);
var view = AetheriaRuntimeDaemonSoaViewDocument.Create(
string.IsNullOrWhiteSpace(frame.DaemonId) ? "aetheria-daemon" : frame.DaemonId,
string.IsNullOrWhiteSpace(frame.SessionId) ? "local" : frame.SessionId,
frame.FrameId,
generation,
new[]
{
new AetheriaRuntimeDaemonSoaBufferDocument
{
BufferId = BodyId,
DisplayName = "Current zone daemon entity hot slab",
ByteOffset = 0,
ByteLength = layout.TotalByteLength,
Generation = generation,
DaemonWritable = true,
ObserverWritable = false
}
},
layout.CreateColumns(count),
layout.CreateDirtyRanges(count, generation),
backend: AetheriaRuntimeDaemonSoaBackends.CultMesh,
synchronizationMode: AetheriaRuntimeDaemonSoaSynchronizationModes.ImmutableFrame,
renderGroups: CreateRenderGroups(entities, pickups, payloads, celestialBodies, asteroidInstances),
identities: entities.Select(entity => new AetheriaRuntimeDaemonSoaIdentityDocument
{
EntityIndex = entity.EntityIndex,
EntityId = entity.EntityId,
Kind = entity.Kind,
Label = entity.Name,
Faction = entity.FactionKey,
Selectable = entity.EntityIndex != controlled?.EntityIndex,
Controllable = entity.EntityIndex == controlled?.EntityIndex,
AssetRef = AetheriaRuntimeAssets.ResolveEntityPrefabAssetRef(entity, catalog)
})
.Concat(pickups.Select((pickup, pickupRow) => new AetheriaRuntimeDaemonSoaIdentityDocument
{
EntityIndex = syntheticEntityIndices[pickupEntityIds[pickupRow]],
EntityId = pickupEntityIds[pickupRow],
Kind = "pickup",
Label = string.IsNullOrWhiteSpace(pickup.Item?.ItemKey) ? "Pickup" : pickup.Item.ItemKey,
Faction = "",
Selectable = true,
Controllable = false,
AssetRef = "prefab.entity.pickup"
}))
.Concat(payloads.Select((payload, payloadRow) => new AetheriaRuntimeDaemonSoaIdentityDocument
{
EntityIndex = syntheticEntityIndices[payloadEntityIds[payloadRow]],
EntityId = payloadEntityIds[payloadRow],
Kind = "physical-payload",
Label = string.IsNullOrWhiteSpace(payload.PayloadKind) ? "Physical payload" : payload.PayloadKind,
Faction = payload.FactionKey ?? "",
Selectable = false,
Controllable = false,
AssetRef = "prefab.entity.mine"
}))
.Concat(celestialBodies.Select(value => new AetheriaRuntimeDaemonSoaIdentityDocument
{
EntityIndex = syntheticEntityIndices[value.EntityId],
EntityId = value.EntityId,
Kind = value.EntityKind,
Label = value.Label,
Faction = "",
Selectable = false,
Controllable = false,
AssetRef = value.AssetRef
}))
.Concat(asteroidInstances.Select(value => new AetheriaRuntimeDaemonSoaIdentityDocument
{
EntityIndex = syntheticEntityIndices[value.EntityId],
EntityId = value.EntityId,
Kind = "celestial.asteroid",
Label = "Asteroid",
Faction = "",
Selectable = false,
Controllable = false,
AssetRef = "prefab.body.asteroid"
}))
.ToArray());
return new AetheriaRuntimeDaemonSoaFrame(
view,
write,
checked((int)layout.TotalByteLength),
publishSharedMemory,
publishNetwork);
}
catch
{
write.Dispose();
throw;
}
}
public async Task<AetheriaRuntimeDaemonSoaPublication> PublishAsync(AetheriaRuntimeDaemonSoaFrame frame)
{
if (frame == null) throw new ArgumentNullException(nameof(frame));
var now = DateTimeOffset.UtcNow;
var networkBytes = frame.PublishNetwork ? frame.Span.ToArray() : null;
var local = frame.Commit(now);
var generation = new CultMeshBodyGeneration
{
BodyId = BodyId,
ProducerId = ProducerId,
SchemaId = BodySchemaId,
LayoutVersion = LayoutVersion,
Capacity = Capacity,
ProducerEpoch = local.ProducerEpoch,
Sequence = local.Sequence,
Synchronization = local.Synchronization,
LeaseExpiresAtUnixMs = local.LeaseExpiresAtUnixMs
};
var representations = new List<CultMeshBodyDescriptor>();
if (frame.PublishSharedMemory) representations.Add(local);
if (frame.PublishNetwork)
representations.Add(await _networkPublisher.PublishAsync(generation, networkBytes!).ConfigureAwait(false));
var publication = new CultMeshBodyPublicationDocument
{
BodyId = BodyId,
ProducerId = ProducerId,
SchemaId = BodySchemaId,
LayoutVersion = LayoutVersion,
ByteSize = local.ByteSize,
Capacity = Capacity,
ProducerEpoch = local.ProducerEpoch,
Sequence = local.Sequence,
Synchronization = local.Synchronization,
LivenessExpiresAtUnixMs = local.LeaseExpiresAtUnixMs,
Representations = representations.ToArray()
};
new CultMeshBodyPublicationHandle(BodyId, publication.ProducerEpoch, publication.Sequence)
.Validate(publication);
var view = AetheriaRuntimeEveEntitySoaProjection.Project(frame.View, generation);
if (view.Buffers.Length != 1 || !string.Equals(view.Buffers[0].BufferId, publication.BodyId, StringComparison.Ordinal) ||
view.Columns.Any(column => !string.Equals(column.BufferId, publication.BodyId, StringComparison.Ordinal)))
throw new InvalidOperationException("Aetheria Eve SoA layout does not reference its published logical body identity.");
return new AetheriaRuntimeDaemonSoaPublication(publication, view);
}
public void Dispose() => _localPublisher.Dispose();
private static IReadOnlyList<AetheriaRuntimeDaemonRenderGroupDocument> CreateRenderGroups(
IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities,
IReadOnlyList<AetheriaRuntimeDroppedPickupCommit> pickups,
IReadOnlyList<AetheriaRuntimePhysicalPayloadCommit> payloads,
IReadOnlyList<CelestialBodyPresentation> celestialBodies,
IReadOnlyList<AsteroidPresentation> asteroidInstances)
{
if (entities.Count == 0 && pickups.Count == 0 && payloads.Count == 0 &&
celestialBodies.Count == 0 && asteroidInstances.Count == 0)
return Array.Empty<AetheriaRuntimeDaemonRenderGroupDocument>();
var positions = entities.Select(entity => (entity.PositionX, entity.PositionY, entity.PositionZ))
.Concat(pickups.Select(pickup => (pickup.PositionX, pickup.PositionY, pickup.PositionZ)))
.Concat(payloads.Select(payload => (payload.PositionX, PositionY: payload.PositionY, payload.PositionZ)))
.Concat(celestialBodies.Select(value => (value.PositionX, value.PositionY, value.PositionZ)))
.Concat(asteroidInstances.Select(value => (value.PositionX, value.PositionY, value.PositionZ)))
.ToArray();
var minX = positions.Min(position => (float)position.PositionX);
var minY = positions.Min(position => (float)position.PositionY);
var minZ = positions.Min(position => (float)position.PositionZ);
var maxX = positions.Max(position => (float)position.PositionX);
var maxY = positions.Max(position => (float)position.PositionY);
var maxZ = positions.Max(position => (float)position.PositionZ);
const float boundsCell = 1024.0f;
var boundsMinX = MathF.Floor((minX - 16.0f) / boundsCell) * boundsCell;
var boundsMinY = MathF.Floor((minY - 16.0f) / boundsCell) * boundsCell;
var boundsMinZ = MathF.Floor((minZ - 16.0f) / boundsCell) * boundsCell;
var boundsMaxX = MathF.Ceiling((maxX + 16.0f) / boundsCell) * boundsCell;
var boundsMaxY = MathF.Ceiling((maxY + 16.0f) / boundsCell) * boundsCell;
var boundsMaxZ = MathF.Ceiling((maxZ + 16.0f) / boundsCell) * boundsCell;
return new[]
{
new AetheriaRuntimeDaemonRenderGroupDocument
{
GroupId = EntityRenderGroupId,
MeshKey = EntityProxyMeshUri,
MaterialKey = EntityProxyMaterialUri,
MeshAsset = AetheriaRuntimeAssetRef.FromKey(
EntityProxyMeshAssetKey,
AetheriaRuntimeAssetKinds.Mesh,
EntityProxyMeshUri,
AetheriaRuntimeAssetTransports.CultMesh),
MaterialAsset = AetheriaRuntimeAssetRef.FromKey(
EntityProxyMaterialAssetKey,
AetheriaRuntimeAssetKinds.Material,
EntityProxyMaterialUri,
AetheriaRuntimeAssetTransports.CultMesh),
SubMeshIndex = 0,
Layer = 0,
ShaderKey = "aetheria.daemon.entity-proxy",
DisplayName = "Daemon current-zone entities",
InstanceCount = entities.Count + pickups.Count + payloads.Count +
celestialBodies.Count + asteroidInstances.Count,
BoundsCenterX = (boundsMinX + boundsMaxX) * 0.5f,
BoundsCenterY = (boundsMinY + boundsMaxY) * 0.5f,
BoundsCenterZ = (boundsMinZ + boundsMaxZ) * 0.5f,
BoundsSizeX = Math.Max(boundsMaxX - boundsMinX, boundsCell),
BoundsSizeY = Math.Max(boundsMaxY - boundsMinY, boundsCell),
BoundsSizeZ = Math.Max(boundsMaxZ - boundsMinZ, boundsCell),
ShadowMode = AetheriaRuntimeDaemonRenderShadowModes.On,
ReceiveShadows = true,
DefaultScale = 1.0f,
Lod = -1
}
};
}
private static void WriteEntities(
Span<byte> bytes,
EntityHotSlabLayout layout,
IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities)
{
for (var index = 0; index < entities.Count; index++)
{
var entity = entities[index];
WriteInt32(bytes, layout.EntityIndex + index * IntStride, entity.EntityIndex);
WriteInt32(bytes, layout.CargoQuantity + index * IntStride, AetheriaRuntimeCargoCapacityQueries.Quantity(entity));
WriteFloat(bytes, layout.BeamPower, index, entity.TractorPower);
WriteFloat3(bytes, layout.Position, index, entity.PositionX, entity.PositionY, entity.PositionZ);
WriteFloat(bytes, layout.RotationRadians, index, Math.Atan2(entity.DirectionX, entity.DirectionY));
WriteFloat3(bytes, layout.Velocity, index, entity.VelocityX, 0.0, entity.VelocityY);
WriteFloat(bytes, layout.PhysicsBodyRadius, index, 1.0);
WriteFloat(bytes, layout.PhysicsBodyMass, index, 1.0);
WriteFloat(bytes, layout.PhysicsBodyInverseMass, index, 1.0);
WriteFloat(bytes, layout.RenderScale, index, 1.0);
bytes[checked((int)(layout.RenderVisibility + index * ByteStride))] = (byte)(entity.IsActive ? 1 : 0);
WriteInt32(bytes, layout.RenderLod + index * IntStride, 0);
WriteUInt32(bytes, layout.RenderGroupId + index * IntStride, EntityRenderGroupId);
}
}
private static void WritePickups(
Span<byte> bytes,
EntityHotSlabLayout layout,
IReadOnlyList<AetheriaRuntimeDroppedPickupCommit> pickups,
IReadOnlyList<string> pickupEntityIds,
IReadOnlyDictionary<string, int> syntheticEntityIndices,
int rowOffset)
{
for (var pickupRow = 0; pickupRow < pickups.Count; pickupRow++)
{
var pickup = pickups[pickupRow];
var row = rowOffset + pickupRow;
WriteInt32(bytes, layout.EntityIndex + row * IntStride, syntheticEntityIndices[pickupEntityIds[pickupRow]]);
WriteInt32(bytes, layout.CargoQuantity + row * IntStride, 0);
WriteFloat3(bytes, layout.Position, row, pickup.PositionX, pickup.PositionY, pickup.PositionZ);
WriteFloat(bytes, layout.RotationRadians, row, 0.0);
WriteFloat3(bytes, layout.Velocity, row, pickup.VelocityX, pickup.VelocityY, pickup.VelocityZ);
WriteFloat(bytes, layout.PhysicsBodyRadius, row, 0.5);
WriteFloat(bytes, layout.PhysicsBodyMass, row, 0.25);
WriteFloat(bytes, layout.PhysicsBodyInverseMass, row, 4.0);
WriteFloat(bytes, layout.RenderScale, row, 1.0);
bytes[checked((int)(layout.RenderVisibility + row * ByteStride))] = 1;
WriteInt32(bytes, layout.RenderLod + row * IntStride, 0);
WriteUInt32(bytes, layout.RenderGroupId + row * IntStride, EntityRenderGroupId);
}
}
private static void WritePayloads(
Span<byte> bytes,
EntityHotSlabLayout layout,
IReadOnlyList<AetheriaRuntimePhysicalPayloadCommit> payloads,
IReadOnlyList<string> payloadEntityIds,
IReadOnlyDictionary<string, int> syntheticEntityIndices,
int rowOffset)
{
for (var payloadRow = 0; payloadRow < payloads.Count; payloadRow++)
{
var payload = payloads[payloadRow];
var row = rowOffset + payloadRow;
WriteInt32(bytes, layout.EntityIndex + row * IntStride, syntheticEntityIndices[payloadEntityIds[payloadRow]]);
WriteInt32(bytes, layout.CargoQuantity + row * IntStride, 0);
WriteFloat3(bytes, layout.Position, row, payload.PositionX, payload.PositionY, payload.PositionZ);
WriteFloat(bytes, layout.RotationRadians, row, Math.Atan2(payload.DirectionX, payload.DirectionY));
WriteFloat3(bytes, layout.Velocity, row, payload.VelocityX, 0.0, payload.VelocityY);
WriteFloat(bytes, layout.PhysicsBodyRadius, row, Math.Max(0.01, payload.Radius));
WriteFloat(bytes, layout.PhysicsBodyMass, row, payload.Stationary ? 0.0 : 1.0);
WriteFloat(bytes, layout.PhysicsBodyInverseMass, row, payload.Stationary ? 0.0 : 1.0);
WriteFloat(bytes, layout.RenderScale, row, 1.0);
bytes[checked((int)(layout.RenderVisibility + row * ByteStride))] = 1;
WriteInt32(bytes, layout.RenderLod + row * IntStride, 0);
WriteUInt32(bytes, layout.RenderGroupId + row * IntStride, EntityRenderGroupId);
}
}
private static IReadOnlyList<CelestialBodyPresentation> BuildCelestialBodies(
AetheriaRuntimeDaemonFrameDocument frame,
AetheriaRuntimeZoneSnapshotCommit? zone)
{
if (zone == null)
return Array.Empty<CelestialBodyPresentation>();
var poses = AetheriaRuntimeDaemonRenderQueries.QueryBodyPoses(zone)
.ToDictionary(pose => pose.BodyKey, StringComparer.Ordinal);
var values = new List<CelestialBodyPresentation>();
foreach (var body in zone.Bodies ?? Array.Empty<AetheriaRuntimeBodySnapshotCommit>())
{
if (body == null ||
string.Equals(body.Kind, "asteroid_belt", StringComparison.OrdinalIgnoreCase) ||
string.IsNullOrWhiteSpace(body.BodyKey) ||
!poses.TryGetValue(body.BodyKey, out var pose))
continue;
var scale = Math.Max(
0.1,
frame.RenderSettings.ResolveBodyRadius(body.Mass) * Math.Max(0, body.BodyRadiusMultiplier));
var terrainHeight = AetheriaRuntimeDaemonRenderQueries.EvaluateGravityTerrainHeight(
zone,
pose.CenterX,
pose.CenterZ,
frame.SimulationTimeSeconds);
var kind = NormalizeCelestialKind(body.Kind);
values.Add(new CelestialBodyPresentation(
$"{frame.Run.RunId}:zone:{zone.ZoneIndex}:body:{body.BodyKey}",
kind,
string.IsNullOrWhiteSpace(body.Name) ? body.BodyKey : body.Name,
ResolveCelestialAssetRef(kind),
pose.CenterX,
terrainHeight + scale * 2.0,
pose.CenterZ,
frame.SimulationTimeSeconds * frame.RenderSettings.PlanetRotationSpeed * Math.PI / 180.0,
scale));
}
return values;
}
private static IReadOnlyList<AsteroidPresentation> BuildAsteroidInstances(
AetheriaRuntimeDaemonFrameDocument frame,
AetheriaRuntimeZoneSnapshotCommit? zone)
{
if (zone == null)
return Array.Empty<AsteroidPresentation>();
var values = new List<AsteroidPresentation>();
foreach (var belt in zone.Bodies ?? Array.Empty<AetheriaRuntimeBodySnapshotCommit>())
{
if (belt == null ||
!string.Equals(belt.Kind, "asteroid_belt", StringComparison.OrdinalIgnoreCase) ||
string.IsNullOrWhiteSpace(belt.BodyKey))
continue;
foreach (var pose in AetheriaRuntimeDaemonRenderQueries.QueryAsteroidInstancePoses(
zone,
belt.BodyKey,
frame.SimulationTimeSeconds))
{
if (pose.Size <= 0)
continue;
var terrainHeight = AetheriaRuntimeDaemonRenderQueries.EvaluateGravityTerrainHeight(
zone,
pose.PositionX,
pose.PositionZ,
frame.SimulationTimeSeconds);
values.Add(new AsteroidPresentation(
$"{frame.Run.RunId}:zone:{zone.ZoneIndex}:asteroid:{belt.BodyKey}:{pose.AsteroidIndex}",
pose.PositionX,
terrainHeight + frame.RenderSettings.AsteroidVerticalOffset,
pose.PositionZ,
pose.Rotation,
pose.Size));
}
}
return values;
}
private static string NormalizeCelestialKind(string? kind)
{
var normalized = (kind ?? "").Trim().ToLowerInvariant().Replace('_', '-');
return normalized switch
{
"sun" => "sun",
"gas-giant" => "gas-giant",
_ => "planet"
};
}
private static string ResolveCelestialAssetRef(string kind)
{
return kind switch
{
"sun" => "prefab.body.sun",
"gas-giant" => "prefab.body.gas-giant",
_ => "prefab.body.planet"
};
}
private static void WriteCelestialBodies(
Span<byte> bytes,
EntityHotSlabLayout layout,
IReadOnlyList<CelestialBodyPresentation> values,
IReadOnlyDictionary<string, int> syntheticEntityIndices,
int rowOffset)
{
for (var valueIndex = 0; valueIndex < values.Count; valueIndex++)
{
var value = values[valueIndex];
var row = rowOffset + valueIndex;
WritePresentationRow(
bytes,
layout,
row,
syntheticEntityIndices[value.EntityId],
value.PositionX,
value.PositionY,
value.PositionZ,
value.RotationRadians,
value.Scale);
}
}
private static void WriteAsteroidInstances(
Span<byte> bytes,
EntityHotSlabLayout layout,
IReadOnlyList<AsteroidPresentation> values,
IReadOnlyDictionary<string, int> syntheticEntityIndices,
int rowOffset)
{
for (var valueIndex = 0; valueIndex < values.Count; valueIndex++)
{
var value = values[valueIndex];
var row = rowOffset + valueIndex;
WritePresentationRow(
bytes,
layout,
row,
syntheticEntityIndices[value.EntityId],
value.PositionX,
value.PositionY,
value.PositionZ,
value.RotationRadians,
value.Scale);
}
}
private static void WritePresentationRow(
Span<byte> bytes,
EntityHotSlabLayout layout,
int row,
int entityIndex,
double positionX,
double positionY,
double positionZ,
double rotationRadians,
double scale)
{
WriteInt32(bytes, layout.EntityIndex + row * IntStride, entityIndex);
WriteInt32(bytes, layout.CargoQuantity + row * IntStride, 0);
WriteFloat3(bytes, layout.Position, row, positionX, positionY, positionZ);
WriteFloat(bytes, layout.RotationRadians, row, rotationRadians);
WriteFloat3(bytes, layout.Velocity, row, 0, 0, 0);
WriteFloat(bytes, layout.PhysicsBodyRadius, row, Math.Max(0.01, scale));
WriteFloat(bytes, layout.PhysicsBodyMass, row, 0);
WriteFloat(bytes, layout.PhysicsBodyInverseMass, row, 0);
WriteFloat(bytes, layout.RenderScale, row, Math.Max(0.01, scale));
bytes[checked((int)(layout.RenderVisibility + row * ByteStride))] = 1;
WriteInt32(bytes, layout.RenderLod + row * IntStride, 0);
WriteUInt32(bytes, layout.RenderGroupId + row * IntStride, EntityRenderGroupId);
}
private int GetOrAllocateSyntheticEntityIndex(string entityId)
{
if (_syntheticEntityIndices.TryGetValue(entityId, out var existing))
return existing;
if (_nextSyntheticEntityIndex == int.MinValue)
throw new InvalidOperationException("Aetheria SoA synthetic entity index space is exhausted.");
var allocated = _nextSyntheticEntityIndex--;
_syntheticEntityIndices.Add(entityId, allocated);
return allocated;
}
private sealed class CelestialBodyPresentation
{
public CelestialBodyPresentation(
string entityId,
string kind,
string label,
string assetRef,
double positionX,
double positionY,
double positionZ,
double rotationRadians,
double scale)
{
EntityId = entityId;
EntityKind = "celestial." + kind;
Label = label;
AssetRef = assetRef;
PositionX = positionX;
PositionY = positionY;
PositionZ = positionZ;
RotationRadians = rotationRadians;
Scale = scale;
}
public string EntityId { get; }
public string EntityKind { get; }
public string Label { get; }
public string AssetRef { get; }
public double PositionX { get; }
public double PositionY { get; }
public double PositionZ { get; }
public double RotationRadians { get; }
public double Scale { get; }
}
private sealed class AsteroidPresentation
{
public AsteroidPresentation(
string entityId,
double positionX,
double positionY,
double positionZ,
double rotationRadians,
double scale)
{
EntityId = entityId;
PositionX = positionX;
PositionY = positionY;
PositionZ = positionZ;
RotationRadians = rotationRadians;
Scale = scale;
}
public string EntityId { get; }
public double PositionX { get; }
public double PositionY { get; }
public double PositionZ { get; }
public double RotationRadians { get; }
public double Scale { get; }
}
private static void WriteFloat(Span<byte> bytes, long byteOffset, int index, double value)
{
var scalar = IsFinite(value) ? (float)value : 0.0f;
BinaryPrimitives.WriteInt32LittleEndian(
bytes.Slice(checked((int)(byteOffset + index * FloatStride)), FloatStride),
BitConverter.SingleToInt32Bits(scalar));
}
private static void WriteFloat3(
Span<byte> bytes,
long byteOffset,
int index,
double x,
double y,
double z)
{
var elementOffset = byteOffset + index * Float3Stride;
WriteFloat(bytes, elementOffset, 0, x);
WriteFloat(bytes, elementOffset + FloatStride, 0, y);
WriteFloat(bytes, elementOffset + FloatStride * 2, 0, z);
}
private static void WriteInt32(Span<byte> bytes, long offset, int value) =>
BinaryPrimitives.WriteInt32LittleEndian(bytes.Slice(checked((int)offset), IntStride), value);
private static void WriteUInt32(Span<byte> bytes, long offset, int value) =>
BinaryPrimitives.WriteUInt32LittleEndian(bytes.Slice(checked((int)offset), IntStride), (uint)value);
private static bool IsFinite(double value)
{
return !double.IsNaN(value) && !double.IsInfinity(value);
}
private readonly struct EntityHotSlabLayout
{
private EntityHotSlabLayout(
long entityIndex,
long cargoQuantity,
long beamPower,
long position,
long rotationRadians,
long velocity,
long physicsBodyRadius,
long physicsBodyMass,
long physicsBodyInverseMass,
long renderScale,
long renderVisibility,
long renderLod,
long renderGroupId,
long totalByteLength)
{
EntityIndex = entityIndex;
CargoQuantity = cargoQuantity;
BeamPower = beamPower;
Position = position;
RotationRadians = rotationRadians;
Velocity = velocity;
PhysicsBodyRadius = physicsBodyRadius;
PhysicsBodyMass = physicsBodyMass;
PhysicsBodyInverseMass = physicsBodyInverseMass;
RenderScale = renderScale;
RenderVisibility = renderVisibility;
RenderLod = renderLod;
RenderGroupId = renderGroupId;
TotalByteLength = totalByteLength;
}
public long EntityIndex { get; }
public long CargoQuantity { get; }
public long BeamPower { get; }
public long Position { get; }
public long RotationRadians { get; }
public long Velocity { get; }
public long PhysicsBodyRadius { get; }
public long PhysicsBodyMass { get; }
public long PhysicsBodyInverseMass { get; }
public long RenderScale { get; }
public long RenderVisibility { get; }
public long RenderLod { get; }
public long RenderGroupId { get; }
public long TotalByteLength { get; }
public static EntityHotSlabLayout Create(int count)
{
count = Math.Max(0, count);
var offset = 0L;
var entityIndex = Take(ref offset, count, IntStride);
var cargoQuantity = Take(ref offset, count, IntStride);
var beamPower = Take(ref offset, count, FloatStride);
var position = Take(ref offset, count, Float3Stride);
var rotationRadians = Take(ref offset, count, FloatStride);
var velocity = Take(ref offset, count, Float3Stride);
var physicsBodyRadius = Take(ref offset, count, FloatStride);
var physicsBodyMass = Take(ref offset, count, FloatStride);
var physicsBodyInverseMass = Take(ref offset, count, FloatStride);
var renderScale = Take(ref offset, count, FloatStride);
var renderVisibility = Take(ref offset, count, ByteStride);
offset = Align4(offset);
var renderLod = Take(ref offset, count, IntStride);
var renderGroupId = Take(ref offset, count, IntStride);
return new EntityHotSlabLayout(
entityIndex,
cargoQuantity,
beamPower,
position,
rotationRadians,
velocity,
physicsBodyRadius,
physicsBodyMass,
physicsBodyInverseMass,
renderScale,
renderVisibility,
renderLod,
renderGroupId,
Math.Max(1, offset));
}
public AetheriaRuntimeDaemonSoaColumnDocument[] CreateColumns(int count)
{
return new[]
{
Column("entity-index", AetheriaRuntimeDaemonSoaColumnKinds.EntityIndex, "int32", EntityIndex, IntStride, count, "index", "world"),
Column("cargo-quantity", AetheriaRuntimeDaemonSoaColumnKinds.CargoQuantity, "int32", CargoQuantity, IntStride, count, "items", "entity"),
Column("beam-power", AetheriaRuntimeDaemonSoaColumnKinds.BeamPower, "float32", BeamPower, FloatStride, count, "normalized", "entity"),
Column("position", AetheriaRuntimeDaemonSoaColumnKinds.Position, "float3", Position, Float3Stride, count, "world_units", "world"),
Column("rotation-radians", AetheriaRuntimeDaemonSoaColumnKinds.RotationRadians, "float32", RotationRadians, FloatStride, count, "radians", "world"),
Column("velocity", AetheriaRuntimeDaemonSoaColumnKinds.Velocity, "float3", Velocity, Float3Stride, count, "world_units_per_second", "world"),
Column("physics-body-radius", AetheriaRuntimeDaemonSoaColumnKinds.PhysicsBodyRadius, "float32", PhysicsBodyRadius, FloatStride, count, "world_units", "world"),
Column("physics-body-mass", AetheriaRuntimeDaemonSoaColumnKinds.PhysicsBodyMass, "float32", PhysicsBodyMass, FloatStride, count, "mass_units", "world"),
Column("physics-body-inverse-mass", AetheriaRuntimeDaemonSoaColumnKinds.PhysicsBodyInverseMass, "float32", PhysicsBodyInverseMass, FloatStride, count, "inverse_mass_units", "world"),
Column("render-scale", AetheriaRuntimeDaemonSoaColumnKinds.RenderScale, "float32", RenderScale, FloatStride, count, "scale", "world"),
Column("render-visibility", AetheriaRuntimeDaemonSoaColumnKinds.RenderVisibility, "uint8", RenderVisibility, ByteStride, count, "bool", "world"),
Column("render-lod", AetheriaRuntimeDaemonSoaColumnKinds.RenderLod, "int32", RenderLod, IntStride, count, "lod", "world"),
Column("render-group-id", AetheriaRuntimeDaemonSoaColumnKinds.RenderGroupId, "uint32", RenderGroupId, IntStride, count, "id", "world")
};
}
public AetheriaRuntimeDaemonSoaDirtyRangeDocument[] CreateDirtyRanges(int count, long generation)
{
return CreateColumns(count)
.Select(column => new AetheriaRuntimeDaemonSoaDirtyRangeDocument
{
ColumnId = column.ColumnId,
StartIndex = 0,
Count = count,
Generation = generation
})
.ToArray();
}
private static AetheriaRuntimeDaemonSoaColumnDocument Column(
string columnId,
string kind,
string scalarType,
long byteOffset,
int stride,
int count,
string unit,
string coordinateSpace)
{
return new AetheriaRuntimeDaemonSoaColumnDocument
{
ColumnId = columnId,
Kind = kind,
BufferId = BodyId,
ScalarType = scalarType,
ByteOffset = byteOffset,
ElementStride = stride,
ElementCount = count,
Unit = unit,
CoordinateSpace = coordinateSpace
};
}
private static long Take(ref long offset, int count, int stride)
{
var current = offset;
offset += (long)count * stride;
return current;
}
private static long Align4(long value)
{
var remainder = value % 4;
return remainder == 0 ? value : value + 4 - remainder;
}
}
}
}