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(sdk): per-App PostProcess + pipeline DI, delete sync.ts (F3 B2b-3b)

esenginee5fbdf971e9a
diff --git a/sdk/src/core-render.ts b/sdk/src/core-render.ts
index b0740d066..875bbdbe0 100644
--- a/sdk/src/core-render.ts
+++ b/sdk/src/core-render.ts
@@ -90,18 +90,15 @@ export {
export {
PostProcess,
+ PostProcessApi,
PostProcessStack,
initPostProcessAPI,
shutdownPostProcessAPI,
type EffectDef,
type EffectUniformDef,
- type PostProcessEffectData,
getEffectDef,
getEffectTypes,
getAllEffectDefs,
- syncPostProcessVolume,
- cleanupPostProcessVolume,
- cleanupAllPostProcessVolumes,
} from './postprocess';
// =============================================================================
diff --git a/sdk/src/postprocess.ts b/sdk/src/postprocess.ts
index 70a6692c2..5acd92985 100644
--- a/sdk/src/postprocess.ts
+++ b/sdk/src/postprocess.ts
@@ -1,5 +1,6 @@
export {
PostProcess,
+ PostProcessApi,
PostProcessStack,
postProcessEffects,
initPostProcessAPI,
@@ -13,11 +14,6 @@ export {
getEffectDef,
getEffectTypes,
getAllEffectDefs,
- type PostProcessEffectData,
- type PostProcessVolumeData,
- syncPostProcessVolume,
- cleanupPostProcessVolume,
- cleanupAllPostProcessVolumes,
PostProcessPlugin,
postProcessPlugin,
} from './postprocess/index';
diff --git a/sdk/src/postprocess/PostProcessAPI.ts b/sdk/src/postprocess/PostProcessAPI.ts
index f9c3afcff..fe3925c2f 100644
--- a/sdk/src/postprocess/PostProcessAPI.ts
+++ b/sdk/src/postprocess/PostProcessAPI.ts
@@ -1,5 +1,7 @@
import type { ESEngineModule } from '../wasm';
import type { Entity } from '../types';
+import type { ShaderHandle } from '../material';
+import { defineResource } from '../resource';
import { handleWasmError } from '../wasmError';
import { CoreApiBridge } from '../CoreApiBridge';
import { PostProcessStack, PostProcessState } from './PostProcessStack';
@@ -13,9 +15,13 @@ export function initPostProcessAPI(wasmModule: ESEngineModule): void {
}
export function shutdownPostProcessAPI(): void {
- PostProcess.state.reset();
- if (module && PostProcess.isInitialized()) {
- PostProcess.shutdown();
+ // Per-App state dies with its App; here we only tear down the shared module.
+ if (module) {
+ try {
+ if (module.postprocess_isInitialized()) module.postprocess_shutdown();
+ } catch (e) {
+ handleWasmError(e, 'PostProcess.shutdown');
+ }
}
bridge.disconnect();
module = null;
@@ -80,6 +86,10 @@ export function syncStackToWasm(stack: PostProcessStack): void {
export class PostProcessApi {
readonly state = new PostProcessState();
+ /** Volume-system bookkeeping (per-App): camera → the stack it created, and shared effect shaders. */
+ readonly volumeStacks = new Map<Entity, PostProcessStack>();
+ readonly volumeShaders = new Map<string, ShaderHandle>();
+
// -- per-App state (stacks / bindings / screen stack) --------------------
get screenStack(): PostProcessStack | null {
@@ -204,14 +214,6 @@ export class PostProcessApi {
}
}
- _cleanupDestroyedCameras(isValid: (e: Entity) => boolean): void {
- for (const camera of this.state.cameraBindings.keys()) {
- if (!isValid(camera)) {
- this.state.cameraBindings.delete(camera);
- }
- }
- }
-
_beginScreenCapture(): void {
try {
getModule().postprocess_beginScreenCapture();
@@ -276,5 +278,8 @@ export class PostProcessApi {
}
}
-/** B2b-3a transitional default instance (becomes a per-App resource in B2b-3b). */
-export const PostProcess = new PostProcessApi();
+/**
+ * Per-App post-process resource. Published + injected into the render pipeline
+ * by `PostProcessPlugin`; read as `app.getResource(PostProcess)`.
+ */
+export const PostProcess = defineResource<PostProcessApi>(null!, 'PostProcess');
diff --git a/sdk/src/postprocess/PostProcessPlugin.ts b/sdk/src/postprocess/PostProcessPlugin.ts
index e515cbd37..61f11f59e 100644
--- a/sdk/src/postprocess/PostProcessPlugin.ts
+++ b/sdk/src/postprocess/PostProcessPlugin.ts
@@ -1,21 +1,26 @@
import type { App, Plugin } from '../app';
import { Schedule } from '../system';
-import { PostProcess } from './PostProcessAPI';
-import { cleanupAllPostProcessVolumes } from './sync';
+import { PostProcess, PostProcessApi } from './PostProcessAPI';
import { postProcessVolumeSystem, cleanupVolumeSystem, PostProcessVolumeConfigResource } from './volumeSystem';
export class PostProcessPlugin implements Plugin {
name = 'postProcess';
build(app: App): void {
+ // Per-App post-process API, injected into the render pipeline as an
+ // optional stage (the pipeline has no hard dependency on it).
+ const api = new PostProcessApi();
+ app.insertResource(PostProcess, api);
+ app.pipeline?.setPostProcess(api);
+
app.insertResource(PostProcessVolumeConfigResource, { enabled: true });
app.addSystemToSchedule(Schedule.PostUpdate, postProcessVolumeSystem);
}
- cleanup(): void {
- cleanupAllPostProcessVolumes();
- cleanupVolumeSystem();
- PostProcess.setScreenStack(null);
+ cleanup(app?: App): void {
+ if (app?.hasResource(PostProcess)) {
+ cleanupVolumeSystem(app.getResource(PostProcess));
+ }
}
}
diff --git a/sdk/src/postprocess/index.ts b/sdk/src/postprocess/index.ts
index 5da1a784a..0bcef45f6 100644
--- a/sdk/src/postprocess/index.ts
+++ b/sdk/src/postprocess/index.ts
@@ -1,6 +1,6 @@
export { PostProcessStack } from './PostProcessStack';
export type { PassConfig } from './PostProcessStack';
-export { PostProcess, initPostProcessAPI, shutdownPostProcessAPI, syncStackToWasm } from './PostProcessAPI';
+export { PostProcess, PostProcessApi, initPostProcessAPI, shutdownPostProcessAPI, syncStackToWasm } from './PostProcessAPI';
export { postProcessEffects } from './postProcessEffects';
export { POSTPROCESS_VERTEX } from './shaders';
export {
@@ -11,13 +11,6 @@ export {
getEffectTypes,
getAllEffectDefs,
} from './effects';
-export {
- type PostProcessEffectData,
- type PostProcessVolumeData,
- syncPostProcessVolume,
- cleanupPostProcessVolume,
- cleanupAllPostProcessVolumes,
-} from './sync';
export {
signedDistanceBox,
signedDistanceSphere,
diff --git a/sdk/src/postprocess/sync.ts b/sdk/src/postprocess/sync.ts
deleted file mode 100644
index 7b9a94daa..000000000
--- a/sdk/src/postprocess/sync.ts
+++ /dev/null
@@ -1,103 +0,0 @@
-import type { Entity } from '../types';
-import type { ShaderHandle } from '../material';
-import { Material } from '../material';
-import { PostProcessStack } from './PostProcessStack';
-import { PostProcess } from './PostProcessAPI';
-import { getEffectDef } from './effects';
-
-export interface PostProcessEffectData {
- type: string;
- enabled: boolean;
- uniforms: Record<string, number>;
-}
-
-export interface PostProcessVolumeData {
- effects: PostProcessEffectData[];
- isGlobal: boolean;
- shape: 'box' | 'sphere';
- size: { x: number; y: number };
- priority: number;
- weight: number;
- blendDistance: number;
-}
-
-const volumeStacks = new Map<Entity, PostProcessStack>();
-const volumeShaders = new Map<Entity, Map<string, ShaderHandle>>();
-
-export function syncPostProcessVolume(camera: Entity, data: PostProcessVolumeData): void {
- let stack = volumeStacks.get(camera);
- let shaders = volumeShaders.get(camera);
-
- const activeEffects = data.effects.filter(e => e.enabled);
- if (activeEffects.length === 0) {
- if (stack) {
- PostProcess.unbind(camera);
- stack.destroy();
- volumeStacks.delete(camera);
- }
- if (shaders) {
- for (const handle of shaders.values()) {
- Material.releaseShader(handle);
- }
- volumeShaders.delete(camera);
- }
- return;
- }
-
- if (!stack) {
- stack = PostProcess.createStack();
- volumeStacks.set(camera, stack);
- }
-
- if (!shaders) {
- shaders = new Map();
- volumeShaders.set(camera, shaders);
- }
-
- while (stack.passCount > 0) {
- const passes = stack.passes;
- stack.removePass(passes[passes.length - 1].name);
- }
-
- for (const effect of activeEffects) {
- const def = getEffectDef(effect.type);
- if (!def) continue;
-
- let shader = shaders.get(effect.type);
- if (shader === undefined) {
- shader = def.factory();
- shaders.set(effect.type, shader);
- }
-
- stack.addPass(effect.type, shader);
-
- for (const uDef of def.uniforms) {
- const value = effect.uniforms[uDef.name] ?? uDef.defaultValue;
- stack.setUniform(effect.type, uDef.name, value);
- }
- }
-
- PostProcess.bind(camera, stack);
-}
-
-export function cleanupPostProcessVolume(camera: Entity): void {
- const stack = volumeStacks.get(camera);
- if (stack) {
- PostProcess.unbind(camera);
- stack.destroy();
- volumeStacks.delete(camera);
- }
- const shaders = volumeShaders.get(camera);
- if (shaders) {
- for (const handle of shaders.values()) {
- Material.releaseShader(handle);
- }
- volumeShaders.delete(camera);
- }
-}
-
-export function cleanupAllPostProcessVolumes(): void {
- for (const camera of volumeStacks.keys()) {
- cleanupPostProcessVolume(camera);
- }
-}
diff --git a/sdk/src/postprocess/volumeBlending.ts b/sdk/src/postprocess/volumeBlending.ts
index 8c4f822c8..821a2a55e 100644
--- a/sdk/src/postprocess/volumeBlending.ts
+++ b/sdk/src/postprocess/volumeBlending.ts
@@ -1,4 +1,4 @@
-import type { PostProcessVolumeData } from './sync';
+import type { PostProcessVolumeData } from '../component';
export interface VolumeTransform {
x: number;
diff --git a/sdk/src/postprocess/volumeSystem.ts b/sdk/src/postprocess/volumeSystem.ts
index 9803a09ba..3352a872f 100644
--- a/sdk/src/postprocess/volumeSystem.ts
+++ b/sdk/src/postprocess/volumeSystem.ts
@@ -1,10 +1,9 @@
import { defineSystem } from '../system';
-import { defineResource } from '../resource';
+import { defineResource, Res } from '../resource';
import { Query } from '../query';
import type { Entity } from '../types';
import { PostProcessVolume, Transform, Camera, type PostProcessVolumeData, type TransformData, type CameraData } from '../component';
-import { PostProcess } from './PostProcessAPI';
-import { PostProcessStack } from './PostProcessStack';
+import { PostProcess, type PostProcessApi } from './PostProcessAPI';
import { getEffectDef } from './effects';
import { blendVolumeEffects, type ActiveVolume } from './volumeBlending';
import type { ShaderHandle } from '../material';
@@ -19,33 +18,34 @@ export const PostProcessVolumeConfigResource = defineResource<PostProcessVolumeC
'PostProcessVolumeConfig'
);
-const volumeStacks = new Map<Entity, PostProcessStack>();
-const volumeShaders = new Map<string, ShaderHandle>();
-
-function getOrCreateShader(key: string, factory: () => ShaderHandle): ShaderHandle {
- const existing = volumeShaders.get(key);
+function getOrCreateShader(api: PostProcessApi, key: string, factory: () => ShaderHandle): ShaderHandle {
+ const existing = api.volumeShaders.get(key);
if (existing !== undefined) return existing;
const shader = factory();
- volumeShaders.set(key, shader);
+ api.volumeShaders.set(key, shader);
return shader;
}
-function applyBlendedEffects(camera: Entity, effects: Map<string, { enabled: boolean; uniforms: Map<string, number> }>): void {
+function applyBlendedEffects(
+ api: PostProcessApi,
+ camera: Entity,
+ effects: Map<string, { enabled: boolean; uniforms: Map<string, number> }>,
+): void {
if (effects.size === 0) {
- const existing = volumeStacks.get(camera);
+ const existing = api.volumeStacks.get(camera);
if (existing) {
- PostProcess.unbind(camera);
+ api.unbind(camera);
existing.destroy();
- volumeStacks.delete(camera);
+ api.volumeStacks.delete(camera);
}
return;
}
- let stack = volumeStacks.get(camera);
+ let stack = api.volumeStacks.get(camera);
if (!stack) {
- stack = PostProcess.createStack();
- volumeStacks.set(camera, stack);
+ stack = api.createStack();
+ api.volumeStacks.set(camera, stack);
}
stack.clearPasses();
@@ -58,14 +58,14 @@ function applyBlendedEffects(camera: Entity, effects: Map<string, { enabled: boo
if (def.multiPass) {
for (const subPass of def.multiPass) {
- const shader = getOrCreateShader(subPass.name, subPass.factory);
+ const shader = getOrCreateShader(api, subPass.name, subPass.factory);
stack.addPass(subPass.name, shader);
for (const [uniformName, uniformValue] of effectData.uniforms) {
stack.setUniform(subPass.name, uniformName, uniformValue);
}
}
} else {
- const shader = getOrCreateShader(effectType, def.factory);
+ const shader = getOrCreateShader(api, effectType, def.factory);
stack.addPass(effectType, shader);
for (const [uniformName, uniformValue] of effectData.uniforms) {
stack.setUniform(effectType, uniformName, uniformValue);
@@ -74,15 +74,19 @@ function applyBlendedEffects(camera: Entity, effects: Map<string, { enabled: boo
}
if (stack.enabledPassCount > 0) {
- PostProcess.bind(camera, stack);
+ api.bind(camera, stack);
} else {
- PostProcess.unbind(camera);
+ api.unbind(camera);
}
}
export const postProcessVolumeSystem = defineSystem(
- [Query(PostProcessVolume, Transform), Query(Camera)],
- (volumeQuery: Iterable<[Entity, PostProcessVolumeData, TransformData]>, cameraQuery: Iterable<[Entity, CameraData]>) => {
+ [Res(PostProcess), Query(PostProcessVolume, Transform), Query(Camera)],
+ (
+ api: PostProcessApi,
+ volumeQuery: Iterable<[Entity, PostProcessVolumeData, TransformData]>,
+ cameraQuery: Iterable<[Entity, CameraData]>,
+ ) => {
const volumes: { data: PostProcessVolumeData; tx: { x: number; y: number } }[] = [];
for (const [_entity, volumeData, transform] of volumeQuery) {
volumes.push({ data: volumeData, tx: { x: transform.position.x, y: transform.position.y } });
@@ -101,22 +105,22 @@ export const postProcessVolumeSystem = defineSystem(
for (const [cameraEntity, cameraData] of cameraQuery) {
if (cameraData.isActive) {
- applyBlendedEffects(cameraEntity, blended);
+ applyBlendedEffects(api, cameraEntity, blended);
}
}
},
{ name: 'PostProcessVolumeSystem' }
);
-export function cleanupVolumeSystem(): void {
- for (const [camera, stack] of volumeStacks) {
- PostProcess.unbind(camera);
+export function cleanupVolumeSystem(api: PostProcessApi): void {
+ for (const [camera, stack] of api.volumeStacks) {
+ api.unbind(camera);
stack.destroy();
}
- volumeStacks.clear();
+ api.volumeStacks.clear();
- for (const shader of volumeShaders.values()) {
+ for (const shader of api.volumeShaders.values()) {
Material.releaseShader(shader);
}
- volumeShaders.clear();
+ api.volumeShaders.clear();
}
diff --git a/sdk/src/renderPipeline.ts b/sdk/src/renderPipeline.ts
index d9426086a..d3b1dd404 100644
--- a/sdk/src/renderPipeline.ts
+++ b/sdk/src/renderPipeline.ts
@@ -6,7 +6,7 @@
import type { CppRegistry } from './wasm';
import type { Entity } from './types';
import { Renderer } from './renderer';
-import { PostProcess } from './postprocess';
+import type { PostProcessApi } from './postprocess';
import { Draw } from './draw';
import { getDrawCallbacks, unregisterDrawCallback } from './customDraw';
import { log } from './logger';
@@ -40,11 +40,21 @@ export class RenderPipeline {
private lastHeight_ = 0;
private activeScenes_: Set<string> | null = null;
private preFlushCallbacks_: ((registry: { _cpp: CppRegistry }) => void)[] = [];
+ private postProcess_: PostProcessApi | null = null;
setActiveScenes(scenes: Set<string> | null): void {
this.activeScenes_ = scenes;
}
+ /**
+ * Inject this App's post-process API (by PostProcessPlugin). When null, the
+ * pipeline does no post-processing — it has no hard dependency on the
+ * post-process subsystem.
+ */
+ setPostProcess(pp: PostProcessApi | null): void {
+ this.postProcess_ = pp;
+ }
+
addPreFlushCallback(cb: (registry: { _cpp: CppRegistry }) => void): void {
this.preFlushCallbacks_.push(cb);
}
@@ -54,19 +64,21 @@ export class RenderPipeline {
}
beginScreenCapture(): void {
- if (PostProcess.screenStack && PostProcess.screenStack.enabledPassCount > 0) {
- if (!PostProcess.isInitialized()) {
- PostProcess.init(1, 1);
+ const pp = this.postProcess_;
+ if (pp && pp.screenStack && pp.screenStack.enabledPassCount > 0) {
+ if (!pp.isInitialized()) {
+ pp.init(1, 1);
}
- PostProcess._applyScreenStack();
- PostProcess._beginScreenCapture();
+ pp._applyScreenStack();
+ pp._beginScreenCapture();
}
}
endScreenCapture(): void {
- if (PostProcess.screenStack && PostProcess.screenStack.enabledPassCount > 0) {
- PostProcess._endScreenCapture();
- PostProcess._executeScreenPasses();
+ const pp = this.postProcess_;
+ if (pp && pp.screenStack && pp.screenStack.enabledPassCount > 0) {
+ pp._endScreenCapture();
+ pp._executeScreenPasses();
}
}
@@ -104,13 +116,14 @@ export class RenderPipeline {
renderCamera(params: CameraRenderParams): void {
const { registry, viewProjection, viewportPixels: vp, clearFlags, elapsed, cameraEntity } = params;
- const hasPostProcess = cameraEntity !== undefined && PostProcess.getStack(cameraEntity) !== null;
+ const pp = this.postProcess_;
+ const hasPostProcess = pp !== null && cameraEntity !== undefined && pp.getStack(cameraEntity) !== null;
if (hasPostProcess) {
- PostProcess._applyForCamera(cameraEntity!);
- PostProcess.resize(vp.w, vp.h);
- PostProcess.setOutputViewport(vp.x, vp.y, vp.w, vp.h);
- PostProcess.begin();
+ pp!._applyForCamera(cameraEntity!);
+ pp!.resize(vp.w, vp.h);
+ pp!.setOutputViewport(vp.x, vp.y, vp.w, vp.h);
+ pp!.begin();
}
Renderer.setViewport(vp.x, vp.y, vp.w, vp.h);
@@ -123,8 +136,8 @@ export class RenderPipeline {
Renderer.end();
if (hasPostProcess) {
- PostProcess.end();
- PostProcess._resetAfterCamera();
+ pp!.end();
+ pp!._resetAfterCamera();
}
}
diff --git a/sdk/src/sceneManager.ts b/sdk/src/sceneManager.ts
index c1e342bbc..1927008d5 100644
--- a/sdk/src/sceneManager.ts
+++ b/sdk/src/sceneManager.ts
@@ -134,12 +134,12 @@ class SceneContextImpl implements SceneContext {
}
bindPostProcess(camera: Entity, stack: PostProcessStack): void {
- PostProcess.bind(camera, stack);
+ if (this.app_.hasResource(PostProcess)) this.app_.getResource(PostProcess).bind(camera, stack);
this.instance_.postProcessBindings.set(camera, stack);
}
unbindPostProcess(camera: Entity): void {
- PostProcess.unbind(camera);
+ if (this.app_.hasResource(PostProcess)) this.app_.getResource(PostProcess).unbind(camera);
this.instance_.postProcessBindings.delete(camera);
}
@@ -180,8 +180,9 @@ export class SceneManagerState {
for (const id of instance.drawCallbacks.keys()) {
unregisterDrawCallback(id);
}
+ const pp = this.app_.hasResource(PostProcess) ? this.app_.getResource(PostProcess) : null;
for (const camera of instance.postProcessBindings.keys()) {
- PostProcess.unbind(camera);
+ pp?.unbind(camera);
}
}
@@ -398,8 +399,9 @@ export class SceneManagerState {
}
instance.systemIds.length = 0;
+ const pp = this.app_.hasResource(PostProcess) ? this.app_.getResource(PostProcess) : null;
for (const camera of instance.postProcessBindings.keys()) {
- PostProcess.unbind(camera);
+ pp?.unbind(camera);
}
instance.postProcessBindings.clear();
diff --git a/sdk/tests/postprocess.test.ts b/sdk/tests/postprocess.test.ts
index 38ad4705d..036783d00 100644
--- a/sdk/tests/postprocess.test.ts
+++ b/sdk/tests/postprocess.test.ts
@@ -6,7 +6,7 @@ vi.mock('../src/material', () => ({
}));
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { PostProcess, PostProcessStack, postProcessEffects, initPostProcessAPI, shutdownPostProcessAPI } from '../src/postprocess';
+import { PostProcessApi, PostProcessStack, postProcessEffects, initPostProcessAPI, shutdownPostProcessAPI } from '../src/postprocess';
import { Material } from '../src/material';
import type { ESEngineModule } from '../src/wasm';
@@ -39,11 +39,13 @@ type MockModule = ReturnType<typeof createPostProcessMockModule>;
describe('PostProcess API', () => {
let mock: MockModule;
+ let pp: PostProcessApi;
beforeEach(() => {
mock = createPostProcessMockModule();
initPostProcessAPI(mock as unknown as ESEngineModule);
vi.clearAllMocks();
+ pp = new PostProcessApi();
});
afterEach(() => {
@@ -88,22 +90,22 @@ describe('PostProcess API', () => {
describe('uninitialized guard', () => {
it('should return false for isInitialized after shutdown', () => {
shutdownPostProcessAPI();
- expect(PostProcess.isInitialized()).toBe(false);
+ expect(pp.isInitialized()).toBe(false);
});
it('should return false from init after shutdown', () => {
shutdownPostProcessAPI();
- expect(PostProcess.init(800, 600)).toBe(false);
+ expect(pp.init(800, 600)).toBe(false);
});
it('should not throw from shutdown after shutdown', () => {
shutdownPostProcessAPI();
- expect(() => PostProcess.shutdown()).not.toThrow();
+ expect(() => pp.shutdown()).not.toThrow();
});
it('should not throw from setBypass after shutdown', () => {
shutdownPostProcessAPI();
- expect(() => PostProcess.setBypass(true)).not.toThrow();
+ expect(() => pp.setBypass(true)).not.toThrow();
});
});
@@ -113,25 +115,25 @@ describe('PostProcess API', () => {
describe('pipeline lifecycle', () => {
it('should call postprocess_init with width and height', () => {
- PostProcess.init(1920, 1080);
+ pp.init(1920, 1080);
expect(mock.postprocess_init).toHaveBeenCalledWith(1920, 1080);
});
it('should return the WASM result from init', () => {
mock.postprocess_init.mockReturnValue(true);
- expect(PostProcess.init(800, 600)).toBe(true);
+ expect(pp.init(800, 600)).toBe(true);
mock.postprocess_init.mockReturnValue(false);
- expect(PostProcess.init(800, 600)).toBe(false);
+ expect(pp.init(800, 600)).toBe(false);
});
it('should call postprocess_shutdown', () => {
- PostProcess.shutdown();
+ pp.shutdown();
expect(mock.postprocess_shutdown).toHaveBeenCalledOnce();
});
it('should call postprocess_resize with width and height', () => {
- PostProcess.resize(1280, 720);
+ pp.resize(1280, 720);
expect(mock.postprocess_resize).toHaveBeenCalledWith(1280, 720);
});
});
@@ -142,20 +144,20 @@ describe('PostProcess API', () => {
describe('PostProcessStack', () => {
it('should create a stack with unique id', () => {
- const stack1 = PostProcess.createStack();
- const stack2 = PostProcess.createStack();
+ const stack1 = pp.createStack();
+ const stack2 = pp.createStack();
expect(stack1.id).not.toBe(stack2.id);
});
it('should add passes and track count', () => {
- const stack = PostProcess.createStack();
+ const stack = pp.createStack();
stack.addPass('bloom', 1);
stack.addPass('blur', 2);
expect(stack.passCount).toBe(2);
});
it('should remove passes by name', () => {
- const stack = PostProcess.createStack();
+ const stack = pp.createStack();
stack.addPass('bloom', 1);
stack.addPass('blur', 2);
stack.removePass('bloom');
@@ -164,7 +166,7 @@ describe('PostProcess API', () => {
});
it('should set pass enabled state', () => {
- const stack = PostProcess.createStack();
+ const stack = pp.createStack();
stack.addPass('bloom', 1);
stack.setEnabled('bloom', false);
expect(stack.enabledPassCount).toBe(0);
@@ -173,7 +175,7 @@ describe('PostProcess API', () => {
});
it('should set float uniforms on passes', () => {
- const stack = PostProcess.createStack();
+ const stack = pp.createStack();
stack.addPass('bloom', 1);
stack.setUniform('bloom', 'u_intensity', 0.5);
const pass = stack.passes[0];
@@ -181,7 +183,7 @@ describe('PostProcess API', () => {
});
it('should set vec4 uniforms on passes', () => {
- const stack = PostProcess.createStack();
+ const stack = pp.createStack();
stack.addPass('bloom', 1);
stack.setUniformVec4('bloom', 'u_color', { x: 1, y: 0.5, z: 0.25, w: 1 });
const pass = stack.passes[0];
@@ -189,7 +191,7 @@ describe('PostProcess API', () => {
});
it('should enable/disable all passes', () => {
- const stack = PostProcess.createStack();
+ const stack = pp.createStack();
stack.addPass('bloom', 1);
stack.addPass('blur', 2);
stack.setAllPassesEnabled(false);
@@ -199,14 +201,14 @@ describe('PostProcess API', () => {
});
it('should mark as destroyed after destroy()', () => {
- const stack = PostProcess.createStack();
+ const stack = pp.createStack();
expect(stack.isDestroyed).toBe(false);
stack.destroy();
expect(stack.isDestroyed).toBe(true);
});
it('should support chaining on addPass/removePass/setEnabled/setUniform', () => {
- const stack = PostProcess.createStack();
+ const stack = pp.createStack();
const result = stack
.addPass('bloom', 1)
.setEnabled('bloom', true)
@@ -222,26 +224,26 @@ describe('PostProcess API', () => {
describe('camera binding', () => {
it('should bind a stack to a camera entity', () => {
- const stack = PostProcess.createStack();
- PostProcess.bind(1 as any, stack);
- expect(PostProcess.getStack(1 as any)).toBe(stack);
+ const stack = pp.createStack();
+ pp.bind(1 as any, stack);
+ expect(pp.getStack(1 as any)).toBe(stack);
});
it('should unbind a camera', () => {
- const stack = PostProcess.createStack();
- PostProcess.bind(1 as any, stack);
- PostProcess.unbind(1 as any);
- expect(PostProcess.getStack(1 as any)).toBeNull();
+ const stack = pp.createStack();
+ pp.bind(1 as any, stack);
+ pp.unbind(1 as any);
+ expect(pp.getStack(1 as any)).toBeNull();
});
it('should return null for unbound camera', () => {
- expect(PostProcess.getStack(99 as any)).toBeNull();
+ expect(pp.getStack(99 as any)).toBeNull();
});
it('should throw when binding a destroyed stack', () => {
- const stack = PostProcess.createStack();
+ const stack = pp.createStack();
stack.destroy();
- expect(() => PostProcess.bind(1 as any, stack)).toThrow('destroyed');
+ expect(() => pp.bind(1 as any, stack)).toThrow('destroyed');
});
});
@@ -251,12 +253,12 @@ describe('PostProcess API', () => {
describe('bypass mode', () => {
it('should call postprocess_setBypass with true', () => {
- PostProcess.setBypass(true);
+ pp.setBypass(true);
expect(mock.postprocess_setBypass).toHaveBeenCalledWith(true);
});
it('should call postprocess_setBypass with false', () => {
- PostProcess.setBypass(false);
+ pp.setBypass(false);
expect(mock.postprocess_setBypass).toHaveBeenCalledWith(false);
});
});
@@ -267,17 +269,17 @@ describe('PostProcess API', () => {
describe('_applyForCamera', () => {
it('should set bypass=true when camera has no bound stack', () => {
- PostProcess._applyForCamera(1 as any);
+ pp._applyForCamera(1 as any);
expect(mock.postprocess_setBypass).toHaveBeenCalledWith(true);
});
it('should sync enabled passes to WASM when stack is bound', () => {
- const stack = PostProcess.createStack();
+ const stack = pp.createStack();
stack.addPass('bloom', 42);
stack.setUniform('bloom', 'u_intensity', 0.5);
- PostProcess.bind(1 as any, stack);
+ pp.bind(1 as any, stack);
- PostProcess._applyForCamera(1 as any);
+ pp._applyForCamera(1 as any);
expect(mock.postprocess_setBypass).toHaveBeenCalledWith(false);
expect(mock.postprocess_clearPasses).toHaveBeenCalled();
@@ -286,22 +288,22 @@ describe('PostProcess API', () => {
});
it('should set bypass=true when all passes are disabled', () => {
- const stack = PostProcess.createStack();
+ const stack = pp.createStack();
stack.addPass('bloom', 42);
stack.setEnabled('bloom', false);
- PostProcess.bind(1 as any, stack);
+ pp.bind(1 as any, stack);
- PostProcess._applyForCamera(1 as any);
+ pp._applyForCamera(1 as any);
expect(mock.postprocess_setBypass).toHaveBeenCalledWith(true);
});
it('should sync vec4 uniforms to WASM', () => {
- const stack = PostProcess.createStack();
+ const stack = pp.createStack();
stack.addPass('bloom', 42);
stack.setUniformVec4('bloom', 'u_color', { x: 1, y: 0.5, z: 0.25, w: 1 });
- PostProcess.bind(1 as any, stack);
+ pp.bind(1 as any, stack);
- PostProcess._applyForCamera(1 as any);
+ pp._applyForCamera(1 as any);
expect(mock.postprocess_setUniformVec4).toHaveBeenCalledWith('bloom', 'u_color', 1, 0.5, 0.25, 1);
});
});
@@ -312,7 +314,7 @@ describe('PostProcess API', () => {
describe('_resetAfterCamera', () => {
it('should clear passes and set bypass=true', () => {
- PostProcess._resetAfterCamera();
+ pp._resetAfterCamera();
expect(mock.postprocess_clearPasses).toHaveBeenCalled();
expect(mock.postprocess_setBypass).toHaveBeenCalledWith(true);
});
@@ -381,22 +383,22 @@ describe('PostProcess API', () => {
describe('WASM exception safety', () => {
it('should return false when postprocess_init throws', () => {
mock.postprocess_init.mockImplementation(() => { throw new Error('WASM crash'); });
- expect(PostProcess.init(800, 600)).toBe(false);
+ expect(pp.init(800, 600)).toBe(false);
});
it('should not throw when postprocess_shutdown throws', () => {
mock.postprocess_shutdown.mockImplementation(() => { throw new Error('WASM crash'); });
- expect(() => PostProcess.shutdown()).not.toThrow();
+ expect(() => pp.shutdown()).not.toThrow();
});
it('should not throw when postprocess_resize throws', () => {
mock.postprocess_resize.mockImplementation(() => { throw new Error('WASM crash'); });
- expect(() => PostProcess.resize(800, 600)).not.toThrow();
+ expect(() => pp.resize(800, 600)).not.toThrow();
});
it('should return false when postprocess_isInitialized throws', () => {
mock.postprocess_isInitialized.mockImplementation(() => { throw new Error('WASM crash'); });
- expect(PostProcess.isInitialized()).toBe(false);
+ expect(pp.isInitialized()).toBe(false);
});
});
});
diff --git a/sdk/tests/renderPipeline.test.ts b/sdk/tests/renderPipeline.test.ts
index fba133ce3..ed722c12f 100644
--- a/sdk/tests/renderPipeline.test.ts
+++ b/sdk/tests/renderPipeline.test.ts
@@ -71,6 +71,8 @@ describe('RenderPipeline', () => {
vi.clearAllMocks();
mockCallbacks.clear();
pipeline = new RenderPipeline();
+ // PostProcess is now injected (no longer a global the pipeline reaches for).
+ pipeline.setPostProcess(PostProcess as any);
registry = { _cpp: {} as any };
viewProjection = new Float32Array(16);
});
diff --git a/sdk/tests/sceneManager.test.ts b/sdk/tests/sceneManager.test.ts
index f1f2c0f16..ebbde0065 100644
--- a/sdk/tests/sceneManager.test.ts
+++ b/sdk/tests/sceneManager.test.ts
@@ -75,6 +75,9 @@ function createMockApp() {
const entities = new Map<number, Map<symbol, any>>();
let nextEntity = 1;
const resources = new Map<any, any>();
+ // PostProcess is now a per-App resource; register the mock so sceneManager's
+ // app.getResource(PostProcess).bind/unbind hits the spies.
+ resources.set(PostProcess, PostProcess);
const world = {
spawn: vi.fn(() => {