diff --git a/src/scenes/director.js b/src/scenes/director.js index ee87f7d9b..75d8174f5 100644 --- a/src/scenes/director.js +++ b/src/scenes/director.js @@ -1281,6 +1281,7 @@ export class SceneDirector { const { scene, shot } = this._getShot(sceneId, shotId); if (!scene || !shot) return { started: false, reason: 'shot-not-found' }; flyDuration ??= shot.move ? shot.durationSec : 2.2; + const releaseAuthority = this._releaseAuthority(); const previousScene = this._project.scenes.find((item) => item.id === this._loadedSceneId) || null; @@ -1305,7 +1306,11 @@ export class SceneDirector { this._setProgress(0); if (previousScene && previousScene.id !== scene.id) { - const released = await this._releaseSceneLayers(previousScene, token); + const released = await this._releaseSceneLayers( + previousScene, + token, + releaseAuthority, + ); if (!released || token.cancelled) { if (!token.cancelled) this._updateStatus(() => @@ -2238,6 +2243,9 @@ export class SceneDirector { this._usesAuthoredCamera = queue.some(({ shot }) => !!shot.move); + // Every release this run reaches, however late, answers to the + // authority it starts under (revokeSceneRelease). + const releaseAuthority = this._releaseAuthority(); // Transition to running state this._running = true; this._previewRun = preview; @@ -2290,7 +2298,9 @@ export class SceneDirector { try { await playSceneQueue(queue, { token, - adapter: createScenePlaybackAdapter(this, DEFAULT_SHOT_DURATION_SEC), + adapter: createScenePlaybackAdapter(this, DEFAULT_SHOT_DURATION_SEC, { + releaseAuthority, + }), previousScene: this._project.scenes.find( (scene) => scene.id === this._loadedSceneId, ), @@ -2690,15 +2700,18 @@ export class SceneDirector { * @param {{ cancelled?: boolean, signal?: AbortSignal }} [token] - Optional LOAD/run token * @returns {Promise} True only when every owned layer is released */ - async _releaseSceneLayers(scene, token = null) { + async _releaseSceneLayers( + scene, + token = null, + authority = this._releaseAuthority(), + ) { this._interactions?.clear(); this._dataPacks?.clear(); const layerIds = Array.isArray(scene?.releaseLayerIds) ? scene.releaseLayerIds : []; // revokeSceneRelease() ends this release's authority over layers. - this._releaseAbort ??= new AbortController(); - const revoked = this._releaseAbort.signal; + const revoked = authority; const signal = token?.signal ? AbortSignal.any([token.signal, revoked]) : revoked; @@ -2747,6 +2760,17 @@ export class SceneDirector { this._releaseAbort = null; } + /** + * The current authority to turn scene layers off, as an abort signal. A run + * or LOAD takes it when it starts, so a revocation also covers the cleanup + * it reaches later (a release at a scene change or at the run's end). + * @returns {AbortSignal} + */ + _releaseAuthority() { + this._releaseAbort ??= new AbortController(); + return this._releaseAbort.signal; + } + /** * Leave a Context mode that isolates the globe, before a shot's layers land. * diff --git a/src/scenes/director.test.mjs b/src/scenes/director.test.mjs index e940a749d..8faee864d 100644 --- a/src/scenes/director.test.mjs +++ b/src/scenes/director.test.mjs @@ -2074,6 +2074,40 @@ test('a revoked scene release turns no further layer off', async () => { } finally { await director.destroy(); restore(); } }); +test('a revocation also covers the release a stopped run reaches later', async () => { + const project = structuredClone(PROJECT_FIXTURE); + project.scenes[0].releaseLayerIds = ['flights']; + const { director, styleManager, dataManager, restore } = makeDirector({ project }); + try { + // The run's visual phase hangs and ignores Stop, as a stuck teardown does. + let settlePhase; + styleManager.applyVisualState = () => + new Promise((resolve) => { + settlePhase = resolve; + }); + const run = director.startScene('scene-1', { single: true, preview: true }); + await settle(); + assert.ok(settlePhase, 'the run is waiting in its phase'); + director.stopScene(); + director.revokeSceneRelease(); + const after = dataManager.setEnabledCalls.length; + settlePhase(true); + await run; + const late = dataManager.setEnabledCalls + .slice(after) + .filter(({ enabled, signal }) => !enabled && !signal?.aborted); + assert.deepEqual(late, [], 'no layer is turned off after the revoke'); + // A run started afterwards releases its layers again. + styleManager.applyVisualState = async () => true; + await director.startScene('scene-1', { single: true, preview: true }); + assert.ok( + dataManager.setEnabledCalls.some( + ({ id, enabled, signal }) => id === 'flights' && !enabled && !signal?.aborted, + ), + ); + } finally { await director.destroy(); restore(); } +}); + /** Drive frame-by-frame camera motion headlessly for one test. */ function installAnimationFrames() { const original = globalThis.requestAnimationFrame; diff --git a/src/scenes/playbackAdapter.js b/src/scenes/playbackAdapter.js index 079387ec5..a53052ff8 100644 --- a/src/scenes/playbackAdapter.js +++ b/src/scenes/playbackAdapter.js @@ -10,12 +10,20 @@ import { displaySceneTitle, displayShotTitle } from './recipes.js'; */ const inHold = (resume) => resume?.holdElapsedSec > 0; -export function createScenePlaybackAdapter(director, defaultShotDurationSec) { +export function createScenePlaybackAdapter( + director, + defaultShotDurationSec, + { releaseAuthority } = {}, +) { let timing; let travel; return { async releaseScene(scene, token) { - const released = await director._releaseSceneLayers(scene, token); + const released = await director._releaseSceneLayers( + scene, + token, + releaseAuthority, + ); if (!token || released) director._loadedSceneId = null; return released; },