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.

feat: enhance post-process pipeline and scene manager

esengine57e7441555f7
diff --git a/editor/src/panels/inspector/EntityInspector.ts b/editor/src/panels/inspector/EntityInspector.ts
index e1796b74a..38fd4c414 100644
--- a/editor/src/panels/inspector/EntityInspector.ts
+++ b/editor/src/panels/inspector/EntityInspector.ts
@@ -165,12 +165,14 @@ export function renderComponent(
if (!schema) {
console.warn(`[Inspector] No schema found for component "${component.type}"`);
}
+ if (schema?.hidden) return;
if (schema?.category === 'tag') {
renderTagComponent(container, entity, component, store);
return;
}
const defaults = getDefaultComponentData(component.type);
+ const displayTitle = schema?.displayName ?? component.type;
const section = document.createElement('div');
section.className = 'es-component-section es-collapsible es-expanded';
@@ -190,7 +192,7 @@ export function renderComponent(
header.innerHTML = `
<span class="es-collapse-icon">${icons.chevronDown(12)}</span>
<span class="es-component-icon">${icon}</span>
- <span class="es-component-title">${component.type}</span>
+ <span class="es-component-title">${displayTitle}</span>
${hasEnabled ? `<input type="checkbox" class="es-component-enabled-toggle" title="Enable/Disable component" ${isEnabled ? 'checked' : ''}>` : ''}
${removable ? `<button class="es-btn es-btn-icon es-btn-remove">${icons.x(12)}</button>` : ''}
`;
@@ -317,7 +319,7 @@ export function renderComponent(
if (customInspector) {
const propsContainer = document.createElement('div');
propsContainer.className = 'es-component-properties es-collapsible-content';
- customInspector.render(propsContainer, {
+ const instance = customInspector.render(propsContainer, {
store,
entity,
componentType: component.type,
@@ -326,6 +328,13 @@ export function renderComponent(
store.updateProperty(entity, component.type, property, oldValue, newValue);
},
});
+ if (instance) {
+ editors.push({
+ editor: instance,
+ componentType: component.type,
+ propertyName: '*',
+ });
+ }
section.appendChild(propsContainer);
container.appendChild(section);
return;
diff --git a/editor/src/panels/inspector/InspectorHelpers.ts b/editor/src/panels/inspector/InspectorHelpers.ts
index 557a9eed4..00a58972f 100644
--- a/editor/src/panels/inspector/InspectorHelpers.ts
+++ b/editor/src/panels/inspector/InspectorHelpers.ts
@@ -116,6 +116,7 @@ const COMPONENT_ICON_MAP = new Map<string, (size: number) => string>([
['UIMask', icons.shield],
['UIInteraction', icons.zap],
['ParticleEmitter', icons.star],
+ ['PostProcessVolume', icons.layers],
]);
export function getComponentIcon(type: string): string {
diff --git a/editor/src/panels/inspector/InspectorRegistry.ts b/editor/src/panels/inspector/InspectorRegistry.ts
index 16da79f3c..d52c79de9 100644
--- a/editor/src/panels/inspector/InspectorRegistry.ts
+++ b/editor/src/panels/inspector/InspectorRegistry.ts
@@ -43,7 +43,7 @@ export interface ComponentInspectorContext {
export interface ComponentInspectorInstance {
dispose(): void;
- update?(data: Record<string, unknown>): void;
+ update(data: Record<string, unknown>): void;
}
export interface ComponentInspectorDescriptor {
diff --git a/editor/src/panels/inspector/PostProcessVolumeInspector.ts b/editor/src/panels/inspector/PostProcessVolumeInspector.ts
new file mode 100644
index 000000000..62c5f2655
--- /dev/null
+++ b/editor/src/panels/inspector/PostProcessVolumeInspector.ts
@@ -0,0 +1,223 @@
+/**
+ * @file PostProcessVolumeInspector.ts
+ * @brief Custom inspector for PostProcessVolume component
+ */
+
+import {
+ getAllEffectDefs,
+ getEffectDef,
+ syncPostProcessVolume,
+ type PostProcessEffectData,
+} from 'esengine';
+import type { ComponentInspectorContext, ComponentInspectorInstance } from './InspectorRegistry';
+import { registerComponentInspector } from './InspectorRegistry';
+import { createFloatEditor } from './SharedEditors';
+import { icons } from '../../utils/icons';
+
+function cloneEffects(effects: PostProcessEffectData[]): PostProcessEffectData[] {
+ return effects.map(e => ({
+ type: e.type,
+ enabled: e.enabled,
+ uniforms: { ...e.uniforms },
+ }));
+}
+
+function renderInspector(
+ container: HTMLElement,
+ ctx: ComponentInspectorContext,
+): ComponentInspectorInstance {
+ let currentEffects: PostProcessEffectData[] =
+ (ctx.componentData.effects as PostProcessEffectData[]) ?? [];
+
+ function emitChange(newEffects: PostProcessEffectData[]): void {
+ const old = cloneEffects(currentEffects);
+ currentEffects = newEffects;
+ ctx.onChange('effects', old, cloneEffects(newEffects));
+
+ syncToRuntime();
+ }
+
+ function syncToRuntime(): void {
+ syncPostProcessVolume(ctx.entity, { effects: currentEffects });
+ }
+
+ function rebuild(): void {
+ container.innerHTML = '';
+ renderEffectList(container, currentEffects, emitChange);
+ renderAddButton(container, currentEffects, emitChange);
+ }
+
+ rebuild();
+ syncToRuntime();
+
+ return {
+ dispose() {},
+ update(data: Record<string, unknown>) {
+ const newEffects = (data.effects as PostProcessEffectData[]) ?? [];
+ currentEffects = newEffects;
+ rebuild();
+ syncToRuntime();
+ },
+ };
+}
+
+function renderEffectList(
+ container: HTMLElement,
+ effects: PostProcessEffectData[],
+ onChange: (effects: PostProcessEffectData[]) => void,
+): void {
+ for (let i = 0; i < effects.length; i++) {
+ const effect = effects[i];
+ const def = getEffectDef(effect.type);
+ if (!def) continue;
+
+ const section = document.createElement('div');
+ section.className = 'es-pp-effect es-collapsible es-expanded';
+
+ const header = document.createElement('div');
+ header.className = 'es-pp-effect-header es-collapsible-header';
+
+ const collapseIcon = document.createElement('span');
+ collapseIcon.className = 'es-collapse-icon';
+ collapseIcon.innerHTML = icons.chevronDown(8);
+
+ const label = document.createElement('span');
+ label.className = 'es-pp-effect-label';
+ label.textContent = def.label;
+
+ const spacer = document.createElement('span');
+ spacer.style.flex = '1';
+
+ const enableCb = document.createElement('input');
+ enableCb.type = 'checkbox';
+ enableCb.checked = effect.enabled;
+ enableCb.title = 'Enable/Disable';
+ enableCb.addEventListener('change', (e) => {
+ e.stopPropagation();
+ const updated = cloneEffects(effects);
+ updated[i].enabled = enableCb.checked;
+ onChange(updated);
+ });
+
+ const removeBtn = document.createElement('span');
+ removeBtn.className = 'es-pp-effect-remove';
+ removeBtn.innerHTML = icons.x(12);
+ removeBtn.title = 'Remove effect';
+ removeBtn.addEventListener('click', (e) => {
+ e.stopPropagation();
+ const updated = cloneEffects(effects);
+ updated.splice(i, 1);
+ onChange(updated);
+ });
+
+ header.appendChild(collapseIcon);
+ header.appendChild(label);
+ header.appendChild(spacer);
+ header.appendChild(enableCb);
+ header.appendChild(removeBtn);
+
+ header.addEventListener('click', () => {
+ section.classList.toggle('es-expanded');
+ });
+
+ section.appendChild(header);
+
+ const body = document.createElement('div');
+ body.className = 'es-pp-effect-body es-collapsible-content';
+
+ for (const uDef of def.uniforms) {
+ const row = document.createElement('div');
+ row.className = 'es-property-row';
+
+ const propLabel = document.createElement('span');
+ propLabel.className = 'es-property-label';
+ propLabel.textContent = uDef.label;
+
+ const propValue = document.createElement('div');
+ propValue.className = 'es-property-value';
+
+ const currentVal = effect.uniforms[uDef.name] ?? uDef.defaultValue;
+ createFloatEditor(propValue, currentVal, (v) => {
+ const updated = cloneEffects(effects);
+ updated[i].uniforms[uDef.name] = v;
+ onChange(updated);
+ }, uDef.min, uDef.max, uDef.step);
+
+ row.appendChild(propLabel);
+ row.appendChild(propValue);
+ body.appendChild(row);
+ }
+
+ section.appendChild(body);
+ container.appendChild(section);
+ }
+}
+
+function renderAddButton(
+ container: HTMLElement,
+ effects: PostProcessEffectData[],
+ onChange: (effects: PostProcessEffectData[]) => void,
+): void {
+ const wrapper = document.createElement('div');
+ wrapper.className = 'es-pp-add-wrapper';
+
+ const btn = document.createElement('button');
+ btn.className = 'es-btn es-btn-small es-pp-add-btn';
+ btn.textContent = 'Add Effect';
+
+ btn.addEventListener('click', () => {
+ const allDefs = getAllEffectDefs();
+ const existingTypes = new Set(effects.map(e => e.type));
+ const available = allDefs.filter(d => !existingTypes.has(d.type));
+
+ if (available.length === 0) return;
+
+ const menu = document.createElement('div');
+ menu.className = 'es-pp-add-menu';
+
+ for (const def of available) {
+ const item = document.createElement('div');
+ item.className = 'es-pp-add-menu-item';
+ item.textContent = def.label;
+ item.addEventListener('click', () => {
+ menu.remove();
+
+ const uniforms: Record<string, number> = {};
+ for (const u of def.uniforms) {
+ uniforms[u.name] = u.defaultValue;
+ }
+
+ const updated = cloneEffects(effects);
+ updated.push({ type: def.type, enabled: true, uniforms });
+ onChange(updated);
+ });
+ menu.appendChild(item);
+ }
+
+ const rect = btn.getBoundingClientRect();
+ menu.style.position = 'fixed';
+ menu.style.left = `${rect.left}px`;
+ menu.style.top = `${rect.bottom + 2}px`;
+ menu.style.zIndex = '9999';
+ document.body.appendChild(menu);
+
+ const dismiss = (e: MouseEvent) => {
+ if (!menu.contains(e.target as Node)) {
+ menu.remove();
+ document.removeEventListener('mousedown', dismiss);
+ }
+ };
+ setTimeout(() => document.addEventListener('mousedown', dismiss), 0);
+ });
+
+ wrapper.appendChild(btn);
+ container.appendChild(wrapper);
+}
+
+export function registerPostProcessVolumeInspector(): void {
+ registerComponentInspector({
+ id: 'postprocess-volume',
+ componentType: 'PostProcessVolume',
+ render: renderInspector,
+ });
+}
diff --git a/editor/src/property/editors.ts b/editor/src/property/editors.ts
index af25e543c..8e618ad5a 100644
--- a/editor/src/property/editors.ts
+++ b/editor/src/property/editors.ts
@@ -2048,6 +2048,133 @@ function createAudioFileEditor(
};
}
+// =============================================================================
+// Tilemap File Editor
+// =============================================================================
+
+function createTilemapFileEditor(
+ container: HTMLElement,
+ ctx: PropertyEditorContext
+): PropertyEditorInstance {
+ const { value, onChange } = ctx;
+
+ const wrapper = document.createElement('div');
+ wrapper.className = 'es-file-editor';
+
+ const input = document.createElement('input');
+ input.type = 'text';
+ input.className = 'es-input es-input-file es-asset-link';
+ input.value = resolveDisplayName(String(value ?? ''));
+ input.placeholder = 'None';
+ input.readOnly = true;
+ checkAssetMissing(String(value ?? ''), input);
+
+ const browseBtn = document.createElement('button');
+ browseBtn.className = 'es-btn es-btn-icon es-btn-browse';
+ browseBtn.title = 'Browse';
+ browseBtn.innerHTML = `<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 7v10a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V9a2 2 0 0 0-2-2h-6l-2-2H5a2 2 0 0 0-2 2z"></path></svg>`;
+
+ const clearBtn = document.createElement('button');
+ clearBtn.className = 'es-btn es-btn-icon es-btn-clear';
+ clearBtn.title = 'Clear';
+ clearBtn.innerHTML = `<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>`;
+
+ input.addEventListener('click', () => {
+ if (input.value) {
+ navigateToAsset(input.value);
+ }
+ });
+
+ wrapper.addEventListener('dragover', (e) => {
+ e.preventDefault();
+ const data = e.dataTransfer?.types.includes('application/esengine-asset');
+ if (data) {
+ wrapper.classList.add('es-drag-over');
+ e.dataTransfer!.dropEffect = 'copy';
+ } else {
+ e.dataTransfer!.dropEffect = 'none';
+ }
+ });
+
+ wrapper.addEventListener('dragleave', () => {
+ wrapper.classList.remove('es-drag-over');
+ });
+
+ wrapper.addEventListener('drop', (e) => {
+ e.preventDefault();
+ wrapper.classList.remove('es-drag-over');
+
+ const jsonData = e.dataTransfer?.getData('application/esengine-asset');
+ if (!jsonData) return;
+
+ try {
+ const assetData = JSON.parse(jsonData);
+ if (assetData.type === 'tilemap') {
+ const projectDir = getProjectDir();
+ if (projectDir && assetData.path.startsWith(projectDir)) {
+ const relativePath = assetData.path.substring(projectDir.length + 1);
+ const uuid = getAssetLibrary().getUuid(relativePath);
+ const ref = uuid ?? relativePath;
+ input.value = relativePath;
+ onChange(ref);
+ }
+ }
+ } catch (err) {
+ console.error('Failed to parse drop data:', err);
+ }
+ });
+
+ browseBtn.addEventListener('click', async () => {
+ const projectDir = getProjectDir();
+ if (!projectDir) return;
+
+ const assetsDir = `${projectDir}/assets`;
+
+ try {
+ const platform = getPlatformAdapter();
+ const result = await platform.openFileDialog({
+ title: 'Select Tilemap',
+ defaultPath: assetsDir,
+ filters: [{ name: 'Tiled Map', extensions: ['tmj'] }],
+ });
+ if (result) {
+ const normalizedPath = result.replace(/\\/g, '/');
+ const assetsIndex = normalizedPath.indexOf('/assets/');
+ if (assetsIndex !== -1) {
+ const relativePath = normalizedPath.substring(assetsIndex + 1);
+ const uuid = getAssetLibrary().getUuid(relativePath);
+ const ref = uuid ?? relativePath;
+ input.value = relativePath;
+ onChange(ref);
+ }
+ }
+ } catch (err) {
+ console.error('Failed to open file dialog:', err);
+ }
+ });
+
+ clearBtn.addEventListener('click', () => {
+ input.value = '';
+ onChange('');
+ });
+
+ wrapper.appendChild(input);
+ wrapper.appendChild(browseBtn);
+ wrapper.appendChild(clearBtn);
+ container.appendChild(wrapper);
+
+ return {
+ update(v: unknown) {
+ const ref = String(v ?? '');
+ input.value = resolveDisplayName(ref);
+ checkAssetMissing(ref, input);
+ },
+ dispose() {
+ wrapper.remove();
+ },
+ };
+}
+
// =============================================================================
// Register All Editors
// =============================================================================
@@ -2076,4 +2203,5 @@ export function registerBuiltinEditors(): void {
registerPropertyEditor('string-array', createStringArrayEditor);
registerPropertyEditor('anim-file', createAnimFileEditor);
registerPropertyEditor('audio-file', createAudioFileEditor);
+ registerPropertyEditor('tilemap-file', createTilemapFileEditor);
}
diff --git a/editor/src/renderer/EditorSceneRenderer.ts b/editor/src/renderer/EditorSceneRenderer.ts
index 268c2af06..f62e7ac9c 100644
--- a/editor/src/renderer/EditorSceneRenderer.ts
+++ b/editor/src/renderer/EditorSceneRenderer.ts
@@ -5,6 +5,10 @@ import {
ButtonState,
RenderPipeline,
Renderer,
+ PostProcess,
+ syncPostProcessVolume,
+ cleanupPostProcessVolume,
+ type PostProcessEffectData,
} from 'esengine';
import type { SpineModuleController } from 'esengine/spine';
import type { SceneData, ComponentData } from '../types/SceneTypes';
@@ -91,6 +95,12 @@ export class EditorSceneRenderer {
store.subscribeToComponentChanges((e) => {
if (e.action === 'removed') {
sm.removeComponentFromEntity(e.entity, e.componentType);
+ if (e.componentType === 'PostProcessVolume') {
+ cleanupPostProcessVolume(e.entity);
+ }
+ }
+ if (e.action === 'added' && e.componentType === 'PostProcessVolume') {
+ this.syncPostProcessVolumeForEntity(e.entity);
}
this.scheduleEntityUpdate(e.entity);
}),
@@ -135,6 +145,9 @@ export class EditorSceneRenderer {
this.store_!.updatePropertyDirect(event.entity, 'Sprite', 'color', event.newValue);
}
break;
+ case 'PostProcessVolume':
+ this.syncPostProcessVolumeForEntity(event.entity);
+ break;
}
if (event.componentType === 'Transform'
@@ -256,6 +269,7 @@ export class EditorSceneRenderer {
async syncScene(scene: SceneData): Promise<void> {
await this.sceneManager_?.loadScene(scene);
+ this.syncAllPostProcessVolumes();
}
async updateEntity(entityId: number, components: ComponentData[]): Promise<void> {
@@ -412,7 +426,15 @@ export class EditorSceneRenderer {
gameRenderer.renderAndCapture(this.context_);
}
+ const ppCamera = this.findFirstPPCamera();
+ if (ppCamera >= 0) {
+ PostProcess._applyForCamera(ppCamera);
+ PostProcess.resize(width, height);
+ PostProcess.setOutputViewport(0, 0, width, height);
+ }
+
Renderer.setClearColor(bg.r, bg.g, bg.b, bg.a);
+ Renderer.resize(width, height);
Renderer.setViewport(0, 0, width, height);
Renderer.clearBuffers(3);
Renderer.begin(matrix);
@@ -429,6 +451,10 @@ export class EditorSceneRenderer {
}
Renderer.flush();
Renderer.end();
+
+ if (ppCamera >= 0) {
+ PostProcess._resetAfterCamera();
+ }
} catch (e) {
if (e instanceof WebAssembly.RuntimeError) {
console.warn('[EditorSceneRenderer] WASM error during render:', (e as Error).message);
@@ -473,6 +499,41 @@ export class EditorSceneRenderer {
}
}
+ private findFirstPPCamera(): number {
+ if (!this.store_) return -1;
+ for (const entity of this.store_.scene.entities) {
+ const hasCam = entity.components.some(c => c.type === 'Camera');
+ const hasPP = entity.components.some(c => c.type === 'PostProcessVolume');
+ if (hasCam && hasPP && PostProcess.getStack(entity.id)) {
+ return entity.id;
+ }
+ }
+ return -1;
+ }
+
+ private syncPostProcessVolumeForEntity(entityId: number): void {
+ const entityData = this.store_?.getEntityData(entityId);
+ if (!entityData) return;
+ const ppComp = entityData.components.find(c => c.type === 'PostProcessVolume');
+ if (ppComp) {
+ const effects = (ppComp.data.effects as PostProcessEffectData[]) ?? [];
+ syncPostProcessVolume(entityId, { effects });
+ } else {
+ cleanupPostProcessVolume(entityId);
+ }
+ }
+
+ syncAllPostProcessVolumes(): void {
+ if (!this.store_) return;
+ for (const entity of this.store_.scene.entities) {
+ const ppComp = entity.components.find(c => c.type === 'PostProcessVolume');
+ if (ppComp) {
+ const effects = (ppComp.data.effects as PostProcessEffectData[]) ?? [];
+ syncPostProcessVolume(entity.id, { effects });
+ }
+ }
+ }
+
private findCanvasBackgroundColor(): { r: number; g: number; b: number; a: number } {
if (this.store_) {
for (const entity of this.store_.scene.entities) {
diff --git a/editor/src/renderer/GameViewRenderer.ts b/editor/src/renderer/GameViewRenderer.ts
index 050c6660d..8a6237ee1 100644
--- a/editor/src/renderer/GameViewRenderer.ts
+++ b/editor/src/renderer/GameViewRenderer.ts
@@ -99,6 +99,7 @@ export class GameViewRenderer {
private worldRight_ = 0;
private worldBottom_ = 0;
private worldTop_ = 0;
+ private cameraEntity_ = -1;
constructor(canvas2d: HTMLCanvasElement, webglCanvas: HTMLCanvasElement) {
this.canvas2d_ = canvas2d;
@@ -142,6 +143,7 @@ export class GameViewRenderer {
if (cameraEntities.length === 0) return false;
const e = cameraEntities[0];
+ this.cameraEntity_ = e;
const camera = registry.getCamera(e);
const transform = registry.getTransform(e);
@@ -233,22 +235,28 @@ export class GameViewRenderer {
const registry = { _cpp: cppReg };
try {
- Renderer.setViewport(0, 0, renderW, renderH);
- Renderer.clearBuffers(3);
- Renderer.begin(this.vpMatrix_);
- if (pipeline?.maskProcessor) {
- pipeline.maskProcessor(registry._cpp, this.vpMatrix_, 0, 0, renderW, renderH);
- }
- Renderer.submitSprites(registry);
- Renderer.submitBitmapText(registry);
- if (pipeline?.spineRenderer) {
- pipeline.spineRenderer(registry, elapsed);
+ Renderer.resize(renderW, renderH);
+
+ if (pipeline) {
+ pipeline.renderCamera({
+ registry,
+ viewProjection: this.vpMatrix_,
+ viewportPixels: { x: 0, y: 0, w: renderW, h: renderH },
+ clearFlags: 3,
+ elapsed,
+ cameraEntity: this.cameraEntity_,
+ });
} else {
+ Renderer.setViewport(0, 0, renderW, renderH);
+ Renderer.clearBuffers(3);
+ Renderer.begin(this.vpMatrix_);
+ Renderer.submitSprites(registry);
+ Renderer.submitBitmapText(registry);
Renderer.submitSpine(registry);
+ Renderer.submitParticles(registry);
+ Renderer.flush();
+ Renderer.end();
}
- Renderer.submitParticles(registry);
- Renderer.flush();
- Renderer.end();
const srcY = this.webglCanvas_.height - renderH;
this.ctx2d_.clearRect(0, 0, this.width_, this.height_);
diff --git a/editor/src/styles/inspector.css b/editor/src/styles/inspector.css
index 1e82883f6..1488e506b 100644
--- a/editor/src/styles/inspector.css
+++ b/editor/src/styles/inspector.css
@@ -1596,3 +1596,99 @@
background: rgba(79, 145, 255, 0.08);
color: var(--es-text-primary);
}
+
+/* =============================================================================
+ * PostProcess Volume Inspector
+ * ============================================================================= */
+
+.es-pp-effect {
+ border: 1px solid var(--es-border);
+ border-radius: 4px;
+ margin-bottom: 4px;
+ overflow: hidden;
+}
+
+.es-pp-effect-header {
+ display: flex;
+ align-items: center;
+ gap: 6px;
+ padding: 4px 8px;
+ background: var(--es-bg-primary);
+ cursor: pointer;
+ font-size: 11px;
+ font-weight: 600;
+ color: var(--es-text-primary);
+}
+
+.es-pp-effect-header:hover {
+ background: var(--es-bg-hover);
+}
+
+.es-pp-effect-label {
+ user-select: none;
+}
+
+.es-pp-effect-remove {
+ flex-shrink: 0;
+ cursor: pointer;
+ color: var(--es-text-secondary);
+ opacity: 0;
+ transition: opacity 0.15s;
+ display: flex;
+ align-items: center;
+}
+
+.es-pp-effect-header:hover .es-pp-effect-remove {
+ opacity: 0.6;
+}
+
+.es-pp-effect-remove:hover {
+ color: var(--es-error);
+ opacity: 1 !important;
+}
+
+.es-pp-effect-body {
+ padding: 4px 8px;
+}
+
+.es-pp-add-wrapper {
+ margin-top: 6px;
+ text-align: center;
+}
+
+.es-pp-add-btn {
+ width: 100%;
+ padding: 4px 0;
+ font-size: 11px;
+ background: var(--es-bg-primary);
+ border: 1px dashed var(--es-border);
+ color: var(--es-text-secondary);
+ cursor: pointer;
+ border-radius: 3px;
+}
+
+.es-pp-add-btn:hover {
+ background: var(--es-bg-hover);
+ color: var(--es-text-primary);
+ border-color: var(--es-accent);
+}
+
+.es-pp-add-menu {
+ background: var(--es-bg-secondary);
+ border: 1px solid var(--es-border);
+ border-radius: 4px;
+ box-shadow: 0 4px 16px rgba(0, 0, 0, 0.4);
+ min-width: 160px;
+ padding: 4px 0;
+}
+
+.es-pp-add-menu-item {
+ padding: 6px 12px;
+ font-size: 11px;
+ color: var(--es-text-primary);
+ cursor: pointer;
+}
+
+.es-pp-add-menu-item:hover {
+ background: var(--es-bg-hover);
+}
diff --git a/sdk/src/app.ts b/sdk/src/app.ts
index 1b58a1573..ce3e37ae2 100644
--- a/sdk/src/app.ts
+++ b/sdk/src/app.ts
@@ -744,9 +744,6 @@ export function createWebApp(module: ESEngineModule, options?: WebAppOptions): A
const elapsed = (platformNow() - startTime) / 1000;
Renderer.resize(width, height);
- if (PostProcess.isInitialized() && PostProcess.getPassCount() > 0 && !PostProcess.isBypassed()) {
- PostProcess.resize(width, height);
- }
let activeScenes: Set<string> | undefined;
if (app.hasResource(SceneManager)) {
@@ -781,6 +778,7 @@ export function createWebApp(module: ESEngineModule, options?: WebAppOptions): A
viewportPixels: { x: px, y: py, w: pw, h: ph },
clearFlags: cam.clearFlags,
elapsed,
+ cameraEntity: cam.entity,
});
}
Renderer.setViewport(0, 0, width, height);
diff --git a/sdk/src/playableRuntime.ts b/sdk/src/playableRuntime.ts
index 0566873ae..e5c8d676e 100644
--- a/sdk/src/playableRuntime.ts
+++ b/sdk/src/playableRuntime.ts
@@ -22,8 +22,8 @@ export interface PlayableRuntimeConfig {
module: ESEngineModule;
canvas: HTMLCanvasElement;
assets: Record<string, string>;
- sceneData: SceneData;
- sceneName: string;
+ scenes: Array<{ name: string; data: SceneData }>;
+ firstScene: string;
spineWasmBase64?: string;
physicsWasmBase64?: string;
physicsConfig?: { gravity?: Vec2; fixedTimestep?: number; subStepCount?: number };
@@ -137,7 +137,7 @@ async function initPhysicsModule(wasmBase64: string): Promise<PhysicsWasmModule
}
export async function initPlayableRuntime(config: PlayableRuntimeConfig): Promise<void> {
- const { app, module, assets, sceneData, sceneName } = config;
+ const { app, module, assets, scenes, firstScene } = config;
const assetServer = app.getResource(Assets);
if (assetServer) {
@@ -159,8 +159,8 @@ export async function initPlayableRuntime(config: PlayableRuntimeConfig): Promis
app,
module,
provider,
- scenes: [{ name: sceneName, data: sceneData }],
- firstScene: sceneName,
+ scenes,
+ firstScene,
spineModule,
physicsModule,
physicsConfig: config.physicsConfig,
diff --git a/sdk/src/postprocess.ts b/sdk/src/postprocess.ts
index d4e113601..bb3facb81 100644
--- a/sdk/src/postprocess.ts
+++ b/sdk/src/postprocess.ts
@@ -1,10 +1,10 @@
/**
* @file postprocess.ts
- * @brief Post-processing effects API
- * @details Provides full-screen post-processing effects like blur, vignette, etc.
+ * @brief Per-camera post-processing effects API
*/
import type { ESEngineModule } from './wasm';
+import type { Entity } from './types';
import type { ShaderHandle, Vec4 } from './material';
import { Material } from './material';
import { handleWasmError } from './wasmError';
@@ -14,6 +14,10 @@ import { handleWasmError } from './wasmError';
// =============================================================================
let module: ESEngineModule | null = null;
+let nextStackId = 1;
+
+const stacks: Map<number, PostProcessStack> = new Map();
+const cameraBindings: Map<Entity, PostProcessStack> = new Map();
// =============================================================================
// Initialization
@@ -24,6 +28,11 @@ export function initPostProcessAPI(wasmModule: ESEngineModule): void {
}
export function shutdownPostProcessAPI(): void {
+ for (const stack of stacks.values()) {
+ stack.destroy();
+ }
+ stacks.clear();
+ cameraBindings.clear();
if (module && PostProcess.isInitialized()) {
PostProcess.shutdown();
}
@@ -31,7 +40,112 @@ export function shutdownPostProcessAPI(): void {
}
// =============================================================================
-// PostProcess API
+// PostProcessStack
+// =============================================================================
+
+interface PassConfig {
+ name: string;
+ shader: ShaderHandle;
+ enabled: boolean;
+ floatUniforms: Map<string, number>;
+ vec4Uniforms: Map<string, Vec4>;
+}
+
+export class PostProcessStack {
+ readonly id: number;
+ private passes_: PassConfig[] = [];
+ private destroyed_ = false;
+
+ constructor() {
+ this.id = nextStackId++;
+ stacks.set(this.id, this);
+ }
+
+ addPass(name: string, shader: ShaderHandle): this {
+ this.passes_.push({
+ name,
+ shader,
+ enabled: true,
+ floatUniforms: new Map(),
+ vec4Uniforms: new Map(),
+ });
+ return this;
+ }
+
+ removePass(name: string): this {
+ const idx = this.passes_.findIndex(p => p.name === name);
+ if (idx !== -1) {
+ this.passes_.splice(idx, 1);
+ }
+ return this;
+ }
+
+ setEnabled(name: string, enabled: boolean): this {
+ const pass = this.passes_.find(p => p.name === name);
+ if (pass) {
+ pass.enabled = enabled;
+ }
+ return this;
+ }
+
+ setUniform(passName: string, uniform: string, value: number): this {
+ const pass = this.passes_.find(p => p.name === passName);
+ if (pass) {
+ pass.floatUniforms.set(uniform, value);
+ }
+ return this;
+ }
+
+ setUniformVec4(passName: string, uniform: string, value: Vec4): this {
+ const pass = this.passes_.find(p => p.name === passName);
+ if (pass) {
+ pass.vec4Uniforms.set(uniform, { ...value });
+ }
+ return this;
+ }
+
+ setAllPassesEnabled(enabled: boolean): void {
+ for (const pass of this.passes_) {
+ pass.enabled = enabled;
+ }
+ }
+
+ get passCount(): number {
+ return this.passes_.length;
+ }
+
+ get enabledPassCount(): number {
+ let count = 0;
+ for (const pass of this.passes_) {
+ if (pass.enabled) count++;
+ }
+ return count;
+ }
+
+ get passes(): readonly PassConfig[] {
+ return this.passes_;
+ }
+
+ get isDestroyed(): boolean {
+ return this.destroyed_;
+ }
+
+ destroy(): void {
+ if (this.destroyed_) return;
+ this.destroyed_ = true;
+
+ for (const [camera, stack] of cameraBindings) {
+ if (stack === this) {
+ cameraBindings.delete(camera);
+ }
+ }
+
+ stacks.delete(this.id);
+ }
+}
+
+// =============================================================================
+// Internal helpers
// =============================================================================
function getModule(): ESEngineModule {
@@ -41,202 +155,163 @@ function getModule(): ESEngineModule {
return module;
}
-export const PostProcess = {
- /**
- * Initializes the post-processing pipeline.
- * @param width Framebuffer width
- * @param height Framebuffer height
- * @returns True on success
- */
- init(width: number, height: number): boolean {
+function syncStackToWasm(stack: PostProcessStack): void {
+ const m = getModule();
+
+ try {
+ m.postprocess_clearPasses();
+ } catch (e) {
+ handleWasmError(e, 'PostProcess._applyForCamera:clearPasses');
+ return;
+ }
+
+ for (const pass of stack.passes) {
+ if (!pass.enabled) continue;
try {
- return getModule().postprocess_init(width, height);
+ m.postprocess_addPass(pass.name, pass.shader);
} catch (e) {
- handleWasmError(e, `PostProcess.init(${width}x${height})`);
- return false;
+ handleWasmError(e, `PostProcess._applyForCamera:addPass("${pass.name}")`);
+ continue;
}
- },
- /**
- * Shuts down the post-processing pipeline.
- */
- shutdown(): void {
- try {
- getModule().postprocess_shutdown();
- } catch (e) {
- handleWasmError(e, 'PostProcess.shutdown');
+ for (const [name, value] of pass.floatUniforms) {
+ try {
+ m.postprocess_setUniformFloat(pass.name, name, value);
+ } catch (e) {
+ handleWasmError(e, `PostProcess._applyForCamera:setUniform("${pass.name}", "${name}")`);
+ }
}
- },
- /**
- * Resizes the framebuffers.
- * @param width New width
- * @param height New height
- */
- resize(width: number, height: number): void {
- try {
- getModule().postprocess_resize(width, height);
- } catch (e) {
- handleWasmError(e, `PostProcess.resize(${width}x${height})`);
+ for (const [name, value] of pass.vec4Uniforms) {
+ try {
+ m.postprocess_setUniformVec4(pass.name, name, value.x, value.y, value.z, value.w);
+ } catch (e) {
+ handleWasmError(e, `PostProcess._applyForCamera:setUniformVec4("${pass.name}", "${name}")`);
+ }
}
+ }
+}
+
+// =============================================================================
+// PostProcess Static API
+// =============================================================================
+
+export const PostProcess = {
+ // =========================================================================
+ // Stack Management
+ // =========================================================================
+
+ createStack(): PostProcessStack {
+ return new PostProcessStack();
},
- /**
- * Adds a post-processing pass.
- * @param name Unique name for the pass
- * @param shader Shader handle
- * @returns Pass index
- */
- addPass(name: string, shader: ShaderHandle): number {
- try {
- return getModule().postprocess_addPass(name, shader);
- } catch (e) {
- handleWasmError(e, `PostProcess.addPass("${name}")`);
- return -1;
+ // =========================================================================
+ // Camera Binding
+ // =========================================================================
+
+ bind(camera: Entity, stack: PostProcessStack): void {
+ if (stack.isDestroyed) {
+ throw new Error('Cannot bind a destroyed PostProcessStack');
}
+ cameraBindings.set(camera, stack);
},
- /**
- * Removes a pass by name.
- * @param name Pass name
- */
- removePass(name: string): void {
- try {
- getModule().postprocess_removePass(name);
- } catch (e) {
- handleWasmError(e, `PostProcess.removePass("${name}")`);
- }
+ unbind(camera: Entity): void {
+ cameraBindings.delete(camera);
},
- /**
- * Enables or disables a pass.
- * @param name Pass name
- * @param enabled Whether to enable the pass
- */
- setEnabled(name: string, enabled: boolean): void {
- try {
- getModule().postprocess_setPassEnabled(name, enabled);
- } catch (e) {
- handleWasmError(e, `PostProcess.setEnabled("${name}")`);
- }
+ getStack(camera: Entity): PostProcessStack | null {
+ return cameraBindings.get(camera) ?? null;
},
- /**
- * Checks if a pass is enabled.
- * @param name Pass name
- * @returns True if enabled
- */
- isEnabled(name: string): boolean {
+ // =========================================================================
+ // Pipeline Lifecycle (delegates to C++ singleton)
+ // =========================================================================
+
+ init(width: number, height: number): boolean {
try {
- return getModule().postprocess_isPassEnabled(name);
+ return getModule().postprocess_init(width, height);
} catch (e) {
- handleWasmError(e, `PostProcess.isEnabled("${name}")`);
+ handleWasmError(e, `PostProcess.init(${width}x${height})`);
return false;
}
},
- /**
- * Sets a float uniform on a pass.
- * @param passName Pass name
- * @param uniform Uniform name
- * @param value Float value
- */
- setUniform(passName: string, uniform: string, value: number): void {
+ shutdown(): void {
try {
- getModule().postprocess_setUniformFloat(passName, uniform, value);
+ getModule().postprocess_shutdown();
} catch (e) {
- handleWasmError(e, `PostProcess.setUniform("${passName}", "${uniform}")`);
+ handleWasmError(e, 'PostProcess.shutdown');
}
},
- /**
- * Sets a vec4 uniform on a pass.
- * @param passName Pass name
- * @param uniform Uniform name
- * @param value Vec4 value
- */
- setUniformVec4(passName: string, uniform: string, value: Vec4): void {
+ resize(width: number, height: number): void {
try {
- getModule().postprocess_setUniformVec4(passName, uniform, value.x, value.y, value.z, value.w);
+ getModule().postprocess_resize(width, height);
} catch (e) {
- handleWasmError(e, `PostProcess.setUniformVec4("${passName}", "${uniform}")`);
+ handleWasmError(e, `PostProcess.resize(${width}x${height})`);
}
},
- /**
- * Begins rendering to the post-process pipeline.
- * Call this before rendering your scene.
- */
- begin(): void {
+ isInitialized(): boolean {
+ if (!module) return false;
try {
- getModule().postprocess_begin();
+ return module.postprocess_isInitialized();
} catch (e) {
- handleWasmError(e, 'PostProcess.begin');
+ handleWasmError(e, 'PostProcess.isInitialized');
+ return false;
}
},
- /**
- * Ends and processes all passes.
- * Call this after rendering your scene.
- */
- end(): void {
+ setBypass(bypass: boolean): void {
try {
- getModule().postprocess_end();
+ getModule().postprocess_setBypass(bypass);
} catch (e) {
- handleWasmError(e, 'PostProcess.end');
+ handleWasmError(e, 'PostProcess.setBypass');
}
},
- /**
- * Gets the number of passes.
- */
- getPassCount(): number {
+ setOutputViewport(x: number, y: number, w: number, h: number): void {
try {
- return getModule().postprocess_getPassCount();
+ getModule().postprocess_setOutputViewport(x, y, w, h);
} catch (e) {
- handleWasmError(e, 'PostProcess.getPassCount');
- return 0;
+ handleWasmError(e, 'PostProcess.setOutputViewport');
}
},
- /**
- * Checks if the pipeline is initialized.
- */
- isInitialized(): boolean {
- if (!module) return false;
- try {
- return module.postprocess_isInitialized();
- } catch (e) {
- handleWasmError(e, 'PostProcess.isInitialized');
- return false;
+ // =========================================================================
+ // Per-Camera Render Integration (called by RenderPipeline)
+ // =========================================================================
+
+ _applyForCamera(camera: Entity): void {
+ const stack = cameraBindings.get(camera);
+ if (!stack || stack.isDestroyed || stack.enabledPassCount === 0) {
+ PostProcess.setBypass(true);
+ return;
}
+
+ if (!PostProcess.isInitialized()) {
+ PostProcess.init(1, 1);
+ }
+
+ PostProcess.setBypass(false);
+ syncStackToWasm(stack);
},
- /**
- * Sets bypass mode to skip FBO rendering entirely.
- * When bypassed, begin()/end() become no-ops and scene renders directly to screen.
- * Use this when no post-processing passes are needed for maximum performance.
- * @param bypass Whether to bypass the pipeline
- */
- setBypass(bypass: boolean): void {
+ _resetAfterCamera(): void {
try {
- getModule().postprocess_setBypass(bypass);
+ getModule().postprocess_clearPasses();
+ getModule().postprocess_setBypass(true);
} catch (e) {
- handleWasmError(e, 'PostProcess.setBypass');
+ handleWasmError(e, 'PostProcess._resetAfterCamera');
}
},
- /**
- * Checks if bypass mode is enabled.
- * @returns True if bypassed
- */
- isBypassed(): boolean {
- if (!module) return true;
- try {
- return module.postprocess_isBypassed();
- } catch (e) {
- handleWasmError(e, 'PostProcess.isBypassed');
- return true;
+ _cleanupDestroyedCameras(isValid: (e: Entity) => boolean): void {
+ for (const camera of cameraBindings.keys()) {
+ if (!isValid(camera)) {
+ cameraBindings.delete(camera);
+ }
}
},
@@ -244,10 +319,6 @@ export const PostProcess = {
// Built-in Effects
// =========================================================================
- /**
- * Creates a blur effect shader.
- * @returns Shader handle
- */
createBlur(): ShaderHandle {
const fragmentSrc = `#version 300 es
precision highp float;
@@ -279,10 +350,6 @@ void main() {
return Material.createShader(POSTPROCESS_VERTEX, fragmentSrc);
},
- /**
- * Creates a vignette effect shader.
- * @returns Shader handle
- */
createVignette(): ShaderHandle {
const fragmentSrc = `#version 300 es
precision highp float;
@@ -304,10 +371,6 @@ void main() {
return Material.createShader(POSTPROCESS_VERTEX, fragmentSrc);
},
- /**
- * Creates a grayscale effect shader.
- * @returns Shader handle
- */
createGrayscale(): ShaderHandle {
const fragmentSrc = `#version 300 es
precision highp float;
@@ -326,10 +389,42 @@ void main() {
return Material.createShader(POSTPROCESS_VERTEX, fragmentSrc);
},
- /**
- * Creates a chromatic aberration effect shader.
- * @returns Shader handle
- */
+ createBloom(): ShaderHandle {
+ const fragmentSrc = `#version 300 es
+precision highp float;
+
+in vec2 v_texCoord;
+uniform sampler2D u_texture;
+uniform vec2 u_resolution;
+uniform float u_threshold;
+uniform float u_intensity;
+uniform float u_radius;
+out vec4 fragColor;
+
+void main() {
+ vec4 color = texture(u_texture, v_texCoord);
+ vec2 texelSize = 1.0 / u_resolution;
+
+ vec3 bloom = vec3(0.0);
+ float total = 0.0;
+ for (float x = -3.0; x <= 3.0; x += 1.0) {
+ for (float y = -3.0; y <= 3.0; y += 1.0) {
+ vec2 offset = vec2(x, y) * texelSize * u_radius;
+ vec4 s = texture(u_texture, v_texCoord + offset);
+ float brightness = dot(s.rgb, vec3(0.2126, 0.7152, 0.0722));
+ float w = max(brightness - u_threshold, 0.0);
+ bloom += s.rgb * w;
+ total += w;
+ }
+ }
+ if (total > 0.0) bloom /= total;
+
+ fragColor = vec4(color.rgb + bloom * u_intensity, color.a);
+}
+`;
+ return Material.createShader(POSTPROCESS_VERTEX, fragmentSrc);
+ },
+
createChromaticAberration(): ShaderHandle {
const fragmentSrc = `#version 300 es
precision highp float;
@@ -370,3 +465,184 @@ void main() {
gl_Position = vec4(a_position, 0.0, 1.0);
}
`;
+
+// =============================================================================
+// Built-in Effect Metadata
+// =============================================================================
+
+export interface EffectUniformDef {
+ name: string;
+ label: string;
+ min: number;
+ max: number;
+ step: number;
+ defaultValue: number;
+}
+
+export interface EffectDef {
+ type: string;
+ label: string;
+ factory: () => ShaderHandle;
+ uniforms: EffectUniformDef[];
+}
+
+const effectRegistry = new Map<string, EffectDef>();
+
+function registerEffect(def: EffectDef): void {
+ effectRegistry.set(def.type, def);
+}
+
+registerEffect({
+ type: 'blur',
+ label: 'Blur',
+ factory: () => PostProcess.createBlur(),
+ uniforms: [
+ { name: 'u_intensity', label: 'Intensity', min: 0, max: 20, step: 0.1, defaultValue: 2 },
+ ],
+});
+
+registerEffect({
+ type: 'bloom',
+ label: 'Bloom',
+ factory: () => PostProcess.createBloom(),
+ uniforms: [
+ { name: 'u_threshold', label: 'Threshold', min: 0, max: 2, step: 0.01, defaultValue: 0.8 },
+ { name: 'u_intensity', label: 'Intensity', min: 0, max: 10, step: 0.1, defaultValue: 1.5 },
+ { name: 'u_radius', label: 'Radius', min: 0, max: 20, step: 0.1, defaultValue: 4 },
+ ],
+});
+
+registerEffect({
+ type: 'vignette',
+ label: 'Vignette',
+ factory: () => PostProcess.createVignette(),
+ uniforms: [
+ { name: 'u_intensity', label: 'Intensity', min: 0, max: 3, step: 0.01, defaultValue: 0.8 },
+ { name: 'u_softness', label: 'Softness', min: 0, max: 2, step: 0.01, defaultValue: 0.3 },
+ ],
+});
+
+registerEffect({
+ type: 'grayscale',
+ label: 'Grayscale',
+ factory: () => PostProcess.createGrayscale(),
+ uniforms: [
+ { name: 'u_intensity', label: 'Intensity', min: 0, max: 1, step: 0.01, defaultValue: 1 },
+ ],
+});
+
+registerEffect({
+ type: 'chromaticAberration',
+ label: 'Chromatic Aberration',
+ factory: () => PostProcess.createChromaticAberration(),
+ uniforms: [
+ { name: 'u_intensity', label: 'Intensity', min: 0, max: 20, step: 0.1, defaultValue: 3 },
+ ],
+});
+
+export function getEffectDef(type: string): EffectDef | undefined {
+ return effectRegistry.get(type);
+}
+
+export function getEffectTypes(): string[] {
+ return Array.from(effectRegistry.keys());
+}
+
+export function getAllEffectDefs(): EffectDef[] {
+ return Array.from(effectRegistry.values());
+}
+
+// =============================================================================
+// PostProcessVolume Data
+// =============================================================================
+
+export interface PostProcessEffectData {
+ type: string;
+ enabled: boolean;
+ uniforms: Record<string, number>;
+}
+
+export interface PostProcessVolumeData {
+ effects: PostProcessEffectData[];
+}
+
+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/sceneManager.ts b/sdk/src/sceneManager.ts
index c9457f9f9..5396f3b85 100644
--- a/sdk/src/sceneManager.ts
+++ b/sdk/src/sceneManager.ts
@@ -7,12 +7,12 @@ import type { App } from './app';
import type { Entity, Color } from './types';
import type { SceneData, SceneLoadOptions, LoadedSceneAssets } from './scene';
import type { SystemDef } from './system';
-import { Material, type ShaderHandle } from './material';
+import { Material } from './material';
import type { DrawCallback } from './customDraw';
import { Schedule } from './system';
import { loadSceneWithAssets } from './scene';
import { registerDrawCallback, unregisterDrawCallback } from './customDraw';
-import { PostProcess } from './postprocess';
+import { PostProcess, PostProcessStack } from './postprocess';
import { Draw } from './draw';
import { defineResource } from './resource';
import { SceneOwner, Sprite, SpineAnimation, BitmapText } from './component';
@@ -40,8 +40,8 @@ export interface SceneContext {
spawn(): Entity;
despawn(entity: Entity): void;
registerDrawCallback(id: string, fn: DrawCallback): void;
- addPostProcessPass(name: string, shader: ShaderHandle): number;
- removePostProcessPass(name: string): void;
+ bindPostProcess(camera: Entity, stack: PostProcessStack): void;
+ unbindPostProcess(camera: Entity): void;
setPersistent(entity: Entity, persistent: boolean): void;
}
@@ -77,7 +77,7 @@ class SceneInstance {
readonly config: SceneConfig;
readonly entities = new Set<Entity>();
readonly drawCallbacks = new Map<string, DrawCallback>();
- readonly postProcessPasses: string[] = [];
+ readonly postProcessBindings = new Map<Entity, PostProcessStack>();
readonly savedAlphas = new Map<Entity, { sprite?: number; spine?: number; bitmapText?: number }>();
loadedAssets: LoadedSceneAssets | null = null;
status: SceneStatus = 'loading';
@@ -128,18 +128,14 @@ class SceneContextImpl implements SceneContext {
registerDrawCallback(id, fn, this.instance_.config.name);
}
- addPostProcessPass(name: string, shader: ShaderHandle): number {
- const index = PostProcess.addPass(name, shader);
- this.instance_.postProcessPasses.push(name);
- return index;
+ bindPostProcess(camera: Entity, stack: PostProcessStack): void {
+ PostProcess.bind(camera, stack);
+ this.instance_.postProcessBindings.set(camera, stack);
}
- removePostProcessPass(name: string): void {
- PostProcess.removePass(name);
- const idx = this.instance_.postProcessPasses.indexOf(name);
- if (idx !== -1) {
- this.instance_.postProcessPasses.splice(idx, 1);
- }
+ unbindPostProcess(camera: Entity): void {
+ PostProcess.unbind(camera);
+ this.instance_.postProcessBindings.delete(camera);
}
setPersistent(entity: Entity, persistent: boolean): void {
@@ -174,6 +170,34 @@ export class SceneManagerState {
this.app_ = app;
}
+ reset(): void {
+ for (const instance of this.scenes_.values()) {
+ for (const id of instance.drawCallbacks.keys()) {
+ unregisterDrawCallback(id);
+ }
+ for (const camera of instance.postProcessBindings.keys()) {
+ PostProcess.unbind(camera);
+ }
+ }
+
+ if (this.transition_) {
+ unregisterDrawCallback(TRANSITION_CALLBACK_ID);
+ this.transition_ = null;
+ }
+
+ this.configs_.clear();
+ this.scenes_.clear();
+ this.contexts_.clear();
+ this.additiveScenes_.clear();
+ this.pausedScenes_.clear();
+ this.sleepingScenes_.clear();
+ this.loadOrder_.length = 0;
+ this.activeScene_ = null;
+ this.initialScene_ = null;
+ this.switching_ = false;
+ this.loadPromises_.clear();
+ }
+
register(config: SceneConfig): void {
this.configs_.set(config.name, config);
}
@@ -419,14 +443,10 @@ export class SceneManagerState {
}
instance.drawCallbacks.clear();
- for (const passName of instance.postProcessPasses) {
- try {
- PostProcess.removePass(passName);
- } catch {
- // pass may already be removed
- }
+ for (const camera of instance.postProcessBindings.keys()) {
+ PostProcess.unbind(camera);
}
- instance.postProcessPasses.length = 0;
+ instance.postProcessBindings.clear();
this.releaseSceneAssets_(instance);
@@ -608,12 +628,8 @@ export class SceneManagerState {
}
private setPostProcessPassesEnabled(instance: SceneInstance, enabled: boolean): void {
- for (const passName of instance.postProcessPasses) {
- try {
- PostProcess.setEnabled(passName, enabled);
- } catch {
- // pass may have been removed externally
- }
+ for (const stack of instance.postProcessBindings.values()) {
+ stack.setAllPassesEnabled(enabled);
}
}
diff --git a/src/esengine/bindings/PostProcessBindings.cpp b/src/esengine/bindings/PostProcessBindings.cpp
index 5bc04bf01..871ba7254 100644
--- a/src/esengine/bindings/PostProcessBindings.cpp
+++ b/src/esengine/bindings/PostProcessBindings.cpp
@@ -122,6 +122,24 @@ bool postprocess_isBypassed() {
return g_postProcessPipeline->isBypassed();
}
+void postprocess_clearPasses() {
+ if (g_postProcessPipeline) {
+ g_postProcessPipeline->clearPasses();
+ }
+}
+
+void postprocess_setOutputTarget(u32 fboId) {
+ if (g_postProcessPipeline) {
+ g_postProcessPipeline->setOutputTarget(fboId);
+ }
+}
+
+void postprocess_setOutputViewport(u32 x, u32 y, u32 w, u32 h) {
+ if (g_postProcessPipeline) {
+ g_postProcessPipeline->setOutputViewport(x, y, w, h);
+ }
+}
+
} // namespace esengine
#endif // ES_PLATFORM_WEB
diff --git a/src/esengine/bindings/PostProcessBindings.hpp b/src/esengine/bindings/PostProcessBindings.hpp
index 05b634d21..e9a52878c 100644
--- a/src/esengine/bindings/PostProcessBindings.hpp
+++ b/src/esengine/bindings/PostProcessBindings.hpp
@@ -25,6 +25,9 @@ u32 postprocess_getPassCount();
bool postprocess_isInitialized();
void postprocess_setBypass(bool bypass);
bool postprocess_isBypassed();
+void postprocess_clearPasses();
+void postprocess_setOutputTarget(u32 fboId);
+void postprocess_setOutputViewport(u32 x, u32 y, u32 w, u32 h);
} // namespace esengine
diff --git a/src/esengine/bindings/WebSDKEntry.cpp b/src/esengine/bindings/WebSDKEntry.cpp
index 4db511947..a6caad1ed 100644
--- a/src/esengine/bindings/WebSDKEntry.cpp
+++ b/src/esengine/bindings/WebSDKEntry.cpp
@@ -363,6 +363,9 @@ EMSCRIPTEN_BINDINGS(esengine_renderer) {
emscripten::function("postprocess_isInitialized", &esengine::postprocess_isInitialized);
emscripten::function("postprocess_setBypass", &esengine::postprocess_setBypass);
emscripten::function("postprocess_isBypassed", &esengine::postprocess_isBypassed);
+ emscripten::function("postprocess_clearPasses", &esengine::postprocess_clearPasses);
+ emscripten::function("postprocess_setOutputTarget", &esengine::postprocess_setOutputTarget);
+ emscripten::function("postprocess_setOutputViewport", &esengine::postprocess_setOutputViewport);
emscripten::function("renderer_init", &esengine::renderer_init);
emscripten::function("renderer_resize", &esengine::renderer_resize);
diff --git a/src/esengine/renderer/Framebuffer.hpp b/src/esengine/renderer/Framebuffer.hpp
index 6c7ad87bb..69d7987f4 100644
--- a/src/esengine/renderer/Framebuffer.hpp
+++ b/src/esengine/renderer/Framebuffer.hpp
@@ -151,6 +151,9 @@ public:
/** @brief Gets the framebuffer specification */
const FramebufferSpec& getSpecification() const { return spec_; }
+ /** @brief Gets the underlying GL framebuffer object ID */
+ u32 getFramebufferId() const { return framebufferId_; }
+
private:
/**
* @brief Initializes the framebuffer on GPU
diff --git a/src/esengine/renderer/PostProcessPipeline.cpp b/src/esengine/renderer/PostProcessPipeline.cpp
index 64ad58f3d..f6097ecbe 100644
--- a/src/esengine/renderer/PostProcessPipeline.cpp
+++ b/src/esengine/renderer/PostProcessPipeline.cpp
@@ -254,7 +254,7 @@ void PostProcessPipeline::end() {
if (enabledCount == 0) {
fboA_->unbind();
- blitToScreen(fboA_->getColorAttachment());
+ blitToOutput(fboA_->getColorAttachment());
} else {
u32 inputTexture = fboA_->getColorAttachment();
currentFBO_ = 0;
@@ -275,12 +275,13 @@ void PostProcessPipeline::end() {
Framebuffer* lastFBO = (currentFBO_ == 0) ? fboA_.get() : fboB_.get();
lastFBO->unbind();
- blitToScreen(inputTexture);
+ blitToOutput(inputTexture);
}
RenderCommand::setBlending(true);
RenderCommand::setDepthTest(true);
inFrame_ = false;
+ output_target_fbo_ = 0;
}
void PostProcessPipeline::renderPass(const PostProcessPass& pass, u32 inputTexture) {
@@ -305,10 +306,31 @@ void PostProcessPipeline::renderPass(const PostProcessPass& pass, u32 inputTextu
RenderCommand::drawIndexed(*screenQuadVAO_, 6);
}
-void PostProcessPipeline::blitToScreen(u32 texture) {
+void PostProcessPipeline::clearPasses() {
+ passes_.clear();
+}
+
+void PostProcessPipeline::setOutputTarget(u32 fboId) {
+ output_target_fbo_ = fboId;
+}
+
+void PostProcessPipeline::setOutputViewport(u32 x, u32 y, u32 w, u32 h) {
+ output_vp_x_ = x;
+ output_vp_y_ = y;
+ output_vp_w_ = w;
+ output_vp_h_ = h;
+}
+
+void PostProcessPipeline::blitToOutput(u32 texture) {
Shader* shader = resourceManager_.getShader(blitShader_);
if (!shader) return;
+ glBindFramebuffer(GL_FRAMEBUFFER, output_target_fbo_);
+
+ if (output_vp_w_ > 0 && output_vp_h_ > 0) {
+ RenderCommand::setViewport(output_vp_x_, output_vp_y_, output_vp_w_, output_vp_h_);
+ }
+
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
diff --git a/src/esengine/renderer/PostProcessPipeline.hpp b/src/esengine/renderer/PostProcessPipeline.hpp
index 4e7c0e0e3..90efbb5ae 100644
--- a/src/esengine/renderer/PostProcessPipeline.hpp
+++ b/src/esengine/renderer/PostProcessPipeline.hpp
@@ -155,11 +155,26 @@ public:
*/
bool isBypassed() const { return bypass_; }
+ /**
+ * @brief Clears all passes
+ */
+ void clearPasses();
+
+ /**
+ * @brief Sets the output target FBO for the final blit (0 = default framebuffer / screen)
+ */
+ void setOutputTarget(u32 fboId);
+
+ /**
+ * @brief Sets the output viewport for the final blit
+ */
+ void setOutputViewport(u32 x, u32 y, u32 w, u32 h);
+
private:
PostProcessPass* findPass(const std::string& name);
void ensureFBOs();
void renderPass(const PostProcessPass& pass, u32 inputTexture);
- void blitToScreen(u32 texture);
+ void blitToOutput(u32 texture);
RenderContext& context_;
resource::ResourceManager& resourceManager_;
@@ -177,6 +192,12 @@ private:
bool inFrame_ = false;
bool bypass_ = false;
u32 currentFBO_ = 0;
+
+ u32 output_target_fbo_ = 0;
+ u32 output_vp_x_ = 0;
+ u32 output_vp_y_ = 0;
+ u32 output_vp_w_ = 0;
+ u32 output_vp_h_ = 0;
};
} // namespace esengine
diff --git a/src/esengine/renderer/RenderFrame.cpp b/src/esengine/renderer/RenderFrame.cpp
index 3c0524934..576593733 100644
--- a/src/esengine/renderer/RenderFrame.cpp
+++ b/src/esengine/renderer/RenderFrame.cpp
@@ -390,6 +390,12 @@ void RenderFrame::begin(const glm::mat4& view_projection, RenderTargetManager::H
!post_process_->isBypassed() && post_process_->getPassCount() > 0;
if (usePostProcess) {
+ if (target != RenderTargetManager::INVALID_HANDLE) {
+ auto* rt = target_manager_.get(target);
+ if (rt) {
+ post_process_->setOutputTarget(rt->getFramebufferId());
+ }
+ }
post_process_->begin();
} else if (target != RenderTargetManager::INVALID_HANDLE) {
auto* rt = target_manager_.get(target);
diff --git a/src/esengine/renderer/RenderTarget.cpp b/src/esengine/renderer/RenderTarget.cpp
index 809867c08..c258b4582 100644
--- a/src/esengine/renderer/RenderTarget.cpp
+++ b/src/esengine/renderer/RenderTarget.cpp
@@ -54,6 +54,10 @@ u32 RenderTarget::getDepthTexture() const {
return framebuffer_ ? framebuffer_->getDepthAttachment() : 0;
}
+u32 RenderTarget::getFramebufferId() const {
+ return framebuffer_ ? framebuffer_->getFramebufferId() : 0;
+}
+
RenderTargetManager::Handle RenderTargetManager::create(u32 width, u32 height, bool depth, bool linearFilter) {
Handle handle;
diff --git a/src/esengine/renderer/RenderTarget.hpp b/src/esengine/renderer/RenderTarget.hpp
index a88dd0eba..df0febfba 100644
--- a/src/esengine/renderer/RenderTarget.hpp
+++ b/src/esengine/renderer/RenderTarget.hpp
@@ -32,6 +32,7 @@ public:
u32 getHeight() const { return height_; }
bool isValid() const { return framebuffer_ != nullptr; }
+ u32 getFramebufferId() const;
private:
Unique<Framebuffer> framebuffer_;