f8e55ba5e4
RuntimePlacementPresentationSink.TryPublishPlace previously published the local player's collision-shadow pose with a direct LocalPlayerShadowState.Set call — a plain cache write that never touched PhysicsEngine.ShadowObjects. Because LocalPlayerShadowSynchronizer.SyncPose's own dedup check compares against that same cache, the direct write could pre-seed the cache with the destination pose and cause the next real SyncPose call to see "nothing changed" and skip its own ShadowObjects publish — leaving the real collision shadow at the pre-teleport position until an unrelated movement tick forced a real publish. Fix: TryPublishPlace now calls _localPlayerShadowSync.SyncPose(..., force: true), the same publisher ordinary per-tick movement uses, so Place always drives a real ShadowObjects write before the cache updates. TryPublishWithdrawal carried the exact mirror asymmetry (a bare LocalPlayerShadowState.Clear with no ShadowObjects.Suspend, leaving a live phantom shadow row at the park's source cell for the whole park window — the #184 shape) and is fixed in the same commit, same one-call shape: _localPlayerShadowSync.Suspend(entity). The sink no longer holds a direct LocalPlayerShadowState reference; both halves route exclusively through the one synchronizer, which owns the cache internally. The single LocalPlayerShadowSynchronizer instance is now constructed in LivePresentationComposition (before the sink) and threaded through LivePresentationResult to SessionPlayerComposition, which no longer builds its own — this guarantees the sink's Place/Withdraw edge and ordinary per-tick movement publish through the exact same publisher and cache rather than two independent instances that could drift out of sync with each other. TryPublishPlace's xmldoc now states the behavioural nuance directly: routing through SyncPose means Place inherits SyncPose's own admission guard (IsHidden, cellId == 0, not-current-visible-projection), which the old direct .Set() call never consulted. Under those conditions SyncPose now calls Suspend instead of publishing — correct and symmetric, but new behaviour worth flagging at the call site, not just in a test comment. RuntimePlacementShadowCompositionTests.cs (#318) proves four facts against the real ShadowObjects registry, not the cache: a bare Place publishes a real row at the destination cell with the source cell's row gone; a subsequent ordinary per-tick Sync is then a correct no-op; a Place for a registered non-local-player entity leaves its row at the source cell untouched and never touches the player's cache (route 7 P4 — the fix lives entirely inside the pre-existing player-only gate); and Withdraw suspends the real registry row, not just the cache, with the retained (suspendable) registration surviving for a later restore. All four were sabotage-verified in both directions. RuntimeForcePositionRenderCommitTests.cs (B2) drives a real end-to-end accepted ForcePosition through RuntimeEntityObjectLifetime.TryApplyPosition and RuntimeAcceptedPositionDriveController.TryExecuteAcceptedLocalPosition against a live HostFixture, asserting both the committed render position AND a cell change that deliberately crosses out of the spawn's outdoor grid cell, so the cell assertion is independently falsifiable rather than riding along with the position assertion. Retires AP-145 (this fix) in docs/architecture/retail-divergence-register.md. AP-1 and AD-1 are untouched by this commit — they retire separately in the deletion-sweep commit that follows. Evidence chain: docs/research/2026-08-05-c5a-contract.md (the governing C5a slice contract), docs/research/2026-08-05-c5a-architecture-review.md (round 1, FAIL — three MAJORs: vacuous route-7 P4 test, unfixed Withdraw-side mirror asymmetry, non-driving B2 test), docs/research/2026-08-05-c5a-architecture-review-round2.md (round 2, PASS with two MINORs — an unfalsifiable B2 cell assertion and the undocumented SyncPose guard nuance, both fixed here). Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
1310 lines
57 KiB
C#
1310 lines
57 KiB
C#
using System.Numerics;
|
|
using AcDream.Content;
|
|
using AcDream.App.Diagnostics;
|
|
using AcDream.App.Input;
|
|
using AcDream.App.Interaction;
|
|
using AcDream.App.Physics;
|
|
using AcDream.App.Rendering;
|
|
using AcDream.App.Rendering.Residency;
|
|
using AcDream.App.Rendering.Scene;
|
|
using AcDream.App.Rendering.Selection;
|
|
using AcDream.App.Rendering.Sky;
|
|
using AcDream.App.Rendering.Vfx;
|
|
using AcDream.App.Rendering.Wb;
|
|
using AcDream.App.Settings;
|
|
using AcDream.App.Streaming;
|
|
using AcDream.App.UI;
|
|
using AcDream.App.UI.Layout;
|
|
using AcDream.App.World;
|
|
using AcDream.Core.Audio;
|
|
using AcDream.Core.Items;
|
|
using AcDream.Core.Lighting;
|
|
using AcDream.Core.Physics;
|
|
using AcDream.Core.Plugins;
|
|
using AcDream.Core.Rendering;
|
|
using AcDream.Core.Selection;
|
|
using AcDream.Core.Vfx;
|
|
using AcDream.Core.World;
|
|
using AcDream.Runtime;
|
|
using AcDream.Runtime.Entities;
|
|
using AcDream.Runtime.World;
|
|
using DatReaderWriter;
|
|
using DatReaderWriter.DBObjs;
|
|
using Silk.NET.Windowing;
|
|
|
|
namespace AcDream.App.Composition;
|
|
|
|
internal sealed record LivePresentationDependencies(
|
|
RuntimeOptions Options,
|
|
GameWindowGraphics Graphics,
|
|
IWindow Window,
|
|
object DatLock,
|
|
RuntimeSettingsController Settings,
|
|
HostQuiescenceGate HostQuiescence,
|
|
PhysicsEngine PhysicsEngine,
|
|
PhysicsDataCache PhysicsDataCache,
|
|
WorldGameState WorldGameState,
|
|
WorldEvents WorldEvents,
|
|
GameRuntime Runtime,
|
|
LiveEntityRuntimeSlot RuntimeSlot,
|
|
DeferredLiveEntityMotionRuntimeBindings MotionBindings,
|
|
DeferredEntityEffectAdvanceSource EffectAdvance,
|
|
EntityEffectPoseRegistry EffectPoses,
|
|
RemotePhysicsUpdater RemotePhysicsUpdater,
|
|
LocalPlayerShadowState LocalPlayerShadow,
|
|
LiveEntityAnimationRuntimeView<LiveEntityAnimationState> AnimatedEntities,
|
|
AnimationPresentationDiagnostics AnimationDiagnostics,
|
|
EntityClassificationCache ClassificationCache,
|
|
TranslucencyFadeManager TranslucencyFades,
|
|
RetailAlphaQueue RetailAlphaQueue,
|
|
CellVisibility CellVisibility,
|
|
LiveWorldOriginState WorldOrigin,
|
|
LocalPlayerIdentityState PlayerIdentity,
|
|
PointerPositionState PointerPosition,
|
|
PlayerApproachCompletionState PlayerApproachCompletions,
|
|
GameRenderResourceLifetime RenderResourceLifetime,
|
|
TransferableResourceSlot<PortalTunnelPresentation> PortalTunnelFallback,
|
|
AnimationHookRouter HookRouter,
|
|
IRenderFrameDiagnosticLog RenderDiagnosticLog,
|
|
WorldTimeService WorldTime,
|
|
DeferredCanonicalWorldEntityCountSource? DevWorldEntities,
|
|
DeferredRenderFrameDiagnosticsSource? DevFrameDiagnostics,
|
|
DeferredRenderFrameDiagnosticsSource UiFrameDiagnostics,
|
|
Action<string> Log,
|
|
Action<string>? Toast)
|
|
{
|
|
public SelectionState Selection => Runtime.ActionOwner.Selection;
|
|
|
|
public RuntimeEntityObjectLifetime EntityObjects =>
|
|
Runtime.EntityObjects;
|
|
|
|
public RuntimeWorldTransitState WorldTransit => Runtime.TransitOwner;
|
|
|
|
public RuntimeLocalPlayerMovementState PlayerController =>
|
|
Runtime.MovementOwner;
|
|
}
|
|
|
|
internal sealed record LivePresentationResult(
|
|
DeferredLiveEntityRuntimeComponentLifecycle ComponentLifecycle,
|
|
LiveEntityMotionRuntimeController MotionRuntime,
|
|
DeferredLiveEntityParentAcceptance ParentAcceptance,
|
|
EntitySpawnAdapter EntitySpawnAdapter,
|
|
EntityScriptActivator EntityScriptActivator,
|
|
RetailStaticAnimatingObjectScheduler StaticAnimationScheduler,
|
|
RuntimeWorldTransitState WorldTransit,
|
|
WorldGenerationAvailabilityState WorldAvailability,
|
|
GpuWorldState WorldState,
|
|
RenderSceneShadowRuntime? RenderSceneShadow,
|
|
LiveEntityRuntime LiveEntities,
|
|
RuntimePlacementPresentationSink PlacementProjection,
|
|
// AP-145 fix (2026-08-05, #318): constructed HERE (before the sink that
|
|
// consumes it) rather than later in SessionPlayerComposition, so both
|
|
// consumers share the ONE synchronizer instance / ONE
|
|
// LocalPlayerShadowState cache. Two instances would themselves
|
|
// reintroduce a cache-desync class this fix exists to close.
|
|
LocalPlayerShadowSynchronizer LocalPlayerShadowSynchronizer,
|
|
ProjectileController ProjectileController,
|
|
LiveEntityProjectionWithdrawalController ProjectionWithdrawal,
|
|
LiveEntityLightController Lights,
|
|
LiveEntityAnimationScheduler AnimationScheduler,
|
|
LiveEntityAnimationPresenter AnimationPresenter,
|
|
EquippedChildRenderController EquippedChildren,
|
|
EntityEffectController EntityEffects,
|
|
LiveEntityPresentationController Presentation,
|
|
WbDrawDispatcher? DrawDispatcher,
|
|
RetailSelectionScene SelectionScene,
|
|
WorldSelectionQuery SelectionQuery,
|
|
SelectionInteractionController SelectionInteractions,
|
|
RetainedUiGameplayBinding? RetainedGameplay,
|
|
PaperdollViewportRenderer? PaperdollRenderer,
|
|
PaperdollFramePresenter? PaperdollPresenter,
|
|
CreatureAppraisalViewportRenderer? CreatureAppraisalRenderer,
|
|
CreatureAppraisalFramePresenter? CreatureAppraisalPresenter,
|
|
WbFrustum EnvCellFrustum,
|
|
EnvCellRenderer? EnvCellRenderer,
|
|
LandblockPresentationPipeline LandblockPipeline,
|
|
ClipFrame ClipFrame,
|
|
PortalDepthMaskRenderer? PortalDepthMask,
|
|
SkyRenderer? SkyRenderer,
|
|
ParticleRenderer? ParticleRenderer,
|
|
RenderFrameDiagnosticsController FrameDiagnostics,
|
|
LivePresentationRuntimeBindings RuntimeBindings,
|
|
DeferredLiveEntityLandblockLoadedSink LandblockLoaded);
|
|
|
|
internal interface IGameWindowLivePresentationPublication
|
|
{
|
|
void PublishLivePresentation(LivePresentationResult result);
|
|
}
|
|
|
|
internal enum LivePresentationCompositionPoint
|
|
{
|
|
CanonicalRuntimeCreated,
|
|
CanonicalRuntimeBound,
|
|
MotionRuntimeBound,
|
|
ProjectionVisibilityBound,
|
|
CorePresentationCreated,
|
|
EffectRoutingBound,
|
|
SelectionAndRadarBound,
|
|
RetainedGameplayBound,
|
|
PrivateCreatureViewportsCreated,
|
|
EnvironmentCellsCreated,
|
|
LandblockPipelineCreated,
|
|
PortalResourcesCreated,
|
|
SkyAndParticlesCreated,
|
|
DiagnosticsBound,
|
|
ResultPublished,
|
|
}
|
|
|
|
internal sealed class LivePresentationCompositionPhase
|
|
: ILivePresentationCompositionPhase<
|
|
GameWindowPlatformResult<GameWindowGraphics, Silk.NET.Input.IInputContext>,
|
|
HostInputCameraResult,
|
|
ContentEffectsAudioResult,
|
|
SettingsDevToolsResult,
|
|
WorldRenderResult,
|
|
InteractionRetainedUiResult,
|
|
LivePresentationResult>
|
|
{
|
|
private readonly LivePresentationDependencies _dependencies;
|
|
private readonly IGameWindowLivePresentationPublication _publication;
|
|
private readonly Action<LivePresentationCompositionPoint>? _faultInjection;
|
|
|
|
public LivePresentationCompositionPhase(
|
|
LivePresentationDependencies dependencies,
|
|
IGameWindowLivePresentationPublication publication,
|
|
Action<LivePresentationCompositionPoint>? faultInjection = null)
|
|
{
|
|
_dependencies = dependencies
|
|
?? throw new ArgumentNullException(nameof(dependencies));
|
|
_publication = publication
|
|
?? throw new ArgumentNullException(nameof(publication));
|
|
_faultInjection = faultInjection;
|
|
}
|
|
|
|
public LivePresentationResult Compose(
|
|
GameWindowPlatformResult<GameWindowGraphics, Silk.NET.Input.IInputContext> platform,
|
|
HostInputCameraResult host,
|
|
ContentEffectsAudioResult content,
|
|
SettingsDevToolsResult settings,
|
|
WorldRenderResult world,
|
|
InteractionRetainedUiResult interaction)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(platform);
|
|
ArgumentNullException.ThrowIfNull(host);
|
|
ArgumentNullException.ThrowIfNull(content);
|
|
ArgumentNullException.ThrowIfNull(settings);
|
|
ArgumentNullException.ThrowIfNull(world);
|
|
ArgumentNullException.ThrowIfNull(interaction);
|
|
if (!ReferenceEquals(_dependencies.Graphics, platform.Graphics))
|
|
{
|
|
throw new InvalidOperationException(
|
|
"Live-presentation dependencies do not match the ordered platform result.");
|
|
}
|
|
return ComposeCore(host, content, world, interaction);
|
|
}
|
|
|
|
private LivePresentationResult ComposeCore(
|
|
HostInputCameraResult host,
|
|
ContentEffectsAudioResult content,
|
|
WorldRenderResult world,
|
|
InteractionRetainedUiResult interaction)
|
|
{
|
|
LivePresentationDependencies d = _dependencies;
|
|
WorldRenderFoundation foundation = world.Foundation;
|
|
var scope = new CompositionAcquisitionScope();
|
|
LivePresentationRuntimeBindings? bindings = null;
|
|
bool bindingsOwnedByScope = false;
|
|
|
|
try
|
|
{
|
|
CompositionAcquisitionScope.CompositionAcquisitionLease<
|
|
RenderSceneShadowRuntime>? renderSceneShadowLease = null;
|
|
renderSceneShadowLease = scope.Acquire(
|
|
"render scene",
|
|
() => new RenderSceneShadowRuntime(
|
|
RenderSceneGeneration.FromRaw(1)),
|
|
static value => value.Dispose());
|
|
RenderSceneShadowRuntime? renderSceneShadow =
|
|
renderSceneShadowLease?.Resource;
|
|
|
|
var componentLifecycle =
|
|
new DeferredLiveEntityRuntimeComponentLifecycle();
|
|
var wbSpawnAdapter = new LandblockSpawnAdapter(
|
|
foundation.MeshAdapter
|
|
?? throw new InvalidOperationException(
|
|
"The landblock spawn ledger requires the mesh pipeline, which "
|
|
+ "Campaign V slice V6i-3 made backend-neutral."));
|
|
Setup? LoadPreparedSetup(uint sourceId)
|
|
{
|
|
if (!content.Dats.TryResolvePreferred(
|
|
sourceId,
|
|
out IDatDatabase? database,
|
|
out DatReaderWriter.Enums.DBObjType type)
|
|
|| type != DatReaderWriter.Enums.DBObjType.Setup)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return database.TryGet<Setup>(
|
|
sourceId,
|
|
out Setup? setup)
|
|
? setup
|
|
: null;
|
|
}
|
|
|
|
var setupResolver = new PreparedSetupResolver(
|
|
content.PreparedAssets,
|
|
LoadPreparedSetup,
|
|
message => Console.Error.WriteLine(
|
|
$"setup activation: {message}"));
|
|
|
|
AnimationSequencer SequencerFactory(WorldEntity entity)
|
|
{
|
|
if (setupResolver.TryResolve(
|
|
entity.SourceGfxObjOrSetupId,
|
|
out Setup? setup))
|
|
{
|
|
uint motionTableId = (uint)setup.DefaultMotionTable;
|
|
if (motionTableId != 0
|
|
&& content.Dats.Get<MotionTable>(motionTableId) is { } motionTable)
|
|
{
|
|
return new AnimationSequencer(
|
|
setup,
|
|
motionTable,
|
|
content.AnimationLoader);
|
|
}
|
|
|
|
return new AnimationSequencer(
|
|
setup,
|
|
new MotionTable(),
|
|
content.AnimationLoader);
|
|
}
|
|
|
|
return new AnimationSequencer(
|
|
new Setup(),
|
|
new MotionTable(),
|
|
NullAnimationLoader.Instance);
|
|
}
|
|
|
|
var entitySpawnAdapter = new EntitySpawnAdapter(
|
|
foundation.TextureCache,
|
|
SequencerFactory,
|
|
foundation.MeshAdapter);
|
|
EntityEffectController? entityEffects = null;
|
|
LiveEntityRuntime? liveEntities = null;
|
|
var staticRootCommitter = new StaticLiveRootCommitter(
|
|
d.RuntimeSlot,
|
|
d.PhysicsEngine.ShadowObjects,
|
|
d.WorldOrigin,
|
|
d.EffectPoses);
|
|
var staticResidency = new LiveStaticAnimationResidency(d.RuntimeSlot);
|
|
(LiveEntityAnimationState Animation, PhysicsBody Body)?
|
|
ResolveLiveStaticOwner(WorldEntity entity)
|
|
{
|
|
if (entity.ServerGuid == 0
|
|
|| liveEntities?.TryGetRecord(
|
|
entity.ServerGuid,
|
|
out LiveEntityRecord record) != true
|
|
|| !ReferenceEquals(record.WorldEntity, entity)
|
|
|| !record.IsSpatiallyProjected
|
|
|| !record.IsSpatiallyVisible
|
|
|| record.AnimationRuntime
|
|
is not LiveEntityAnimationState animation
|
|
|| record.PhysicsBody is not { } body)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return (animation, body);
|
|
}
|
|
var staticAnimationScheduler =
|
|
new RetailStaticAnimatingObjectScheduler(
|
|
content.AnimationLoader,
|
|
content.AnimationHookFrames.Capture,
|
|
d.EffectPoses.Publish,
|
|
staticResidency.IsResident,
|
|
(entity, body) => _ = staticRootCommitter.Commit(entity, body),
|
|
staticResidency.ProjectionVersion,
|
|
ResolveLiveStaticOwner);
|
|
|
|
ScriptActivationInfo? ResolveActivation(WorldEntity entity)
|
|
{
|
|
if (!setupResolver.TryResolve(
|
|
entity.SourceGfxObjOrSetupId,
|
|
out Setup? setup))
|
|
{
|
|
return null;
|
|
}
|
|
uint scriptId = setup.DefaultScript.DataId;
|
|
if (entity.IndexedPartTransforms.Count == 0)
|
|
{
|
|
var indexed = IndexedSetupPartPoseBuilder.Build(setup, entity);
|
|
entity.SetIndexedPartPoses(indexed.Poses, indexed.Available);
|
|
}
|
|
|
|
bool usesStaticAnimationWorkset = entity.ServerGuid == 0
|
|
|| (liveEntities?.TryGetRecord(
|
|
entity.ServerGuid,
|
|
out LiveEntityRecord liveRecord) == true
|
|
&& (liveRecord.FinalPhysicsState
|
|
& PhysicsStateFlags.Static) != 0);
|
|
return new ScriptActivationInfo(
|
|
scriptId,
|
|
entity.IndexedPartTransforms,
|
|
EntityEffectProfile.CreateDatStatic(setup),
|
|
entity.IndexedPartAvailable,
|
|
setup,
|
|
(uint)setup.DefaultAnimation,
|
|
usesStaticAnimationWorkset);
|
|
}
|
|
|
|
var entityScriptActivator = new EntityScriptActivator(
|
|
content.ScriptRunner,
|
|
content.ParticleSink,
|
|
d.EffectPoses,
|
|
ResolveActivation,
|
|
(ownerId, entity, profile) =>
|
|
entityEffects?.OnDatStaticEntityReady(ownerId, entity, profile),
|
|
ownerId =>
|
|
{
|
|
entityEffects?.OnDatStaticEntityRemoved(ownerId);
|
|
content.LightingSink.UnregisterOwner(ownerId);
|
|
d.TranslucencyFades.ClearEntity(ownerId);
|
|
},
|
|
(entity, info) => staticAnimationScheduler.Register(entity, info),
|
|
staticAnimationScheduler.Unregister,
|
|
(entity, info) => staticAnimationScheduler.Rebind(entity, info));
|
|
|
|
RuntimeWorldTransitState worldTransit = d.WorldTransit;
|
|
var worldAvailability =
|
|
new WorldGenerationAvailabilityState(worldTransit);
|
|
var worldState = new GpuWorldState(
|
|
wbSpawnAdapter,
|
|
d.ClassificationCache.InvalidateLandblock,
|
|
entityScriptActivator,
|
|
worldAvailability);
|
|
bindings = new LivePresentationRuntimeBindings();
|
|
if (d.DevWorldEntities is { } devWorldEntities)
|
|
{
|
|
bindings.Adopt(
|
|
"developer world-entity source",
|
|
devWorldEntities.BindOwned(worldState));
|
|
}
|
|
var resourceOwners =
|
|
new List<CompositeLiveEntityResourceLifecycle.Owner>
|
|
{
|
|
new(
|
|
entity =>
|
|
{
|
|
if (liveEntities is null
|
|
|| !liveEntities.TryGetRecordByLocalEntityId(
|
|
entity.Id,
|
|
out LiveEntityRecord record)
|
|
|| record.ProjectionKey is not { } key)
|
|
{
|
|
throw new InvalidOperationException(
|
|
"Live presentation registration requires an exact Runtime projection key.");
|
|
}
|
|
_ = entitySpawnAdapter.OnCreate(key, entity);
|
|
},
|
|
entity => _ = entitySpawnAdapter.OnRemove(entity)),
|
|
new(
|
|
entityScriptActivator.OnCreate,
|
|
entityScriptActivator.OnRemove),
|
|
};
|
|
if (renderSceneShadow is not null)
|
|
{
|
|
resourceOwners.Add(new(
|
|
renderSceneShadow.OnLiveResourceRegistered,
|
|
renderSceneShadow.OnLiveResourceUnregistered));
|
|
}
|
|
liveEntities = new LiveEntityRuntime(
|
|
worldState,
|
|
new CompositeLiveEntityResourceLifecycle(
|
|
[.. resourceOwners]),
|
|
componentLifecycle,
|
|
d.EntityObjects);
|
|
var liveRuntimeLease = scope.Own(
|
|
"canonical live-entity runtime",
|
|
liveEntities,
|
|
static runtime => runtime.Clear());
|
|
LiveRenderProjectionJournal? liveRenderProjections =
|
|
renderSceneShadow?.BindLiveRuntime(
|
|
liveEntities,
|
|
new GpuWorldRenderTraversalOrderSource(worldState));
|
|
Fault(LivePresentationCompositionPoint.CanonicalRuntimeCreated);
|
|
|
|
bindings.Adopt(
|
|
"canonical live-runtime slot",
|
|
d.RuntimeSlot.BindOwned(liveEntities));
|
|
Fault(LivePresentationCompositionPoint.CanonicalRuntimeBound);
|
|
|
|
var selectionInteractionSource =
|
|
new DeferredSelectionInteractionSource();
|
|
var motionRuntime = new LiveEntityMotionRuntimeController(
|
|
liveEntities,
|
|
d.PhysicsDataCache,
|
|
() => selectionInteractionSource.Current,
|
|
d.Selection,
|
|
d.WorldOrigin);
|
|
bindings.Adopt(
|
|
"live motion runtime",
|
|
d.MotionBindings.BindOwned(motionRuntime));
|
|
Fault(LivePresentationCompositionPoint.MotionRuntimeBound);
|
|
|
|
Action<LiveEntityRecord, bool> wbVisibility = (record, visible) =>
|
|
{
|
|
if (record.WorldEntity is { } entity)
|
|
entitySpawnAdapter.SetPresentationResident(entity, visible);
|
|
};
|
|
bindings.BindProjectionVisibility(
|
|
liveEntities,
|
|
wbVisibility,
|
|
"WB projection visibility");
|
|
if (liveRenderProjections is not null)
|
|
{
|
|
bindings.BindProjectionVisibility(
|
|
liveEntities,
|
|
liveRenderProjections.OnProjectionVisibilityChanged,
|
|
"shadow render projection visibility");
|
|
}
|
|
Action<LiveEntityRecord, bool> particleVisibility = (record, visible) =>
|
|
{
|
|
if (record.WorldEntity is { } entity)
|
|
content.ParticleSink.SetEntityPresentationVisible(entity.Id, visible);
|
|
};
|
|
bindings.BindProjectionVisibility(
|
|
liveEntities,
|
|
particleVisibility,
|
|
"particle projection visibility");
|
|
var placementVisibilitySinks = new List<
|
|
Action<LiveEntityRecord, bool>>(4)
|
|
{
|
|
wbVisibility,
|
|
};
|
|
if (liveRenderProjections is not null)
|
|
{
|
|
placementVisibilitySinks.Add(
|
|
liveRenderProjections.OnProjectionVisibilityChanged);
|
|
}
|
|
placementVisibilitySinks.Add(particleVisibility);
|
|
// Retail enters the CPhysicsObj before ProcessObjectNetBlobs.
|
|
// C3c's initial Runtime placement is the equivalent world-entry
|
|
// edge, so open/replay the one-shot F754/F755 barrier only after
|
|
// mesh poses and particle presentation have both been published.
|
|
placementVisibilitySinks.Add((record, visible) =>
|
|
{
|
|
if (visible)
|
|
entityEffects?.OnPresentationBound(record);
|
|
});
|
|
// AP-145 fix (2026-08-05, #318): constructed here, BEFORE the
|
|
// sink, so the sink can publish the local player's Place
|
|
// through the same seam ordinary per-tick movement uses rather
|
|
// than writing LocalPlayerShadowState directly. Threaded through
|
|
// to SessionPlayerComposition via LivePresentationResult so
|
|
// there remains exactly one synchronizer / one cache for the
|
|
// whole session — SessionPlayerComposition no longer constructs
|
|
// its own.
|
|
var localPlayerShadowSynchronizer = new LocalPlayerShadowSynchronizer(
|
|
d.PhysicsEngine,
|
|
liveEntities,
|
|
d.PlayerIdentity,
|
|
d.WorldOrigin,
|
|
d.LocalPlayerShadow);
|
|
var placementProjection = new RuntimePlacementPresentationSink(
|
|
liveEntities,
|
|
worldTransit,
|
|
d.WorldGameState,
|
|
d.WorldEvents,
|
|
d.EffectPoses,
|
|
localPlayerShadowSynchronizer,
|
|
() => d.PlayerIdentity.ServerGuid,
|
|
guid =>
|
|
{
|
|
if (d.Selection.SelectedObjectId == guid)
|
|
{
|
|
d.Selection.Clear(
|
|
SelectionChangeSource.System,
|
|
SelectionChangeReason.SelectedObjectRemoved);
|
|
}
|
|
},
|
|
placementVisibilitySinks);
|
|
Fault(LivePresentationCompositionPoint.ProjectionVisibilityBound);
|
|
|
|
var projectileController = new ProjectileController(
|
|
liveEntities,
|
|
new DatProjectileSetupResolver(content.Dats, d.DatLock),
|
|
new EntityRootPosePublisher(d.EffectPoses),
|
|
d.WorldOrigin)
|
|
{
|
|
DiagnosticSink = message =>
|
|
Console.Error.WriteLine($"projectile: {message}"),
|
|
};
|
|
var projectionWithdrawal =
|
|
new LiveEntityProjectionWithdrawalController(
|
|
liveEntities,
|
|
projectileController,
|
|
d.WorldGameState,
|
|
d.WorldEvents,
|
|
d.PhysicsEngine.ShadowObjects,
|
|
d.EffectPoses,
|
|
d.LocalPlayerShadow);
|
|
var lightsLease = scope.Acquire(
|
|
"live-entity lights",
|
|
() => new LiveEntityLightController(
|
|
liveEntities,
|
|
d.EffectPoses,
|
|
content.LightingSink,
|
|
setupId => content.Dats.Get<Setup>(setupId)),
|
|
static value => value.Dispose());
|
|
var ordinaryPhysicsUpdater = new LiveEntityOrdinaryPhysicsUpdater(
|
|
d.EntityObjects.Physics,
|
|
d.MotionBindings.GetSetupCylinder,
|
|
d.MotionBindings.GetSetupMoverShape,
|
|
// TS-23 (Campaign P Slice P3, 2026-07-30): the ordinary
|
|
// mover's own PK/PKLite/Impenetrable bits — same
|
|
// ClientObjectTable-backed lookup GameWindow's remote
|
|
// updater uses.
|
|
guid => AcDream.Core.Physics.EntityCollisionFlagsExt.ResolveMoverPvpState(
|
|
d.EntityObjects.Objects,
|
|
guid));
|
|
var animationScheduler = new LiveEntityAnimationScheduler(
|
|
liveEntities,
|
|
d.PlayerIdentity,
|
|
d.RemotePhysicsUpdater,
|
|
ordinaryPhysicsUpdater,
|
|
projectileController,
|
|
new EntityRootPosePublisher(d.EffectPoses),
|
|
new AnimationHookCaptureSink(content.AnimationHookFrames));
|
|
var animationPresenter = new LiveEntityAnimationPresenter(
|
|
liveEntities,
|
|
staticAnimationScheduler,
|
|
d.EffectPoses,
|
|
new LiveAnimationPresentationContext(
|
|
liveEntities,
|
|
d.PlayerIdentity,
|
|
d.PlayerController),
|
|
d.AnimationDiagnostics,
|
|
d.Options.HidePartIndex);
|
|
var parentAcceptance = new DeferredLiveEntityParentAcceptance();
|
|
var equippedLease = scope.Acquire(
|
|
"equipped-child renderer",
|
|
() => new EquippedChildRenderController(
|
|
content.Dats,
|
|
d.DatLock,
|
|
d.EntityObjects.Objects,
|
|
liveEntities,
|
|
d.EffectPoses,
|
|
parentAcceptance.TryAccept,
|
|
(childRecord, positionVersion, projectionVersion) =>
|
|
projectionWithdrawal.WithdrawExact(
|
|
childRecord,
|
|
positionVersion,
|
|
projectionVersion,
|
|
d.PlayerIdentity.ServerGuid)),
|
|
static value => value.Dispose());
|
|
Fault(LivePresentationCompositionPoint.CorePresentationCreated);
|
|
|
|
var tableResolver = new PhysicsScriptTableResolver(
|
|
id => content.Dats.Get<PhysicsScriptTable>(id));
|
|
entityEffects = new EntityEffectController(
|
|
liveEntities,
|
|
content.ScriptRunner,
|
|
tableResolver,
|
|
d.EffectPoses,
|
|
(parentLocalId, partIndex) =>
|
|
equippedLease.Resource.FindChildLocalIdAtPart(
|
|
parentLocalId,
|
|
partIndex),
|
|
equippedLease.Resource.FindParentLocalId,
|
|
ownerId => content.Audio?.EntitySoundTables.Remove(ownerId),
|
|
(ownerId, soundTableDid) =>
|
|
{
|
|
content.Audio?.EntitySoundTables.Remove(ownerId);
|
|
if (soundTableDid is { } did)
|
|
content.Audio?.EntitySoundTables.Set(ownerId, did);
|
|
});
|
|
bindings.Adopt(
|
|
"entity-effect advance",
|
|
d.EffectAdvance.BindOwned(entityEffects));
|
|
entityEffects.DiagnosticSink = message =>
|
|
Console.Error.WriteLine($"vfx: {message}");
|
|
var partArrayLifecycle = new LiveEntityPartArrayLifecycle(
|
|
d.AnimatedEntities);
|
|
var presentationLease = scope.Acquire(
|
|
"live-entity presentation",
|
|
() => new LiveEntityPresentationController(
|
|
liveEntities,
|
|
d.PhysicsEngine.ShadowObjects,
|
|
entityEffects.PlayTypedFromHiddenTransition,
|
|
new LiveEntityPartArrayEnterWorldPort(
|
|
partArrayLifecycle.HandleEnterWorld),
|
|
equippedLease.Resource.SetDirectChildrenNoDraw,
|
|
d.MotionBindings.ClearTargetForHiddenEntity,
|
|
d.WorldOrigin.GetCenter),
|
|
static value => value.Dispose());
|
|
// #297 second edge: keep every live entity's shadow-registry
|
|
// PK/PKLite/Impenetrable flags in sync with its live PWD
|
|
// bitfield, not just the mover-side read the table already
|
|
// resolves fresh on every call.
|
|
bindings.Adopt(
|
|
"live-entity pvp bitfield sync",
|
|
new LiveEntityPvpBitfieldSync(
|
|
d.EntityObjects.Objects,
|
|
liveEntities,
|
|
d.PhysicsEngine.ShadowObjects));
|
|
bindings.BindProjectionPoseReady(
|
|
equippedLease.Resource,
|
|
lightsLease.Resource.OnAttachedPoseReady);
|
|
if (liveRenderProjections is not null)
|
|
{
|
|
bindings.BindProjectionPoseReady(
|
|
equippedLease.Resource,
|
|
liveRenderProjections.OnProjectionPoseReady);
|
|
bindings.BindProjectionRemoved(
|
|
equippedLease.Resource,
|
|
liveRenderProjections.OnProjectionRemoved);
|
|
}
|
|
bindings.Adopt(
|
|
"entity-effect animation hooks",
|
|
content.HookRegistrations.RegisterOwned(entityEffects));
|
|
Fault(LivePresentationCompositionPoint.EffectRoutingBound);
|
|
|
|
return CompletePresentation(
|
|
host,
|
|
content,
|
|
world,
|
|
interaction,
|
|
componentLifecycle,
|
|
motionRuntime,
|
|
parentAcceptance,
|
|
entitySpawnAdapter,
|
|
entityScriptActivator,
|
|
staticAnimationScheduler,
|
|
worldTransit,
|
|
worldAvailability,
|
|
worldState,
|
|
renderSceneShadow,
|
|
renderSceneShadowLease,
|
|
liveEntities,
|
|
placementProjection,
|
|
localPlayerShadowSynchronizer,
|
|
projectileController,
|
|
projectionWithdrawal,
|
|
lightsLease,
|
|
animationScheduler,
|
|
animationPresenter,
|
|
equippedLease,
|
|
entityEffects,
|
|
presentationLease,
|
|
selectionInteractionSource,
|
|
bindings,
|
|
scope,
|
|
ref bindingsOwnedByScope,
|
|
liveRuntimeLease);
|
|
}
|
|
catch (Exception failure)
|
|
{
|
|
if (bindings is not null && !bindingsOwnedByScope)
|
|
{
|
|
scope.Own(
|
|
"live-presentation runtime bindings",
|
|
bindings,
|
|
static value => value.Dispose());
|
|
bindingsOwnedByScope = true;
|
|
}
|
|
|
|
scope.RollbackAndThrow(failure);
|
|
throw new System.Diagnostics.UnreachableException();
|
|
}
|
|
}
|
|
|
|
private LivePresentationResult CompletePresentation(
|
|
HostInputCameraResult host,
|
|
ContentEffectsAudioResult content,
|
|
WorldRenderResult world,
|
|
InteractionRetainedUiResult interaction,
|
|
DeferredLiveEntityRuntimeComponentLifecycle componentLifecycle,
|
|
LiveEntityMotionRuntimeController motionRuntime,
|
|
DeferredLiveEntityParentAcceptance parentAcceptance,
|
|
EntitySpawnAdapter entitySpawnAdapter,
|
|
EntityScriptActivator entityScriptActivator,
|
|
RetailStaticAnimatingObjectScheduler staticAnimationScheduler,
|
|
RuntimeWorldTransitState worldTransit,
|
|
WorldGenerationAvailabilityState worldAvailability,
|
|
GpuWorldState worldState,
|
|
RenderSceneShadowRuntime? renderSceneShadow,
|
|
CompositionAcquisitionScope.CompositionAcquisitionLease<
|
|
RenderSceneShadowRuntime>? renderSceneShadowLease,
|
|
LiveEntityRuntime liveEntities,
|
|
RuntimePlacementPresentationSink placementProjection,
|
|
LocalPlayerShadowSynchronizer localPlayerShadowSynchronizer,
|
|
ProjectileController projectileController,
|
|
LiveEntityProjectionWithdrawalController projectionWithdrawal,
|
|
CompositionAcquisitionScope.CompositionAcquisitionLease<LiveEntityLightController> lightsLease,
|
|
LiveEntityAnimationScheduler animationScheduler,
|
|
LiveEntityAnimationPresenter animationPresenter,
|
|
CompositionAcquisitionScope.CompositionAcquisitionLease<EquippedChildRenderController> equippedLease,
|
|
EntityEffectController entityEffects,
|
|
CompositionAcquisitionScope.CompositionAcquisitionLease<LiveEntityPresentationController> presentationLease,
|
|
DeferredSelectionInteractionSource selectionInteractionSource,
|
|
LivePresentationRuntimeBindings bindings,
|
|
CompositionAcquisitionScope scope,
|
|
ref bool bindingsOwnedByScope,
|
|
CompositionAcquisitionScope.CompositionAcquisitionLease<LiveEntityRuntime> liveRuntimeLease)
|
|
{
|
|
LivePresentationDependencies d = _dependencies;
|
|
WorldRenderFoundation foundation = world.Foundation;
|
|
AlphaScratchBudgetProfile alphaScratchBudgets =
|
|
AlphaScratchBudgetProfile.Create(
|
|
d.Options.ResidencyBudgets.AlphaScratchBytes);
|
|
|
|
var selectionScene = new RetailSelectionScene(
|
|
new RetailSelectionGeometryCache(content.Dats, d.DatLock));
|
|
// Campaign V slice V6j: the world dispatcher records into the pass the
|
|
// world scene phase publishes on this scope. The raw-GL arm was
|
|
// deleted at slice V11.
|
|
IWorldPassScope? worldPassScope = d.Graphics.WorldPassScope;
|
|
var dispatcherLease = scope.Acquire(
|
|
"WB draw dispatcher",
|
|
() => new WbDrawDispatcher(
|
|
host.GpuDevice,
|
|
host.GpuFrameLifetime,
|
|
worldPassScope
|
|
?? throw new InvalidOperationException(
|
|
"The graphics backend must publish a world pass scope."),
|
|
foundation.TextureCache,
|
|
foundation.MeshAdapter!,
|
|
entitySpawnAdapter,
|
|
d.ClassificationCache,
|
|
d.TranslucencyFades,
|
|
selectionScene,
|
|
d.RetailAlphaQueue,
|
|
alphaScratchBudgets.DispatcherBytes),
|
|
static value => value.Dispose());
|
|
var selectionQuery = new WorldSelectionQuery(
|
|
liveEntities,
|
|
d.EntityObjects.Objects,
|
|
selectionScene,
|
|
() => d.PlayerIdentity.ServerGuid,
|
|
interaction.LateBindings.SelectionCamera.Snapshot,
|
|
() => new Vector2(
|
|
d.PointerPosition.X,
|
|
d.PointerPosition.Y),
|
|
() => d.PlayerController.Controller is { } player
|
|
? new PlayerInteractionPose(player.CellId, player.Position)
|
|
: null,
|
|
d.MotionBindings.GetSetupCylinder,
|
|
setupId =>
|
|
{
|
|
lock (d.DatLock)
|
|
{
|
|
if (!content.Dats.TryGet<Setup>(setupId, out Setup? setup)
|
|
|| setup.SelectionSphere is not { } sphere)
|
|
{
|
|
return null;
|
|
}
|
|
return (sphere.Origin, sphere.Radius);
|
|
}
|
|
},
|
|
// CPhysicsObj::UpdateChild @ 0x00512D50 recomposes an equipped
|
|
// child's own m_position from Frame::combine(parent part frame,
|
|
// holding frame) every tick; SmartBox::GetObjectBoundingBox @
|
|
// 0x00452E20 anchors the selection sphere on that own frame.
|
|
// EquippedChildRenderController publishes exactly that composed
|
|
// root here each frame, so selection borrows it rather than the
|
|
// parent-derived bookkeeping pose.
|
|
localEntityId =>
|
|
d.EffectPoses.TryGetRootPose(localEntityId, out Matrix4x4 childRoot)
|
|
? childRoot
|
|
: null);
|
|
var radarSnapshotProvider = new RadarSnapshotProvider(
|
|
d.EntityObjects.Objects,
|
|
liveEntities,
|
|
() => liveEntities.Snapshots,
|
|
playerGuid: () => d.PlayerIdentity.ServerGuid,
|
|
playerYawRadians: () => d.PlayerController.Controller?.Yaw ?? 0f,
|
|
playerCellId: () => d.PlayerController.Controller?.CellId ?? 0u,
|
|
selectedGuid: () => d.Selection.SelectedObjectId,
|
|
coordinatesOnRadar: () => d.Settings.Gameplay.CoordinatesOnRadar,
|
|
uiLocked: () => d.Settings.Gameplay.LockUI,
|
|
spatialQuery: () => worldState);
|
|
bindings.Adopt(
|
|
"radar snapshot",
|
|
interaction.LateBindings.Radar.Bind(radarSnapshotProvider));
|
|
var selectionInteractions = new SelectionInteractionController(
|
|
d.Selection,
|
|
selectionQuery,
|
|
interaction.ItemInteraction,
|
|
new WorldSessionSelectionInteractionTransport(
|
|
() => interaction.LateBindings.Session.CurrentSession),
|
|
new PlayerInteractionMovementSink(
|
|
() => d.PlayerController.Controller,
|
|
d.PlayerApproachCompletions),
|
|
d.Toast,
|
|
d.PlayerApproachCompletions);
|
|
selectionInteractionSource.Bind(selectionInteractions);
|
|
bindings.Adopt(
|
|
"world selection",
|
|
interaction.LateBindings.Selection.Bind(
|
|
selectionQuery,
|
|
selectionInteractions));
|
|
Fault(LivePresentationCompositionPoint.SelectionAndRadarBound);
|
|
|
|
CompositionAcquisitionScope.CompositionAcquisitionLease<
|
|
RetainedUiGameplayBinding>? retainedGameplayLease = null;
|
|
if (interaction.RetainedUi is { } retainedUi)
|
|
{
|
|
retainedGameplayLease = scope.Acquire(
|
|
"retained gameplay binding",
|
|
() => RetainedUiGameplayBinding.Create(
|
|
retainedUi.Host.Root,
|
|
(item, x, y) =>
|
|
selectionInteractions.PlaceDraggedItem(item, x, y),
|
|
d.HostQuiescence),
|
|
static value => value.Dispose());
|
|
retainedGameplayLease.Resource.Attach();
|
|
}
|
|
Fault(LivePresentationCompositionPoint.RetainedGameplayBound);
|
|
if (dispatcherLease.Resource is { } alphaDispatcher)
|
|
{
|
|
alphaDispatcher.AlphaToCoverage =
|
|
d.Settings.ResolvedQuality.AlphaToCoverage;
|
|
}
|
|
|
|
CompositionAcquisitionScope.CompositionAcquisitionLease<
|
|
PaperdollViewportRenderer>? paperdollLease = null;
|
|
PaperdollFramePresenter? paperdollPresenter = null;
|
|
// Campaign V slice V6l: both retained-UI viewports exist on BOTH arms.
|
|
// The RHI arm needed two backend fixes first — a layered sampled view per
|
|
// render target, so a colour attachment can legally enter the
|
|
// sampler2DArray table, and sample-count pipeline variants in
|
|
// WbDrawDispatcher, because a world pipeline is built at the backbuffer's
|
|
// count and an offscreen target is single-sampled by contract (plan
|
|
// §5.5.16 defect 3).
|
|
if (dispatcherLease.Resource is { } paperdollDispatcher
|
|
&& interaction.RetainedUi?.Runtime.PaperdollViewportWidget is { } viewport
|
|
&& interaction.RetainedUi.Runtime.InventoryFrame is { } inventoryFrame)
|
|
{
|
|
paperdollLease = scope.Acquire(
|
|
"paperdoll viewport",
|
|
() => new PaperdollViewportRenderer(
|
|
worldPassScope
|
|
?? throw new InvalidOperationException(
|
|
"The graphics backend must publish a world pass scope."),
|
|
host.GpuDevice,
|
|
host.GpuFrameLifetime,
|
|
paperdollDispatcher,
|
|
foundation.SceneLighting!,
|
|
foundation.TextureCache,
|
|
foundation.MeshAdapter!),
|
|
static value => value.Dispose());
|
|
IUiViewportRenderer? previousRenderer = viewport.Renderer;
|
|
viewport.Renderer = paperdollLease.Resource;
|
|
bindings.AdoptRelease(
|
|
"paperdoll viewport target",
|
|
() =>
|
|
{
|
|
if (ReferenceEquals(viewport.Renderer, paperdollLease.Resource))
|
|
viewport.Renderer = previousRenderer;
|
|
});
|
|
paperdollPresenter = new PaperdollFramePresenter(
|
|
paperdollLease.Resource,
|
|
new RetailPaperdollFrameView(
|
|
viewport,
|
|
new PaperdollInventoryVisibility(inventoryFrame)),
|
|
new RetailPaperdollDollFactory(
|
|
new LivePaperdollEntityLookup(liveEntities),
|
|
d.PlayerIdentity,
|
|
new RetailPaperdollPoseApplicator(
|
|
content.Dats,
|
|
content.AnimationLoader,
|
|
d.DatLock)));
|
|
}
|
|
|
|
CompositionAcquisitionScope.CompositionAcquisitionLease<
|
|
CreatureAppraisalViewportRenderer>? creatureAppraisalLease = null;
|
|
CreatureAppraisalFramePresenter? creatureAppraisalPresenter = null;
|
|
if (dispatcherLease.Resource is { } appraisalDispatcher
|
|
&& interaction.RetainedUi?.Runtime.CreatureAppraisalViewportWidget
|
|
is { } creatureViewport
|
|
&& interaction.RetainedUi.Runtime.ExaminationFrame
|
|
is { } examinationFrame
|
|
&& interaction.RetainedUi.Runtime.AppraisalController
|
|
is { } appraisalController)
|
|
{
|
|
creatureAppraisalLease = scope.Acquire(
|
|
"creature appraisal viewport",
|
|
() => new CreatureAppraisalViewportRenderer(
|
|
worldPassScope
|
|
?? throw new InvalidOperationException(
|
|
"The graphics backend must publish a world pass scope."),
|
|
host.GpuDevice,
|
|
host.GpuFrameLifetime,
|
|
appraisalDispatcher,
|
|
foundation.SceneLighting!,
|
|
foundation.TextureCache,
|
|
foundation.MeshAdapter!),
|
|
static value => value.Dispose());
|
|
IUiViewportRenderer? previousRenderer = creatureViewport.Renderer;
|
|
creatureViewport.Renderer = creatureAppraisalLease.Resource;
|
|
bindings.AdoptRelease(
|
|
"creature appraisal viewport target",
|
|
() =>
|
|
{
|
|
if (ReferenceEquals(
|
|
creatureViewport.Renderer,
|
|
creatureAppraisalLease.Resource))
|
|
{
|
|
creatureViewport.Renderer = previousRenderer;
|
|
}
|
|
});
|
|
creatureAppraisalPresenter = new CreatureAppraisalFramePresenter(
|
|
creatureAppraisalLease.Resource,
|
|
new RetailCreatureAppraisalFrameView(
|
|
creatureViewport,
|
|
examinationFrame,
|
|
appraisalController),
|
|
new RetailCreatureAppraisalCloneFactory(
|
|
new LiveCreatureAppraisalEntityLookup(liveEntities)));
|
|
}
|
|
Fault(LivePresentationCompositionPoint.PrivateCreatureViewportsCreated);
|
|
|
|
var envCellFrustum = new WbFrustum();
|
|
var envCellLease = scope.Acquire(
|
|
"environment-cell renderer",
|
|
() => new EnvCellRenderer(
|
|
host.GpuDevice,
|
|
host.GpuFrameLifetime,
|
|
worldPassScope
|
|
?? throw new InvalidOperationException(
|
|
"The graphics backend must publish a world pass scope."),
|
|
foundation.MeshAdapter!.MeshManager!,
|
|
envCellFrustum),
|
|
static value => value.Dispose());
|
|
// The three pipelines ARE its program, built at construction — the
|
|
// raw-GL arm's separate Initialize(Shader) step was deleted at V11.
|
|
Fault(LivePresentationCompositionPoint.EnvironmentCellsCreated);
|
|
|
|
// The streaming pipeline itself is backend-neutral and runs on both
|
|
// arms: landblocks load, heightfields and collision build, and the
|
|
// spatial index fills. Only publication into GPU state is renderer-
|
|
// owned, so the Vulkan arm publishes into nothing until the world arm
|
|
// lands.
|
|
TerrainModernRenderer? terrainRenderer = foundation.Terrain;
|
|
EnvCellRenderer? envCells = envCellLease.Resource;
|
|
var landblockRenderPublisher = new LandblockRenderPublisher(
|
|
(landblockId, meshData, origin) =>
|
|
terrainRenderer?.AddLandblockWithMesh(
|
|
landblockId,
|
|
meshData,
|
|
origin),
|
|
landblockId => terrainRenderer?.RemoveLandblock(landblockId),
|
|
d.CellVisibility,
|
|
worldState,
|
|
prepareEnvCells: build =>
|
|
{
|
|
if (foundation.MeshAdapter?.MeshManager is { } envCellMeshes)
|
|
EnvCellMeshPreparationScheduler.Schedule(build, envCellMeshes);
|
|
},
|
|
removeEnvCells: landblockId => envCells?.RemoveLandblock(landblockId),
|
|
envCellPublisher: envCells);
|
|
var landblockPhysicsPublisher = new LandblockPhysicsPublisher(
|
|
d.EntityObjects.Physics,
|
|
world.TerrainBuild.HeightTable);
|
|
var landblockStaticPublisher =
|
|
new LandblockStaticPresentationPublisher(
|
|
content.LightingSink,
|
|
d.TranslucencyFades,
|
|
d.WorldGameState,
|
|
d.WorldEvents);
|
|
var landblockRetirementOwner =
|
|
new LandblockPresentationRetirementOwner(
|
|
landblockRenderPublisher,
|
|
landblockPhysicsPublisher,
|
|
landblockStaticPublisher,
|
|
content.LightingSink,
|
|
d.TranslucencyFades);
|
|
var landblockLoaded = new DeferredLiveEntityLandblockLoadedSink();
|
|
var landblockPipeline = new LandblockPresentationPipeline(
|
|
landblockRenderPublisher,
|
|
landblockPhysicsPublisher,
|
|
landblockStaticPublisher,
|
|
worldState,
|
|
landblockRetirementOwner,
|
|
landblockLoaded.OnLandblockLoaded,
|
|
landblockRenderPublisher.PrepareAfterRenderPins,
|
|
renderSceneShadow?.StaticProjections);
|
|
Fault(LivePresentationCompositionPoint.LandblockPipelineCreated);
|
|
|
|
var clipFrameLease = scope.Acquire(
|
|
"portal clip frame",
|
|
ClipFrame.NoClip,
|
|
static value => value.Dispose());
|
|
// Campaign V slice V6l: the portal depth mask compiles portal_depth
|
|
// from SPIR-V into three pipelines and records into the pass the
|
|
// world scene phase publishes on this scope. The raw-GL inline
|
|
// program and raw draws were deleted at slice V11.
|
|
var portalDepthLease = scope.Acquire(
|
|
"portal depth mask",
|
|
() => new PortalDepthMaskRenderer(
|
|
host.GpuDevice,
|
|
host.GpuFrameLifetime,
|
|
worldPassScope
|
|
?? throw new InvalidOperationException(
|
|
"The graphics backend must publish a world pass scope.")),
|
|
static value => value.Dispose());
|
|
CompositionAcquisitionScope.CompositionAcquisitionLease<
|
|
PortalWaitNoticeController>? portalWaitNoticeLease = null;
|
|
if (interaction.RetainedUi is { } portalRetainedUi)
|
|
{
|
|
portalWaitNoticeLease = scope.Acquire(
|
|
"portal wait notice",
|
|
() => new PortalWaitNoticeController(
|
|
portalRetainedUi.Host.Root),
|
|
static value => value.Dispose());
|
|
}
|
|
Action<string?>? displayPortalWaitNotice =
|
|
portalWaitNoticeLease is { } waitNoticeLease
|
|
? waitNoticeLease.Resource.Set
|
|
: null;
|
|
CompositionAcquisitionScope.CompositionAcquisitionLease<
|
|
PortalTunnelPresentation>? portalTunnelLease = null;
|
|
// Campaign V slice V6m: portal space opens a backbuffer pass of its
|
|
// own and publishes it on the scope for the span of the draw, the way
|
|
// the two offscreen viewports do. The raw-GL arm was deleted at V11.
|
|
if (dispatcherLease.Resource is { } portalDispatcher)
|
|
{
|
|
PortalTunnelPresentation portalTunnel;
|
|
try
|
|
{
|
|
portalTunnel = d.PortalTunnelFallback.AcquirePrepared(
|
|
() => PortalTunnelPresentation.CreateRequired(
|
|
worldPassScope
|
|
?? throw new InvalidOperationException(
|
|
"The graphics backend must publish a world pass scope."),
|
|
host.GpuFrameLifetime,
|
|
content.Dats,
|
|
content.AnimationLoader,
|
|
d.HookRouter,
|
|
portalDispatcher,
|
|
foundation.SceneLighting!,
|
|
foundation.MeshAdapter!,
|
|
displayPortalWaitNotice,
|
|
portalWaitNoticeLease?.Resource),
|
|
static tunnel => tunnel.PrepareResources());
|
|
}
|
|
catch (Exception acquisitionFailure)
|
|
{
|
|
try
|
|
{
|
|
d.PortalTunnelFallback.ReleaseFallback();
|
|
}
|
|
catch (Exception cleanupFailure)
|
|
{
|
|
throw new AggregateException(
|
|
"Portal-tunnel construction and fallback rollback both failed.",
|
|
acquisitionFailure,
|
|
cleanupFailure);
|
|
}
|
|
|
|
throw;
|
|
}
|
|
portalTunnelLease = scope.Own(
|
|
"portal tunnel fallback",
|
|
portalTunnel,
|
|
_ => d.PortalTunnelFallback.ReleaseFallback());
|
|
}
|
|
Fault(LivePresentationCompositionPoint.PortalResourcesCreated);
|
|
|
|
// Campaign V slice V6k: the sky compiles its pair from SPIR-V and
|
|
// records into the pass the world scene phase publishes on this
|
|
// scope. The raw-GL arm — its own shader pair (acquired through
|
|
// GameRenderResourceLifetime.AcquireSkyShader, deleted with it) and
|
|
// its own bindless/device-table wiring — was deleted at slice V11.
|
|
var skyLease = scope.Acquire(
|
|
"sky renderer",
|
|
() => new SkyRenderer(
|
|
host.GpuDevice,
|
|
host.GpuFrameLifetime,
|
|
worldPassScope
|
|
?? throw new InvalidOperationException(
|
|
"The graphics backend must publish a world pass scope."),
|
|
content.Dats,
|
|
foundation.TextureCache)
|
|
{
|
|
// Campaign V slice V7: null unless ACDREAM_SKY_PHASE_SECONDS
|
|
// is set, which is every run but a differential gate's.
|
|
AnimationPhaseSecondsOverride = d.Options.SkyAnimationPhaseSeconds,
|
|
},
|
|
static value => value.Dispose());
|
|
// Campaign V slice V6l: the RHI arm compiles the two particle pairs
|
|
// from SPIR-V, draws instances through the vertex binding the V6l
|
|
// contract amendment added, and records into the pass the world scene
|
|
// phase publishes on this scope. The raw-GL arm was deleted at V11.
|
|
var particleLease = scope.AcquireOptional(
|
|
"particle renderer",
|
|
() => new ParticleRenderer(
|
|
host.GpuDevice,
|
|
host.GpuFrameLifetime,
|
|
worldPassScope
|
|
?? throw new InvalidOperationException(
|
|
"The graphics backend must publish a world pass scope."),
|
|
content.ParticleSystem,
|
|
foundation.TextureCache,
|
|
content.Dats,
|
|
foundation.MeshAdapter!,
|
|
d.RetailAlphaQueue,
|
|
alphaScratchBudgets.ParticleBytes),
|
|
static value => value.Dispose());
|
|
Fault(LivePresentationCompositionPoint.SkyAndParticlesCreated);
|
|
|
|
IRenderFrameResourceDiagnosticsSource? resourceDiagnostics =
|
|
d.Options.UiProbeDump
|
|
&& dispatcherLease.Resource is { } diagnosticDispatcher
|
|
&& envCellLease.Resource is { } diagnosticEnvCells
|
|
&& particleLease.Resource is { } diagnosticParticles
|
|
&& portalDepthLease.Resource is { } diagnosticPortalDepth
|
|
? new RuntimeRenderFrameResourceDiagnosticsSource(
|
|
content.ParticleSystem,
|
|
content.ParticleSink,
|
|
diagnosticDispatcher,
|
|
diagnosticEnvCells,
|
|
diagnosticParticles,
|
|
interaction.RetainedUi?.Host.TextRenderer,
|
|
diagnosticPortalDepth,
|
|
clipFrameLease.Resource,
|
|
foundation.Terrain!,
|
|
foundation.SceneLighting!,
|
|
foundation.MeshAdapter!,
|
|
foundation.TextureCache,
|
|
content.PreparedAssets)
|
|
: null;
|
|
var frameDiagnostics = new RenderFrameDiagnosticsController(
|
|
new RuntimeRenderFrameTitleFactsSource(
|
|
worldState,
|
|
d.AnimatedEntities,
|
|
d.WorldTime),
|
|
new SilkRenderFrameTitleSink(d.Window),
|
|
d.RenderDiagnosticLog,
|
|
d.Options.UiProbeDump,
|
|
resourceDiagnostics);
|
|
if (d.DevFrameDiagnostics is { } devFrameDiagnostics)
|
|
{
|
|
bindings.Adopt(
|
|
"developer frame diagnostics",
|
|
devFrameDiagnostics.BindOwned(frameDiagnostics));
|
|
}
|
|
bindings.Adopt(
|
|
"retained-UI frame diagnostics",
|
|
d.UiFrameDiagnostics.BindOwned(frameDiagnostics));
|
|
Fault(LivePresentationCompositionPoint.DiagnosticsBound);
|
|
|
|
var bindingsLease = scope.Own(
|
|
"live-presentation runtime bindings",
|
|
bindings,
|
|
static value => value.Dispose());
|
|
bindingsOwnedByScope = true;
|
|
var result = new LivePresentationResult(
|
|
componentLifecycle,
|
|
motionRuntime,
|
|
parentAcceptance,
|
|
entitySpawnAdapter,
|
|
entityScriptActivator,
|
|
staticAnimationScheduler,
|
|
worldTransit,
|
|
worldAvailability,
|
|
worldState,
|
|
renderSceneShadow,
|
|
liveEntities,
|
|
placementProjection,
|
|
localPlayerShadowSynchronizer,
|
|
projectileController,
|
|
projectionWithdrawal,
|
|
lightsLease.Resource,
|
|
animationScheduler,
|
|
animationPresenter,
|
|
equippedLease.Resource,
|
|
entityEffects,
|
|
presentationLease.Resource,
|
|
dispatcherLease.Resource,
|
|
selectionScene,
|
|
selectionQuery,
|
|
selectionInteractions,
|
|
retainedGameplayLease?.Resource,
|
|
paperdollLease?.Resource,
|
|
paperdollPresenter,
|
|
creatureAppraisalLease?.Resource,
|
|
creatureAppraisalPresenter,
|
|
envCellFrustum,
|
|
envCellLease.Resource,
|
|
landblockPipeline,
|
|
clipFrameLease.Resource,
|
|
portalDepthLease.Resource,
|
|
skyLease.Resource,
|
|
particleLease.Resource,
|
|
frameDiagnostics,
|
|
bindings,
|
|
landblockLoaded);
|
|
foundation.Residency.RegisterDomainSource(
|
|
new DelegateResidencyDomainSource(
|
|
ResidencyDomain.AlphaScratch,
|
|
() => new ResidencyDomainSnapshot(
|
|
ResidencyDomain.AlphaScratch,
|
|
EntryCount: 3,
|
|
OwnerCount: 3,
|
|
Charges: new ResidencyCharges(
|
|
ScratchBytes: checked(
|
|
d.RetailAlphaQueue.RetainedScratchBytes
|
|
+ (dispatcherLease.Resource?.RetainedAlphaScratchBytes ?? 0)
|
|
+ (particleLease.Resource?.RetainedAlphaScratchBytes ?? 0))),
|
|
BudgetBytes: alphaScratchBudgets.TotalBytes)));
|
|
_publication.PublishLivePresentation(result);
|
|
|
|
liveRuntimeLease.Transfer();
|
|
renderSceneShadowLease?.Transfer();
|
|
lightsLease.Transfer();
|
|
equippedLease.Transfer();
|
|
presentationLease.Transfer();
|
|
dispatcherLease.Transfer();
|
|
retainedGameplayLease?.Transfer();
|
|
paperdollLease?.Transfer();
|
|
creatureAppraisalLease?.Transfer();
|
|
envCellLease.Transfer();
|
|
clipFrameLease.Transfer();
|
|
portalDepthLease.Transfer();
|
|
portalTunnelLease?.Transfer();
|
|
portalWaitNoticeLease?.Transfer();
|
|
skyLease.Transfer();
|
|
particleLease.Transfer();
|
|
bindingsLease.Transfer();
|
|
Fault(LivePresentationCompositionPoint.ResultPublished);
|
|
scope.Complete();
|
|
return result;
|
|
}
|
|
|
|
private void Fault(LivePresentationCompositionPoint point) =>
|
|
_faultInjection?.Invoke(point);
|
|
|
|
private sealed class NullAnimationLoader : IAnimationLoader
|
|
{
|
|
public static NullAnimationLoader Instance { get; } = new();
|
|
public Animation? LoadAnimation(uint id) => null;
|
|
}
|
|
|
|
private sealed class DeferredSelectionInteractionSource
|
|
{
|
|
public SelectionInteractionController? Current { get; private set; }
|
|
|
|
public void Bind(SelectionInteractionController value)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(value);
|
|
if (Current is not null)
|
|
{
|
|
throw new InvalidOperationException(
|
|
"Live motion selection interactions are already bound.");
|
|
}
|
|
Current = value;
|
|
}
|
|
}
|
|
}
|