Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

refactor: improve editor layout, play mode, and build pipeline

esengineaac7ba532252
diff --git a/editor/src/DockLayoutManager.ts b/editor/src/DockLayoutManager.ts
index a6702f4a6..77ac7b7db 100644
--- a/editor/src/DockLayoutManager.ts
+++ b/editor/src/DockLayoutManager.ts
@@ -116,6 +116,7 @@ export class DockLayoutManager {
if (saved) {
try {
this.api_.fromJSON(saved);
+ this.ensureRequiredPanels_();
this.startSavingLayout();
return;
} catch {
@@ -128,6 +129,10 @@ export class DockLayoutManager {
this.startSavingLayout();
}
+ private ensureRequiredPanels_(): void {
+ // no-op: all required panels are created via default layout
+ }
+
private applyDefaultLayout(): void {
if (!this.api_) return;
@@ -216,13 +221,24 @@ export class DockLayoutManager {
if (!panel) {
const desc = getPanel(id);
if (!desc) return;
- this.api_.addPanel({
- id: desc.id,
- component: desc.id,
- title: desc.title,
- position: { referencePanel: 'scene', direction: 'below' },
- initialHeight: 200,
- });
+
+ if (desc.position === 'center') {
+ this.api_.addPanel({
+ id: desc.id,
+ component: desc.id,
+ title: desc.title,
+ position: { referencePanel: 'scene', direction: 'within' },
+ inactive: true,
+ });
+ } else {
+ this.api_.addPanel({
+ id: desc.id,
+ component: desc.id,
+ title: desc.title,
+ position: { referencePanel: 'scene', direction: 'below' },
+ initialHeight: 200,
+ });
+ }
panel = this.api_.getPanel(id);
}
panel?.api.setActive();
diff --git a/editor/src/Editor.ts b/editor/src/Editor.ts
index 8075f0ba9..f0bfa136d 100644
--- a/editor/src/Editor.ts
+++ b/editor/src/Editor.ts
@@ -57,6 +57,8 @@ import {
lockBuiltinInspectorExtensions,
clearExtensionInspectorExtensions,
} from './panels/inspector/InspectorRegistry';
+import { registerPostProcessVolumeInspector } from './panels/inspector/PostProcessVolumeInspector';
+
import { showConfirmDialog, showInputDialog, showDialog } from './ui/dialog';
import { getEditorStore } from './store';
import { generateUniqueName } from './utils/naming';
@@ -142,6 +144,7 @@ export class Editor {
registerBuiltinEditors();
registerMaterialEditors();
registerBuiltinSchemas();
+ registerPostProcessVolumeInspector();
initBoundsProviders();
registerBuiltinGizmos();
registerBuiltinSettings();
diff --git a/editor/src/__tests__/PlayModeService.test.ts b/editor/src/__tests__/PlayModeService.test.ts
new file mode 100644
index 000000000..4cff2b523
--- /dev/null
+++ b/editor/src/__tests__/PlayModeService.test.ts
@@ -0,0 +1,158 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { mockSceneManager, mockApp, mockAssetServer, SceneManagerSymbol, mockDbEntries } = vi.hoisted(() => {
+ const SceneManagerSymbol = { _name: 'SceneManager' };
+
+ const mockSceneManager = {
+ register: vi.fn(),
+ reset: vi.fn(),
+ };
+
+ const mockAssetServer = {
+ baseUrl: '',
+ setAssetRefResolver: vi.fn(),
+ };
+
+ const mockApp = {
+ hasResource: vi.fn().mockReturnValue(true),
+ getResource: vi.fn((key: any) => {
+ if (key?._name === 'SceneManager') return mockSceneManager;
+ return mockAssetServer;
+ }),
+ world: {
+ spawn: vi.fn(() => 1),
+ despawn: vi.fn(),
+ valid: vi.fn(() => true),
+ has: vi.fn(() => false),
+ get: vi.fn(),
+ tryGet: vi.fn(() => null),
+ insert: vi.fn(),
+ remove: vi.fn(),
+ getAllEntities: vi.fn(() => []),
+ getComponentTypes: vi.fn(() => []),
+ onSpawn: vi.fn(() => () => {}),
+ onDespawn: vi.fn(() => () => {}),
+ },
+ tick: vi.fn(),
+ setPaused: vi.fn(),
+ };
+
+ const mockDbEntries = [
+ { uuid: 'u1', path: 'assets/scenes/main.esscene', type: 'json' },
+ { uuid: 'u2', path: 'assets/scenes/level1.esscene', type: 'json' },
+ { uuid: 'u3', path: 'assets/textures/bg.png', type: 'image' },
+ { uuid: 'u4', path: 'assets/scenes/bonus.esscene', type: 'json' },
+ ];
+
+ return { mockSceneManager, mockApp, mockAssetServer, SceneManagerSymbol, mockDbEntries };
+});
+
+vi.mock('esengine', () => ({
+ Assets: { _name: 'Assets' },
+ Name: Symbol('Name'),
+ Parent: Symbol('Parent'),
+ Children: Symbol('Children'),
+ SceneManager: SceneManagerSymbol,
+ Audio: { stopAll: vi.fn() },
+ audioPlugin: { stopAllSources: vi.fn() },
+ getComponent: vi.fn(() => null),
+ getComponentAssetFields: vi.fn(() => []),
+}));
+
+vi.mock('../renderer/SharedRenderContext', () => ({
+ getSharedRenderContext: vi.fn(() => ({
+ app_: mockApp,
+ pathResolver_: {
+ getProjectDir: vi.fn(() => '/project'),
+ },
+ sceneManager_: {
+ getEntityMap: vi.fn(() => new Map()),
+ },
+ enterPlayMode: vi.fn(),
+ exitPlayMode: vi.fn().mockResolvedValue(undefined),
+ })),
+}));
+
+vi.mock('../store/EditorStore', () => ({
+ getEditorStore: vi.fn(() => ({
+ takeSnapshot: vi.fn(() => ({ scene: {} })),
+ restoreSnapshot: vi.fn(),
+ scene: { entities: [] },
+ })),
+}));
+
+vi.mock('../context/EditorContext', () => ({
+ getEditorInstance: vi.fn(() => null),
+ getEditorContext: vi.fn(() => ({
+ fs: { toAssetUrl: vi.fn((p: string) => `asset://${p}`) },
+ })),
+}));
+
+vi.mock('../asset', () => ({
+ getAssetDatabase: vi.fn(() => ({
+ getAllEntries: vi.fn(() => mockDbEntries[Symbol.iterator]()),
+ })),
+ isUUID: vi.fn(() => false),
+}));
+
+import { getPlayModeService } from '../services/PlayModeService';
+
+describe('PlayModeService — SceneManager integration', () => {
+ let service: ReturnType<typeof getPlayModeService>;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ service = getPlayModeService();
+ });
+
+ it('registers all .esscene files from AssetDatabase on enter()', async () => {
+ await service.enter();
+
+ expect(mockSceneManager.register).toHaveBeenCalledTimes(3);
+ expect(mockSceneManager.register).toHaveBeenCalledWith({
+ name: 'main',
+ path: 'assets/scenes/main.esscene',
+ });
+ expect(mockSceneManager.register).toHaveBeenCalledWith({
+ name: 'level1',
+ path: 'assets/scenes/level1.esscene',
+ });
+ expect(mockSceneManager.register).toHaveBeenCalledWith({
+ name: 'bonus',
+ path: 'assets/scenes/bonus.esscene',
+ });
+ });
+
+ it('does not register non-.esscene assets', async () => {
+ await service.enter();
+
+ const registeredNames = mockSceneManager.register.mock.calls.map(
+ (c: any[]) => c[0].name
+ );
+ expect(registeredNames).not.toContain('bg');
+ });
+
+ it('calls SceneManager.reset() on exit()', async () => {
+ await service.enter();
+ await service.exit();
+
+ expect(mockSceneManager.reset).toHaveBeenCalledTimes(1);
+ });
+
+ it('reset() is called before snapshot restore', async () => {
+ const callOrder: string[] = [];
+ mockSceneManager.reset.mockImplementation(() => callOrder.push('reset'));
+
+ const { getEditorStore } = await import('../store/EditorStore');
+ vi.mocked(getEditorStore).mockReturnValue({
+ takeSnapshot: vi.fn(() => ({ scene: {} })),
+ restoreSnapshot: vi.fn(() => callOrder.push('restore')),
+ scene: { entities: [] },
+ } as any);
+
+ await service.enter();
+ await service.exit();
+
+ expect(callOrder.indexOf('reset')).toBeLessThan(callOrder.indexOf('restore'));
+ });
+});
diff --git a/editor/src/__tests__/PlayableEmitter.test.ts b/editor/src/__tests__/PlayableEmitter.test.ts
new file mode 100644
index 000000000..eb27da58c
--- /dev/null
+++ b/editor/src/__tests__/PlayableEmitter.test.ts
@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { PLAYABLE_HTML_TEMPLATE } from '../builder/templates';
+
+describe('Playable HTML Template — multi-scene support', () => {
+ it('template contains __SCENES__ variable instead of __SCENE__', () => {
+ expect(PLAYABLE_HTML_TEMPLATE).toContain('var __SCENES__={{SCENES_DATA}}');
+ expect(PLAYABLE_HTML_TEMPLATE).not.toContain('var __SCENE__=');
+ });
+
+ it('template passes scenes and firstScene to initPlayableRuntime', () => {
+ expect(PLAYABLE_HTML_TEMPLATE).toContain("scenes:__SCENES__,firstScene:'{{STARTUP_SCENE}}'");
+ expect(PLAYABLE_HTML_TEMPLATE).not.toContain('sceneData:');
+ expect(PLAYABLE_HTML_TEMPLATE).not.toContain('sceneName:');
+ });
+
+ it('template placeholders are replaced correctly for multi-scene', () => {
+ const scenes = [
+ { name: 'main', data: '{"entities":[]}' },
+ { name: 'level1', data: '{"entities":[{"id":1}]}' },
+ ];
+ const startupScene = 'main';
+
+ const scenesDataStr = `[${scenes.map(s => `{name:${JSON.stringify(s.name)},data:${s.data}}`).join(',')}]`;
+
+ const html = PLAYABLE_HTML_TEMPLATE
+ .replace('{{SCENES_DATA}}', scenesDataStr)
+ .replace('{{STARTUP_SCENE}}', startupScene)
+ .replace('{{WASM_SDK}}', '')
+ .replace('{{SPINE_SCRIPT}}', '')
+ .replace('{{PHYSICS_SCRIPT}}', '')
+ .replace('{{GAME_CODE}}', '')
+ .replace('{{ASSETS_MAP}}', '{}')
+ .replace('{{PHYSICS_CONFIG}}', '{}')
+ .replace('{{MANIFEST}}', 'null')
+ .replace('{{RUNTIME_CONFIG}}', '')
+ .replace('{{RUNTIME_APP_CONFIG}}', '')
+ .replace('{{CTA_STYLE}}', '')
+ .replace('{{CTA_HTML}}', '')
+ .replace('{{CTA_SCRIPT}}', '')
+ .replace('{{CTA_SHOW}}', '');
+
+ expect(html).toContain(`var __SCENES__=[{name:"main",data:{"entities":[]}},{name:"level1",data:{"entities":[{"id":1}]}}]`);
+ expect(html).toContain("firstScene:'main'");
+ expect(html).not.toContain('{{');
+ });
+});
diff --git a/editor/src/__tests__/setup.ts b/editor/src/__tests__/setup.ts
index aff36506a..cae19c75f 100644
--- a/editor/src/__tests__/setup.ts
+++ b/editor/src/__tests__/setup.ts
@@ -1,38 +1 @@
-import { vi } from 'vitest';
-
-global.ResizeObserver = vi.fn().mockImplementation(() => ({
- observe: vi.fn(),
- unobserve: vi.fn(),
- disconnect: vi.fn(),
-}));
-
-global.IntersectionObserver = vi.fn().mockImplementation(() => ({
- observe: vi.fn(),
- unobserve: vi.fn(),
- disconnect: vi.fn(),
-}));
-
-HTMLCanvasElement.prototype.getContext = vi.fn(() => ({
- fillRect: vi.fn(),
- clearRect: vi.fn(),
- getImageData: vi.fn(),
- putImageData: vi.fn(),
- createImageData: vi.fn(),
- setTransform: vi.fn(),
- drawImage: vi.fn(),
- save: vi.fn(),
- restore: vi.fn(),
- beginPath: vi.fn(),
- moveTo: vi.fn(),
- lineTo: vi.fn(),
- closePath: vi.fn(),
- stroke: vi.fn(),
- translate: vi.fn(),
- scale: vi.fn(),
- rotate: vi.fn(),
- arc: vi.fn(),
- fill: vi.fn(),
- measureText: vi.fn(() => ({ width: 0 })),
- fillText: vi.fn(),
- strokeText: vi.fn(),
-})) as any;
+// Vitest setup for editor tests
diff --git a/editor/src/builder/PlayableEmitter.ts b/editor/src/builder/PlayableEmitter.ts
index 338c40a37..b89bc011e 100644
--- a/editor/src/builder/PlayableEmitter.ts
+++ b/editor/src/builder/PlayableEmitter.ts
@@ -42,6 +42,8 @@ const COMPONENT_TO_PLUGIN: Record<string, string> = {
'LayoutGroup': 'layoutGroupPlugin',
'AudioSource': 'audioPlugin',
'ParticleEmitter': 'particlePlugin',
+ 'Tilemap': 'tilemapPlugin',
+ 'TilemapLayer': 'tilemapPlugin',
};
function analyzeUsedPlugins(artifact: BuildArtifact): string[] {
@@ -111,15 +113,17 @@ export class PlayableEmitter implements PlatformEmitter {
const gameCode = await this.compileUserScripts(fs, projectDir, context, artifact);
progress.log('info', `Scripts compiled: ${gameCode.length} bytes`);
- // 3. Process startup scene (resolve UUIDs)
- const sceneName = startupScene.replace(/.*\//, '').replace('.esscene', '');
- const sceneData = artifact.scenes.get(sceneName);
- if (!sceneData) {
+ // 3. Process all scenes (resolve UUIDs)
+ const startupSceneName = startupScene.replace(/.*\//, '').replace('.esscene', '');
+ const allScenes: Array<{ name: string; data: string }> = [];
+ for (const [name, data] of artifact.scenes) {
+ const copy = JSON.parse(JSON.stringify(data));
+ this.resolveSceneUUIDs(copy, artifact);
+ allScenes.push({ name, data: JSON.stringify(copy) });
+ }
+ if (!allScenes.some(s => s.name === startupSceneName)) {
return { success: false, error: `Startup scene not found: ${startupScene}` };
}
- const sceneDataCopy = JSON.parse(JSON.stringify(sceneData));
- this.resolveSceneUUIDs(sceneDataCopy, artifact);
- const rewrittenScene = JSON.stringify(sceneDataCopy);
// 4. Load spine module if needed
progress.setCurrentTask('Loading modules...', 25);
@@ -165,7 +169,7 @@ export class PlayableEmitter implements PlatformEmitter {
// 7. Assemble HTML
progress.setCurrentTask('Assembling HTML...', 50);
const html = this.assembleHTML(
- wasmSdk, gameCode, rewrittenScene, sceneName, assets,
+ wasmSdk, gameCode, allScenes, startupSceneName, assets,
spineJsSource, spineWasmBase64,
physicsJsSource, physicsWasmBase64,
context, manifestJson
@@ -390,7 +394,8 @@ const __plugins = [${pluginList}];
}
private assembleHTML(
- wasmSdk: string, gameCode: string, sceneData: string, sceneName: string,
+ wasmSdk: string, gameCode: string,
+ allScenes: Array<{ name: string; data: string }>, startupScene: string,
assets: Map<string, string>,
spineJs: string, spineWasmBase64: string,
physicsJs: string, physicsWasmBase64: string,
@@ -442,8 +447,11 @@ const __plugins = [${pluginList}];
.replace('{{PHYSICS_SCRIPT}}', () => physicsScript)
.replace('{{GAME_CODE}}', () => gameCode)
.replace('{{ASSETS_MAP}}', () => `{${entries.join(',')}}`)
- .replace('{{SCENE_DATA}}', () => sceneData)
- .replace('{{SCENE_NAME}}', () => sceneName)
+ .replace('{{SCENES_DATA}}', () => {
+ const items = allScenes.map(s => `{name:${JSON.stringify(s.name)},data:${s.data}}`);
+ return `[${items.join(',')}]`;
+ })
+ .replace('{{STARTUP_SCENE}}', () => startupScene)
.replace('{{PHYSICS_CONFIG}}', () => physicsConfig)
.replace('{{MANIFEST}}', () => manifestJson)
.replace('{{RUNTIME_CONFIG}}', () => runtimeConfigCode)
diff --git a/editor/src/builder/templates.ts b/editor/src/builder/templates.ts
index 953a8f1a1..5cc1f445a 100644
--- a/editor/src/builder/templates.ts
+++ b/editor/src/builder/templates.ts
@@ -36,7 +36,7 @@ html,body{width:100%;height:100%;overflow:hidden;background:#000}
</script>
<script>
var __PA__={{ASSETS_MAP}};
-var __SCENE__={{SCENE_DATA}};
+var __SCENES__={{SCENES_DATA}};
var __MANIFEST__={{MANIFEST}};
{{CTA_SCRIPT}}
@@ -59,7 +59,7 @@ var __MANIFEST__={{MANIFEST}};
{{CTA_SHOW}}
await es.initPlayableRuntime({
app:app,module:Module,canvas:c,
- assets:__PA__,sceneData:__SCENE__,sceneName:'{{SCENE_NAME}}',
+ assets:__PA__,scenes:__SCENES__,firstScene:'{{STARTUP_SCENE}}',
spineWasmBase64:typeof __SPINE_WASM_B64__!=='undefined'?__SPINE_WASM_B64__:undefined,
physicsWasmBase64:typeof __PHYSICS_WASM_B64__!=='undefined'?__PHYSICS_WASM_B64__:undefined,
physicsConfig:{{PHYSICS_CONFIG}},manifest:__MANIFEST__
diff --git a/editor/src/extension/ExtensionContext.ts b/editor/src/extension/ExtensionContext.ts
index 082b021e4..10b554a87 100644
--- a/editor/src/extension/ExtensionContext.ts
+++ b/editor/src/extension/ExtensionContext.ts
@@ -20,11 +20,14 @@ export class ExtensionContext {
PostProcess: {
...(base.PostProcess as object),
- addPass: (name: string, shader: number) => {
- if (this.disposed_) return -1;
- const idx = (base.PostProcess as any).addPass(name, shader);
- this.postProcessPasses_.add(name);
- return idx;
+ bind: (camera: number, stack: unknown) => {
+ if (this.disposed_) return;
+ PostProcess.bind(camera, stack as any);
+ this.postProcessCameras_.add(camera);
+ },
+ unbind: (camera: number) => {
+ PostProcess.unbind(camera);
+ this.postProcessCameras_.delete(camera);
},
},
@@ -54,8 +57,8 @@ export class ExtensionContext {
unregisterDrawCallback(id);
}
- for (const name of this.postProcessPasses_) {
- try { PostProcess.removePass(name); } catch {}
+ for (const camera of this.postProcessCameras_) {
+ try { PostProcess.unbind(camera); } catch {}
}
for (const handle of this.shaderHandles_) {
@@ -65,7 +68,7 @@ export class ExtensionContext {
private disposed_ = false;
private drawCallbackIds_ = new Set<string>();
- private postProcessPasses_ = new Set<string>();
+ private postProcessCameras_ = new Set<number>();
private shaderHandles_ = new Set<number>();
private disposables_: (() => void)[] = [];
}
diff --git a/editor/src/panels/builtinPanels.ts b/editor/src/panels/builtinPanels.ts
index 0adc5ed70..e397dcbc9 100644
--- a/editor/src/panels/builtinPanels.ts
+++ b/editor/src/panels/builtinPanels.ts
@@ -38,7 +38,7 @@ export function registerBuiltinPanels(options: BuiltinPanelOptions): void {
title: 'Game',
icon: icons.play(14),
position: 'center',
- order: 1,
+ order: 2,
defaultVisible: true,
factory: (c, s) => new GameViewPanel(c, s, { projectPath: options.projectPath }),
});
diff --git a/editor/src/services/PlayModeService.ts b/editor/src/services/PlayModeService.ts
index 5772279e1..d743bf5a5 100644
--- a/editor/src/services/PlayModeService.ts
+++ b/editor/src/services/PlayModeService.ts
@@ -1,5 +1,5 @@
import type { EntityData } from '../types/SceneTypes';
-import { Assets, Name, Parent, Children, getComponent, getComponentAssetFields, Audio, audioPlugin } from 'esengine';
+import { Assets, Name, Parent, Children, getComponent, getComponentAssetFields, Audio, audioPlugin, SceneManager } from 'esengine';
import type { Entity, World } from 'esengine';
import { getEditorStore, type SceneSnapshot } from '../store/EditorStore';
import { getSharedRenderContext } from '../renderer/SharedRenderContext';
@@ -78,6 +78,7 @@ class PlayModeService {
const ctx = getSharedRenderContext();
this.configureAssetBaseUrl(ctx);
+ this.registerProjectScenes(ctx);
await this.injectUserScripts(ctx);
ctx.enterPlayMode();
@@ -90,6 +91,7 @@ class PlayModeService {
Audio.stopAll();
audioPlugin.stopAllSources();
+ this.cleanupSceneManager();
for (const cleanup of this.sharedCleanups_) cleanup();
this.sharedCleanups_ = [];
@@ -202,6 +204,26 @@ class PlayModeService {
}
}
+ private registerProjectScenes(ctx: ReturnType<typeof getSharedRenderContext>): void {
+ const app = ctx.app_;
+ if (!app || !app.hasResource(SceneManager)) return;
+
+ const mgr = app.getResource(SceneManager);
+ const db = getAssetDatabase();
+
+ for (const entry of db.getAllEntries()) {
+ if (!entry.path.endsWith('.esscene')) continue;
+ const name = entry.path.replace(/.*\//, '').replace('.esscene', '');
+ mgr.register({ name, path: entry.path });
+ }
+ }
+
+ private cleanupSceneManager(): void {
+ const app = getSharedRenderContext().app_;
+ if (!app || !app.hasResource(SceneManager)) return;
+ app.getResource(SceneManager).reset();
+ }
+
private configureAssetBaseUrl(ctx: ReturnType<typeof getSharedRenderContext>): void {
const app = ctx.app_;
if (!app || !app.hasResource(Assets)) return;
diff --git a/editor/src/styles/index.css b/editor/src/styles/index.css
index 4a7b1e6e8..4384b70f1 100644
--- a/editor/src/styles/index.css
+++ b/editor/src/styles/index.css
@@ -10,3 +10,4 @@
@import './output.css';
@import './builder.css';
@import './profiler.css';
+
diff --git a/sdk/tests/playableRuntime.test.ts b/sdk/tests/playableRuntime.test.ts
new file mode 100644
index 000000000..e51edf535
--- /dev/null
+++ b/sdk/tests/playableRuntime.test.ts
@@ -0,0 +1,79 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('../src/runtimeLoader', () => ({
+ initRuntime: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('../src/asset/AssetPlugin', () => ({
+ Assets: Symbol('Assets'),
+}));
+
+import { initPlayableRuntime } from '../src/playableRuntime';
+import type { PlayableRuntimeConfig } from '../src/playableRuntime';
+import { initRuntime } from '../src/runtimeLoader';
+import { Assets } from '../src/asset/AssetPlugin';
+
+function createMockConfig(overrides?: Partial<PlayableRuntimeConfig>): PlayableRuntimeConfig {
+ const canvas = { width: 320, height: 480 } as HTMLCanvasElement;
+ const mockApp = {
+ getResource: vi.fn().mockReturnValue({
+ registerEmbeddedAssets: vi.fn(),
+ setEmbeddedOnly: vi.fn(),
+ }),
+ hasResource: vi.fn().mockReturnValue(true),
+ run: vi.fn(),
+ } as any;
+
+ return {
+ app: mockApp,
+ module: {} as any,
+ canvas,
+ assets: {},
+ scenes: [
+ { name: 'main', data: { version: '1', name: 'main', entities: [] } as any },
+ ],
+ firstScene: 'main',
+ ...overrides,
+ };
+}
+
+describe('initPlayableRuntime', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('passes scenes array and firstScene to initRuntime', async () => {
+ const scenes = [
+ { name: 'level1', data: { version: '1', name: 'level1', entities: [] } as any },
+ { name: 'level2', data: { version: '1', name: 'level2', entities: [] } as any },
+ ];
+ const config = createMockConfig({ scenes, firstScene: 'level1' });
+
+ await initPlayableRuntime(config);
+
+ expect(initRuntime).toHaveBeenCalledWith(
+ expect.objectContaining({
+ scenes,
+ firstScene: 'level1',
+ }),
+ );
+ });
+
+ it('PlayableRuntimeConfig requires scenes and firstScene fields', async () => {
+ const config = createMockConfig();
+
+ await initPlayableRuntime(config);
+
+ const call = vi.mocked(initRuntime).mock.calls[0][0];
+ expect(call.scenes).toEqual(config.scenes);
+ expect(call.firstScene).toBe('main');
+ });
+
+ it('calls app.run() after initRuntime', async () => {
+ const config = createMockConfig();
+
+ await initPlayableRuntime(config);
+
+ expect(config.app.run).toHaveBeenCalled();
+ });
+});
diff --git a/sdk/tests/sceneManager.test.ts b/sdk/tests/sceneManager.test.ts
index c7e7ab32b..d394db9b7 100644
--- a/sdk/tests/sceneManager.test.ts
+++ b/sdk/tests/sceneManager.test.ts
@@ -14,7 +14,10 @@ vi.mock('../src/postprocess', () => ({
addPass: vi.fn().mockReturnValue(0),
removePass: vi.fn(),
setEnabled: vi.fn(),
+ bind: vi.fn(),
+ unbind: vi.fn(),
},
+ PostProcessStack: vi.fn(),
}));
vi.mock('../src/material', () => ({
@@ -898,4 +901,101 @@ describe('SceneManager', () => {
expect(PostProcess.removePass).toHaveBeenCalledWith('bloom');
});
});
+
+ // =========================================================================
+ // reset()
+ // =========================================================================
+ describe('reset()', () => {
+ it('clears all loaded scenes and configs', async () => {
+ manager.register({ name: 'level1', data: makeSceneData() });
+ manager.register({ name: 'level2', data: makeSceneData() });
+ await manager.load('level1');
+ await manager.loadAdditive('level2');
+
+ manager.reset();
+
+ expect(manager.getActive()).toBeNull();
+ expect(manager.getLoaded()).toEqual([]);
+ expect(manager.getLoadOrder()).toEqual([]);
+ expect(manager.getScene('level1')).toBeNull();
+ expect(manager.getScene('level2')).toBeNull();
+ });
+
+ it('clears initial scene', async () => {
+ manager.setInitial('level1');
+ manager.reset();
+ expect(manager.getInitial()).toBeNull();
+ });
+
+ it('clears paused and sleeping sets', async () => {
+ manager.register({ name: 'level1', data: makeSceneData() });
+ manager.register({ name: 'level2', data: makeSceneData() });
+ await manager.load('level1');
+ await manager.loadAdditive('level2');
+ manager.pause('level1');
+ manager.sleep('level2');
+
+ manager.reset();
+
+ expect(manager.isPaused('level1')).toBe(false);
+ expect(manager.isSleeping('level2')).toBe(false);
+ });
+
+ it('unregisters draw callbacks from loaded scenes', async () => {
+ manager.register({ name: 'level1', data: makeSceneData() });
+ const ctx = await manager.load('level1');
+ ctx.registerDrawCallback('myDraw', () => {});
+
+ manager.reset();
+ expect(unregisterDrawCallback).toHaveBeenCalledWith('myDraw');
+ });
+
+ it('unbinds post process from loaded scenes', async () => {
+ manager.register({ name: 'level1', data: makeSceneData() });
+ const ctx = await manager.load('level1');
+ const mockStack = { setAllPassesEnabled: vi.fn() };
+ ctx.bindPostProcess(42 as any, mockStack as any);
+
+ manager.reset();
+ expect(PostProcess.unbind).toHaveBeenCalledWith(42);
+ });
+
+ it('does not despawn entities', async () => {
+ const entityMap = new Map([[100, 1]]);
+ vi.mocked(loadSceneWithAssets).mockResolvedValueOnce(entityMap);
+ app._entities.set(1, new Map());
+
+ manager.register({ name: 'level1', data: makeSceneData() });
+ await manager.load('level1');
+
+ manager.reset();
+ expect(app.world.despawn).not.toHaveBeenCalled();
+ });
+
+ it('clears transition state', async () => {
+ manager.register({ name: 'level1', data: makeSceneData() });
+ manager.register({ name: 'level2', data: makeSceneData() });
+ await manager.load('level1');
+
+ manager.switchTo('level2', { transition: 'fade', duration: 1.0 });
+ await Promise.resolve();
+ expect(manager.isTransitioning()).toBe(true);
+
+ manager.reset();
+ expect(manager.isTransitioning()).toBe(false);
+ expect(unregisterDrawCallback).toHaveBeenCalledWith('__scene_transition_overlay__');
+ });
+
+ it('allows re-registration and loading after reset', async () => {
+ manager.register({ name: 'level1', data: makeSceneData() });
+ await manager.load('level1');
+
+ manager.reset();
+
+ manager.register({ name: 'level1', data: makeSceneData() });
+ const ctx = await manager.load('level1');
+ expect(ctx.name).toBe('level1');
+ expect(manager.getActive()).toBe('level1');
+ });
+ });
});