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: improve post-process with Kawase bloom, multi-pass effects, and camera-based volumes

esengine45a9f6563165
diff --git a/sdk/src/core.ts b/sdk/src/core.ts
index 3ad3245f5..9c3e31151 100644
--- a/sdk/src/core.ts
+++ b/sdk/src/core.ts
@@ -21,7 +21,6 @@ export {
DEFAULT_GRAVITY,
DEFAULT_FIXED_TIMESTEP,
DEFAULT_SPINE_SKIN,
- RuntimeConfig,
applyRuntimeConfig,
} from './defaults';
@@ -780,6 +779,7 @@ export {
} from './playableRuntime';
export {
+ RuntimeConfig,
applyBuildRuntimeConfig,
type RuntimeBuildConfig,
} from './defaults';
diff --git a/sdk/src/postprocess/PostProcessAPI.ts b/sdk/src/postprocess/PostProcessAPI.ts
index f6a1a62f1..22e5a0d54 100644
--- a/sdk/src/postprocess/PostProcessAPI.ts
+++ b/sdk/src/postprocess/PostProcessAPI.ts
@@ -131,6 +131,22 @@ export const PostProcess = {
}
},
+ begin(): void {
+ try {
+ getModule().postprocess_begin();
+ } catch (e) {
+ handleWasmError(e, 'PostProcess.begin');
+ }
+ },
+
+ end(): void {
+ try {
+ getModule().postprocess_end();
+ } catch (e) {
+ handleWasmError(e, 'PostProcess.end');
+ }
+ },
+
setOutputViewport(x: number, y: number, w: number, h: number): void {
try {
getModule().postprocess_setOutputViewport(x, y, w, h);
@@ -285,8 +301,8 @@ void main() {
vec4 color = texture(u_texture, v_texCoord);
vec2 uv = v_texCoord * 2.0 - 1.0;
float dist = length(uv);
- float vignette = smoothstep(u_intensity, u_intensity - u_softness, dist);
- fragColor = vec4(color.rgb * vignette, color.a);
+ float vig = 1.0 - smoothstep(1.0 - u_softness, 1.0, dist);
+ fragColor = vec4(color.rgb * mix(1.0, vig, u_intensity), color.a);
}
`;
return Material.createShader(POSTPROCESS_VERTEX, fragmentSrc);
@@ -310,37 +326,68 @@ void main() {
return Material.createShader(POSTPROCESS_VERTEX, fragmentSrc);
},
- createBloom(): ShaderHandle {
+ createBloomExtract(): 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;
+ float brightness = dot(color.rgb, vec3(0.2126, 0.7152, 0.0722));
+ float knee = u_threshold * 0.5;
+ float soft = brightness - u_threshold + knee;
+ soft = clamp(soft, 0.0, 2.0 * knee);
+ soft = soft * soft / (4.0 * knee + 0.00001);
+ float contrib = max(soft, brightness - u_threshold);
+ contrib /= max(brightness, 0.00001);
+ fragColor = vec4(color.rgb * contrib, 1.0);
+}
+`;
+ return Material.createShader(POSTPROCESS_VERTEX, fragmentSrc);
+ },
- 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;
+ createBloomKawase(iteration: number): ShaderHandle {
+ const fragmentSrc = `#version 300 es
+precision highp float;
- fragColor = vec4(color.rgb + bloom * u_intensity, color.a);
+in vec2 v_texCoord;
+uniform sampler2D u_texture;
+uniform vec2 u_resolution;
+uniform float u_radius;
+out vec4 fragColor;
+
+void main() {
+ float d = (${iteration.toFixed(1)} + 0.5) * max(u_radius, 0.5);
+ vec2 ts = 1.0 / u_resolution;
+ fragColor = (
+ texture(u_texture, v_texCoord + vec2(-d, -d) * ts) +
+ texture(u_texture, v_texCoord + vec2( d, -d) * ts) +
+ texture(u_texture, v_texCoord + vec2(-d, d) * ts) +
+ texture(u_texture, v_texCoord + vec2( d, d) * ts)
+ ) * 0.25;
+}
+`;
+ return Material.createShader(POSTPROCESS_VERTEX, fragmentSrc);
+ },
+
+ createBloomComposite(): ShaderHandle {
+ const fragmentSrc = `#version 300 es
+precision highp float;
+
+in vec2 v_texCoord;
+uniform sampler2D u_texture;
+uniform sampler2D u_sceneTexture;
+uniform float u_intensity;
+out vec4 fragColor;
+
+void main() {
+ vec4 blur = texture(u_texture, v_texCoord);
+ vec4 scene = texture(u_sceneTexture, v_texCoord);
+ fragColor = vec4(scene.rgb + blur.rgb * u_intensity, scene.a);
}
`;
return Material.createShader(POSTPROCESS_VERTEX, fragmentSrc);
diff --git a/sdk/src/postprocess/PostProcessStack.ts b/sdk/src/postprocess/PostProcessStack.ts
index e20e86c90..56d53fef6 100644
--- a/sdk/src/postprocess/PostProcessStack.ts
+++ b/sdk/src/postprocess/PostProcessStack.ts
@@ -55,6 +55,11 @@ export class PostProcessStack {
return this;
}
+ clearPasses(): this {
+ this.passes_.length = 0;
+ return this;
+ }
+
setEnabled(name: string, enabled: boolean): this {
const pass = this.passes_.find(p => p.name === name);
if (pass) {
diff --git a/sdk/src/postprocess/effects.ts b/sdk/src/postprocess/effects.ts
index 83a7ed64c..8a41c3a9b 100644
--- a/sdk/src/postprocess/effects.ts
+++ b/sdk/src/postprocess/effects.ts
@@ -10,11 +10,17 @@ export interface EffectUniformDef {
defaultValue: number;
}
+export interface EffectSubPass {
+ name: string;
+ factory: () => ShaderHandle;
+}
+
export interface EffectDef {
type: string;
label: string;
factory: () => ShaderHandle;
uniforms: EffectUniformDef[];
+ multiPass?: EffectSubPass[];
}
const effectRegistry = new Map<string, EffectDef>();
@@ -47,11 +53,20 @@ registerEffect({
registerEffect({
type: 'bloom',
label: 'Bloom',
- factory: () => PostProcess.createBloom(),
+ factory: () => PostProcess.createBloomExtract(),
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 },
+ { name: 'u_threshold', label: 'Threshold', min: 0, max: 1, step: 0.01, defaultValue: 0.4 },
+ { name: 'u_intensity', label: 'Intensity', min: 0, max: 5, step: 0.1, defaultValue: 1.5 },
+ { name: 'u_radius', label: 'Radius', min: 0.5, max: 5, step: 0.1, defaultValue: 1 },
+ ],
+ multiPass: [
+ { name: 'bloom_extract', factory: () => PostProcess.createBloomExtract() },
+ { name: 'bloom_kawase_0', factory: () => PostProcess.createBloomKawase(0) },
+ { name: 'bloom_kawase_1', factory: () => PostProcess.createBloomKawase(1) },
+ { name: 'bloom_kawase_2', factory: () => PostProcess.createBloomKawase(2) },
+ { name: 'bloom_kawase_3', factory: () => PostProcess.createBloomKawase(3) },
+ { name: 'bloom_kawase_4', factory: () => PostProcess.createBloomKawase(4) },
+ { name: 'bloom_composite', factory: () => PostProcess.createBloomComposite() },
],
});
@@ -60,8 +75,8 @@ registerEffect({
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 },
+ { name: 'u_intensity', label: 'Intensity', min: 0, max: 1, step: 0.01, defaultValue: 0.6 },
+ { name: 'u_softness', label: 'Softness', min: 0, max: 1, step: 0.01, defaultValue: 0.5 },
],
});
diff --git a/sdk/src/postprocess/volumeSystem.ts b/sdk/src/postprocess/volumeSystem.ts
index 1c6d3776d..9803a09ba 100644
--- a/sdk/src/postprocess/volumeSystem.ts
+++ b/sdk/src/postprocess/volumeSystem.ts
@@ -2,11 +2,11 @@ import { defineSystem } from '../system';
import { defineResource } from '../resource';
import { Query } from '../query';
import type { Entity } from '../types';
-import { PostProcessVolume, Transform, type PostProcessVolumeData, type TransformData } from '../component';
+import { PostProcessVolume, Transform, Camera, type PostProcessVolumeData, type TransformData, type CameraData } from '../component';
import { PostProcess } from './PostProcessAPI';
import { PostProcessStack } from './PostProcessStack';
import { getEffectDef } from './effects';
-import { computeVolumeFactor, blendVolumeEffects, type ActiveVolume } from './volumeBlending';
+import { blendVolumeEffects, type ActiveVolume } from './volumeBlending';
import type { ShaderHandle } from '../material';
import { Material } from '../material';
@@ -22,15 +22,12 @@ export const PostProcessVolumeConfigResource = defineResource<PostProcessVolumeC
const volumeStacks = new Map<Entity, PostProcessStack>();
const volumeShaders = new Map<string, ShaderHandle>();
-function getOrCreateShader(effectType: string): ShaderHandle | null {
- const existing = volumeShaders.get(effectType);
+function getOrCreateShader(key: string, factory: () => ShaderHandle): ShaderHandle {
+ const existing = volumeShaders.get(key);
if (existing !== undefined) return existing;
- const def = getEffectDef(effectType);
- if (!def) return null;
-
- const shader = def.factory();
- volumeShaders.set(effectType, shader);
+ const shader = factory();
+ volumeShaders.set(key, shader);
return shader;
}
@@ -51,21 +48,28 @@ function applyBlendedEffects(camera: Entity, effects: Map<string, { enabled: boo
volumeStacks.set(camera, stack);
}
- while (stack.passCount > 0) {
- const passes = stack.passes;
- stack.removePass(passes[passes.length - 1].name);
- }
+ stack.clearPasses();
for (const [effectType, effectData] of effects) {
if (!effectData.enabled) continue;
- const shader = getOrCreateShader(effectType);
- if (shader === null) continue;
+ const def = getEffectDef(effectType);
+ if (!def) continue;
- stack.addPass(effectType, shader);
-
- for (const [uniformName, uniformValue] of effectData.uniforms) {
- stack.setUniform(effectType, uniformName, uniformValue);
+ if (def.multiPass) {
+ for (const subPass of def.multiPass) {
+ const shader = getOrCreateShader(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);
+ stack.addPass(effectType, shader);
+ for (const [uniformName, uniformValue] of effectData.uniforms) {
+ stack.setUniform(effectType, uniformName, uniformValue);
+ }
}
}
@@ -77,26 +81,27 @@ function applyBlendedEffects(camera: Entity, effects: Map<string, { enabled: boo
}
export const postProcessVolumeSystem = defineSystem(
- [Query(PostProcessVolume, Transform)],
- (query: Iterable<[Entity, PostProcessVolumeData, TransformData]>) => {
+ [Query(PostProcessVolume, Transform), Query(Camera)],
+ (volumeQuery: Iterable<[Entity, PostProcessVolumeData, TransformData]>, cameraQuery: Iterable<[Entity, CameraData]>) => {
const volumes: { data: PostProcessVolumeData; tx: { x: number; y: number } }[] = [];
- for (const [_entity, volumeData, transform] of query) {
+ for (const [_entity, volumeData, transform] of volumeQuery) {
volumes.push({ data: volumeData, tx: { x: transform.position.x, y: transform.position.y } });
}
- if (volumes.length === 0) return;
-
const activeVolumes: ActiveVolume[] = [];
- for (const { data, tx } of volumes) {
+ for (const { data } of volumes) {
if (data.isGlobal) {
activeVolumes.push({ data, factor: 1 });
}
}
- if (activeVolumes.length > 0) {
- const blended = blendVolumeEffects(activeVolumes);
- for (const [camera] of volumeStacks) {
- applyBlendedEffects(camera, blended);
+ const blended = activeVolumes.length > 0
+ ? blendVolumeEffects(activeVolumes)
+ : new Map<string, { enabled: boolean; uniforms: Map<string, number> }>();
+
+ for (const [cameraEntity, cameraData] of cameraQuery) {
+ if (cameraData.isActive) {
+ applyBlendedEffects(cameraEntity, blended);
}
}
},
diff --git a/sdk/src/renderPipeline.ts b/sdk/src/renderPipeline.ts
index 52f93afc4..cbe77b313 100644
--- a/sdk/src/renderPipeline.ts
+++ b/sdk/src/renderPipeline.ts
@@ -129,6 +129,7 @@ export class RenderPipeline {
PostProcess._applyForCamera(cameraEntity!);
PostProcess.resize(vp.w, vp.h);
PostProcess.setOutputViewport(vp.x, vp.y, vp.w, vp.h);
+ PostProcess.begin();
}
Renderer.setViewport(vp.x, vp.y, vp.w, vp.h);
@@ -158,6 +159,7 @@ export class RenderPipeline {
Renderer.end();
if (hasPostProcess) {
+ PostProcess.end();
PostProcess._resetAfterCamera();
}
}