6dc7ba51ee
Flips the last remote classification (SetPosition: teleport-advanced and
cell-less) onto 4b-1's RuntimeRemotePlacementDriveController, runs retail's
teleport_hook before the placement, and deletes the legacy remote-teleport
machinery. Contract: docs/research/2026-08-04-c4-route-4b-3-contract.md.
Retail: MoveOrTeleport @0x00516330's branch @0x00516386 -> teleport_hook
@0x005163EF -> SetFlags(0x1012) @0x00516414 -> SetPosition @0x00516420 ->
return 1 @0x00516438. The hook @0x00514ED0 runs BEFORE the placement and
regardless of its outcome. Retail places this branch unconditionally, at any
distance and any contact state (arg4 is read only @0x0051638E, after the
branch) — which is what retires AP-137's cell-less enqueue-vs-place delta.
D1 — the classifier's cell-less input is now the PRE-merge committed cell.
Retail's predicate is `this_1->cell == 0`, the BODY's own cell at
MoveOrTeleport entry (this_1 is assigned from this @0x00516334). acdream fed
the POST-merge canonical.FullCellId, which RefreshSnapshot ->
RefreshDerivedState -> SetFullCell has already stamped with the accepted wire
cell; a zero wire cell fails validation into RejectedData first. The shipped
remote cell-less predicate was therefore dead code, not merely different from
remotePlacementRequired. Threaded via a builder overload; route 1's overload
is untouched. The graphical !IsSpatiallyVisible arm of
projectionRequiresTeleportHook is deleted — a presentation predicate with no
retail analogue that fired the teleport machinery on a routine hot path.
Deleted: RemoteTeleportController (605), RemoteTeleportPlacement (85),
RemoteShadowPlacementSynchronizer (49), their 1,709 lines of tests, the
remotePlacementRequired predicate, the TeleportHookRequired plumbing, the
legacy pre-operation ConstrainTo fallback, and the player arm's legacy
!IsGrounded fallback. Net -2,030 lines.
Structural fix (two independent Opus reviews, round 1 FAIL/FAIL): three of the
four MAJORs were one defect — OnPosition carried two parallel inline copies of
the routing tail (player-guid, NPC-guid) that had drifted. Extracted
RunRemoteArmTail (3 call sites) and ApplyWireAirborneLeftoverBookkeeping (2),
both branches now share one implementation.
A1 ToConstraintArm mapped AirborneSnap -> AirborneNoOperation, so the NPC
arm armed ConstrainTo ZERO times for an out-of-contact wire-grounded
creature — a regression this slice introduced while closing a
structurally identical hole. Now maps to NearInterpolate; switch made
total with a throwing default proven unreachable.
R1 D2's write-nothing shape existed on the player arm only; NPC packets
fell through and wrote the body. Retail makes no player/NPC distinction.
R2 report_collision_end(this,1) @0x00514F31 was bound to
ShadowObjects.Suspend, a port of a DIFFERENT retail function
(remove_shadows_from_cells) that teleport_hook never calls. Now routes
to RuntimeCollisionReportingState.LeaveWorld, which wraps the private
ForceEnd in an admission-blocking transaction so a DoCollisionEnd
callback cannot recreate the contact table.
R3/A2 A teleported NPC synthesized ServerVelocity from the teleport distance
(~1,000+ m/s) and planned a run cycle from it. Both the install and
RemoteServerControlledVelocityCycle.Apply now gate on !isTeleportRoute.
BISECT HAZARD — A1's fix is correct only BECAUSE R1 landed. AirborneSnap is
reachable wire-airborne on the NPC arm only while D2's shape is missing there.
Reverting R1 alone silently inverts A1 into the opposite divergence: arming
where retail returns 0. Revert both or neither.
Also in the velocity hunk: the NPC block's two !IsPlayerGuid(update.Guid)
guards were dropped when it was wrapped in `if (!isTeleportRoute)`. Safe — all
five exit paths of the enclosing IsPlayerGuid block return, so the predicate is
unconditionally false below it — but it was unremarked by both reviews.
Register: AP-137 REWRITTEN (not deleted) to the surviving acdream-only
divergences — null classification during the login window and Rejected*
through UnroutedCatchUp keep a row. AD-42's RemoteTeleportController citation
retired; AP-136/AP-138 writer lists corrected to the two surviving non-Position
rebucket writers; AP-138 gains the teleport arm as a second producer of the
visible-without-collision residual (retirement path remains #309). AP-135 is
untouched and its two airborne bookkeeping writes are preserved on both arms.
AP-131 does not retire; #276 does not close.
Proof obligation 1: ParkCollisionResidents' overlap throw stays unreachable —
the teleport arm adds packets to the same TryBeginExclusiveAuthoredPlacement
one-operation-per-key machinery the far arm uses, opens no new operation shape,
and every DeferredCell outcome cancels synchronously with
restoreCancelledPark: true. The guarded property remains
HasOldPrefixPlacementDebt's stall, not a throw (4b-1's B2 caveat stands).
Correction to an earlier claim: LiveEntityPresentationController's
_activePlacementOwners was NOT write-never at HEAD —
remotePlacementRequired -> BeginPlacement -> Begin -> BeginAuthoritativePlacement
was a live writer chain. It becomes write-never BECAUSE this slice deletes that
chain, which is why deleting the dead half is behaviour-preserving.
Probe: ACDREAM_PROBE_REMOTE_TELEPORT=1 emits one [remote-teleport] line per
routed arm (guid, cause, hook-ran, placement status). TEMPORARY, strip with the
probe family.
Carried, disclosed not fixed: no dedicated bidirectional collision-partner test
for R2 (the wiring, not LeaveWorld itself, is what lacks coverage); the
stress test's teleport step drives hand-written field assignments rather than
the canonical arm; the per-packet runTeleportHook closure allocation (network
path, not the resolve path Slice I's 0 B discipline governs — file before
route 5 adds a fourth call site). B2: IRuntimeCollisionReportObserver has zero
production implementations, so retail's bidirectional DoCollisionEnd half still
reaches no gameplay consumer — this fix closes the wrong-function binding, not
that nobody listens.
Complete Release suite MEASURED at 11,013 passed / 4 skipped / 0 failed
(baseline 11,027/4/0; net -14 = ~33 deleted test cases against ~19 added).
Neither known flake fired (#302 PortalProjectionTests GC-allocation, #308
NakEmissionTests wall-clock).
STILL OWED: the two-client connected gate, which MUST use an NPC/creature
teleport target. Both round-1 MAJORs lived on the NPC arm and the velocity
cycle early-returns for 0x50xxxxxx guids, so a player target structurally
cannot observe A1, A2, or R3.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
1287 lines
55 KiB
C#
1287 lines
55 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,
|
|
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);
|
|
});
|
|
var placementProjection = new RuntimePlacementPresentationSink(
|
|
liveEntities,
|
|
worldTransit,
|
|
d.WorldGameState,
|
|
d.WorldEvents,
|
|
d.EffectPoses,
|
|
d.LocalPlayerShadow,
|
|
() => 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,
|
|
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,
|
|
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,
|
|
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;
|
|
}
|
|
}
|
|
}
|