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(render): a quality level can smooth edges temporally, and the temporal pass keeps more detail

yhh06ceafe3d9f7
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 840a24f15..a438362a5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,7 @@ published separately; it ships inside the editor.
### Added
+- **A quality level can smooth edges temporally.** `QualityProfile.antialiasing` is `'msaa'` (what every level does today) or `'temporal'`: that level draws at one sample, adds the `taa` pass to the camera's post-process volume whether or not the scene lists it, leaves `fxaa` out, and runs `taa` even where the level skips it. On the terrain-water example at 1080p it is 12.9 ms against 15.4 ms for 4 samples and FXAA, and 12.6 ms against 13.5 ms for the medium level's 2 samples; the pass itself is 0.18 ms. The picture is softer, a cut-out leaf has no coverage dither, and water, which has no motion vector, smears a little when the camera moves fast, so no level uses it by default.
- **An Offset side the layout drops is dimmed, with the reason in its tooltip.** In the inspector, a UI node whose Offset has both a start side and a size set already has this axis fixed, so the far side does nothing; that field is dimmed, and its tooltip says which two settings decide the axis and that setting one of them to auto brings the side back.
- **Every render-graph pass has its own GPU time in the profiler, and the scene pass can be split by shader.** The profiler reads a GPU time for each pass of the frame on WebGL2 and WebGPU, not one number for the frame. With the profiler on and `module.esGpuDetail` set, each run of draws that use one shader is its own timed segment of the scene pass (WebGL2). `docs/TERRAIN_WATER_GPU_COST.md` says what each part of the Terrain & Water example costs and why.
- **Optional tools a project switches on, fetched and checked by the engine.** A project names a tool in `project.esproject` (`tools.luban.enabled`); until it does, the engine does not look for it, mention it or download it. Luban, the industry's configuration tool, turns the Excel tables a game's designers keep into JSON and the TypeScript that reads it, with references between tables checked (a site that produces an item that does not exist fails with the table, the record and the field). It is a .NET program, so the engine also fetches the .NET runtime it runs on. When either is missing, `estella tools install luban` shows exactly what it would download (name, version, licence, size, and where from) and asks before it does; `--yes` agrees in advance for CI. Each tool is pinned in `external-tools.manifest.json` to one vendor file, and a release publishes those files, repackaged as `.zip`, beside an index naming each one's size and SHA-256 and the vendor file it was made from: the engine takes them from the release mirror first and the release itself second, refuses a file that does not match, and refuses an index built from a different vendor file than it pins, so an engine version always runs the tool versions it was built against. There is no fallback to the vendor's own site. `estella luban gen` writes the tables (only the files that changed, and it removes what a deleted table used to produce), `estella luban check` fails when they are out of date, and an export of a project that has Luban on rebuilds them first. Windows, macOS (both architectures) and Linux (both architectures).
@@ -47,6 +48,7 @@ published separately; it ships inside the editor.
### Changed
+- **The temporal anti-aliasing pass samples its history with a Catmull-Rom fit instead of one bilinear fetch.** A fetch at a fractional offset blurs a little, and every frame resamples the frame before it, so the blur accumulates: the softness of the pass and the smear of a moving camera. The detail the pass keeps in water goes from 44% to 64% of what 4x multisampling gives, and leaves stop being softer than it. Five taps, 0.18 ms of a 1080p frame.
- **A draw that changes buffer no longer re-points its vertex attributes.** The WebGL2 device kept one vertex array object per vertex layout, so every draw from a different buffer (each strip of a tilemap, each mesh sharing a layout) rebound the buffer and set its five attributes again: 15 GL calls a draw that a vertex array object exists to save. It now keeps one per layout and the buffers it reads, and deletes them with the buffer. The 47,000-tile view goes from 651 GL calls a frame to 190 and the 3,300-tile view from 188 to 73, with the same picture; the 3D example is unchanged (about 2,000 calls, a few more vertex array switches).
- **A tilemap that has not changed uploads nothing and copies no vertex.** Every frame the layer copied the vertices of each visible chunk into a list, placed them, copied them again into the frame's buffer and uploaded all of it: 47,000 visible tiles were 6 MB a frame and 5.8 ms of CPU. The layer now keeps its geometry on the GPU in strips (a row of up to 32 chunks, in world space) and a frame in which no chunk changed submits them as they are. 47,000 tiles go from 5.8 ms to 0.5 ms; a 3,300-tile view from 0.59 ms to 0.40 ms. The picture is the same: the strips are submitted slot by slot and row by row, the order the merged draw laid tiles out in, which matters where tiles overlap, and the near and far views are pixel-identical to before (the far one within the run-to-run noise of its animated tiles). A strip is made again only when a chunk in it changes, the layer is placed somewhere else, or the device was lost; a layer faded, tinted or carried along is placed anew every frame, and a strip is every chunk of a row, so such a layer (and one with parallax) keeps the old per-frame path until it has stood still for thirty frames. What the strips hold is bounded (96 MB, the ones not drawn lately go first). The cost is more, smaller draws: 8 for the near view and 32 for the far one, and about four times the triangles in the near view, which the GPU clips.
- **A label's glyph pipeline no longer costs a transform read per label per frame.** An automatic label draws with hinted bitmaps near 1:1 and with SDF past 2% of it, so script read every label's world scale every frame to see whether the choice had changed, a `Transform` converted through embind each time: about two thirds of what the script still spent on 600 static labels. The engine now holds the choice it was laid out with and watches the scale itself in `renderer_retainedTextStale`, by the same rule (pinned by one table on each side). 600 static labels go from 1.6 ms to 1.1 ms of CPU a frame, and the script's own per-frame loop to about 0.05 ms. Evaluated and not taken: driving the check from the change tracker (a script component written in place through `world.get` is not reported, and that is documented and tested behaviour), and making `Text` an engine component (an in-place write to one is dropped, which would end that behaviour for user code).
diff --git a/docs/GPU_PERFORMANCE_OPTIONS.md b/docs/GPU_PERFORMANCE_OPTIONS.md
index ef55ff67f..5256f3188 100644
--- a/docs/GPU_PERFORMANCE_OPTIONS.md
+++ b/docs/GPU_PERFORMANCE_OPTIONS.md
@@ -36,6 +36,12 @@
**估计:**5 到 8 ms(MSAA)加上动态分辨率的余量。**风险:**画面特性变了(时间稳定性换空间锐度),镂空叶片和细线容易鬼影;**用户已经决定 high 档的 4× MSAA 不动**,所以这一项只能作为新的档位或选项。
+**2026-10-27 的实测与落地(1080p,这个示例):**
+- **成本:**1× 加时域 AA 比 4× MSAA 加 FXAA 快约 2.5 ms(15.4 到 12.9 ms),`taa` 这一趟本身 0.18 ms;中档现在用 2× MSAA,换成时域 AA 省约 0.9 ms。
+- **画质(静止和相机平移,看放大对比图和拉普拉斯细节能量):**历史帧原来按双线性重采样,每帧小数偏移都糊一点,累积起来水面的细节只剩 MSAA 的 44%。改成 Catmull-Rom 双三次(5 次采样)后,水面回到 64%,树叶不低于 MSAA,天空 63%。再加锐化效果会把噪点一起放大(0.35 的强度让树叶细节变成 MSAA 的 5 倍),没有采用。
+- **落地:**`QualityProfile.antialiasing`(`'msaa'` 默认,`'temporal'` 可选)。选了 `temporal`,这一档用 1 个采样、给后处理体积加上 `taa` 通道(体积没列也加)、不跑 `fxaa`,并且低档也会跑 `taa`。**没有改任何档位的默认值**,所以现有项目的画面不变;要不要把中档默认改成它,是画面取舍,需要拍板。
+- **仍缺:**水面和云没有运动向量,镜头快速移动时仍比 MSAA 软;镂空叶片关掉 MSAA 后没有覆盖抖动,树冠观感偏亮;还没做时间上采样(低分辨率渲染加时域重建),那才是比换掉 MSAA 更大的杠杆。
+
### 3. 阴影:缓存与更新率,而不是更便宜的查找
**证据:**阴影整个是 3.6 ms(默认)到 9.8 ms(沿河)。接收端只有 3 到 4 ms,而且试过的减采样、背面跳过、硬边都没有收益;**投射**才是随场景变的那一块。级联模式下投射体的绘制数是一张图的 2 到 4 倍(因为默认范围太大,不是剔除缺失)。
diff --git a/sdk/src/postprocess/PostProcessAPI.ts b/sdk/src/postprocess/PostProcessAPI.ts
index 6489de174..5f8e0b676 100644
--- a/sdk/src/postprocess/PostProcessAPI.ts
+++ b/sdk/src/postprocess/PostProcessAPI.ts
@@ -245,6 +245,11 @@ export class PostProcessAPI {
this.engineStack_ = null;
}
+ /** How the quality level in force smooths edges: the volume system adds the temporal pass where it says `temporal`. */
+ get antialiasing(): 'msaa' | 'temporal' {
+ return this.qualityFilter_?.antialiasing ?? 'msaa';
+ }
+
private allowQualityPass_ = (name: string): boolean => {
return qualityPassAllowed(this.qualityFilter_, name);
};
diff --git a/sdk/src/postprocess/qualityFilter.ts b/sdk/src/postprocess/qualityFilter.ts
index 819ed7825..cee969f76 100644
--- a/sdk/src/postprocess/qualityFilter.ts
+++ b/sdk/src/postprocess/qualityFilter.ts
@@ -16,6 +16,11 @@ export function qualityPassAllowed(profile: Readonly<QualityProfile> | null, pas
if (profile === null) return true;
if (!profile.postProcess) return false;
const name = passName.toLowerCase();
+ // Temporal anti-aliasing is the level's smoothing: its pass runs whatever the level skips, and FXAA, which would soften what it has settled, does not.
+ if (profile.antialiasing === 'temporal') {
+ if (effectPassNames('taa').some((pass) => pass.toLowerCase() === name)) return true;
+ if (effectPassNames('fxaa').some((pass) => pass.toLowerCase() === name)) return false;
+ }
// The profile's own switch for ambient occlusion governs both estimators: it was written for the one and means the other.
if (!profile.ssao && ['ssao', 'gtao'].some((type) => effectPassNames(type).some((pass) => pass.toLowerCase() === name))) return false;
for (const skipped of profile.skipEffects) {
diff --git a/sdk/src/postprocess/sources/lighting.ts b/sdk/src/postprocess/sources/lighting.ts
index 980151965..294e08c70 100644
--- a/sdk/src/postprocess/sources/lighting.ts
+++ b/sdk/src/postprocess/sources/lighting.ts
@@ -61,6 +61,31 @@ out vec4 fragColor;
${SSAO_GLSL}
${GLSL}
+/// The history at a uv, by a Catmull-Rom fit in five taps. A bilinear fetch at a fractional offset blurs the picture a little, and every frame
+/// resamples the frame before it, so the blur accumulates: the softness of a temporal pass and the smear of a moving one.
+vec3 historyBicubic(vec2 uv) {
+ vec2 texSize = vec2(textureSize(u_history, 0));
+ vec2 samplePos = uv * texSize;
+ vec2 tc1 = floor(samplePos - 0.5) + 0.5;
+ vec2 f = samplePos - tc1;
+ vec2 w0 = f * (-0.5 + f * (1.0 - 0.5 * f));
+ vec2 w1 = 1.0 + f * f * (-2.5 + 1.5 * f);
+ vec2 w2 = f * (0.5 + f * (2.0 - 1.5 * f));
+ vec2 w3 = f * f * (-0.5 + 0.5 * f);
+ vec2 w12 = w1 + w2;
+ vec2 tc0 = (tc1 - 1.0) / texSize;
+ vec2 tc3 = (tc1 + 2.0) / texSize;
+ vec2 tc12 = (tc1 + w2 / w12) / texSize;
+ vec3 sum = texture(u_history, vec2(tc12.x, tc0.y)).rgb * (w12.x * w0.y)
+ + texture(u_history, vec2(tc0.x, tc12.y)).rgb * (w0.x * w12.y)
+ + texture(u_history, vec2(tc12.x, tc12.y)).rgb * (w12.x * w12.y)
+ + texture(u_history, vec2(tc3.x, tc12.y)).rgb * (w3.x * w12.y)
+ + texture(u_history, vec2(tc12.x, tc3.y)).rgb * (w12.x * w3.y);
+ float weight = w12.x * w0.y + w0.x * w12.y + w12.x * w12.y + w3.x * w12.y + w12.x * w3.y;
+ // The lobes on either side of the fit are negative, so a bright texel beside a dark one overshoots: no light below black.
+ return max(sum / weight, vec3(0.0));
+}
+
void main() {
ivec2 size = textureSize(u_texture, 0);
vec2 texel = 1.0 / vec2(size);
@@ -101,7 +126,7 @@ void main() {
&& puv.x >= 0.0 && puv.x <= 1.0 && puv.y >= 0.0 && puv.y <= 1.0;
if (!seen) { fragColor = cur; return; }
- vec3 hist = toYCoCg(compress(texture(u_history, puv).rgb));
+ vec3 hist = toYCoCg(compress(historyBicubic(puv)));
// Pulled toward the neighbourhood's mean until it sits inside the box the
// current frame spans: what it clips is what no longer matches.
vec3 lo = mean - sigma * 1.25;
@@ -122,6 +147,29 @@ void main() {
${SSAO_WGSL}
${WGSL}
+// See the GLSL twin: the history by a Catmull-Rom fit in five taps, not one bilinear fetch.
+fn historyBicubic(uv : vec2f) -> vec3f {
+ let texSize = vec2f(textureDimensions(u_history, 0));
+ let samplePos = uv * texSize;
+ let tc1 = floor(samplePos - 0.5) + 0.5;
+ let f = samplePos - tc1;
+ let w0 = f * (-0.5 + f * (1.0 - 0.5 * f));
+ let w1 = 1.0 + f * f * (-2.5 + 1.5 * f);
+ let w2 = f * (0.5 + f * (2.0 - 1.5 * f));
+ let w3 = f * f * (-0.5 + 0.5 * f);
+ let w12 = w1 + w2;
+ let tc0 = (tc1 - 1.0) / texSize;
+ let tc3 = (tc1 + 2.0) / texSize;
+ let tc12 = (tc1 + w2 / w12) / texSize;
+ let sum = textureSampleLevel(u_history, u_history_s, vec2f(tc12.x, tc0.y), 0.0).rgb * (w12.x * w0.y)
+ + textureSampleLevel(u_history, u_history_s, vec2f(tc0.x, tc12.y), 0.0).rgb * (w0.x * w12.y)
+ + textureSampleLevel(u_history, u_history_s, vec2f(tc12.x, tc12.y), 0.0).rgb * (w12.x * w12.y)
+ + textureSampleLevel(u_history, u_history_s, vec2f(tc3.x, tc12.y), 0.0).rgb * (w3.x * w12.y)
+ + textureSampleLevel(u_history, u_history_s, vec2f(tc12.x, tc3.y), 0.0).rgb * (w12.x * w3.y);
+ let weight = w12.x * w0.y + w0.x * w12.y + w12.x * w12.y + w3.x * w12.y + w12.x * w3.y;
+ return max(sum / weight, vec3f(0.0));
+}
+
@fragment fn fs_main(v : VSOut) -> @location(0) vec4f {
let size = vec2i(textureDimensions(t0, 0));
let texel = 1.0 / vec2f(size);
@@ -162,7 +210,7 @@ ${WGSL}
&& puv.x >= 0.0 && puv.x <= 1.0 && puv.y >= 0.0 && puv.y <= 1.0;
if (!seen) { return cur; }
- var hist = toYCoCg(compress(textureSampleLevel(u_history, u_history_s, puv, 0.0).rgb));
+ var hist = toYCoCg(compress(historyBicubic(puv)));
let lo = mean - sigma * 1.25;
let hi = mean + sigma * 1.25;
let dir = hist - mean;
diff --git a/sdk/src/postprocess/volumeSystem.ts b/sdk/src/postprocess/volumeSystem.ts
index 1e22b2208..086a79b60 100644
--- a/sdk/src/postprocess/volumeSystem.ts
+++ b/sdk/src/postprocess/volumeSystem.ts
@@ -169,11 +169,33 @@ function effectsSignature(effects: ResolvedEffects): string {
return sig;
}
+/**
+ * The effects with the temporal anti-aliasing pass in them, where the quality level asks for it and the scene has not listed it: before the exposure
+ * and the grading, after the lighting and the fog, which is where the harness measured it and where an author puts it. A level that does not ask
+ * leaves the effects as they are.
+ */
+function withTemporalAntialiasing(api: PostProcessAPI, effects: ResolvedEffects): ResolvedEffects {
+ if (api.antialiasing !== 'temporal' || effects.has('taa')) return effects;
+ const taa: BlendedEffect = { enabled: true, uniforms: new Map([['u_blend', 0.1], ['u_objectMotion', 1]]), textures: new Map(), colors: new Map() };
+ const out: ResolvedEffects = new Map();
+ let placed = false;
+ for (const [type, data] of effects) {
+ if (!placed && type === 'autoExposure') {
+ out.set('taa', taa);
+ placed = true;
+ }
+ out.set(type, data);
+ }
+ if (!placed) out.set('taa', taa);
+ return out;
+}
+
function applyBlendedEffects(
api: PostProcessAPI,
camera: Entity,
- effects: ResolvedEffects,
+ blended: ResolvedEffects,
): void {
+ const effects = withTemporalAntialiasing(api, blended);
if (effects.size === 0) {
const existing = api.volumeStacks.get(camera);
if (existing) {
diff --git a/sdk/src/render/quality.ts b/sdk/src/render/quality.ts
index dc21fd93a..95ec0a1b1 100644
--- a/sdk/src/render/quality.ts
+++ b/sdk/src/render/quality.ts
@@ -15,6 +15,14 @@ export interface QualityProfile {
renderScale: number;
minRenderScale: number;
msaaSamples: 1 | 2 | 4 | 8;
+ /**
+ * How the edges of the picture are smoothed. `msaa` is the multisampling above (plus an FXAA pass where the scene has one). `temporal` draws
+ * at one sample and lets the `taa` pass do it from the frames before: it costs a tenth of a millisecond at 1080p where four samples cost three
+ * and two cost over one, and in return the picture is somewhat softer, a cut-out leaf has no coverage dither and a surface that moves by itself
+ * without a motion vector (water) smears a little while the camera moves. The level takes the `taa` pass whether or not the scene's volume
+ * lists it, and leaves `fxaa` out; it needs a post-process volume on the camera.
+ */
+ antialiasing: 'msaa' | 'temporal';
shadowAtlasSize: number;
shadowCellSize: number;
/**
@@ -101,7 +109,7 @@ export interface QualityConfig {
const LEVELS: readonly QualityLevel[] = ['low', 'medium', 'high'];
const PROFILES: Record<QualityLevel, QualityProfile> = {
low: {
- renderScale: 0.75, minRenderScale: 0.5, msaaSamples: 1,
+ renderScale: 0.75, minRenderScale: 0.5, msaaSamples: 1, antialiasing: 'msaa',
shadowAtlasSize: 1024, shadowCellSize: 256, shadowCascades: 2,
planarReflectionScale: 0.25, planarReflectionMaxSize: 512, planarReflectionUpdatesPerSecond: 0, depthPrepass: false,
shadowDistance: 0, detailScale: 0.5, particleLimit: 1000, postProcess: true, ssao: false,
@@ -109,7 +117,7 @@ const PROFILES: Record<QualityLevel, QualityProfile> = {
skipEffects: ['ssr', 'taa', 'depthOfField', 'lightShafts', 'motionBlur', 'lensFlare', 'gtao', 'subsurface', 'voxelGI'],
},
medium: {
- renderScale: 1, minRenderScale: 0.65, msaaSamples: 2,
+ renderScale: 1, minRenderScale: 0.65, msaaSamples: 2, antialiasing: 'msaa',
shadowAtlasSize: 2048, shadowCellSize: 512, shadowCascades: 3,
planarReflectionScale: 0.5, planarReflectionMaxSize: 1024, planarReflectionUpdatesPerSecond: 0, depthPrepass: true,
shadowDistance: 0, detailScale: 0.8, particleLimit: 5000, postProcess: true, ssao: true,
@@ -117,7 +125,7 @@ const PROFILES: Record<QualityLevel, QualityProfile> = {
skipEffects: ['ssr', 'depthOfField'],
},
high: {
- renderScale: 1, minRenderScale: 0.75, msaaSamples: 4,
+ renderScale: 1, minRenderScale: 0.75, msaaSamples: 4, antialiasing: 'msaa',
// A face is millimetres of relief: at 512 texels a cascade, a skin-hugging card (a brow, a hairline) falls inside one texel of the skin and the
// shadow speckles it with dirt. 1024 is the cell that clears it for a character at arm's length.
shadowAtlasSize: 4096, shadowCellSize: 1024, shadowCascades: 4,
@@ -192,6 +200,7 @@ function resolveProfile(level: QualityLevel, value: unknown): QualityProfile {
0.25, renderScale),
msaaSamples: [1, 2, 4, 8].includes(r.msaaSamples as number)
? r.msaaSamples as QualityProfile['msaaSamples'] : base.msaaSamples,
+ antialiasing: r.antialiasing === 'msaa' || r.antialiasing === 'temporal' ? r.antialiasing : base.antialiasing,
shadowAtlasSize: atlas,
shadowCellSize: Math.min(cell, atlas / 2),
shadowCascades: Math.round(finite(r.shadowCascades, base.shadowCascades, 1, 4)),
diff --git a/sdk/src/render/qualityRuntime.ts b/sdk/src/render/qualityRuntime.ts
index b7a851bf4..ae5d3f8bb 100644
--- a/sdk/src/render/qualityRuntime.ts
+++ b/sdk/src/render/qualityRuntime.ts
@@ -32,7 +32,8 @@ export function installQuality(app: App, config: QualityConfig, authoredMsaa: nu
applied = quality.profile;
enabled = quality.enabled;
const api = engineApi(app);
- api?.postprocess_setMsaaSamples?.(enabled ? applied.msaaSamples : authoredMsaa);
+ // Temporal anti-aliasing is the one smoothing there is: a multisampled target under it would be paid for and resolved for nothing.
+ api?.postprocess_setMsaaSamples?.(enabled ? (applied.antialiasing === 'temporal' ? 1 : applied.msaaSamples) : authoredMsaa);
const budgets = api?.renderer_setQualityBudgets;
quality.setLimitation('quality-budgets-unavailable', enabled && !budgets);
budgets?.(enabled ? applied.shadowAtlasSize : 2048,
diff --git a/sdk/tests/quality.test.ts b/sdk/tests/quality.test.ts
index 3aefa087d..2a58e741b 100644
--- a/sdk/tests/quality.test.ts
+++ b/sdk/tests/quality.test.ts
@@ -147,6 +147,32 @@ describe('what a quality level lets the chain run', () => {
});
});
+describe('temporal anti-aliasing as the smoothing of a level', () => {
+ const temporal = (level: 'low' | 'medium' | 'high') => new QualityController({
+ mode: level, profiles: { [level]: { antialiasing: 'temporal' } },
+ }).profile;
+
+ it('is off in every level until a project asks, and parses only the two names', () => {
+ for (const level of ['low', 'medium', 'high'] as const) {
+ expect(new QualityController({ mode: level }).profile.antialiasing, level).toBe('msaa');
+ }
+ const odd = new QualityController({ mode: 'high', profiles: { high: { antialiasing: 'fxaa' as never } } }).profile;
+ expect(odd.antialiasing).toBe('msaa');
+ expect(temporal('medium').antialiasing).toBe('temporal');
+ });
+
+ it('runs the taa pass even where the level skips it, and leaves fxaa out', async () => {
+ const { qualityPassAllowed } = await import('../src/postprocess/qualityFilter');
+ // Low skips `taa` for the cost of everything that needs it: a project that asks for temporal smoothing there has said it wants it.
+ expect(qualityPassAllowed(new QualityController({ mode: 'low' }).profile, 'taa')).toBe(false);
+ expect(qualityPassAllowed(temporal('low'), 'taa')).toBe(true);
+ expect(qualityPassAllowed(temporal('medium'), 'fxaa')).toBe(false);
+ expect(qualityPassAllowed(new QualityController({ mode: 'medium' }).profile, 'fxaa')).toBe(true);
+ // Nothing else changes.
+ expect(qualityPassAllowed(temporal('medium'), 'bloom_extract')).toBe(true);
+ });
+});
+
describe('how far plants keep their detail', () => {
it('is a share of a plant\'s distances that falls with the level, and a project may set it', () => {
const share = (mode: 'low' | 'medium' | 'high', detailScale?: unknown) =>
diff --git a/tools/releaseNotes.mjs b/tools/releaseNotes.mjs
index 4b0f1078e..53d487b44 100644
--- a/tools/releaseNotes.mjs
+++ b/tools/releaseNotes.mjs
@@ -3090,4 +3090,8 @@ export const NOTED = {
{"note":"Fewer GL calls when a draw changes buffer"},
"fix(render): the sky's clouds are worked out at half size again":
{"internal":"Undoes the quarter-size clouds, which showed a coarse checkerboard in the cloud and streaks near the horizon."},
+ "feat(render): a quality level can smooth edges temporally":
+ {"note":"A quality level can smooth edges temporally."},
+ "perf(render): the temporal anti-aliasing pass samples its history with a Catmull-Rom fit":
+ {"note":"Temporal anti-aliasing keeps more detail"},
};
diff --git a/tools/terrain-water-cost.mjs b/tools/terrain-water-cost.mjs
index 8b8ba0808..45dbc4a5c 100644
--- a/tools/terrain-water-cost.mjs
+++ b/tools/terrain-water-cost.mjs
@@ -157,6 +157,9 @@ const VARIANTS = [
{ id: 'detail-50', label: 'plant detail scale 0.5', config: quality('high', { detailScale: 0.5 }) },
// Levels as a project would ship them
{ id: 'medium', label: 'quality medium', config: quality('medium') },
+ // The level smooths edges by itself: one sample, and the volume gets its temporal pass (and loses fxaa) without the scene listing it.
+ { id: 'temporal-medium', label: 'quality medium with temporal anti-aliasing', config: quality('medium', { antialiasing: 'temporal' }) },
+ { id: 'temporal-high', label: 'quality high with temporal anti-aliasing', config: quality('high', { antialiasing: 'temporal' }) },
{ id: 'low', label: 'quality low', config: quality('low') },
{ id: 'base-again', label: 'the scene again, to see the machine drift' },
];