@driftengine/core 4.2.1 → 4.4.0

package/dist/environment/daylight.js

@@ -0,0 +1,77 @@
+/** Sort and check the keys. Throws at construction, so a bad palette never reaches a frame. */
+export function createDaylightPalette(keys) {
+    if (keys.length === 0)
+        throw new Error('a daylight palette needs at least one key');
+    const sorted = [...keys].sort((a, b) => a.at - b.at);
+    for (let i = 0; i < sorted.length; i++) {
+        const current = sorted[i];
+        if (!(current.exposure > 0)) {
+            throw new Error(`the key at ${current.at} has exposure ${current.exposure}; it must be > 0`);
+        }
+        if (i > 0 && sorted[i - 1].at === current.at) {
+            throw new Error(`a daylight palette has two keys at ${current.at}`);
+        }
+    }
+    return { keys: sorted };
+}
+export function createDaylightState() {
+    return {
+        sunColor: [0, 0, 0],
+        moonColor: [0, 0, 0],
+        skyTop: [0, 0, 0],
+        skyHorizon: [0, 0, 0],
+        skyDeep: [0, 0, 0],
+        ambient: [0, 0, 0],
+        ambientGround: [0, 0, 0],
+        fogColor: [0, 0, 0],
+        fogDensity: 0,
+        shadowStrength: 0,
+        emissiveGain: 0,
+        exposure: 1,
+    };
+}
+function blendInto(out, a, b, t) {
+    out[0] = a[0] + (b[0] - a[0]) * t;
+    out[1] = a[1] + (b[1] - a[1]) * t;
+    out[2] = a[2] + (b[2] - a[2]) * t;
+}
+/** The palette at `at`, into `out`. Past either end the nearest key holds. */
+export function resolveDaylight(at, palette, out) {
+    const keys = palette.keys;
+    let upper = 0;
+    while (upper < keys.length && keys[upper].at < at)
+        upper++;
+    const b = keys[Math.min(upper, keys.length - 1)];
+    const a = keys[Math.max(upper - 1, 0)];
+    const t = a === b ? 0 : (at - a.at) / (b.at - a.at);
+    blendInto(out.sunColor, a.sunColor, b.sunColor, t);
+    blendInto(out.moonColor, a.moonColor, b.moonColor, t);
+    blendInto(out.skyTop, a.skyTop, b.skyTop, t);
+    blendInto(out.skyHorizon, a.skyHorizon, b.skyHorizon, t);
+    blendInto(out.skyDeep, a.skyDeep, b.skyDeep, t);
+    blendInto(out.ambient, a.ambient, b.ambient, t);
+    blendInto(out.ambientGround, a.ambientGround, b.ambientGround, t);
+    blendInto(out.fogColor, a.fogColor, b.fogColor, t);
+    out.fogDensity = a.fogDensity + (b.fogDensity - a.fogDensity) * t;
+    out.shadowStrength = a.shadowStrength + (b.shadowStrength - a.shadowStrength) * t;
+    out.emissiveGain = a.emissiveGain + (b.emissiveGain - a.emissiveGain) * t;
+    out.exposure = t === 0 ? a.exposure : a.exposure * (b.exposure / a.exposure) ** t;
+    return out;
+}
+/**
+ * `current` moved toward `target` over `dtSec`, closing half the distance in stops every
+ * `halfLifeSec`.
+ *
+ * **In time, not per frame**, so a 144 Hz display adapts exactly as fast as a 60 Hz one: the
+ * remaining distance after any number of steps is `2^(−elapsed / halfLife)` of what it was, however
+ * the elapsed time was cut up. A half-life of zero is a cut to the target. Both exposures must be
+ * positive, which is what an exposure is.
+ */
+export function easeExposure(current, target, dtSec, halfLifeSec) {
+    if (halfLifeSec <= 0)
+        return target;
+    if (dtSec <= 0)
+        return current;
+    const closed = 1 - 2 ** (-dtSec / halfLifeSec);
+    return current * (target / current) ** closed;
+}

package/dist/geometry/meshConcat.d.ts

@@ -0,0 +1,9 @@
+import type { MeshData } from '../render/mesh.ts';
+/**
+ * `mesh` scaled uniformly and then moved by `x, y, z`. The same object when the fit is the
+ * identity; otherwise a copy of the positions and every other attribute shared, since a uniform
+ * scale turns no normal. Morph deltas are the caller's to scale.
+ */
+export declare function placeMesh(mesh: MeshData, x: number, y: number, z: number, scale?: number): MeshData;
+/** `meshes` as one, in order, each member's indices moved past the vertices before it. */
+export declare function concatMeshes(meshes: readonly MeshData[]): MeshData;

package/dist/geometry/meshConcat.js

@@ -0,0 +1,101 @@
+/**
+ * Meshes moved and joined as typed arrays: the loader's fast path, with no builder in between.
+ *
+ * **`MeshBuilder` is for building geometry, and a loader was using it to copy geometry.** It
+ * pushes every vertex one number at a time into growable arrays, and it carries the attributes a
+ * procedural mesh has. Streaming a bought courtyard spent seven seconds of its main thread there,
+ * copying each part twice, once to upload it and once into its merge group. Worse, the builder has
+ * no tangent channel, so every normal-mapped part lost the frame its file carried and the shader
+ * fell back to derivatives.
+ *
+ * So `placeMesh` moves a mesh by a fit, or hands it back untouched when the fit is the identity,
+ * and `concatMeshes` joins a group once, into arrays sized in advance. An attribute one member
+ * lacks is filled with the value a mesh without it draws with (`ABSENT_ATTRIBUTE`). One no member
+ * carries is left out, as absent rather than invented.
+ */
+import { ABSENT_ATTRIBUTE } from '../render/vertexDefaults.js';
+/** The optional per-vertex attributes, with how many floats a vertex each carries. */
+const OPTIONAL = [
+    ['specular', 1],
+    ['tangents', 4],
+    ['uvs', 2],
+    ['emissiveColor', 3],
+    ['roughness', 1],
+    ['grain', 1],
+    ['relief', 1],
+    ['channel', 4],
+    ['joints', 4],
+    ['weights', 4],
+];
+/**
+ * `mesh` scaled uniformly and then moved by `x, y, z`. The same object when the fit is the
+ * identity; otherwise a copy of the positions and every other attribute shared, since a uniform
+ * scale turns no normal. Morph deltas are the caller's to scale.
+ */
+export function placeMesh(mesh, x, y, z, scale = 1) {
+    if (x === 0 && y === 0 && z === 0 && scale === 1)
+        return mesh;
+    const from = mesh.positions;
+    const positions = new Float32Array(from.length);
+    for (let i = 0; i + 2 < from.length; i += 3) {
+        positions[i] = from[i] * scale + x;
+        positions[i + 1] = from[i + 1] * scale + y;
+        positions[i + 2] = from[i + 2] * scale + z;
+    }
+    return { ...mesh, positions };
+}
+/** `meshes` as one, in order, each member's indices moved past the vertices before it. */
+export function concatMeshes(meshes) {
+    const only = meshes[0];
+    if (meshes.length === 1 && only !== undefined)
+        return only;
+    let vertices = 0;
+    let indexCount = 0;
+    for (const mesh of meshes) {
+        vertices += mesh.positions.length / 3;
+        indexCount += mesh.indices.length;
+    }
+    const out = {
+        positions: new Float32Array(vertices * 3),
+        normals: new Float32Array(vertices * 3),
+        colors: new Float32Array(vertices * 3),
+        emissive: new Float32Array(vertices),
+        indices: new Uint32Array(indexCount),
+    };
+    const optional = out;
+    for (const [key, width] of OPTIONAL) {
+        if (meshes.some((mesh) => mesh[key] !== undefined)) {
+            optional[key] = new Float32Array(vertices * width);
+        }
+    }
+    let vertex = 0;
+    let index = 0;
+    for (const mesh of meshes) {
+        const count = mesh.positions.length / 3;
+        out.positions.set(mesh.positions, vertex * 3);
+        out.normals.set(mesh.normals, vertex * 3);
+        out.colors.set(mesh.colors, vertex * 3);
+        out.emissive.set(mesh.emissive, vertex);
+        for (const [key, width] of OPTIONAL) {
+            const target = optional[key];
+            if (target === undefined)
+                continue;
+            const source = mesh[key];
+            if (source !== undefined) {
+                target.set(source, vertex * width);
+                continue;
+            }
+            const fill = ABSENT_ATTRIBUTE[key] ?? [];
+            for (let v = 0; v < count; v++) {
+                for (let c = 0; c < width; c++)
+                    target[(vertex + v) * width + c] = fill[c] ?? 0;
+            }
+        }
+        const from = mesh.indices;
+        for (let i = 0; i < from.length; i++)
+            out.indices[index + i] = from[i] + vertex;
+        vertex += count;
+        index += from.length;
+    }
+    return out;
+}

package/dist/index.d.ts

@@ -28,12 +28,16 @@ export { OnceSet } from './core/onceSet.ts';
 export { MAX_TIME_CURVE_AMOUNT, curveOffsetSec, curveSpanSec, linearCurve, timeCurve, } from './core/timeCurve.ts';
 export type { TimeCurve, TimeCurveKind, TimeCurveOptions } from './core/timeCurve.ts';
 export { CinematicPlayer } from './cinematic/player.ts';
+export { createCameraPath, createCameraPathSample, sampleCameraPath, } from './cinematic/cameraPath.ts';
+export type { CameraPath, CameraPathKey, CameraPathOptions, CameraPathSample, } from './cinematic/cameraPath.ts';
 export { defineCinematic, validateCinematic } from './cinematic/script.ts';
 export type { CameraKeyframe, CinematicLine, CinematicScript, CinematicShot, } from './cinematic/script.ts';
 export { MessageQueue } from './core/messageQueue.ts';
 export type { MessageQueueOptions, QueuedMessage } from './core/messageQueue.ts';
 export { celestialStateAt, createCelestialState, moonIllumination, } from './environment/celestialClock.ts';
 export type { CelestialSite, CelestialState } from './environment/celestialClock.ts';
+export { createDaylightPalette, createDaylightState, easeExposure, resolveDaylight, } from './environment/daylight.ts';
+export type { DaylightKey, DaylightPalette, DaylightState } from './environment/daylight.ts';
 export { TAU, DEG_TO_RAD, clamp, lerp, smoothstep, damp, dampTracking, angleDelta, dampAngle, wrapAngle, lerpAngle, } from './math/scalar.ts';
 export { hslToRgb, mixColor, mixColorInto, scaleColor } from './math/color.ts';
 export type { Vec3 } from './math/color.ts';
@@ -72,7 +76,7 @@ export type { OcclusionOptions } from './render/occlusion.ts';
 export { OcclusionBuffer } from './render/occlusion.ts';
 export type { ComputeContext, ComputeDefinition, ComputeDevice, ComputeHandle, } from './render/compute.ts';
 export { createRenderer } from './render/backend/createRenderer.ts';
-export type { CreatedRenderer, CreateRendererOptions, RenderPipeline, } from './render/backend/createRenderer.ts';
+export type { CreatedRenderer, CreateRendererOptions, QualityForBackend, RenderPipeline, } from './render/backend/createRenderer.ts';
 export { GPU_DRIVEN_LISTS, GpuDrivenPass, MATERIAL_FLOATS, VERTEX_FLOATS, } from './render/backend/webgpu/gpuDrivenPass.ts';
 export type { GpuDrivenList, GpuDrivenMaterial, GpuDrivenShadowOptions, GpuDrivenView, } from './render/backend/webgpu/gpuDrivenPass.ts';
 export { atmosphereFog, createFogTarget } from './render/fog.ts';
@@ -113,6 +117,8 @@ export { GI_SOURCE_FIELD, GI_SOURCE_PROBES, GI_SOURCE_SCREEN, newIndirectResult,
 export type { GiResources, GiSource, IndirectRay, IndirectResult } from './render/gi/chain.ts';
 export { GLOBAL_FIELD_BLEND, composeGlobalField, createGlobalField, sampleGlobalField, } from './render/gi/globalField.ts';
 export type { FieldSource, GlobalField, GlobalFieldCascade, GlobalFieldInstance, } from './render/gi/globalField.ts';
+export { FIELD_FADE_SEC, LightField } from './render/driftLight/lightField.ts';
+export type { LightFieldOptions, LightFieldSource } from './render/driftLight/lightField.ts';
 export { GI_SCREEN_MARCH, SCREEN_TRACE_BIAS_M, screenRayOrigin, traceScreen, } from './render/gi/traceScreen.ts';
 export { FIELD_MARCH, coneRadiusAt, newFieldHit, traceField } from './render/gi/traceField.ts';
 export type { FieldHit, FieldMarch } from './render/gi/traceField.ts';
@@ -189,6 +195,7 @@ export type { PrefilterQuality } from './render/prefilterEnvMap.ts';
 export type { ProbeBakeOptions } from './render/reflectionProbe.ts';
 export type { DirectionalShadowDepthLayers, OutputTransform, RenderQuality, RenderQualityOptions, ShadowFilterTaps, WaterReflectionFilterTaps, } from './render/renderQuality.ts';
 export { MAX_POINT_LIGHTS, SURFACE_TEXTURE_UNIT } from './render/lightBudget.ts';
+export { MAX_CLUSTERED_LIGHTS } from './render/clusteredLights.ts';
 export { SurfaceTexture } from './render/surfaceTexture.ts';
 export type { SurfaceMaterial, SurfaceTextureOptions } from './render/surfaceTexture.ts';
 export { DEFAULT_GOVERNOR_LIMITS, ResolutionGovernor } from './render/resolutionGovernor.ts';
@@ -204,6 +211,8 @@ export { describeGpu } from './render/gpuCapability.ts';
 export type { GpuIdentity, DescribeGpuOptions } from './render/gpuCapability.ts';
 export { DEFAULT_POINT_LIGHT_VIEW_RANGE, createPointLightBuffer, selectPointLights, } from './render/pointLightSelection.ts';
 export type { PointLightBuffer, PointLightSource } from './render/pointLightSelection.ts';
+export { createFlame, flameFrequencyHz, updateFlame } from './render/flameLight.ts';
+export type { Flame, FlameOptions } from './render/flameLight.ts';
 export { computeLightMatrix } from './render/lightMatrix.ts';
 export { PlumeRenderer } from './render/plumeRenderer.ts';
 export { createEnvironment } from './render/backend/webgl2/renderer.ts';
@@ -224,6 +233,7 @@ export { SMOKE_FRAG } from './render/shaders/smoke.ts';
 export { WaterRenderer } from './render/waterRenderer.ts';
 export type { WaterBody, WaterBounds, WaterSettings } from './render/waterRenderer.ts';
 export { MeshBuilder } from './geometry/meshBuilder.ts';
+export { concatMeshes, placeMesh } from './geometry/meshConcat.ts';
 export { generateTangents } from './geometry/tangents.ts';
 export type { MeshBuildOptions } from './geometry/meshBuilder.ts';
 export { Spline, createSplineSample } from './geometry/spline.ts';
@@ -331,7 +341,7 @@ export { BoltBatch } from './render/boltBatch.ts';
 export { createLineSegments, setPolyline } from './render/linePoints.ts';
 export type { LineSegments } from './render/linePoints.ts';
 export { FlockRenderer } from './render/flockRenderer.ts';
-export { DEFAULT_TEXT_STYLE, deviceSnappedCellSize, textHeightPx, textWidthPx, } from './render/textLayout.ts';
+export { DEFAULT_TEXT_STYLE, deviceSnappedCellSize, MAX_CELLS as MAX_TEXT_CELLS, textHeightPx, textWidthPx, } from './render/textLayout.ts';
 export type { TextStyle } from './render/textLayout.ts';
 export { GLYPH_HEIGHT, GLYPH_SPACING, GLYPH_WIDTH, countCells, forEachCell, forEachRun, glyphRows, hasGlyph, measureText, } from './geometry/pixelFont.ts';
 export { parseSdfFont } from './render/sdfFont.ts';

package/dist/index.js

@@ -30,9 +30,11 @@ export { PreferenceStore, loadPreferences, savePreferences } from './core/prefer
 export { OnceSet } from './core/onceSet.js';
 export { MAX_TIME_CURVE_AMOUNT, curveOffsetSec, curveSpanSec, linearCurve, timeCurve, } from './core/timeCurve.js';
 export { CinematicPlayer } from './cinematic/player.js';
+export { createCameraPath, createCameraPathSample, sampleCameraPath, } from './cinematic/cameraPath.js';
 export { defineCinematic, validateCinematic } from './cinematic/script.js';
 export { MessageQueue } from './core/messageQueue.js';
 export { celestialStateAt, createCelestialState, moonIllumination, } from './environment/celestialClock.js';
+export { createDaylightPalette, createDaylightState, easeExposure, resolveDaylight, } from './environment/daylight.js';
 export { TAU, DEG_TO_RAD, clamp, lerp, smoothstep, damp, dampTracking, angleDelta, dampAngle, wrapAngle, lerpAngle, } from './math/scalar.js';
 export { hslToRgb, mixColor, mixColorInto, scaleColor } from './math/color.js';
 export { Camera } from './render/camera.js';
@@ -170,6 +172,7 @@ export { countSplatTiles, fillSplatTiles, splatPixelBox, splatTileGrid, splatTil
  */
 export { GI_SOURCE_FIELD, GI_SOURCE_PROBES, GI_SOURCE_SCREEN, newIndirectResult, traceIndirect, } from './render/gi/chain.js';
 export { GLOBAL_FIELD_BLEND, composeGlobalField, createGlobalField, sampleGlobalField, } from './render/gi/globalField.js';
+export { FIELD_FADE_SEC, LightField } from './render/driftLight/lightField.js';
 export { GI_SCREEN_MARCH, SCREEN_TRACE_BIAS_M, screenRayOrigin, traceScreen, } from './render/gi/traceScreen.js';
 export { FIELD_MARCH, coneRadiusAt, newFieldHit, traceField } from './render/gi/traceField.js';
 export { PROBE_VISIBILITY_SHARPNESS, bakeProbeVisibility, createProbeVisibility, probeUpdateSchedule, probeVisibilityWeight, sampleProbeVolume, visibleProbes, } from './render/gi/probeVolume.js';
@@ -244,6 +247,8 @@ export { MAX_AREA_LIGHTS, createAreaLightBuffer, selectAreaLights } from './rend
  */
 export { areaShadowLayerCount, castingRange, firstAreaShadowLayer, } from './render/areaShadowSet.js';
 export { MAX_POINT_LIGHTS, SURFACE_TEXTURE_UNIT } from './render/lightBudget.js';
+/* The width a light buffer can usefully be with `clusteredLights` on; `createPointLightBuffer`. */
+export { MAX_CLUSTERED_LIGHTS } from './render/clusteredLights.js';
 export { SurfaceTexture } from './render/surfaceTexture.js';
 export { DEFAULT_GOVERNOR_LIMITS, ResolutionGovernor } from './render/resolutionGovernor.js';
 export { isWeakGpuFamily } from './render/gpuCapability.js';
@@ -255,6 +260,7 @@ export { isWeakGpuFamily } from './render/gpuCapability.js';
  */
 export { describeGpu } from './render/gpuCapability.js';
 export { DEFAULT_POINT_LIGHT_VIEW_RANGE, createPointLightBuffer, selectPointLights, } from './render/pointLightSelection.js';
+export { createFlame, flameFrequencyHz, updateFlame } from './render/flameLight.js';
 export { computeLightMatrix } from './render/lightMatrix.js';
 export { PlumeRenderer } from './render/plumeRenderer.js';
 export { createEnvironment } from './render/backend/webgl2/renderer.js';
@@ -292,6 +298,7 @@ export { ARCANE_FRAG } from './render/shaders/arcane.js';
 export { SMOKE_FRAG } from './render/shaders/smoke.js';
 export { WaterRenderer } from './render/waterRenderer.js';
 export { MeshBuilder } from './geometry/meshBuilder.js';
+export { concatMeshes, placeMesh } from './geometry/meshConcat.js';
 /* A tangent frame, which every map in the material track reads. */
 export { generateTangents } from './geometry/tangents.js';
 export { Spline, createSplineSample } from './geometry/spline.js';
@@ -439,7 +446,13 @@ export { DEFAULT_TEXT_STYLE,
  * the note at the cell upload in `render/textRenderer.ts`: snap once, then measure, lay out
  * and draw with that one number.
  */
-deviceSnappedCellSize, textHeightPx, textWidthPx, } from './render/textLayout.js';
+deviceSnappedCellSize, 
+/*
+ * How many lit cells one text object draws before the rest of its string is cut. Exported so a
+ * caller laying out a runtime string, a readout that grows, can break it before the engine does:
+ * the cut is silent by design, since a clipped message beats a frame that does not render.
+ */
+MAX_CELLS as MAX_TEXT_CELLS, textHeightPx, textWidthPx, } from './render/textLayout.js';
 export { GLYPH_HEIGHT, GLYPH_SPACING, GLYPH_WIDTH, countCells, forEachCell, forEachRun, glyphRows, hasGlyph, measureText, } from './geometry/pixelFont.js';
 /*
  * SDF text, reached the same way pixel text is: the verbs are on the renderer and the

package/dist/render/backend/createRenderer.d.ts

@@ -34,6 +34,18 @@ export declare const DEFAULT_PIPELINE: RenderPipeline;
  */
 export declare function pipelineRefusal(pipeline: RenderPipeline, backend: RenderBackend, reason: string): string | null;
 /** Everything about selection a caller may want to decide instead of inherit. */
+/**
+ * The quality to build with, or a function of the backend `createRenderer` chose.
+ *
+ * **A function is how an option only one backend has is asked of that backend alone.** Traced
+ * indirect light and reconstruction are WebGPU's, and WebGL2 refuses either in words when handed
+ * one: right for a consumer who asked for it there, and noise for one who wanted it wherever it
+ * runs, since every device that fell back printed a refusal. Called once for the backend that
+ * draws, and once more for WebGPU's timing request where WebGPU is tried. What would make it wrong
+ * is a consumer needing to know *why* the backend fell back before choosing, which `reason` on the
+ * result says after the fact and nothing says before.
+ */
+export type QualityForBackend = RenderQualityOptions | ((backend: RenderBackend) => RenderQualityOptions);
 export interface CreateRendererOptions {
     /**
      * Whether to try WebGPU at all. **Defaults to true**: WebGPU is the backend this engine is
@@ -189,4 +201,4 @@ export interface CreatedRenderer {
  * returned and ignored by every caller for long enough that a silent fallback could be
  * mistaken for a comparison.
  */
-export declare function createRenderer(canvas: HTMLCanvasElement, quality?: RenderQualityOptions, options?: CreateRendererOptions): Promise<CreatedRenderer>;
+export declare function createRenderer(canvas: HTMLCanvasElement, quality?: QualityForBackend, options?: CreateRendererOptions): Promise<CreatedRenderer>;

package/dist/render/backend/createRenderer.js

@@ -72,6 +72,7 @@ function presentOnFirstFrame(renderer, splash) {
  * mistaken for a comparison.
  */
 export async function createRenderer(canvas, quality = {}, options = {}) {
+    const qualityFor = (backend) => typeof quality === 'function' ? quality(backend) : quality;
     const search = options.search ?? globalThis.location?.search ?? '';
     /*
      * **Mounted before the probe, because the probe is part of the wait.** `selectBackend` asks for
@@ -143,7 +144,7 @@ export async function createRenderer(canvas, quality = {}, options = {}) {
        forward step makes `spent` exceed the budget, so the engine falls back to WebGL2 reporting
        "WebGPU stalled" about a device that was fine. */
     const startedAt = performance.now();
-    const choice = await selectBackend(search, options.preferWebGpu ?? true, quality.gpuTiming ?? false, options.probeShaders ?? [], budgetMs);
+    const choice = await selectBackend(search, options.preferWebGpu ?? true, (options.preferWebGpu ?? true) ? (qualityFor('webgpu').gpuTiming ?? false) : false, options.probeShaders ?? [], budgetMs);
     if (choice.backend === 'webgpu' && choice.device !== null) {
         /*
          * **A failure here falls back rather than propagating.** Everything up to this point
@@ -185,7 +186,7 @@ export async function createRenderer(canvas, quality = {}, options = {}) {
             if (settled === TIMED_OUT) {
                 device.destroy();
                 return built({
-                    renderer: new Renderer(canvas, quality),
+                    renderer: new Renderer(canvas, qualityFor('webgl2')),
                     backend: 'webgl2',
                     reason: `WebGPU stalled while ${stage}, fell back after ${budgetMs} ms`,
                 });
@@ -204,7 +205,7 @@ export async function createRenderer(canvas, quality = {}, options = {}) {
                  * resolves internally, so the two backends get the same numbers by construction rather
                  * than from a copied set of defaults somebody has to keep in step.
                  */
-                renderer: new WebGPURenderer(surface, resolveRenderQuality(quality), 
+                renderer: new WebGPURenderer(surface, resolveRenderQuality(qualityFor('webgpu')), 
                 /* The adapter's own words, so the capability clamp has a part number to
                    recognise rather than the literal string `WebGPU`. */
                 choice.rendererName ?? undefined),
@@ -216,7 +217,7 @@ export async function createRenderer(canvas, quality = {}, options = {}) {
             choice.device.destroy();
             const detail = error instanceof Error ? error.message : String(error);
             return built({
-                renderer: new Renderer(canvas, quality),
+                renderer: new Renderer(canvas, qualityFor('webgl2')),
                 backend: 'webgl2',
                 reason: `WebGPU surface failed, fell back: ${detail}`,
             });
@@ -243,7 +244,7 @@ export async function createRenderer(canvas, quality = {}, options = {}) {
         console.warn(`[driftengine] WebGPU was asked for and is not being used: ${choice.reason}`);
     }
     return built({
-        renderer: new Renderer(canvas, quality),
+        renderer: new Renderer(canvas, qualityFor('webgl2')),
         backend: 'webgl2',
         reason: choice.reason,
     });