@nayan-ui/engine 1.0.0-beta.5 → 1.0.0-beta.6

package/lib/module/media/input.web.js

@@ -0,0 +1,107 @@
+"use strict";
+
+// The page's microphone for the core's recording (`microphone`): asks with getUserMedia, then a
+// worklet node posts mono input blocks that are copied into WASM memory and pushed to the core.
+// Echo cancellation keeps the game's own sounds (a character repeating you) out of the recording.
+
+const BLOCK = 2048;
+const MIC_FAILED = -1;
+export function installMicrophoneInput(core, bridge) {
+  if (typeof navigator === 'undefined' || !navigator.mediaDevices?.getUserMedia) return;
+  let permission = 0;
+  let stream = null;
+  let context = null;
+  let failed = false;
+  /** Bumped by every start and stop, so a slow start that was stopped meanwhile closes itself. */
+  let session = 0;
+  const startCore = bridge.micStart;
+  const stopCore = bridge.micStop;
+  const stateCore = bridge.micState;
+  const allocate = core.engine_web_alloc;
+  const push = core.engine_audio_mic_push;
+  let pointer = 0;
+
+  // A page that was allowed before doesn't prompt again: report it as granted up front.
+  void navigator.permissions?.query({
+    name: 'microphone'
+  }).then(status => {
+    const read = () => {
+      permission = status.state === 'granted' ? 1 : status.state === 'denied' ? -1 : 0;
+    };
+    read();
+    status.onchange = read;
+  }).catch(() => {});
+  const open = async () => {
+    stream ??= await navigator.mediaDevices.getUserMedia({
+      audio: {
+        echoCancellation: true,
+        noiseSuppression: true,
+        autoGainControl: true,
+        channelCount: 1
+      }
+    });
+    permission = 1;
+    return stream;
+  };
+  const close = () => {
+    stream?.getTracks().forEach(track => track.stop()); // turns the browser's recording indicator off
+    stream = null;
+    void context?.close().catch(() => {});
+    context = null;
+  };
+  bridge.micPermission = () => permission;
+  bridge.micRequestPermission = async () => {
+    try {
+      await open();
+      return true;
+    } catch {
+      permission = -1;
+      return false;
+    }
+  };
+  bridge.micStart = maxSeconds => {
+    session++;
+    const current = session;
+    close();
+    failed = false;
+    if (!startCore(maxSeconds)) return false;
+    void (async () => {
+      const input = await open();
+      const audio = new AudioContext();
+      context = audio;
+      await audio.audioWorklet.addModule(new URL('./audio-worklet.js', import.meta.url));
+      if (current !== session) return audio.close();
+      const node = new AudioWorkletNode(audio, 'nayan-microphone', {
+        numberOfInputs: 1,
+        numberOfOutputs: 1
+      });
+      const muted = audio.createGain();
+      muted.gain.value = 0; // keeps the node pulled without playing the input back
+      audio.createMediaStreamSource(input).connect(node).connect(muted).connect(audio.destination);
+      pointer ||= allocate(BLOCK * 4);
+      node.port.onmessage = ({
+        data
+      }) => {
+        if (current !== session) return;
+        new Float32Array(core.memory.buffer, pointer, data.length).set(data);
+        push(pointer, data.length, audio.sampleRate);
+      };
+      await audio.resume();
+    })().catch(() => {
+      if (current !== session) return;
+      failed = true;
+      if (permission === 0) permission = -1;
+      stopCore();
+      close();
+    });
+    return true;
+  };
+  bridge.micStop = () => {
+    session++;
+    failed = false;
+    stopCore();
+    close();
+  };
+  bridge.micState = () => failed ? MIC_FAILED : stateCore();
+}
+//# sourceMappingURL=input.web.js.map

package/lib/module/media/microphone.js

@@ -0,0 +1,89 @@
+"use strict";
+
+// Recording from the device's microphone, kept in the Rust core: it holds the last few seconds of
+// input and how loud it is now, and turns any stretch of it into an ordinary Sound that plays through
+// the mixer (at any pitch: a character repeating you in a squeaky voice). Nothing leaves the device.
+//
+//   if (!(await microphone.requestPermission())) return;   // the system prompt, the first time
+//   microphone.start();                                     // listening (keeps the last 10 s)
+//   // each frame: microphone.level (0..1) to notice speech starting and stopping
+//   const take = microphone.take(spoke, { skipEnd: 0.6 });  // what was said, without the pause after
+//   if (take) audio.play(take.sound, { pitch: 1.6 });       // ... then audio.release(take.sound)
+//
+// iOS: the app needs NSMicrophoneUsageDescription; the audio session switches to play-and-record (to
+// the speaker) while listening and back to ambient after `stop`. Android: the app declares
+// android.permission.RECORD_AUDIO; `requestPermission` asks through the current activity. Web: the
+// page must be served over HTTPS (or localhost) and allowed to use the microphone.
+import NativeEngine from '../native/NativeNayanEngine';
+
+/** What `microphone.take` returns: a sound to play, how long it lasts and its loudness over time. */
+
+const STATES = {
+  0: 'off',
+  1: 'starting',
+  2: 'listening',
+  [-1]: 'failed'
+};
+export const microphone = {
+  /** Whether this engine build can record (false on older app builds and without a native module). */
+  get supported() {
+    return typeof NativeEngine?.micStart === 'function';
+  },
+  /** Whether the app may record. On Android, 'undetermined' also covers a denial (it can't tell). */
+  get permission() {
+    const value = microphone.supported ? NativeEngine.micPermission() : -1;
+    return value > 0 ? 'granted' : value < 0 ? 'denied' : 'undetermined';
+  },
+  /** Shows the system prompt the first time (answering at once after that); true if recording is allowed. */
+  requestPermission() {
+    return microphone.supported ? NativeEngine.micRequestPermission() : Promise.resolve(false);
+  },
+  /** Starts listening (asynchronously: see `state`). Ask for the permission first. */
+  start({
+    maxSeconds = 10
+  } = {}) {
+    return microphone.supported && NativeEngine.micStart(maxSeconds);
+  },
+  /** Stops listening and releases the microphone (its system indicator turns off); forgets what was heard. */
+  stop() {
+    if (microphone.supported) NativeEngine.micStop();
+  },
+  /** 'failed' when there's no microphone, no permission or the input couldn't open. */
+  get state() {
+    return microphone.supported ? STATES[NativeEngine.micState()] ?? 'off' : 'off';
+  },
+  /**
+   * How loud the input is now: 0 at -60 dBFS or quieter, 1 at full scale; speech close to a phone
+   * is usually 0.4..0.8, a quiet room under 0.3. Rises at once and falls back over ~0.15 s. Cheap
+   * enough to read every frame.
+   */
+  get level() {
+    return microphone.supported ? NativeEngine.micLevel() : 0;
+  },
+  /** Seconds of input held (up to `maxSeconds`), since starting or the last `take`. */
+  get held() {
+    return microphone.supported ? NativeEngine.micHeld() : 0;
+  },
+  /**
+   * The last `seconds` of input (ending `skipEnd` seconds ago) as a new Sound, and forgets
+   * everything heard so far so the next take starts fresh. Null if nothing was heard. Release the
+   * sound with `audio.release` once it has played: each take holds its samples until then.
+   */
+  take(seconds = Infinity, {
+    skipEnd = 0,
+    levelsPerSecond = 30
+  } = {}) {
+    if (!microphone.supported) return null;
+    const id = NativeEngine.micTake(Number.isFinite(seconds) ? seconds : 3600, skipEnd);
+    if (id < 0) return null;
+    const sound = id;
+    const buffer = NativeEngine.audioLevels(sound, levelsPerSecond);
+    return {
+      sound,
+      duration: NativeEngine.audioDuration(sound),
+      levels: new Float32Array(buffer),
+      levelsPerSecond
+    };
+  }
+};
+//# sourceMappingURL=microphone.js.map

package/lib/module/media/speech.js

@@ -0,0 +1,80 @@
+"use strict";
+
+import { speechPlatform } from './speechPlatform';
+async function request(command) {
+  if (!speechPlatform.supported) throw new Error('Speech is unavailable on this platform or engine build');
+  const result = JSON.parse(await speechPlatform.request(JSON.stringify(command)));
+  if (result.error) throw new Error(result.error);
+  return result.value;
+}
+
+/** System text-to-speech. Independent of the engine mixer, microphone and asset loading. */
+export const speech = {
+  /** API availability; installed voices and Android TTS initialization may still fail. */
+  get supported() {
+    return speechPlatform.supported;
+  },
+  /**
+   * Queues text using the system synthesizer. Resolves when queued, not when speech finishes.
+   * No audio files are created. Call stop on leaving a screen to cancel its queued speech.
+   */
+  async speak(text, options = {}) {
+    if (typeof text !== 'string') throw new TypeError('Speech text must be a string');
+    for (const [key, min, max] of [['rate', 0.1, 2], ['pitch', 0.5, 2], ['volume', 0, 1]]) {
+      const value = options[key];
+      if (value !== undefined && (!Number.isFinite(value) || value < min || value > max)) {
+        throw new RangeError(`Speech ${key} must be between ${min} and ${max}`);
+      }
+    }
+    for (const key of ['language', 'voice']) {
+      if (options[key] !== undefined && typeof options[key] !== 'string') throw new TypeError(`Speech ${key} must be a string`);
+    }
+    if (!text.trim()) return;
+    const {
+      language,
+      voice,
+      rate,
+      pitch,
+      volume
+    } = options;
+    await request({
+      action: 'speak',
+      text,
+      language,
+      voice,
+      rate,
+      pitch,
+      volume
+    });
+  },
+  /** Stops current speech and clears the entire speech queue. */
+  async stop() {
+    await request({
+      action: 'stop'
+    });
+  },
+  /** iOS and web only; rejects on Android, which has no system pause API. */
+  async pause() {
+    await request({
+      action: 'pause'
+    });
+  },
+  /** iOS and web only; rejects on Android. */
+  async resume() {
+    await request({
+      action: 'resume'
+    });
+  },
+  /** Includes speech paused on iOS/web. */
+  isSpeakingAsync() {
+    return request({
+      action: 'isSpeaking'
+    });
+  },
+  getAvailableVoicesAsync() {
+    return request({
+      action: 'voices'
+    });
+  }
+};
+//# sourceMappingURL=speech.js.map

package/lib/module/media/speechPlatform.js

@@ -0,0 +1,12 @@
+"use strict";
+
+import NativeEngine from '../native/NativeNayanEngine';
+export const speechPlatform = {
+  get supported() {
+    return typeof NativeEngine?.speechRequest === 'function';
+  },
+  request(command) {
+    return NativeEngine.speechRequest(command);
+  }
+};
+//# sourceMappingURL=speechPlatform.js.map

package/lib/module/media/speechPlatform.web.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import { speech_request } from '../../native/core/build/web/engine_core.js';
+import { prepareEngine } from "../native/NativeNayanEngine.web.js";
+
+// The browser API is checked without initializing WASM, including during server rendering.
+export const speechPlatform = {
+  get supported() {
+    return typeof window !== 'undefined' && 'speechSynthesis' in window && 'SpeechSynthesisUtterance' in window;
+  },
+  async request(command) {
+    await prepareEngine();
+    return speech_request(command);
+  }
+};
+//# sourceMappingURL=speechPlatform.web.js.map

package/lib/module/native/BrowserEngine.js

@@ -173,6 +173,18 @@ export function createBrowserEngine(core) {
     while (end < b.length && b[end] !== 0) end++;
     return decoder.decode(b.subarray(pointer, end));
   };
+  /** Copies a UTF-8 argument into scratch slot `index`: [pointer, byte length]. */
+  const text = (index, value) => {
+    const b = encoder.encode(value);
+    return [put(index, b), b.length];
+  };
+  /** A core function's f64 output (asked for its length first) as a new ArrayBuffer. */
+  const readDoubles = read => {
+    const count = read(0, 0);
+    const out = zeroed(2, Math.max(8, count * 8));
+    read(out, count);
+    return copy(out, count * 8);
+  };
   const geometry = handle => {
     try {
       const error = cString(fn('geometry_error', handle));
@@ -404,6 +416,17 @@ export function createBrowserEngine(core) {
       const [x, y, z] = dimensions('model_size', mesh, 3, true);
       return [x, y, z];
     },
+    bakeKept(key) {
+      const [k, length] = text(0, key);
+      return fn('bake_kept', k, length) !== 0;
+    },
+    modelBake(mesh, spec) {
+      const [s, length] = text(0, spec);
+      const out = zeroed(1, 16);
+      if (!fn('model_bake', mesh, s, length, out)) return [];
+      const [texture, x, y, extent] = new Float32Array(u8().slice(out, out + 16).buffer);
+      return [texture, x, y, extent];
+    },
     // The browser core is single-threaded: the "background" loads settle at once with the same work.
     modelLoadAsync(value, center, fit) {
       return settle(() => engine.modelLoad(value, center, fit));
@@ -519,6 +542,14 @@ export function createBrowserEngine(core) {
       const buckets = source(4, ranges);
       ex('render_overlay')(surface, m, c, r, capacity, buckets, ranges.byteLength / 4, count, width, height);
     },
+    renderBackdrop(surface, matrices, colors, regions, ranges, count) {
+      const capacity = Math.min(buf(matrices).byteLength / MATRIX_BYTES, buf(colors).byteLength / VEC4_BYTES, buf(regions).byteLength / VEC4_BYTES);
+      const m = source(1, matrices);
+      const c = source(2, colors);
+      const r = source(3, regions);
+      const buckets = source(4, ranges);
+      ex('render_backdrop')(surface, m, c, r, capacity, buckets, ranges.byteLength / 4, count);
+    },
     renderError: () => string('render_error'),
     renderBackend: () => string('render_backend'),
     drawingCreate: (width, height, ratio) => fn('drawing_create', width, height, ratio),
@@ -557,10 +588,101 @@ export function createBrowserEngine(core) {
       fn('audio_set_muted', +muted);
     },
     audioIsRunning: () => fn('audio_is_running') !== 0,
+    audioRelease(sound) {
+      fn('audio_release', sound);
+    },
+    audioDuration: sound => fn('audio_duration', sound),
+    audioLevels(sound, perSecond) {
+      const count = fn('audio_levels', sound, perSecond, 0, 0);
+      if (!count) return new ArrayBuffer(0);
+      const p = zeroed(0, count * 4);
+      fn('audio_levels', sound, perSecond, p, count);
+      return copy(p, count * 4);
+    },
+    // The page's microphone (permission, getUserMedia and the input node) is installed over these
+    // by `installMicrophoneInput`; the core keeps what was heard either way.
+    micPermission: () => 0,
+    micRequestPermission: () => Promise.resolve(false),
+    micStart: maxSeconds => fn('audio_mic_start', maxSeconds) !== 0,
+    micStop() {
+      fn('audio_mic_stop');
+    },
+    micState: () => fn('audio_mic_state'),
+    micLevel: () => fn('audio_mic_level'),
+    micHeld: () => fn('audio_mic_held'),
+    micTake: (seconds, skipEnd) => fn('audio_mic_take', seconds, skipEnd),
     hapticsSupported: () => fn('haptics_supported') !== 0,
     hapticsPlay(taps, throttle) {
       const p = put(0, new Uint8Array(new Float32Array(taps).buffer));
       fn('haptics_play', p, taps.length / 3, +throttle);
+    },
+    worldgenBuild: (recipe, key, prepareTerrain) => {
+      const [r, rl] = text(0, recipe);
+      const [k, kl] = text(1, key);
+      return fn('worldgen_build', r, rl, k, kl, +prepareTerrain) >>> 0;
+    },
+    // The web core is single-threaded: build now, settle as a promise.
+    worldgenBuildAsync: async (recipe, key, prepareTerrain) => engine.worldgenBuild(recipe, key, prepareTerrain),
+    worldgenError: () => string('worldgen_error'),
+    worldgenKept(key) {
+      const [k, kl] = text(0, key);
+      return fn('worldgen_kept', k, kl) !== 0;
+    },
+    worldgenFree(world) {
+      fn('worldgen_free', world);
+    },
+    worldgenInfo: world => string('worldgen_info', [world]),
+    worldgenLayer(world, name) {
+      const [n, nl] = text(1, name);
+      return readDoubles((out, capacity) => fn('worldgen_layer', world, n, nl, out, capacity));
+    },
+    worldgenReachable: world => readDoubles((out, capacity) => fn('worldgen_reachable', world, out, capacity)),
+    worldgenOverview(world) {
+      const count = fn('worldgen_overview', world, 0, 0);
+      const out = zeroed(0, Math.max(1, count));
+      fn('worldgen_overview', world, out, count);
+      return copy(out, count);
+    },
+    worldgenPick: (world, run) => fn('worldgen_pick', world, run) !== 0,
+    worldgenTerrain: (world, material) => geometry(fn('worldgen_terrain', world, material)),
+    worldgenMesh(recipe) {
+      const [r, rl] = text(0, recipe);
+      return geometry(fn('worldgen_mesh', r, rl));
+    },
+    worldgenPaint(vertices, recipe) {
+      const [v] = data(vertices);
+      const [r, rl] = text(1, recipe);
+      const ok = fn('worldgen_paint', v, bytes(vertices).length / 44, r, rl) !== 0;
+      if (ok) bytes(vertices).set(u8().subarray(v, v + vertices.byteLength));
+      return ok;
+    },
+    worldgenGround: (world, x, z) => fn('worldgen_ground', world, x, z),
+    worldgenSurface: (world, x, z) => fn('worldgen_surface', world, x, z),
+    worldgenPlatform: (world, x, z) => fn('worldgen_platform', world, x, z),
+    worldgenWalkable: (world, x, z, radius) => fn('worldgen_walkable', world, x, z, radius) !== 0,
+    worldgenClearance: (world, x, z, radius) => fn('worldgen_clearance', world, x, z, radius),
+    worldgenSolidClearance: (world, x, z, radius, bottom, top) => fn('worldgen_solid_clearance', world, x, z, radius, bottom, top),
+    worldgenFieldIndex(world, name) {
+      const [n, nl] = text(0, name);
+      return fn('worldgen_field_index', world, n, nl);
+    },
+    worldgenField: (world, field, x, z) => fn('worldgen_field', world, field, x, z),
+    worldgenTilt(world, x, z, yaw) {
+      const out = zeroed(0, 32);
+      fn('worldgen_tilt', world, x, z, yaw, out);
+      const at = out >> 3;
+      const q = f64();
+      return [q[at], q[at + 1], q[at + 2], q[at + 3]];
+    },
+    worldgenSight: (world, ax, az, bx, bz, radius, step, rise) => fn('worldgen_sight', world, ax, az, bx, bz, radius, step, rise) !== 0,
+    worldgenMove(world, x, z, dx, dz, radius, bodies) {
+      const list = bytes(bodies);
+      const b = put(1, list);
+      const p = zeroed(0, 16);
+      f64().set([x, z], p >> 3);
+      fn('worldgen_move', world, p, dx, dz, radius, b, Math.floor(list.byteLength / 24));
+      const q = f64();
+      return [q[p >> 3], q[(p >> 3) + 1]];
     }
   };
   return engine;

package/lib/module/native/NativeNayanEngine.web.js

@@ -2,6 +2,7 @@
 
 import init, { attach_canvas, can_warm_asset_record, install_asset_storage, read_saved_asset, restore_asset_record } from '../../native/core/build/web/engine_core.js';
 import { IndexedDbCache } from "../assets/IndexedDbCache.web.js";
+import { installMicrophoneInput } from "../media/input.web.js";
 import { installAudioOutput } from "../media/output.web.js";
 import { createBrowserEngine } from "./BrowserEngine.js";
 let storage;
@@ -20,6 +21,7 @@ export function prepareEngine() {
     }
     const ready = createBrowserEngine(core);
     ready.audioIsRunning = installAudioOutput(core);
+    installMicrophoneInput(core, ready);
     Object.assign(browser, ready);
   })().catch(error => {
     pending = undefined;

package/lib/module/render/GameView.js

@@ -7,10 +7,12 @@ import { resolveColor } from "../world/color.js";
 import { follow, shake } from "./camera.js";
 import { createTouchResponder, pixelRatio, Surface, useActive } from './host';
 import { getMeshIdLimit, uploadBuiltInMeshes } from "./meshes.js";
-import { AutoQuality, median, QUALITY_LEVELS } from "./quality.js";
+import { AutoQuality, levelPixelRatio, median, QUALITY_LEVELS, rememberQuality, settledQuality } from "./quality.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 const DEFAULT_BACKGROUND = [0.04, 0.05, 0.09];
-const FRAME_LEN = 26; // ENGINE_FRAME_LEN
+
+// ENGINE_FRAME_LEN, plus the scene scale (26), FXAA (27) and live shadows (28), which older native cores ignore.
+const FRAME_LEN = 29;
 const WHITE = [1, 1, 1];
 let nextSurface = 1;
 const defaultCamera = () => ({
@@ -121,12 +123,12 @@ export function GameView(props) {
     let presentedAt = 0;
     if (autoQuality.current?.source !== source) autoQuality.current = {
       source,
-      auto: new AutoQuality()
+      auto: new AutoQuality(settledQuality(live.current.props.qualityKey, native))
     };
     const auto = autoQuality.current.auto;
     const chosen = () => {
       const setting = live.current.props.quality ?? 'auto';
-      return setting === 'auto' ? auto.quality : setting;
+      return setting === 'auto' ? [auto.quality, auto.level] : [setting, QUALITY_LEVELS[setting]];
     };
     const followed = [0, 0, 0];
     const shaken = {
@@ -162,10 +164,13 @@ export function GameView(props) {
       return Math.min(s.count, end);
     };
     let overlay = null;
+    // The backdrop last sent, and its update count then: sent again only when it changes.
+    let backdrop = null;
     let last = 0;
     let frames = 0;
     let fpsStart = 0;
     let updateTime = 0;
+    let publishTime = 0;
     let renderTime = 0;
     // This second's frame intervals and draw times: the quality picker looks at their medians, so a
     // single hiccup (garbage collection, a busy JS frame) never costs quality.
@@ -198,14 +203,16 @@ export function GameView(props) {
       updateTime += performance.now() - t0;
       follow(camera, source, followed, dt);
       const view = shake(camera, shaken, dt);
-      const quality = chosen();
-      const level = QUALITY_LEVELS[quality];
+      const [quality, level] = chosen();
       const {
         width,
         height
       } = size.current;
-      // Phones' GPUs are fill-rate bound: cap the pixels drawn rather than match a 3x+ screen.
-      const ratio = Math.min(pixelRatio(), level.maxPixelRatio);
+      // Phones' GPUs are fill-rate bound: cap the pixels drawn rather than match a 3x+ screen. A level's
+      // pixel budget shrinks only the 3D scene (stretched to fill the view): the screen keeps its own
+      // resolution, so the overlay's text stays sharp at every level.
+      const screenRatio = Math.min(pixelRatio(), level.maxPixelRatio);
+      const ratio = levelPixelRatio(level, pixelRatio(), width, height);
       const f = frameData;
       f.set(view.eye, 0);
       f.set(view.target, 3);
@@ -213,7 +220,7 @@ export function GameView(props) {
       f[7] = view.ortho ?? 0;
       f.set(light.direction, 8);
       f[11] = light.ambient;
-      f[12] = light.shadows ?? true ? 1 : 0;
+      f[12] = (light.shadows ?? true) !== false && level.shadows ? 1 : 0;
       f[13] = light.shadowExtent ?? 30;
       // Exactly three channels each: either color may carry an alpha that must not spill over.
       const lightColor = light.color === undefined ? WHITE : resolveColor(light.color);
@@ -225,11 +232,14 @@ export function GameView(props) {
       f[18] = sky[1];
       f[19] = sky[2];
       f[20] = environment.fog;
-      f[21] = Math.round(width * ratio);
-      f[22] = Math.round(height * ratio);
+      f[21] = Math.round(width * screenRatio);
+      f[22] = Math.round(height * screenRatio);
       f[23] = level.samples;
       f[24] = level.shadowSize;
       f[25] = level.softShadows ? 1 : 0;
+      f[26] = screenRatio > 0 ? ratio / screenRatio : 1;
+      f[27] = level.fxaa ? 1 : 0;
+      f[28] = light.shadows === 'backdrop' ? 0 : 1;
       const t1 = performance.now();
       if (layer) {
         if (overlay?.source !== layer) overlay = {
@@ -241,9 +251,27 @@ export function GameView(props) {
         overlay = null;
         native.renderOverlay(surfaceId, regions.buffer, regions.buffer, regions.buffer, regions.buffer, 0, 0, 0); // removes it
       }
+      const backSource = current.backdrop ?? source.backdrop;
+      const back = backSource && !backSource.isDisposed ? backSource : undefined;
+      if (back && typeof native.renderBackdrop === 'function') {
+        if (backdrop?.source !== back || backdrop.updates !== (back.updateCount ?? 0)) {
+          // A freshly spawned world has no matrices until it's stepped once.
+          if (!back.updateCount && back.update) back.update(0);
+          backdrop = {
+            source: back,
+            updates: back.updateCount ?? 0,
+            regions: wholeRegions(back)
+          };
+          native.renderBackdrop(surfaceId, back.matrices.buffer, back.colors.buffer, backdrop.regions.buffer, back.ranges.buffer, drawn(back));
+        }
+      } else if (backdrop) {
+        backdrop = null;
+        native.renderBackdrop?.(surfaceId, regions.buffer, regions.buffer, regions.buffer, regions.buffer, 0); // removes it
+      }
       const render = threaded ? native2.publishFrame : native.renderFrame;
       const rendered = render(surfaceId, f.buffer, source.matrices.buffer, source.colors.buffer, regions.buffer, source.ranges.buffer, drawn(source), viewProj.buffer, source.nativeWorld ?? -1);
       const drawMs = performance.now() - t1;
+      publishTime += drawMs;
       if (!threaded) {
         renderTime += drawMs;
         draws.push(drawMs);
@@ -267,21 +295,25 @@ export function GameView(props) {
           frameMs = shownFrames > 0 ? Math.max(frameMs, elapsed / shownFrames) : elapsed;
           renderMs = meanRenderMs = nativeMs;
         }
-        auto.report(now, {
+        if (current.adaptQuality ?? true) auto.report(now, {
           frameMs,
           renderMs
-        });
+        });else auto.hold(now);
+        if ((current.quality ?? 'auto') === 'auto') rememberQuality(current.qualityKey, auto.step, native);
         intervals.length = 0;
         draws.length = 0;
         current.onStats?.({
           fps,
           updateMs: updateTime / frames,
+          publishMs: publishTime / frames,
           renderMs: meanRenderMs,
           quality,
+          sceneScale: frameData[26],
           backend: native.renderBackend()
         });
         frames = 0;
         updateTime = 0;
+        publishTime = 0;
         renderTime = 0;
         fpsStart = now;
       }