This repository has been archived on 2026-10-29. You can view files and clone it, but you cannot make any changes to its state, such as pushing and creating new issues, pull requests or comments.
EveUnity/packages/org.gamecult.eve.unity-scene/Runtime/CultMesh/EveUnityCultMeshLiveProviderTransport.cs
2026-08-19 10:14:37 +02:00

2369 lines
109 KiB
C#

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Collections.Concurrent;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using GameCult.Caching;
using GameCult.Eve.PluginFields;
using GameCult.Eve.Surface;
using GameCult.Eve.UnityScene.Fields;
using GameCult.Mesh;
using GameCult.Mesh.Quic.Native;
using UnityEngine;
using Stopwatch = System.Diagnostics.Stopwatch;
#nullable enable
namespace GameCult.Eve.UnityScene
{
public sealed class EveUnityCultMeshLiveProviderTransport :
IEveUnitySceneLiveProviderTransport,
IEveUnityGameObjectAssetProvider,
IDisposable
{
private const int AssetPresentationAttemptLimit = 3;
private readonly string _cachePath;
private readonly string _rendezvousEndpoint;
private readonly CultMeshSessionTarget _target;
private readonly string _providerId;
private readonly string _surfaceId;
private readonly string _runtimeId;
private readonly CultMeshAuthorityTrustPolicy _authorityTrust;
private readonly CultMeshAuthorityTrustPolicy _crossTargetAuthorityTrust;
private readonly Dictionary<string, EveSurfaceCommandRequest> _pendingCommands =
new Dictionary<string, EveSurfaceCommandRequest>(StringComparer.Ordinal);
private readonly Dictionary<string, Task<ReceiptSubscription>> _receiptSubscriptions =
new Dictionary<string, Task<ReceiptSubscription>>(StringComparer.Ordinal);
private readonly object _presentationFinalityGate = new object();
private readonly Dictionary<string, EveCommandReceiptDocument> _deferredTerminalReceipts =
new Dictionary<string, EveCommandReceiptDocument>(StringComparer.Ordinal);
private readonly HashSet<string> _continuousCommandIds = new HashSet<string>(StringComparer.Ordinal);
private readonly ConcurrentQueue<object> _liveDocuments = new ConcurrentQueue<object>();
private readonly object _realtimeFrameGate = new object();
private readonly Dictionary<string, CultMeshRealtimeFrame> _latestRealtimeFrames =
new Dictionary<string, CultMeshRealtimeFrame>(StringComparer.Ordinal);
private readonly HashSet<string> _queuedRealtimeFrameBodies =
new HashSet<string>(StringComparer.Ordinal);
private readonly Dictionary<string, EveSurfaceDocument> _embeddedSurfaces =
new Dictionary<string, EveSurfaceDocument>(StringComparer.Ordinal);
private readonly List<IDisposable> _documentLeases = new List<IDisposable>();
private readonly List<IDisposable> _documentWatches = new List<IDisposable>();
private readonly CancellationTokenSource _lifetime = new CancellationTokenSource();
private readonly SemaphoreSlim _assetGenerationGate = new SemaphoreSlim(1, 1);
private CultMeshClient? _meshClient;
private bool _liveDocumentsReady;
private CultCache? _contentState;
private AssetGeneration _assetGeneration;
private EveProviderAdvertisementDocument? _advertisement;
private EveAdvertisedSurface? _advertisedSurface;
private EveSurfaceDocument? _baseSurface;
private CultMeshBodyPublicationResolver? _bodyResolver;
private EveEntitySoaViewDocument? _latestEntityLayout;
private CultMeshBodyPublicationDocument? _latestEntityPublication;
private CultMeshMappedFrameBodyCursor? _mappedEntityFrameCursor;
private CultMeshBodyDescriptor? _mappedEntityFrameContract;
private CancellationTokenSource? _realtimeLifetime;
private CancellationTokenSource? _surfaceAssetCandidateLifetime;
private Task? _realtimePump;
private CultMeshRealtimeSession? _realtimeSession;
private EveUnityCultMeshCommandOutbox? _commandOutbox;
private PendingAssetCatalogUpdate? _pendingAssetCatalog;
private bool _assetCatalogUpdateRunning;
private long _surfaceAssetGeneration;
private long _highestObservedBaseSurfaceVersion = -1;
private long _activeBaseSurfaceCandidateVersion = -1;
private long _activeBaseSurfaceCandidateGeneration = -1;
private int _lastAssetPresentationAttemptCount;
private long _mountedBaseSurfaceVersion;
private long _presentationBarrierVersion = -1;
private long _lastQueuedEntityViewEpoch = -1;
private long _lastQueuedEntityViewSequence = -1;
private long _lastPresentedEntityViewEpoch = -1;
private long _lastPresentedEntityViewSequence = -1;
private bool _bootstrapped;
private bool _disposed;
public EveUnityCultMeshLiveProviderTransport(
string cachePath,
string rendezvousEndpoint,
string verseId,
string authorityRuntimeId,
string providerId,
string surfaceId,
string runtimeId = "eve-unity",
CultMeshBodyPublicationResolver? bodyResolver = null,
CultMeshAuthorityTrustPolicy? authorityTrust = null,
CultMeshAuthorityTrustPolicy? crossTargetAuthorityTrust = null)
{
_cachePath = string.IsNullOrWhiteSpace(cachePath)
? throw new ArgumentException("Cache path must be non-empty.", nameof(cachePath))
: Path.GetFullPath(cachePath);
_rendezvousEndpoint = string.IsNullOrWhiteSpace(rendezvousEndpoint)
? throw new ArgumentException("CultMesh rendezvous endpoint must be non-empty.", nameof(rendezvousEndpoint))
: rendezvousEndpoint.Trim();
_target = new CultMeshSessionTarget(verseId, authorityRuntimeId);
_providerId = string.IsNullOrWhiteSpace(providerId)
? throw new ArgumentException("Provider id must be non-empty.", nameof(providerId))
: providerId.Trim();
_assetGeneration = new AssetGeneration(
new AssetSource(_target, _providerId, "", Array.Empty<string>()),
sourceIdentity: "",
catalogVersion: -1,
meshClient: null);
_surfaceId = string.IsNullOrWhiteSpace(surfaceId)
? throw new ArgumentException("Surface id must be non-empty.", nameof(surfaceId))
: surfaceId.Trim();
_runtimeId = string.IsNullOrWhiteSpace(runtimeId) ? "eve-unity" : runtimeId.Trim();
_bodyResolver = bodyResolver;
_authorityTrust = authorityTrust ?? new CultMeshAuthorityTrustPolicy(
CultMeshAuthorityTrustMode.AuthenticatedRemote);
_crossTargetAuthorityTrust = crossTargetAuthorityTrust ?? _authorityTrust;
CurrentSurfaceDocument = EmptySurfaceDocument();
CurrentAssetManifestDocument = EmptyAssetManifest();
CurrentInputCapability = new EveInputCapabilityDocument();
}
public string TransportKind => "eve-cultmesh-identity-session";
public string SurfacePointer => CurrentSurfaceDocument.SourcePointer;
public string AssetManifestPointer => CurrentAssetManifestDocument.ManifestRef;
public EveUnitySceneProviderSurfaceDocument CurrentSurfaceDocument { get; private set; }
public EveUnityPlayableWorldAssetManifestDocument CurrentAssetManifestDocument { get; private set; }
public EveInputCapabilityDocument CurrentInputCapability { get; private set; }
public CultMeshBodyTransportKind? CurrentAssetBodyTransportKind => _assetGeneration.BodyTransportKind;
public event Action<EveUnitySceneProviderSurfaceDocument>? SurfaceDocumentAvailable;
public event Action<EveUnityPlayableWorldAssetManifestDocument>? AssetManifestDocumentAvailable;
public event Action<EveUnitySceneCommandReceipt>? CommandReceiptAvailable;
public event Action<EveEntitySoaViewDocument, ICultMeshBodyReadLease>? EntityViewAvailable;
public event Action<EveFieldsSplatsDocument>? FieldsSplatsAvailable;
private static CultMeshBodyPublicationHandle BodyPublicationHandle(EveEntitySoaViewDocument document)
{
if (document == null) throw new ArgumentNullException(nameof(document));
if (document.Buffers == null || document.Buffers.Length == 0)
throw new InvalidOperationException("Entity layout does not name a primary logical buffer.");
return new CultMeshBodyPublicationHandle(
document.Buffers[0].BufferId,
document.ProducerEpoch,
document.Sequence);
}
public void Connect()
{
EnsurePrepared();
}
public void Disconnect()
{
}
public void Refresh()
{
EnsurePrepared();
PumpLiveEvents();
}
public async Task PrepareAsync(CancellationToken cancellationToken = default)
{
if (_bootstrapped)
return;
try
{
EnsureOpen();
var elapsed = Stopwatch.StartNew();
await ResolveAdvertisementAsync(forceRefresh: true, cancellationToken);
TraceStartup("advertisement", elapsed);
await RefreshSurfaceAsync(cancellationToken);
TraceStartup("surface", elapsed);
await RefreshAssetCatalogAsync(cancellationToken);
TraceStartup("asset-catalog-and-bundles", elapsed);
await EnsureLiveDocumentsAsync(cancellationToken);
TraceStartup("subscriptions", elapsed);
_commandOutbox = new EveUnityCultMeshCommandOutbox(
SendCommandAsync,
ContinuousCommandKey,
ForgetPendingCommand);
_bootstrapped = true;
}
catch (Exception error) when (error is IOException || error is SocketException || error is TimeoutException)
{
throw new InvalidOperationException(
$"CultMesh provider '{_providerId}' bootstrap through target '{_target}' failed.",
error);
}
}
private void EnsurePrepared()
{
if (!_bootstrapped)
throw new InvalidOperationException(
"The EveUnity CultMesh transport is not prepared. Await PrepareAsync before mounting or connecting it.");
}
private static void TraceStartup(string phase, Stopwatch elapsed)
{
if (string.Equals(Environment.GetEnvironmentVariable("EVEUNITY_TRACE_STARTUP_PHASES"), "1", StringComparison.Ordinal))
Debug.Log($"EveUnity startup phase {phase} took {elapsed.Elapsed.TotalMilliseconds:0.###}ms.");
elapsed.Restart();
}
private static string FindComponentProp(EveSurfaceComponent component, string key)
{
var value = component.GetProp(key);
if (!string.IsNullOrWhiteSpace(value))
return value;
foreach (var child in component.Children)
{
value = FindComponentProp(child, key);
if (!string.IsNullOrWhiteSpace(value))
return value;
}
return "";
}
public void PumpLiveEvents()
{
while (_liveDocuments.TryDequeue(out var document))
{
if (document is PendingEntityGeneration entityGeneration)
PublishEntityView(entityGeneration.View, entityGeneration.Publication);
else if (document is PendingRealtimeEntityFrame realtimeFrame)
PublishPendingRealtimeEntityFrame(realtimeFrame.BodyId);
else if (document is EveFieldsSplatsDocument fields)
FieldsSplatsAvailable?.Invoke(fields);
else if (document is PendingSurfaceDocument surface)
{
if (string.Equals(surface.RecordKey, _advertisedSurface?.RecordRef, StringComparison.Ordinal))
PublishBaseSurface(surface.Document);
else
PublishEmbeddedSurface(surface.RecordKey, surface.Document);
}
else if (document is EveInputCapabilityDocument inputCapability)
CurrentInputCapability = inputCapability;
else if (document is EveAssetCatalogDocument assetCatalog)
QueueAssetCatalogUpdate(CurrentAssetSourceIdentity, assetCatalog);
else if (document is EveCommandReceiptDocument receipt)
PublishReceipt(receipt);
else if (document is Exception error)
throw error;
}
PumpMappedEntityFrame();
}
private void QueueEntityView(EveEntitySoaViewDocument document)
{
TraceHotState($"layout epoch={document.ProducerEpoch} sequence={document.Sequence} identities={document.Identities?.Length ?? 0}");
_latestEntityLayout = document;
var publication = _latestEntityPublication;
if (publication != null && PublicationMatchesLayout(publication, document))
QueueEntityGeneration(document, publication);
}
private void QueueBodyPublication(CultMeshBodyPublicationDocument publication)
{
_latestEntityPublication = publication;
var layout = _latestEntityLayout;
if (layout == null || layout.Buffers == null || layout.Buffers.Length == 0 ||
!string.Equals(layout.Buffers[0].BufferId, publication.BodyId, StringComparison.Ordinal))
{
TraceHotState($"publication skipped body={publication.BodyId} sequence={publication.Sequence} layout={(layout == null ? "missing" : "incompatible")}");
return;
}
TraceHotState($"publication body={publication.BodyId} epoch={publication.ProducerEpoch} sequence={publication.Sequence} plane={string.Join(",", publication.Representations.Select(value => value.TransportKind))}");
var generation = PublicationMatchesLayout(publication, layout)
? layout
: MaterializeEntityGeneration(layout, publication.ProducerEpoch, publication.Sequence);
QueueEntityGeneration(generation, publication);
}
private void QueueEntityGeneration(
EveEntitySoaViewDocument document,
CultMeshBodyPublicationDocument publication)
{
if (document.ProducerEpoch < _lastQueuedEntityViewEpoch ||
(document.ProducerEpoch == _lastQueuedEntityViewEpoch &&
document.Sequence <= _lastQueuedEntityViewSequence))
return;
_lastQueuedEntityViewEpoch = document.ProducerEpoch;
_lastQueuedEntityViewSequence = document.Sequence;
_liveDocuments.Enqueue(new PendingEntityGeneration(document, publication));
}
private static bool PublicationMatchesLayout(
CultMeshBodyPublicationDocument publication,
EveEntitySoaViewDocument layout) =>
publication.ProducerEpoch == layout.ProducerEpoch &&
publication.Sequence == layout.Sequence;
private sealed class PendingEntityGeneration
{
public PendingEntityGeneration(
EveEntitySoaViewDocument view,
CultMeshBodyPublicationDocument publication)
{
View = view;
Publication = publication;
}
public EveEntitySoaViewDocument View { get; }
public CultMeshBodyPublicationDocument Publication { get; }
}
private static EveEntitySoaViewDocument MaterializeEntityGeneration(
EveEntitySoaViewDocument layout,
long producerEpoch,
long sequence)
{
return new EveEntitySoaViewDocument
{
Schema = layout.Schema,
ProviderId = layout.ProviderId,
ViewId = layout.ViewId,
PublishedAtUtc = DateTimeOffset.UtcNow.ToString("O"),
BodySchemaId = layout.BodySchemaId,
LayoutVersion = layout.LayoutVersion,
ProducerEpoch = producerEpoch,
Sequence = sequence,
Capacity = layout.Capacity,
Buffers = layout.Buffers,
Columns = layout.Columns,
DirtyRanges = (layout.DirtyRanges ?? Array.Empty<EveEntitySoaDirtyRange>())
.Select(range => new EveEntitySoaDirtyRange
{
ColumnId = range.ColumnId,
StartIndex = range.StartIndex,
Count = range.Count,
Sequence = sequence
})
.ToArray(),
RenderGroups = layout.RenderGroups,
Identities = layout.Identities,
FrameId = sequence
};
}
public void SubmitCommand(EveSurfaceCommandRequest request)
{
if (request == null) throw new ArgumentNullException(nameof(request));
EnsurePrepared();
EnsurePresentationWritable();
var interaction = RequireWorldInteraction();
if (string.IsNullOrWhiteSpace(interaction.CommandRecordRef))
throw new InvalidOperationException("The provider advertisement does not publish a command record reference.");
if (!string.Equals(request.ProviderId, _providerId, StringComparison.Ordinal) ||
!string.Equals(request.SurfaceId, _surfaceId, StringComparison.Ordinal))
{
throw new InvalidOperationException("The command does not target the connected provider surface.");
}
var commandId = request.CommandId;
if (string.IsNullOrWhiteSpace(commandId))
throw new InvalidOperationException("Eve command invocations require an idempotency key.");
lock (_pendingCommands)
{
if (_pendingCommands.ContainsKey(commandId))
throw new InvalidOperationException($"Eve command '{commandId}' is already pending.");
_pendingCommands.Add(commandId, request);
}
try { _commandOutbox!.Enqueue(request); }
catch
{
ForgetPendingCommand(commandId);
throw;
}
}
private Task SendCommandAsync(EveSurfaceCommandRequest request, CancellationToken cancellationToken)
{
return SendCommandWithReceiptLeaseAsync(request, cancellationToken);
}
private async Task SendCommandWithReceiptLeaseAsync(
EveSurfaceCommandRequest request,
CancellationToken cancellationToken)
{
await EnsureReceiptSubscriptionAsync(request.CommandId, cancellationToken).ConfigureAwait(false);
var interaction = RequireWorldInteraction();
var recordKey = ChildRecordKey(interaction.CommandRecordRef, request.CommandId);
await _meshClient!.SubmitDocumentAsync(
_target,
recordKey,
request,
_runtimeId,
"eve-unity",
cancellationToken)
.ConfigureAwait(false);
}
private string? ContinuousCommandKey(EveSurfaceCommandRequest request)
{
if (!request.PayloadFields.TryGetValue("commandId", out var commandId) ||
!_continuousCommandIds.Contains(commandId))
return null;
request.PayloadFields.TryGetValue("entityId", out var entityId);
return commandId + "\u001f" + (entityId ?? "");
}
private void ForgetPendingCommand(string commandId)
{
Task<ReceiptSubscription>? subscription = null;
lock (_pendingCommands)
{
_pendingCommands.Remove(commandId);
if (_receiptSubscriptions.TryGetValue(commandId, out subscription))
_receiptSubscriptions.Remove(commandId);
}
if (subscription != null) DisposeReceiptSubscription(subscription);
}
public void Dispose()
{
_disposed = true;
_lifetime.Cancel();
_commandOutbox?.Dispose();
_commandOutbox = null;
_assetGeneration.Dispose();
_mappedEntityFrameCursor?.Dispose();
_mappedEntityFrameCursor = null;
_mappedEntityFrameContract = null;
_realtimeLifetime?.Cancel();
_surfaceAssetCandidateLifetime?.Cancel();
_surfaceAssetCandidateLifetime?.Dispose();
_surfaceAssetCandidateLifetime = null;
_realtimeSession?.Dispose();
_realtimeSession = null;
_realtimePump = null;
_realtimeLifetime?.Dispose();
_realtimeLifetime = null;
DisposeLiveDocuments();
_contentState?.Dispose();
_contentState = null;
_meshClient?.Dispose();
_meshClient = null;
_baseSurface = null;
_embeddedSurfaces.Clear();
lock (_pendingCommands)
{
_pendingCommands.Clear();
foreach (var subscription in _receiptSubscriptions.Values)
DisposeReceiptSubscription(subscription);
_receiptSubscriptions.Clear();
}
lock (_presentationFinalityGate)
{
_deferredTerminalReceipts.Clear();
_presentationBarrierVersion = -1;
}
_lifetime.Dispose();
}
public GameObject? ResolvePrefab(EveUnityPlayableWorldAssetBinding asset)
{
if (asset == null) throw new ArgumentNullException(nameof(asset));
EnsureAssetPrepared(asset.AssetRef);
return _assetGeneration.Prefabs.TryGetValue(asset.AssetRef, out var prefab) ? prefab : null;
}
public UnityEngine.Object? ResolveAsset(EveUnityPlayableWorldAssetBinding asset, Type assetType)
{
if (asset == null) throw new ArgumentNullException(nameof(asset));
if (assetType == null) throw new ArgumentNullException(nameof(assetType));
EnsureAssetPrepared(asset.AssetRef);
return _assetGeneration.NativeAssets.TryGetValue(asset.AssetRef, out var value) && assetType.IsInstanceOfType(value)
? value : null;
}
private void EnsureAssetPrepared(string assetRef)
{
EnsurePrepared();
if (_assetGeneration.AssetSelections.ContainsKey(assetRef) &&
!_assetGeneration.NativeAssets.ContainsKey(assetRef))
throw new InvalidOperationException(
$"Provider asset '{assetRef}' was not materialized during asynchronous preparation.");
}
public bool TryResolveAssetMetadata(
EveUnityPlayableWorldAssetBinding asset,
out IReadOnlyDictionary<string, string> metadata)
{
if (asset == null) throw new ArgumentNullException(nameof(asset));
return _assetGeneration.NativeAssetMetadata.TryGetValue(asset.AssetRef, out metadata!);
}
public bool TryGetRenderChannelLayer(string channel, out int layer)
{
return _assetGeneration.RenderChannelLayers.TryGetValue(channel ?? "", out layer);
}
private void EnsureOpen()
{
if (_meshClient != null)
return;
_meshClient = CreateMeshClient(new[] { _rendezvousEndpoint }, _authorityTrust);
}
private CultMeshClient CreateMeshClient(
IReadOnlyList<string> rendezvousEndpoints,
CultMeshAuthorityTrustPolicy authorityTrust)
{
return new CultMeshClient(new CultMeshClientOptions
{
RendezvousEndpoints = rendezvousEndpoints,
Discovery = EveUnityCultMeshConnectivity.Discovery(),
Sessions = new CultMeshSessionManagerOptions
{
Trust = authorityTrust ?? throw new ArgumentNullException(nameof(authorityTrust))
},
Connectors = EveUnityCultMeshConnectivity.SchemaConnectors(),
ContentConnectors = EveUnityCultMeshConnectivity.ContentConnectors(),
RealtimeConnectors = new ICultMeshRealtimeTransportConnector[]
{
new CultMeshNativeQuicRealtimeTransportConnector()
}
});
}
private CultMeshClient AssetMeshClient(AssetGeneration? generation = null) =>
(generation ?? _assetGeneration).MeshClient ??
_meshClient ?? throw new InvalidOperationException("The CultMesh client is not open.");
private async Task ResolveAdvertisementAsync(
bool forceRefresh = false,
CancellationToken cancellationToken = default)
{
if (!forceRefresh && _advertisement != null && _advertisedSurface != null)
return;
using var lease = await _meshClient!
.LeaseCollectionAsync<EveProviderAdvertisementDocument>(_target, cancellationToken);
var documents = await lease.Handle.LatestAsync();
_advertisement = documents.FirstOrDefault(document =>
string.Equals(document.ProviderId, _providerId, StringComparison.Ordinal))
?? throw new InvalidOperationException($"Provider '{_providerId}' did not publish an Eve advertisement.");
_advertisedSurface = _advertisement.Surfaces.FirstOrDefault(surface =>
string.Equals(surface.SurfaceId, _surfaceId, StringComparison.Ordinal))
?? throw new InvalidOperationException($"Provider '{_providerId}' did not advertise surface '{_surfaceId}'.");
if (!string.Equals(_advertisedSurface.Transport, "cultmesh-record", StringComparison.Ordinal))
throw new InvalidOperationException("EveUnity CultMesh transport requires a cultmesh-record surface advertisement.");
if (string.IsNullOrWhiteSpace(_advertisedSurface.RecordRef))
throw new InvalidOperationException("The provider surface advertisement does not publish a record reference.");
}
private CultMeshBodyPublicationResolver CreateBodyResolver()
{
var producerIds = RequireAdvertisedBodyProducerIds(_advertisement);
if (string.IsNullOrWhiteSpace(_advertisement!.ServiceId))
throw new InvalidOperationException(
$"Eve provider '{_advertisement.ProviderId}' has no service-instance identity for body transport.");
var mappedRoot = _cachePath;
var networkBodies = _meshClient!.BodyProvider(
_advertisement.ProviderId,
_target,
new CultMeshSessionBodyProviderOptions { ResponseTimeout = TimeSpan.FromSeconds(2) });
return new CultMeshBodyPublicationResolver(new CultMeshBodyTransportService(
new ICultMeshBodyTransportAdapter[]
{
new CultMeshSharedMemoryBodyAdapter(),
new CultMeshMappedBodyAdapter(mappedRoot),
new CultMeshNetworkBodyAdapter(networkBodies)
},
(candidateProducerId, _) => IsAdvertisedBodyProducer(producerIds, candidateProducerId)));
}
private static bool IsAdvertisedBodyProducer(
IReadOnlyList<string> advertisedProducerIds,
string candidateProducerId) =>
advertisedProducerIds.Any(producerId =>
string.Equals(candidateProducerId, producerId, StringComparison.Ordinal));
private static IReadOnlyList<string> RequireAdvertisedBodyProducerIds(EveProviderAdvertisementDocument? advertisement)
{
if (advertisement == null)
throw new InvalidOperationException("The Eve provider advertisement must be resolved before body transport authorization.");
var producerIds = advertisement.AuthorizedBodyProducerIds
.Where(producerId => !string.IsNullOrWhiteSpace(producerId))
.Distinct(StringComparer.Ordinal)
.ToArray();
if (producerIds.Length == 0)
throw new InvalidOperationException(
$"Eve provider '{advertisement.ProviderId}' does not advertise an authorized body producer.");
return producerIds;
}
private static string NormalizeContentHash(string value)
{
if (string.IsNullOrWhiteSpace(value))
throw new InvalidDataException("CultMesh content hash is missing.");
var normalized = value.StartsWith("sha256:", StringComparison.OrdinalIgnoreCase)
? value.Substring("sha256:".Length)
: value;
return normalized.ToLowerInvariant();
}
private void PublishEntityView(
EveEntitySoaViewDocument document,
CultMeshBodyPublicationDocument publication)
{
EnsurePrepared();
if (!string.Equals(document.ProviderId, _advertisement!.ProviderId, StringComparison.Ordinal))
throw new UnauthorizedAccessException(
$"Entity layout provider '{document.ProviderId}' does not match advertised Eve provider '{_advertisement.ProviderId}'.");
if (document.Buffers == null || document.Buffers.Length == 0)
throw new InvalidOperationException("Entity layout does not name a primary logical buffer.");
var handle = BodyPublicationHandle(document);
handle.Validate(publication);
var now = DateTimeOffset.UtcNow;
if (!IsPublicationLive(publication, now))
return;
EnsureMappedEntityFrameCursor(publication);
if (_mappedEntityFrameCursor != null)
return;
EnsureRealtimeEntityState();
}
private void EnsureMappedEntityFrameCursor(CultMeshBodyPublicationDocument publication)
{
var descriptor = (publication.Representations ?? Array.Empty<CultMeshBodyDescriptor>())
.FirstOrDefault(CultMeshMappedFrameBodyCursor.CanOpen);
if (descriptor == null)
{
_mappedEntityFrameCursor?.Dispose();
_mappedEntityFrameCursor = null;
_mappedEntityFrameContract = null;
return;
}
var current = _mappedEntityFrameContract;
if (current != null &&
string.Equals(FrameCapabilityIdentity(current.CapabilityToken),
FrameCapabilityIdentity(descriptor.CapabilityToken), StringComparison.Ordinal) &&
string.Equals(current.BodyId, descriptor.BodyId, StringComparison.Ordinal) &&
string.Equals(current.SchemaId, descriptor.SchemaId, StringComparison.Ordinal) &&
current.LayoutVersion == descriptor.LayoutVersion &&
current.Capacity == descriptor.Capacity &&
current.ProducerEpoch == descriptor.ProducerEpoch &&
current.ByteSize == descriptor.ByteSize)
return;
_mappedEntityFrameCursor?.Dispose();
try
{
_mappedEntityFrameCursor = new CultMeshMappedFrameBodyCursor(descriptor);
_mappedEntityFrameContract = descriptor;
TraceHotState(
$"mapped frame cursor body={descriptor.BodyId} epoch={descriptor.ProducerEpoch} sequence={descriptor.Sequence}");
}
catch (Exception error) when (
error is IOException ||
error is UnauthorizedAccessException ||
error is InvalidOperationException)
{
_mappedEntityFrameCursor = null;
_mappedEntityFrameContract = null;
TraceHotState($"mapped frame unavailable; selecting remote realtime plane: {error.Message}");
}
}
private void EnsureRealtimeEntityState()
{
if (_realtimePump != null)
return;
if (_advertisement == null || string.IsNullOrWhiteSpace(_advertisement.VerseId))
throw new InvalidOperationException(
$"Eve provider '{_providerId}' does not advertise the Verse identity required for realtime state.");
_realtimeLifetime = new CancellationTokenSource();
if (!string.Equals(_advertisement.VerseId, _target.VerseId, StringComparison.Ordinal))
throw new InvalidOperationException(
$"Eve provider '{_providerId}' advertisement Verse '{_advertisement.VerseId}' does not match selected Verse '{_target.VerseId}'.");
_realtimePump = Task.Run(() => PumpRealtimeEntityStateAsync(_realtimeLifetime.Token));
}
private async Task PumpRealtimeEntityStateAsync(CancellationToken cancellationToken)
{
try
{
_realtimeSession = await _meshClient!
.ConnectRealtimeAsync(_target, cancellationToken)
.ConfigureAwait(false);
TraceHotState($"realtime state connected transport={_realtimeSession.TransportId} target={_target}");
while (!cancellationToken.IsCancellationRequested)
{
var frame = await _realtimeSession.ReceiveAsync(cancellationToken).ConfigureAwait(false);
EnqueueRealtimeEntityFrame(frame);
}
}
catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
{
}
catch (ObjectDisposedException) when (_disposed)
{
}
catch (Exception error)
{
_liveDocuments.Enqueue(error);
}
}
private void EnqueueRealtimeEntityFrame(CultMeshRealtimeFrame frame)
{
if (frame == null)
throw new ArgumentNullException(nameof(frame));
lock (_realtimeFrameGate)
{
if (_latestRealtimeFrames.TryGetValue(frame.BodyId, out var current) &&
(frame.ProducerEpoch < current.ProducerEpoch ||
(frame.ProducerEpoch == current.ProducerEpoch && frame.Sequence <= current.Sequence)))
return;
_latestRealtimeFrames[frame.BodyId] = frame;
if (_queuedRealtimeFrameBodies.Add(frame.BodyId))
_liveDocuments.Enqueue(new PendingRealtimeEntityFrame(frame.BodyId));
}
}
private void PublishPendingRealtimeEntityFrame(string bodyId)
{
CultMeshRealtimeFrame? frame;
lock (_realtimeFrameGate)
{
_queuedRealtimeFrameBodies.Remove(bodyId);
if (!_latestRealtimeFrames.TryGetValue(bodyId, out frame))
return;
_latestRealtimeFrames.Remove(bodyId);
}
PublishRealtimeEntityFrame(frame);
}
private void PublishRealtimeEntityFrame(CultMeshRealtimeFrame frame)
{
var layout = _latestEntityLayout
?? throw new InvalidOperationException("Realtime entity state arrived before its Eve SoA layout.");
var publication = _latestEntityPublication
?? throw new InvalidOperationException("Realtime entity state arrived before its body publication.");
if (!string.Equals(frame.BodyId, publication.BodyId, StringComparison.Ordinal) ||
!string.Equals(frame.SchemaId, layout.BodySchemaId, StringComparison.Ordinal))
throw new UnauthorizedAccessException("Realtime entity state does not match the advertised Eve body contract.");
if (frame.Delivery != CultMeshRealtimeDelivery.LatestOnly)
throw new InvalidDataException("Playable entity state requires latest-only QUIC delivery.");
if (frame.ProducerEpoch < _lastPresentedEntityViewEpoch ||
(frame.ProducerEpoch == _lastPresentedEntityViewEpoch &&
frame.Sequence <= _lastPresentedEntityViewSequence))
return;
var representation = (publication.Representations ?? Array.Empty<CultMeshBodyDescriptor>())
.FirstOrDefault(value =>
string.Equals(value.BodyId, frame.BodyId, StringComparison.Ordinal) &&
string.Equals(value.SchemaId, frame.SchemaId, StringComparison.Ordinal))
?? throw new InvalidDataException("Realtime entity state has no advertised body representation.");
if (frame.Payload.Length != representation.ByteSize)
throw new InvalidDataException(
$"Realtime entity body size {frame.Payload.Length} does not match advertised size {representation.ByteSize}.");
var generation = MaterializeEntityGeneration(layout, frame.ProducerEpoch, frame.Sequence);
var lease = new RealtimeEntityBodyLease(
new CultMeshBodyDescriptor
{
BodyId = frame.BodyId,
SchemaId = frame.SchemaId,
LayoutVersion = layout.LayoutVersion,
ByteSize = frame.Payload.Length,
Capacity = layout.Capacity,
ProducerEpoch = frame.ProducerEpoch,
Sequence = frame.Sequence,
AccessMode = CultMeshBodyAccessMode.ReadOnly,
Synchronization = CultMeshBodySynchronization.EpochSequence,
LeaseExpiresAtUnixMs = DateTimeOffset.UtcNow.AddSeconds(2).ToUnixTimeMilliseconds(),
TransportKind = CultMeshBodyTransportKind.Network,
CapabilityToken = "authenticated-quic",
SemanticHash = ""
},
frame.Payload.ToArray());
var handler = EntityViewAvailable;
if (handler == null)
{
lease.Dispose();
return;
}
try
{
handler(generation, lease);
_lastPresentedEntityViewEpoch = frame.ProducerEpoch;
_lastPresentedEntityViewSequence = frame.Sequence;
}
catch
{
lease.Dispose();
throw;
}
}
private sealed class PendingRealtimeEntityFrame
{
public PendingRealtimeEntityFrame(string bodyId) =>
BodyId = string.IsNullOrWhiteSpace(bodyId)
? throw new ArgumentException("Body id must be non-empty.", nameof(bodyId))
: bodyId;
public string BodyId { get; }
}
private sealed class RealtimeEntityBodyLease : ICultMeshBodyReadLease
{
private byte[] _bytes;
public RealtimeEntityBodyLease(CultMeshBodyDescriptor descriptor, byte[] bytes)
{
Descriptor = descriptor;
_bytes = bytes;
}
public CultMeshBodyDescriptor Descriptor { get; }
public CultMeshBodyTransportKind TransportKind => CultMeshBodyTransportKind.Network;
public byte ReadByte(long offset) { Validate(offset, 1); return _bytes[(int)offset]; }
public int ReadInt32(long offset) { Validate(offset, 4); return BitConverter.ToInt32(_bytes, (int)offset); }
public long ReadInt64(long offset) { Validate(offset, 8); return BitConverter.ToInt64(_bytes, (int)offset); }
public float ReadSingle(long offset) { Validate(offset, 4); return BitConverter.ToSingle(_bytes, (int)offset); }
public double ReadDouble(long offset) { Validate(offset, 8); return BitConverter.ToDouble(_bytes, (int)offset); }
public int CopyTo(long offset, byte[] destination, int destinationOffset, int count)
{
Validate(offset, count);
Buffer.BlockCopy(_bytes, (int)offset, destination, destinationOffset, count);
return count;
}
public void Dispose() => _bytes = Array.Empty<byte>();
private void Validate(long offset, int count)
{
if (offset < 0 || count < 0 || offset > _bytes.LongLength - count)
throw new ArgumentOutOfRangeException(nameof(offset));
}
}
private void PumpMappedEntityFrame()
{
var cursor = _mappedEntityFrameCursor;
var layout = _latestEntityLayout;
if (cursor == null || layout == null || !cursor.TryAcquireLatest(out var lease))
return;
var descriptor = lease.Descriptor;
if (descriptor.ProducerEpoch < _lastPresentedEntityViewEpoch ||
(descriptor.ProducerEpoch == _lastPresentedEntityViewEpoch &&
descriptor.Sequence <= _lastPresentedEntityViewSequence))
{
lease.Dispose();
return;
}
var generation = MaterializeEntityGeneration(
layout,
descriptor.ProducerEpoch,
descriptor.Sequence);
var handler = EntityViewAvailable;
if (handler == null)
{
lease.Dispose();
return;
}
try
{
handler(generation, lease);
_lastPresentedEntityViewEpoch = descriptor.ProducerEpoch;
_lastPresentedEntityViewSequence = descriptor.Sequence;
}
catch
{
lease.Dispose();
throw;
}
}
private static string FrameCapabilityIdentity(string capabilityToken)
{
var separator = capabilityToken.LastIndexOf('.');
return separator > 0 ? capabilityToken.Substring(0, separator) : capabilityToken;
}
private static bool IsPublicationLive(
CultMeshBodyPublicationDocument publication,
DateTimeOffset now) =>
publication.LivenessExpiresAtUnixMs > now.ToUnixTimeMilliseconds();
private async Task RefreshSurfaceAsync(CancellationToken cancellationToken)
{
var surface = await _meshClient!
.ReadAsync<EveSurfaceDocument>(_target, _advertisedSurface!.RecordRef, cancellationToken);
PublishBaseSurface(surface);
}
private void PublishBaseSurface(EveSurfaceDocument surface)
{
if (surface == null) throw new ArgumentNullException(nameof(surface));
if (!TryBeginBaseSurfaceCandidate(surface.Version, out var generation))
return;
CancellationToken candidateToken;
lock (_presentationFinalityGate)
{
_surfaceAssetCandidateLifetime?.Cancel();
_surfaceAssetCandidateLifetime?.Dispose();
_surfaceAssetCandidateLifetime = CancellationTokenSource.CreateLinkedTokenSource(_lifetime.Token);
candidateToken = _surfaceAssetCandidateLifetime.Token;
}
if (!_bootstrapped)
{
_baseSurface = surface;
PublishComposedSurface(surface.Version);
return;
}
var source = ResolveAssetSource(surface);
if (string.Equals(source.Identity, CurrentAssetSourceIdentity, StringComparison.Ordinal) &&
(source.RequiredCatalogVersion <= 0 || source.RequiredCatalogVersion == CurrentAssetCatalogVersion))
{
_baseSurface = surface;
PublishComposedSurface(surface.Version);
return;
}
// A surface and its provider-qualified asset catalog are one presentation
// candidate. Keep the previous surface mounted until the candidate assets
// have resolved and preloaded; never lower a remote Verse surface against
// the previous Verse's catalog merely because the surface record arrived first.
BeginPresentationTransition(surface.Version);
_ = RefreshAssetsForSurfaceAsync(surface, source, generation, candidateToken);
}
private bool TryBeginBaseSurfaceCandidate(long version, out long generation)
{
lock (_presentationFinalityGate)
{
generation = -1;
if (version < _highestObservedBaseSurfaceVersion ||
version <= _mountedBaseSurfaceVersion ||
(version == _highestObservedBaseSurfaceVersion &&
_activeBaseSurfaceCandidateVersion == version))
return false;
_highestObservedBaseSurfaceVersion = Math.Max(_highestObservedBaseSurfaceVersion, version);
generation = Interlocked.Increment(ref _surfaceAssetGeneration);
_activeBaseSurfaceCandidateVersion = version;
_activeBaseSurfaceCandidateGeneration = generation;
return true;
}
}
private void RetireFailedBaseSurfaceCandidate(long version, long generation)
{
lock (_presentationFinalityGate)
{
if (_activeBaseSurfaceCandidateVersion != version ||
_activeBaseSurfaceCandidateGeneration != generation)
return;
_activeBaseSurfaceCandidateVersion = -1;
_activeBaseSurfaceCandidateGeneration = -1;
}
}
private void PublishEmbeddedSurface(string recordKey, EveSurfaceDocument surface)
{
if (string.IsNullOrWhiteSpace(recordKey))
throw new InvalidOperationException("An embedded Eve surface update has no record identity.");
_embeddedSurfaces[recordKey] = surface ?? throw new ArgumentNullException(nameof(surface));
PublishComposedSurface();
}
private void PublishComposedSurface(long? committedBaseVersion = null)
{
ApplyPreparedSurface(PrepareComposedSurface(
_baseSurface ?? throw new InvalidOperationException("The base Eve surface is unavailable.")),
committedBaseVersion);
}
private PreparedSurface PrepareComposedSurface(EveSurfaceDocument baseSurface)
{
var surface = ComposeSurface(baseSurface, _embeddedSurfaces);
var interaction = RequireWorldInteraction();
var document = new EveUnitySceneProviderSurfaceDocument(
surface,
new EveUnitySceneProviderSurfaceAdvertisement(
_advertisedSurface.SurfaceId,
_advertisedSurface.SurfaceKind,
new EveUnitySceneWorldInteraction(
interaction.ProjectionKind,
interaction.CommandBoundary,
interaction.ReceiptSchema,
interaction.Ownership)),
_advertisedSurface.RecordRef,
surface.Version);
var lowered = new EveUnitySceneSurfaceLowerer()
.Lower(document.SurfaceDocument, document.AdvertisedSurface);
var continuousCommands = new HashSet<string>(StringComparer.Ordinal);
if (!string.IsNullOrWhiteSpace(lowered.PlayableWorld?.MovementCommand))
continuousCommands.Add(lowered.PlayableWorld.MovementCommand);
if (!string.IsNullOrWhiteSpace(lowered.PlayableWorld?.LookCommand))
continuousCommands.Add(lowered.PlayableWorld.LookCommand);
return new PreparedSurface(document, continuousCommands);
}
private void ApplyPreparedSurface(PreparedSurface prepared, long? committedBaseVersion = null)
{
CurrentSurfaceDocument = prepared.Document;
_continuousCommandIds.Clear();
foreach (var command in prepared.ContinuousCommands)
_continuousCommandIds.Add(command);
SurfaceDocumentAvailable?.Invoke(CurrentSurfaceDocument);
if (committedBaseVersion.HasValue)
CompletePresentationTransition(committedBaseVersion.Value);
}
internal static EveSurfaceDocument ComposeSurface(
EveSurfaceDocument surface,
IReadOnlyDictionary<string, EveSurfaceDocument> embeddedSurfaces)
{
var root = ComposeComponent(surface.Surface.Root, embeddedSurfaces);
var version = embeddedSurfaces.Values.Select(value => value.Version)
.DefaultIfEmpty(surface.Version)
.Append(surface.Version)
.Max();
return new EveSurfaceDocument(
surface.Type,
surface.Schema,
surface.ProviderId,
surface.ProviderKind,
surface.Title,
version,
surface.UpdatedAtUtc,
new EveSurfaceTree(surface.Surface.Id, root, surface.Surface.Styles),
surface.Commands);
}
private static EveSurfaceComponent ComposeComponent(
EveSurfaceComponent component,
IReadOnlyDictionary<string, EveSurfaceDocument> embeddedSurfaces)
{
var children = component.Children.Select(child => ComposeComponent(child, embeddedSurfaces)).ToList();
foreach (var slot in component.EmbeddedDocuments ?? Array.Empty<EveEmbeddedDocumentSlot>())
{
if (!string.Equals(slot.SchemaId, EveSurfaceDocument.SchemaId, StringComparison.Ordinal) ||
!embeddedSurfaces.TryGetValue(slot.DocumentId, out var embedded))
continue;
children.Add(ComposeComponent(embedded.Surface.Root, embeddedSurfaces));
}
return new EveSurfaceComponent(
component.Id,
component.Kind,
component.Props,
children,
component.StateBindingRecords,
component.EmbeddedDocuments,
component.Layout,
component.Style);
}
private async Task EnsureLiveDocumentsAsync(CancellationToken cancellationToken)
{
if (_liveDocumentsReady) return;
DisposeLiveDocuments();
try
{
await OpenLiveDocumentsAsync(cancellationToken);
_liveDocumentsReady = true;
}
catch
{
DisposeLiveDocuments();
throw;
}
}
private async Task OpenLiveDocumentsAsync(CancellationToken cancellationToken)
{
var lowered = new EveUnitySceneSurfaceLowerer()
.Lower(CurrentSurfaceDocument.SurfaceDocument, CurrentSurfaceDocument.AdvertisedSurface);
string entityViewPointer = lowered.PlayableWorld == null
? ""
: lowered.PlayableWorld.EntityViewPointerId;
string entityBodyId = lowered.PlayableWorld == null
? ""
: lowered.PlayableWorld.EntityBodyId;
var fieldRefs = lowered.PlayableWorld == null
? Array.Empty<string>()
: lowered.PlayableWorld.FieldVolumes
.Select(field => field.DocumentRef)
.Where(value => !string.IsNullOrWhiteSpace(value))
.Distinct(StringComparer.Ordinal)
.ToArray();
if (!string.IsNullOrWhiteSpace(entityViewPointer))
{
if (string.IsNullOrWhiteSpace(entityBodyId))
throw new InvalidOperationException(
"The playable world advertises an entity-view pointer without its logical body id.");
_bodyResolver ??= CreateBodyResolver();
await LeaseDocumentAsync<EveEntitySoaViewDocument>(entityViewPointer, QueueEntityView, cancellationToken);
await LeaseCollectionAsync<CultMeshBodyPublicationDocument>(publication =>
{
if (string.Equals(publication.BodyId, entityBodyId, StringComparison.Ordinal))
QueueBodyPublication(publication);
}, cancellationToken);
}
foreach (var fieldRef in fieldRefs)
await LeaseDocumentAsync<EveFieldsSplatsDocument>(
fieldRef,
fields => _liveDocuments.Enqueue(fields),
cancellationToken);
await LeaseDocumentAsync<EveSurfaceDocument>(
_advertisedSurface!.RecordRef,
surface => _liveDocuments.Enqueue(new PendingSurfaceDocument(_advertisedSurface.RecordRef, surface)),
cancellationToken,
publishInitial: false);
var embeddedSlots = EnumerateEmbeddedDocuments(CurrentSurfaceDocument.SurfaceDocument.Surface.Root)
.Where(slot => string.Equals(slot.SchemaId, EveSurfaceDocument.SchemaId, StringComparison.Ordinal))
.Where(slot => !string.IsNullOrWhiteSpace(slot.DocumentId))
.GroupBy(slot => slot.DocumentId, StringComparer.Ordinal)
.Select(group => group.First())
.ToArray();
foreach (var slot in embeddedSlots)
{
await LeaseDocumentAsync<EveSurfaceDocument>(
slot.DocumentId,
surface => _liveDocuments.Enqueue(new PendingSurfaceDocument(slot.DocumentId, surface)),
cancellationToken);
}
var inputCapabilityRef = FindComponentProp(
CurrentSurfaceDocument.SurfaceDocument.Surface.Root,
"inputCapability");
if (!string.IsNullOrWhiteSpace(inputCapabilityRef))
{
await LeaseDocumentAsync<EveInputCapabilityDocument>(
inputCapabilityRef,
document => _liveDocuments.Enqueue(document),
cancellationToken);
}
var interaction = RequireWorldInteraction();
if (!string.Equals(interaction.ReceiptSchema, EveCommandReceiptDocument.SchemaId, StringComparison.Ordinal))
throw new InvalidOperationException(
$"The provider advertises receipt schema '{interaction.ReceiptSchema}', expected '{EveCommandReceiptDocument.SchemaId}'.");
if (string.IsNullOrWhiteSpace(interaction.ReceiptRecordRef))
throw new InvalidOperationException("The provider advertisement does not publish a receipt record reference.");
}
private Task<ReceiptSubscription> EnsureReceiptSubscriptionAsync(
string commandId,
CancellationToken cancellationToken)
{
Task<ReceiptSubscription> subscription;
lock (_pendingCommands)
{
if (_receiptSubscriptions.TryGetValue(commandId, out subscription!)) return subscription;
subscription = OpenReceiptSubscriptionAsync(commandId, cancellationToken);
_receiptSubscriptions.Add(commandId, subscription);
}
return RemoveFailedReceiptSubscriptionAsync(commandId, subscription);
}
private async Task<ReceiptSubscription> RemoveFailedReceiptSubscriptionAsync(
string commandId,
Task<ReceiptSubscription> subscription)
{
try { return await subscription.ConfigureAwait(false); }
catch
{
lock (_pendingCommands)
{
if (_receiptSubscriptions.TryGetValue(commandId, out var current) &&
ReferenceEquals(current, subscription))
_receiptSubscriptions.Remove(commandId);
}
throw;
}
}
private async Task<ReceiptSubscription> OpenReceiptSubscriptionAsync(
string commandId,
CancellationToken cancellationToken)
{
var recordKey = ChildRecordKey(RequireWorldInteraction().ReceiptRecordRef, commandId);
var lease = await _meshClient!.LeaseDocumentAsync<EveCommandReceiptDocument>(
_target,
recordKey,
cancellationToken)
.ConfigureAwait(false);
IDisposable? watch = null;
try
{
watch = lease.Handle.Watch(receipt => QueueReceipt(commandId, receipt));
try { QueueReceipt(commandId, await lease.Handle.LatestAsync().ConfigureAwait(false)); }
catch (KeyNotFoundException) { }
return new ReceiptSubscription(lease, watch);
}
catch
{
watch?.Dispose();
lease.Dispose();
throw;
}
}
private void QueueReceipt(string expectedCommandId, EveCommandReceiptDocument receipt)
{
if (receipt == null) return;
lock (_pendingCommands)
{
if (!_pendingCommands.TryGetValue(expectedCommandId, out var request) ||
!ReceiptMatches(request, receipt))
return;
}
_liveDocuments.Enqueue(receipt);
}
private static void DisposeReceiptSubscription(Task<ReceiptSubscription> subscription)
{
if (subscription.Status == TaskStatus.RanToCompletion)
subscription.Result.Dispose();
else
_ = subscription.ContinueWith(
completed => { if (completed.Status == TaskStatus.RanToCompletion) completed.Result.Dispose(); },
CancellationToken.None,
TaskContinuationOptions.ExecuteSynchronously,
TaskScheduler.Default);
}
private void DisposeLiveDocuments()
{
foreach (var watch in _documentWatches) watch.Dispose();
_documentWatches.Clear();
foreach (var lease in _documentLeases) lease.Dispose();
_documentLeases.Clear();
_liveDocumentsReady = false;
}
private async Task LeaseDocumentAsync<TDocument>(
string recordKey,
Action<TDocument> publish,
CancellationToken cancellationToken,
bool publishInitial = true)
where TDocument : class
{
var lease = await _meshClient!.LeaseDocumentAsync<TDocument>(_target, recordKey, cancellationToken);
_documentLeases.Add(lease);
if (publishInitial) publish(await lease.Handle.LatestAsync());
_documentWatches.Add(lease.Handle.Watch(publish));
}
private async Task LeaseCollectionAsync<TDocument>(
Action<TDocument> publish,
CancellationToken cancellationToken,
bool includeInitialSnapshot = true)
where TDocument : class
{
var lease = await _meshClient!.LeaseCollectionAsync<TDocument>(
_target,
includeInitialSnapshot,
cancellationToken);
_documentLeases.Add(lease);
if (includeInitialSnapshot)
foreach (var document in await lease.Handle.LatestAsync())
publish(document);
_documentWatches.Add(lease.Handle.WatchChanges(change =>
{
if (change.Document != null) publish(change.Document);
}));
}
private static IEnumerable<EveEmbeddedDocumentSlot> EnumerateEmbeddedDocuments(EveSurfaceComponent component)
{
foreach (var slot in component.EmbeddedDocuments ?? Array.Empty<EveEmbeddedDocumentSlot>())
yield return slot;
foreach (var child in component.Children ?? Array.Empty<EveSurfaceComponent>())
foreach (var slot in EnumerateEmbeddedDocuments(child))
yield return slot;
}
private sealed class PendingSurfaceDocument
{
public PendingSurfaceDocument(string recordKey, EveSurfaceDocument document)
{
RecordKey = recordKey ?? "";
Document = document ?? throw new ArgumentNullException(nameof(document));
}
public string RecordKey { get; }
public EveSurfaceDocument Document { get; }
}
private sealed class PreparedSurface
{
public PreparedSurface(
EveUnitySceneProviderSurfaceDocument document,
IReadOnlyCollection<string> continuousCommands)
{
Document = document;
ContinuousCommands = continuousCommands;
}
public EveUnitySceneProviderSurfaceDocument Document { get; }
public IReadOnlyCollection<string> ContinuousCommands { get; }
}
private static void TraceHotState(string message)
{
if (string.Equals(Environment.GetEnvironmentVariable("AETHERIA_TRACE_CLIENT_RUDP"), "1", StringComparison.Ordinal))
Debug.Log($"EveUnity CultMesh hot state: {message}");
}
private async Task RefreshAssetCatalogAsync(CancellationToken cancellationToken)
{
var source = ResolveAssetSource(
_baseSurface ?? throw new InvalidOperationException("The provider surface must be available before its assets are resolved."));
if (string.IsNullOrWhiteSpace(source.ManifestRecordRef))
return;
var candidate = await BuildAssetGenerationAsync(source, cancellationToken);
CommitAssetGeneration(candidate);
}
private async Task RefreshAssetsForSurfaceAsync(
EveSurfaceDocument surface,
AssetSource source,
long generation,
CancellationToken cancellationToken)
{
Exception? finalError = null;
Interlocked.Exchange(ref _lastAssetPresentationAttemptCount, 0);
for (var attempt = 1; attempt <= AssetPresentationAttemptLimit; attempt++)
{
Interlocked.Exchange(ref _lastAssetPresentationAttemptCount, attempt);
try
{
if (generation != Interlocked.Read(ref _surfaceAssetGeneration))
return;
await _assetGenerationGate.WaitAsync(cancellationToken);
try
{
if (generation != Interlocked.Read(ref _surfaceAssetGeneration))
return;
var candidate = await BuildAssetGenerationAsync(source, cancellationToken);
if (generation != Interlocked.Read(ref _surfaceAssetGeneration))
{
candidate.Dispose();
return;
}
CommitAssetGeneration(candidate, surface);
return;
}
finally
{
_assetGenerationGate.Release();
}
}
catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
{
return;
}
catch (Exception error)
{
finalError = error;
if (generation != Interlocked.Read(ref _surfaceAssetGeneration))
return;
if (attempt < AssetPresentationAttemptLimit)
{
try
{
await Task.Delay(TimeSpan.FromMilliseconds(100 * attempt), cancellationToken);
}
catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
{
return;
}
}
}
}
RetireFailedBaseSurfaceCandidate(surface.Version, generation);
_liveDocuments.Enqueue(finalError ?? new InvalidOperationException(
$"Eve surface {surface.Version} asset preparation exhausted its retry policy."));
}
private AssetSource ResolveAssetSource(EveSurfaceDocument surface)
{
var world = FindWorldScene(surface.Surface.Root);
var manifestRecordRef = world?.GetProp("assetManifest") ?? "";
if (string.IsNullOrWhiteSpace(manifestRecordRef))
manifestRecordRef = RequireWorldInteraction().AssetManifestRecordRef;
var providerId = world?.GetProp("assetProviderId") ?? "";
var verseId = world?.GetProp("assetVerseId") ?? "";
var authorityRuntimeId = world?.GetProp("assetAuthorityRuntimeId") ?? "";
var requiredCatalogVersion = long.TryParse(
world?.GetProp("assetCatalogVersion"),
out var parsedCatalogVersion)
? Math.Max(0, parsedCatalogVersion)
: 0;
var rendezvousEndpoints = ParseEndpointList(world?.GetProp("assetRendezvousEndpoints") ?? "");
var hasQualifiedSource = !string.IsNullOrWhiteSpace(providerId) ||
!string.IsNullOrWhiteSpace(verseId) ||
!string.IsNullOrWhiteSpace(authorityRuntimeId);
if (!hasQualifiedSource)
return new AssetSource(
_target,
_providerId,
manifestRecordRef,
Array.Empty<string>(),
requiredCatalogVersion);
if (string.IsNullOrWhiteSpace(providerId) || string.IsNullOrWhiteSpace(verseId) ||
string.IsNullOrWhiteSpace(authorityRuntimeId))
throw new InvalidOperationException(
"A provider-qualified Eve asset source requires assetProviderId, assetVerseId, and assetAuthorityRuntimeId.");
return new AssetSource(
new CultMeshSessionTarget(verseId, authorityRuntimeId),
providerId,
manifestRecordRef,
rendezvousEndpoints,
requiredCatalogVersion);
}
private async Task<AssetGeneration> BuildAssetGenerationAsync(
AssetSource source,
CancellationToken cancellationToken)
{
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
var crossTarget = IsCrossTarget(source);
var endpoints = AssetRendezvousEndpoints(source, crossTarget);
var candidate = new AssetGeneration(
source,
source.Identity,
catalogVersion: -1,
crossTarget || source.RendezvousEndpoints.Count > 0
? CreateMeshClient(
endpoints,
AssetAuthorityTrust(source))
: null);
try
{
var catalog = await AttachAssetCatalogSubscriptionAsync(
candidate,
source.RequiredCatalogVersion,
cancellationToken);
ConfigureAssetCatalog(candidate, catalog);
ReuseCompatibleBundles(_assetGeneration, candidate);
await PreloadAssetsAsync(candidate, cancellationToken);
if (source.RequiredCatalogVersion > 0)
return candidate;
var latest = await candidate.CatalogLease!.Handle.LatestAsync();
candidate.ObserveCatalog(latest);
if (latest.Version != candidate.CatalogVersion)
{
candidate.Dispose();
continue;
}
return candidate;
}
catch
{
candidate.Dispose();
throw;
}
}
}
private bool IsCrossTarget(AssetSource source) =>
!string.Equals(source.Target.VerseId, _target.VerseId, StringComparison.Ordinal) ||
!string.Equals(source.Target.AuthorityRuntimeId, _target.AuthorityRuntimeId, StringComparison.Ordinal);
private CultMeshAuthorityTrustPolicy AssetAuthorityTrust(AssetSource source) =>
IsCrossTarget(source) ? _crossTargetAuthorityTrust : _authorityTrust;
private IReadOnlyList<string> AssetRendezvousEndpoints(AssetSource source, bool crossTarget)
{
if (source.RendezvousEndpoints.Count > 0)
return source.RendezvousEndpoints;
if (crossTarget)
throw new InvalidOperationException(
$"Cross-target asset source '{source.Target.VerseId}/{source.Target.AuthorityRuntimeId}' " +
"must advertise at least one Odin rendezvous endpoint.");
return new[] { _rendezvousEndpoint };
}
private async Task<EveAssetCatalogDocument> AttachAssetCatalogSubscriptionAsync(
AssetGeneration candidate,
long requiredCatalogVersion,
CancellationToken cancellationToken)
{
var lease = await AssetMeshClient(candidate)
.LeaseDocumentAsync<EveAssetCatalogDocument>(
candidate.Source.Target,
candidate.Source.ManifestRecordRef,
cancellationToken);
IDisposable? watch = null;
try
{
var catalog = await lease.Handle.LatestAsync();
candidate.ObserveCatalog(catalog);
if (requiredCatalogVersion > 0)
{
RequireCatalogVersion(catalog, requiredCatalogVersion, candidate.Source.ManifestRecordRef);
candidate.CatalogLease = lease;
return catalog;
}
watch = lease.Handle.Watch(observedCatalog =>
{
var pending = candidate.ObserveCatalog(observedCatalog);
if (pending != null)
QueueAssetCatalogUpdate(candidate.SourceIdentity, pending);
});
candidate.CatalogWatch = watch;
candidate.CatalogLease = lease;
return catalog;
}
catch
{
watch?.Dispose();
lease.Dispose();
throw;
}
}
private static void RequireCatalogVersion(
EveAssetCatalogDocument catalog,
long requiredCatalogVersion,
string manifestRecordRef)
{
if (catalog == null) throw new ArgumentNullException(nameof(catalog));
if (requiredCatalogVersion <= 0 || catalog.Version == requiredCatalogVersion)
return;
throw new InvalidDataException(
$"Asset catalog record '{manifestRecordRef}' contains version {catalog.Version}, " +
$"but the Eve surface requires immutable version {requiredCatalogVersion}.");
}
private void CommitAssetGeneration(AssetGeneration candidate, EveSurfaceDocument? surface = null)
{
PreparedSurface prepared;
try
{
prepared = PrepareComposedSurface(surface ?? _baseSurface ??
throw new InvalidOperationException("The base Eve surface is unavailable."));
}
catch
{
candidate.Dispose();
throw;
}
var previous = _assetGeneration;
previous.TransferSharedBundlesTo(candidate);
_assetGeneration = candidate;
var pendingCatalog = candidate.ActivateCatalogObservation();
if (pendingCatalog != null && candidate.Source.RequiredCatalogVersion <= 0)
QueueAssetCatalogUpdate(candidate.SourceIdentity, pendingCatalog);
if (surface != null)
_baseSurface = surface;
try
{
ApplyPreparedSurface(prepared, surface?.Version);
}
finally
{
previous.Dispose();
}
}
private static void ReuseCompatibleBundles(AssetGeneration current, AssetGeneration candidate)
{
foreach (var pair in candidate.BundleVariants)
{
if (!current.LoadedBundlesByUri.TryGetValue(pair.Key, out var bundle) ||
!current.BundleVariants.TryGetValue(pair.Key, out var existing) ||
!string.Equals(existing.ContentHash, pair.Value.ContentHash, StringComparison.Ordinal) ||
existing.SizeBytes != pair.Value.SizeBytes)
continue;
var selections = candidate.BundleSelections[pair.Key];
if (selections.Any(selection =>
!current.NativeAssets.ContainsKey(selection.Asset.AssetRef)))
continue;
candidate.AssetBundles.Add(bundle);
candidate.BorrowedAssetBundles.Add(bundle);
candidate.LoadedBundlesByUri[pair.Key] = bundle;
candidate.LoadedBundleUris.Add(pair.Key);
foreach (var selection in selections)
{
var value = current.NativeAssets[selection.Asset.AssetRef];
candidate.NativeAssets[selection.Asset.AssetRef] = value;
if (value is GameObject prefab)
candidate.Prefabs[selection.Asset.AssetRef] = prefab;
if (selection.Asset.Metadata.TryGetValue("presentationRole", out var role) &&
!string.IsNullOrWhiteSpace(role))
{
candidate.NativeAssets[role] = value;
if (value is GameObject rolePrefab)
candidate.Prefabs[role] = rolePrefab;
}
}
}
}
private static EveSurfaceComponent? FindWorldScene(EveSurfaceComponent component)
{
if (string.Equals(component.Kind, "world.scene3d", StringComparison.Ordinal) ||
string.Equals(component.Kind, "world", StringComparison.Ordinal))
return component;
foreach (var child in component.Children ?? Array.Empty<EveSurfaceComponent>())
{
var found = FindWorldScene(child);
if (found != null) return found;
}
return null;
}
private static IReadOnlyList<string> ParseEndpointList(string value) =>
(value ?? "")
.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
.Select(endpoint => endpoint.Trim())
.Where(endpoint => endpoint.Length > 0)
.Distinct(StringComparer.Ordinal)
.ToArray();
private static void ConfigureAssetCatalog(AssetGeneration candidate, EveAssetCatalogDocument catalog)
{
var selected = catalog.Assets
.Select(asset => new SelectedAsset(
asset,
asset.Variants.FirstOrDefault(variant =>
string.Equals(variant.RuntimeId, "unity-scene", StringComparison.Ordinal) &&
string.Equals(variant.Platform, CurrentBundlePlatform(), StringComparison.Ordinal))))
.Where(selection => selection.Variant != null)
.ToArray();
if (selected.Length == 0)
{
var advertisedVariants = catalog.Assets
.SelectMany(asset => asset.Variants.Select(variant =>
$"{asset.AssetRef}:{variant.RuntimeId}/{variant.Platform}"))
.ToArray();
throw new InvalidOperationException(
$"Provider asset catalog '{catalog.CatalogId}' has no unity-scene/{CurrentBundlePlatform()} variant. " +
$"Advertised variants: {string.Join(", ", advertisedVariants)}");
}
candidate.SetCatalogVersion(catalog.Version);
ReadCameraPolicies(candidate, selected.Select(selection => selection.Variant!));
foreach (var selection in selected)
{
var variant = selection.Variant!;
candidate.AssetSelections[selection.Asset.AssetRef] = selection;
candidate.BundleVariants[variant.Uri] = variant;
if (!candidate.BundleSelections.TryGetValue(variant.Uri, out var group))
{
group = new List<SelectedAsset>();
candidate.BundleSelections[variant.Uri] = group;
}
group.Add(selection);
var metadata = MergeAssetMetadata(selection.Asset.Metadata, variant.Metadata);
candidate.NativeAssetMetadata[selection.Asset.AssetRef] = metadata;
if (selection.Asset.Metadata.TryGetValue("presentationRole", out var role) &&
!string.IsNullOrWhiteSpace(role))
{
candidate.AssetSelections[role] = selection;
candidate.NativeAssetMetadata[role] = metadata;
}
}
}
private void QueueAssetCatalogUpdate(string sourceIdentity, EveAssetCatalogDocument catalog)
{
if (catalog == null) throw new ArgumentNullException(nameof(catalog));
if (_assetGeneration.Source.RequiredCatalogVersion > 0)
{
_pendingAssetCatalog = null;
return;
}
_pendingAssetCatalog = new PendingAssetCatalogUpdate(
sourceIdentity,
catalog);
if (_assetCatalogUpdateRunning) return;
_assetCatalogUpdateRunning = true;
_ = DrainAssetCatalogUpdatesAsync();
}
private async Task DrainAssetCatalogUpdatesAsync()
{
try
{
while (!_lifetime.IsCancellationRequested)
{
var update = _pendingAssetCatalog;
_pendingAssetCatalog = null;
if (update == null) break;
if (_assetGeneration.Source.RequiredCatalogVersion > 0)
continue;
if (!string.Equals(update.SourceIdentity, CurrentAssetSourceIdentity, StringComparison.Ordinal))
continue;
if (update.Catalog.Version == CurrentAssetCatalogVersion)
continue;
await _assetGenerationGate.WaitAsync(_lifetime.Token);
try
{
if (!string.Equals(update.SourceIdentity, CurrentAssetSourceIdentity, StringComparison.Ordinal) ||
update.Catalog.Version == CurrentAssetCatalogVersion ||
_assetGeneration.Source.RequiredCatalogVersion > 0)
continue;
var currentSource = _assetGeneration.Source;
var source = new AssetSource(
currentSource.Target,
currentSource.ProviderId,
currentSource.ManifestRecordRef,
currentSource.RendezvousEndpoints,
0);
var candidate = await BuildAssetGenerationAsync(source, _lifetime.Token);
if (!string.Equals(update.SourceIdentity, CurrentAssetSourceIdentity, StringComparison.Ordinal) ||
_assetGeneration.Source.RequiredCatalogVersion > 0)
{
candidate.Dispose();
continue;
}
CommitAssetGeneration(candidate);
}
finally
{
_assetGenerationGate.Release();
}
}
}
catch (OperationCanceledException) when (_lifetime.IsCancellationRequested)
{
}
catch (Exception error)
{
_liveDocuments.Enqueue(error);
}
finally
{
_assetCatalogUpdateRunning = false;
if (_pendingAssetCatalog != null && !_lifetime.IsCancellationRequested)
QueueAssetCatalogUpdate(_pendingAssetCatalog.SourceIdentity, _pendingAssetCatalog.Catalog);
}
}
private async Task PreloadAssetsAsync(AssetGeneration candidate, CancellationToken cancellationToken)
{
foreach (var uri in candidate.BundleVariants.Keys.OrderBy(value => value, StringComparer.Ordinal).ToArray())
await EnsureBundleLoadedAsync(candidate, uri, cancellationToken);
}
private async Task EnsureBundleLoadedAsync(
AssetGeneration candidate,
string uri,
CancellationToken cancellationToken)
{
if (candidate.LoadedBundleUris.Contains(uri)) return;
if (!candidate.BundleVariants.TryGetValue(uri, out var variant))
throw new InvalidOperationException($"Provider asset bundle '{uri}' is not present in the selected runtime catalog.");
if (!candidate.LoadingBundleUris.Add(uri))
throw new InvalidOperationException($"Provider asset bundle dependency cycle includes '{uri}'.");
try
{
if (variant.Metadata.TryGetValue("unity.bundleDependencyUris", out var dependencies))
foreach (var dependency in dependencies.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
await EnsureBundleLoadedAsync(candidate, dependency, cancellationToken);
var groupElapsed = Stopwatch.StartNew();
var descriptor = await AssetMeshClient(candidate)
.ReadAsync<CultMeshCdnArtifactManifest>(candidate.Source.Target, uri, cancellationToken);
TraceStartup("asset-manifest", groupElapsed);
var bundle = await LoadVerifiedBundleAsync(candidate, descriptor, variant, cancellationToken);
TraceStartup("asset-transfer-and-bundle-load", groupElapsed);
if (bundle == null)
throw new InvalidOperationException($"Unity could not load provider asset bundle '{uri}'.");
candidate.AssetBundles.Add(bundle);
candidate.LoadedBundlesByUri[uri] = bundle;
var bundleAssetNames = bundle.GetAllAssetNames();
foreach (var selection in candidate.BundleSelections[uri])
{
var bundleAssetName = ResolveBundleAssetName(bundleAssetNames, selection.Variant!.AssetKey);
var value = bundleAssetName == null
? null
: await LoadBundleAssetAsync(bundle, bundleAssetName, selection.Asset.AssetKind, cancellationToken);
if (value == null)
throw new InvalidOperationException(
$"Provider asset '{selection.Asset.AssetRef}' advertises missing Unity bundle asset " +
$"'{selection.Variant.AssetKey}'. Available assets: " + string.Join(", ", bundleAssetNames));
candidate.NativeAssets[selection.Asset.AssetRef] = value;
if (selection.Asset.Metadata.TryGetValue("presentationRole", out var role) &&
!string.IsNullOrWhiteSpace(role))
candidate.NativeAssets[role] = value;
if (value is GameObject prefab)
{
candidate.Prefabs[selection.Asset.AssetRef] = prefab;
if (!string.IsNullOrWhiteSpace(role)) candidate.Prefabs[role] = prefab;
}
}
candidate.LoadedBundleUris.Add(uri);
TraceStartup("bundle-assets", groupElapsed);
}
finally
{
candidate.LoadingBundleUris.Remove(uri);
}
}
private static async Task<UnityEngine.Object?> LoadBundleAssetAsync(
AssetBundle bundle,
string assetName,
string assetKind,
CancellationToken cancellationToken)
{
var request = string.Equals(assetKind, "sprite", StringComparison.Ordinal)
? bundle.LoadAssetAsync<Sprite>(assetName)
: bundle.LoadAssetAsync(assetName);
await AwaitUnityAsync(request, cancellationToken);
return request.asset;
}
private sealed class SelectedAsset
{
public SelectedAsset(EveAssetCatalogEntry asset, EveAssetVariant? variant)
{
Asset = asset;
Variant = variant;
}
public EveAssetCatalogEntry Asset { get; }
public EveAssetVariant? Variant { get; }
}
private sealed class AssetGeneration : IDisposable
{
private readonly object _catalogObservationGate = new object();
private EveAssetCatalogDocument? _latestObservedCatalog;
private bool _catalogObservationActive;
public AssetGeneration(
AssetSource source,
string sourceIdentity,
long catalogVersion,
CultMeshClient? meshClient)
{
Source = source;
SourceIdentity = sourceIdentity ?? "";
CatalogVersion = catalogVersion;
MeshClient = meshClient;
}
public AssetSource Source { get; }
public string SourceIdentity { get; }
public long CatalogVersion { get; private set; }
public CultMeshClient? MeshClient { get; }
public CultMeshDocumentLease<EveAssetCatalogDocument>? CatalogLease { get; set; }
public IDisposable? CatalogWatch { get; set; }
public CultMeshContentTransferService? ContentTransfer { get; set; }
public CultMeshVerifiedBodyMappingBroker? BodyMappings { get; set; }
public CultMeshBodyTransportKind? BodyTransportKind { get; set; }
public Dictionary<string, GameObject> Prefabs { get; } = new Dictionary<string, GameObject>(StringComparer.Ordinal);
public Dictionary<string, UnityEngine.Object> NativeAssets { get; } = new Dictionary<string, UnityEngine.Object>(StringComparer.Ordinal);
public Dictionary<string, IReadOnlyDictionary<string, string>> NativeAssetMetadata { get; } =
new Dictionary<string, IReadOnlyDictionary<string, string>>(StringComparer.Ordinal);
public List<AssetBundle> AssetBundles { get; } = new List<AssetBundle>();
public HashSet<AssetBundle> BorrowedAssetBundles { get; } = new HashSet<AssetBundle>();
public Dictionary<string, AssetBundle> LoadedBundlesByUri { get; } =
new Dictionary<string, AssetBundle>(StringComparer.Ordinal);
public Dictionary<string, SelectedAsset> AssetSelections { get; } =
new Dictionary<string, SelectedAsset>(StringComparer.Ordinal);
public Dictionary<string, List<SelectedAsset>> BundleSelections { get; } =
new Dictionary<string, List<SelectedAsset>>(StringComparer.Ordinal);
public Dictionary<string, EveAssetVariant> BundleVariants { get; } =
new Dictionary<string, EveAssetVariant>(StringComparer.Ordinal);
public HashSet<string> LoadedBundleUris { get; } = new HashSet<string>(StringComparer.Ordinal);
public HashSet<string> LoadingBundleUris { get; } = new HashSet<string>(StringComparer.Ordinal);
public List<ICultMeshBodyReadLease> BodyLeases { get; } = new List<ICultMeshBodyReadLease>();
public Dictionary<string, int> RenderChannelLayers { get; } =
new Dictionary<string, int>(StringComparer.Ordinal);
public void TransferSharedBundlesTo(AssetGeneration next)
{
foreach (var bundle in next.BorrowedAssetBundles)
AssetBundles.Remove(bundle);
next.BorrowedAssetBundles.Clear();
}
public void SetCatalogVersion(long catalogVersion)
{
if (CatalogVersion >= 0 && CatalogVersion != catalogVersion)
throw new InvalidOperationException("An asset generation cannot change its catalog version after configuration.");
CatalogVersion = catalogVersion;
}
public EveAssetCatalogDocument? ObserveCatalog(EveAssetCatalogDocument catalog)
{
lock (_catalogObservationGate)
{
_latestObservedCatalog = catalog ?? throw new ArgumentNullException(nameof(catalog));
return _catalogObservationActive && catalog.Version != CatalogVersion ? catalog : null;
}
}
public EveAssetCatalogDocument? ActivateCatalogObservation()
{
lock (_catalogObservationGate)
{
_catalogObservationActive = true;
return _latestObservedCatalog != null && _latestObservedCatalog.Version != CatalogVersion
? _latestObservedCatalog
: null;
}
}
public void Dispose()
{
CatalogWatch?.Dispose();
CatalogWatch = null;
CatalogLease?.Dispose();
CatalogLease = null;
MeshClient?.Dispose();
foreach (var bundle in AssetBundles)
if (!BorrowedAssetBundles.Contains(bundle))
bundle.Unload(unloadAllLoadedObjects: false);
AssetBundles.Clear();
BorrowedAssetBundles.Clear();
foreach (var lease in BodyLeases)
lease.Dispose();
BodyLeases.Clear();
Prefabs.Clear();
NativeAssets.Clear();
NativeAssetMetadata.Clear();
AssetSelections.Clear();
BundleSelections.Clear();
BundleVariants.Clear();
LoadedBundleUris.Clear();
LoadingBundleUris.Clear();
LoadedBundlesByUri.Clear();
RenderChannelLayers.Clear();
}
}
private static string? ResolveBundleAssetName(IEnumerable<string> bundleAssetNames, string advertisedAssetKey)
{
return bundleAssetNames.FirstOrDefault(assetName =>
string.Equals(assetName, advertisedAssetKey, StringComparison.OrdinalIgnoreCase));
}
private static IReadOnlyDictionary<string, string> MergeAssetMetadata(
IReadOnlyDictionary<string, string> assetMetadata,
IReadOnlyDictionary<string, string> variantMetadata)
{
var merged = new Dictionary<string, string>(StringComparer.Ordinal);
foreach (var pair in assetMetadata) merged[pair.Key] = pair.Value;
foreach (var pair in variantMetadata) merged[pair.Key] = pair.Value;
return merged;
}
private static void ReadCameraPolicies(AssetGeneration candidate, IEnumerable<EveAssetVariant> variants)
{
foreach (var variant in variants)
{
foreach (var pair in variant.Metadata)
{
const string prefix = "renderChannel.";
const string suffix = ".unityLayer";
if (!pair.Key.StartsWith(prefix, StringComparison.Ordinal) ||
!pair.Key.EndsWith(suffix, StringComparison.Ordinal))
continue;
var channel = pair.Key.Substring(prefix.Length, pair.Key.Length - prefix.Length - suffix.Length);
if (!string.IsNullOrWhiteSpace(channel) &&
int.TryParse(pair.Value, out var layer) && layer >= 0 && layer < 32)
candidate.RenderChannelLayers[channel] = layer;
}
}
}
private long CurrentAssetCatalogVersion => _assetGeneration.CatalogVersion;
private string CurrentAssetSourceIdentity => _assetGeneration.SourceIdentity;
private static string CurrentBundlePlatform()
{
return Application.platform == RuntimePlatform.WindowsEditor ||
Application.platform == RuntimePlatform.WindowsPlayer
? "StandaloneWindows64"
: Application.platform.ToString();
}
private CultMeshContentTransferService ContentTransfer(AssetGeneration candidate)
{
if (candidate.ContentTransfer != null)
return candidate.ContentTransfer;
if (_advertisement == null)
throw new InvalidOperationException("The Eve provider advertisement must be prepared before content transfer.");
if (string.IsNullOrWhiteSpace(_advertisement!.ServiceId))
throw new InvalidOperationException($"Eve provider '{_advertisement.ProviderId}' has no service-instance identity for content transport.");
var cacheRoot = Environment.GetEnvironmentVariable("EVEUNITY_ASSET_CACHE_PATH");
if (string.IsNullOrWhiteSpace(cacheRoot))
cacheRoot = Path.Combine(Application.persistentDataPath, "EveUnity", "assets");
candidate.BodyMappings = new CultMeshVerifiedBodyMappingBroker(cacheRoot);
_contentState ??= new CultCache(
CultMesh.CreateCultCacheDocumentRegistry(typeof(CultMeshContentTransferStateDocument)));
candidate.ContentTransfer = new CultMeshContentTransferService(
_contentState,
new[]
{
AssetMeshClient(candidate).ContentProvider(
candidate.Source.ProviderId,
candidate.Source.Target)
},
new CultMeshContentTransferOptions(cacheRoot),
candidate.BodyMappings);
return candidate.ContentTransfer;
}
private async Task<AssetBundle?> LoadVerifiedBundleAsync(
AssetGeneration candidate,
CultMeshCdnArtifactManifest manifest,
EveAssetVariant variant,
CancellationToken cancellationToken)
{
var hash = NormalizeContentHash(variant.ContentHash);
if (manifest.SizeBytes != variant.SizeBytes)
throw new InvalidOperationException($"Provider asset bundle '{variant.Uri}' size did not match its catalog.");
if (!string.Equals(NormalizeContentHash(manifest.ContentHash),
hash, StringComparison.Ordinal))
throw new InvalidOperationException($"Provider asset bundle '{variant.Uri}' hash did not match its catalog.");
var now = DateTimeOffset.UtcNow;
var network = NetworkArtifactDescriptor(manifest, now, TimeSpan.FromMinutes(5));
var elapsed = Stopwatch.StartNew();
var mapped = await ContentTransfer(candidate)
.FetchMappedContentAsync(manifest, network, now, TimeSpan.FromMinutes(5), cancellationToken);
TraceStartup("content-materialization", elapsed);
var validationRequest = new CultMeshBodyValidationRequest
{
BodyId = network.BodyId,
SchemaId = network.SchemaId,
LayoutVersion = network.LayoutVersion,
ProducerEpoch = network.ProducerEpoch,
Sequence = network.Sequence,
Capacity = network.Capacity,
AccessMode = CultMeshBodyAccessMode.ReadOnly,
NowUtc = now
};
var transport = new CultMeshBodyTransportService(
new ICultMeshBodyTransportAdapter[]
{
new CultMeshMappedBodyAdapter(candidate.BodyMappings!),
new CultMeshNetworkBodyAdapter(_ => File.ReadAllBytes(mapped.VerifiedPath))
},
descriptor => string.Equals(descriptor.BodyId, manifest.ArtifactId, StringComparison.Ordinal) &&
string.Equals(descriptor.SemanticHash, hash, StringComparison.Ordinal));
var negotiated = transport.NegotiateReadOnly(mapped.Descriptor, network, validationRequest);
candidate.BodyTransportKind = negotiated.SelectedTransport;
candidate.BodyLeases.Add(negotiated.Lease);
var bundleRequest = AssetBundle.LoadFromFileAsync(mapped.VerifiedPath);
await AwaitUnityAsync(bundleRequest, cancellationToken);
TraceStartup("asset-bundle-load-from-file", elapsed);
return bundleRequest.assetBundle;
}
private static async Task AwaitUnityAsync(AsyncOperation operation, CancellationToken cancellationToken)
{
while (!operation.isDone)
{
cancellationToken.ThrowIfCancellationRequested();
await Task.Yield();
}
cancellationToken.ThrowIfCancellationRequested();
}
private static CultMeshBodyDescriptor NetworkArtifactDescriptor(
CultMeshCdnArtifactManifest manifest,
DateTimeOffset now,
TimeSpan leaseDuration)
{
if (manifest.SizeBytes > int.MaxValue)
throw new InvalidOperationException("CultMesh artifact capacity exceeds the current body descriptor bound.");
return new CultMeshBodyDescriptor
{
BodyId = manifest.ArtifactId,
SchemaId = "gamecult.mesh.cdn-artifact.v1",
LayoutVersion = 1,
ByteSize = manifest.SizeBytes,
Capacity = checked((int)manifest.SizeBytes),
ProducerEpoch = 1,
Sequence = 0,
AccessMode = CultMeshBodyAccessMode.ReadOnly,
Synchronization = CultMeshBodySynchronization.ImmutableSequence,
LeaseExpiresAtUnixMs = now.Add(leaseDuration).ToUnixTimeMilliseconds(),
TransportKind = CultMeshBodyTransportKind.Network,
CapabilityToken = CultMeshCdnArtifactManifest.CreateRecordKey(manifest).Value,
SemanticHash = NormalizeContentHash(manifest.ContentHash)
};
}
private void PublishReceipt(EveCommandReceiptDocument receipt)
{
var terminal = IsTerminalReceiptState(receipt.State);
lock (_pendingCommands)
{
if (!_pendingCommands.TryGetValue(receipt.CommandId, out var request) ||
!ReceiptMatches(request, receipt))
return;
}
if (terminal)
{
_commandOutbox?.Acknowledge(receipt.CommandId);
if (DeferTerminalReceiptUntilPresentation(receipt))
return;
}
FinalizeReceipt(receipt, terminal);
}
private void EnsurePresentationWritable()
{
lock (_presentationFinalityGate)
{
if (_presentationBarrierVersion > _mountedBaseSurfaceVersion)
throw new InvalidOperationException(
$"The Eve presentation is awaiting provider surface version {_presentationBarrierVersion}; " +
$"mounted base version {_mountedBaseSurfaceVersion} is read-only until that generation commits.");
}
}
private void BeginPresentationTransition(long sourceVersion)
{
lock (_presentationFinalityGate)
{
if (sourceVersion <= _mountedBaseSurfaceVersion)
return;
_presentationBarrierVersion = Math.Max(_presentationBarrierVersion, sourceVersion);
}
}
private bool DeferTerminalReceiptUntilPresentation(EveCommandReceiptDocument receipt)
{
if (receipt.PresentationSurfaceVersion <= 0)
return false;
lock (_presentationFinalityGate)
{
if (receipt.PresentationSurfaceVersion <= _mountedBaseSurfaceVersion)
return false;
_presentationBarrierVersion = Math.Max(
_presentationBarrierVersion,
receipt.PresentationSurfaceVersion);
_deferredTerminalReceipts[receipt.CommandId] = receipt;
return true;
}
}
private void CompletePresentationTransition(long committedVersion)
{
EveCommandReceiptDocument[] ready;
lock (_presentationFinalityGate)
{
_mountedBaseSurfaceVersion = Math.Max(_mountedBaseSurfaceVersion, committedVersion);
if (_activeBaseSurfaceCandidateVersion == committedVersion)
{
_activeBaseSurfaceCandidateVersion = -1;
_activeBaseSurfaceCandidateGeneration = -1;
}
ready = _deferredTerminalReceipts.Values
.Where(receipt => receipt.PresentationSurfaceVersion <= _mountedBaseSurfaceVersion)
.ToArray();
foreach (var receipt in ready)
_deferredTerminalReceipts.Remove(receipt.CommandId);
if (_presentationBarrierVersion <= _mountedBaseSurfaceVersion)
_presentationBarrierVersion = -1;
}
foreach (var receipt in ready)
FinalizeReceipt(receipt, terminal: true);
}
private long MountedBaseSurfaceVersion
{
get
{
lock (_presentationFinalityGate)
return _mountedBaseSurfaceVersion;
}
}
private void FinalizeReceipt(EveCommandReceiptDocument receipt, bool terminal)
{
if (terminal)
{
lock (_pendingCommands)
{
if (!_pendingCommands.ContainsKey(receipt.CommandId))
return;
_pendingCommands.Remove(receipt.CommandId);
}
ForgetPendingCommand(receipt.CommandId);
}
CommandReceiptAvailable?.Invoke(new EveUnitySceneCommandReceipt(
receipt.ReceiptId,
receipt.Command,
receipt.CommandId,
receipt.State,
receipt.OwnerRepo,
receipt.Authority,
receipt.Schema,
receipt.ProviderId,
receipt.SurfaceId,
receipt.Message,
DateTimeOffset.TryParse(receipt.IssuedAtUtc, out var issuedAt) ? issuedAt : null,
receipt.SourceVersion,
receipt.Navigation == null
? null
: new EveUnitySceneNavigationTarget(
receipt.Navigation.VerseId,
receipt.Navigation.ProviderId,
receipt.Navigation.SurfaceId,
receipt.Navigation.SurfaceKind,
receipt.Navigation.RendezvousEndpoints,
receipt.Navigation.AuthorityRuntimeId)));
}
private sealed class AssetSource
{
public AssetSource(
CultMeshSessionTarget target,
string providerId,
string manifestRecordRef,
IReadOnlyList<string> rendezvousEndpoints)
: this(target, providerId, manifestRecordRef, rendezvousEndpoints, 0)
{
}
public AssetSource(
CultMeshSessionTarget target,
string providerId,
string manifestRecordRef,
IReadOnlyList<string> rendezvousEndpoints,
long requiredCatalogVersion)
{
Target = target;
ProviderId = providerId ?? "";
ManifestRecordRef = manifestRecordRef ?? "";
RendezvousEndpoints = rendezvousEndpoints ?? Array.Empty<string>();
RequiredCatalogVersion = Math.Max(0, requiredCatalogVersion);
Identity = Target.VerseId + "\u001f" + Target.AuthorityRuntimeId + "\u001f" +
ProviderId + "\u001f" + ManifestRecordRef + "\u001f" +
string.Join("\u001e", RendezvousEndpoints);
}
public CultMeshSessionTarget Target { get; }
public string ProviderId { get; }
public string ManifestRecordRef { get; }
public IReadOnlyList<string> RendezvousEndpoints { get; }
public long RequiredCatalogVersion { get; }
public string Identity { get; }
}
private sealed class PendingAssetCatalogUpdate
{
public PendingAssetCatalogUpdate(string sourceIdentity, EveAssetCatalogDocument catalog)
{
SourceIdentity = sourceIdentity ?? "";
Catalog = catalog;
}
public string SourceIdentity { get; }
public EveAssetCatalogDocument Catalog { get; }
}
private bool ReceiptMatches(EveSurfaceCommandRequest request, EveCommandReceiptDocument receipt) =>
string.Equals(receipt.Schema, EveCommandReceiptDocument.SchemaId, StringComparison.Ordinal) &&
string.Equals(receipt.CommandId, request.CommandId, StringComparison.Ordinal) &&
string.Equals(receipt.Command, request.Command, StringComparison.Ordinal) &&
string.Equals(receipt.ProviderId, request.ProviderId, StringComparison.Ordinal) &&
string.Equals(receipt.SurfaceId, request.SurfaceId, StringComparison.Ordinal) &&
string.Equals(receipt.Authority, _target.AuthorityRuntimeId, StringComparison.Ordinal) &&
string.Equals(receipt.InvocationHash, EveCommandInvocationHash.Compute(request), StringComparison.Ordinal) &&
IsKnownReceiptState(receipt.State);
private static bool IsKnownReceiptState(string state) =>
string.Equals(state, "pending", StringComparison.OrdinalIgnoreCase) ||
IsTerminalReceiptState(state);
private static bool IsTerminalReceiptState(string state) =>
string.Equals(state, "accepted", StringComparison.OrdinalIgnoreCase) ||
string.Equals(state, "denied", StringComparison.OrdinalIgnoreCase) ||
string.Equals(state, "reconciled", StringComparison.OrdinalIgnoreCase);
private sealed class ReceiptSubscription : IDisposable
{
private IDisposable? _lease;
private IDisposable? _watch;
public ReceiptSubscription(IDisposable lease, IDisposable watch)
{
_lease = lease;
_watch = watch;
}
public void Dispose()
{
Interlocked.Exchange(ref _watch, null)?.Dispose();
Interlocked.Exchange(ref _lease, null)?.Dispose();
}
}
private EveWorldInteractionAdvertisement RequireWorldInteraction()
{
return _advertisedSurface?.WorldInteraction
?? throw new InvalidOperationException("The advertised surface has no interactive-world contract.");
}
private EveUnitySceneProviderSurfaceDocument EmptySurfaceDocument()
{
var surface = new EveSurfaceDocument(
_providerId,
"",
"",
0,
"",
new EveSurfaceTree(
_surfaceId,
new EveSurfaceComponent(
"root",
"surface",
new Dictionary<string, string>(),
Array.Empty<EveSurfaceComponent>()),
Array.Empty<EveStyleToken>()),
Array.Empty<EveCommandTemplate>());
return new EveUnitySceneProviderSurfaceDocument(
surface,
new EveUnitySceneProviderSurfaceAdvertisement(
_surfaceId,
"interactive-world",
new EveUnitySceneWorldInteraction("", "", EveCommandReceiptDocument.SchemaId, "")),
"",
0);
}
private EveUnityPlayableWorldAssetManifestDocument EmptyAssetManifest()
{
return new EveUnityPlayableWorldAssetManifestDocument(
"",
Array.Empty<EveUnityPlayableWorldAssetManifestDocumentEntry>(),
_providerId);
}
private static string ChildRecordKey(string parent, string child)
{
return $"{parent.TrimEnd(':', '/')}:{child}";
}
}
}