@solidrt/3d 0.0.58 → 0.0.60

package/src/components/scene.tsx

@@ -1,9 +1,9 @@
-import { createEffect, displayScale, getBoundingBoxViewport, getLayoutBox, onCleanup, onLayout, untrack } from "@solidrt/core"
+import { createEffect, createRenderEffect, createSignal, displayScale, getBoundingBoxViewport, getLayoutBox, onCleanup, onLayout, untrack } from "@solidrt/core"
 import type { Element, ParentComponent, PointerFeed, TextureId } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import { createScene } from "../scene.ts"
 import { feedPointer } from "../scene-pointer.ts"
-import type { EnvironmentOptions, FogOptions, Scene as SceneHandle, SkyboxOptions, ToneMapping } from "../scene.ts"
+import type { BloomOptions, EnvironmentOptions, FogOptions, ResolveInput, Scene as SceneHandle, SkyboxOptions, ToneMapping } from "../scene.ts"
 import type { ScenePointerEvent, SceneTapEvent, SceneWheelEvent } from "../node.ts"
 import type { CameraUpdate } from "../camera.ts"
 
@@ -59,6 +59,11 @@ export type SceneProps = ScenePointerProps & {
    * `{ cube, intensity?, rotation? }`, typically the skybox's own cube
    * turned with it. Reactive; undefined removes it. */
   environment?: EnvironmentOptions
+  /** Stagger (ms) for the nodes straight under the scene root: their
+   * enters and exits beginning in one frame are spaced by `index *
+   * stagger`, the whole-scene form of `<Group transition={{ stagger }}>`
+   * (see SceneOptions.stagger). Set at creation. */
+  stagger?: number
   /** Scene-wide fog (scene.setFog): linear `{ color, near, far }` or exp2
    * `{ color, density }`, optionally thinning above `height` by
    * `heightFalloff`; every standard material fades toward `color` by
@@ -94,6 +99,16 @@ export type SceneProps = ScenePointerProps & {
    * feed, which listens at the scene's root.
    */
   output?: (texture: TextureId) => Element
+  /**
+   * The scene's resolve (SceneOptions.resolve): the source, `{ source,
+   * textures }`, or a function of the buffer id `scene.hdrTexture` so a
+   * radiance-reading chain (a bloom) is built over it right there and its
+   * result bound. Fixed at creation, like `output`.
+   */
+  resolve?: ResolveInput
+  /** The stock bloom (scene.setBloom as a prop): `{ threshold?,
+   * intensity?, radius? }`, reactive; undefined turns it off. */
+  bloom?: BloomOptions
   /**
    * Pointer events (default on): the built-in leaf carries scene.handlers,
    * so nodes, the scene's own handlers and a camera control's feed
@@ -138,6 +153,14 @@ export let Scene: ParentComponent<SceneProps> = props => {
     }
     return props.width === undefined
   })
+  // A budget error the scene reports from its sync (a microtask, outside
+  // the tree) is rethrown inside it, so the app's error boundary shows
+  // it: the handler parks the error and bumps a signal, the render effect
+  // below takes and throws it. Taking it first means the boundary's reset
+  // finds nothing to throw and returns to the scene, which kept rendering
+  // with what fits.
+  let pendingError: Error | null = null
+  let [errorTick, setErrorTick] = createSignal(0)
   // The initial props seed createScene, so `ref` (below) hands out a
   // configured scene and the first frame draws it whole; the effects
   // after this follow changes only (`defer`).
@@ -152,11 +175,28 @@ export let Scene: ParentComponent<SceneProps> = props => {
       fog: props.fog,
       toneMapping: props.toneMapping,
       exposure: props.exposure,
+      resolve: props.resolve,
+      bloom: props.bloom,
       layers: props.layers,
+      stagger: props.stagger,
+      onError: e => {
+        pendingError = e
+        setErrorTick(errorTick() + 1)
+      },
     })
     if (props.camera) s.setCamera(props.camera)
     return s
   })
+  createRenderEffect(
+    () => {
+      errorTick()
+      let e = pendingError
+      pendingError = null
+      if (e !== null) throw e
+      return null
+    },
+    () => {},
+  )
   createEffect(
     () => [props.width, props.height] as const,
     ([w, h]) => {
@@ -198,6 +238,11 @@ export let Scene: ParentComponent<SceneProps> = props => {
     e => scene.setExposure(e ?? 1),
     { defer: true },
   )
+  createEffect(
+    () => props.bloom,
+    b => scene.setBloom(b ?? null),
+    { defer: true },
+  )
   createEffect(
     () => props.layers,
     l => scene.setLayers(l ?? 1),
@@ -222,6 +267,14 @@ export let Scene: ParentComponent<SceneProps> = props => {
   )
   let output = untrack(() => props.output)
   let events = untrack(() => props.events) !== false
+  // A feed on a built-in leaf carrying no handlers listens at a root no
+  // event reaches: a contradiction, so it throws (the dev validation
+  // policy) instead of feeding nothing.
+  if (pointer !== null && !events && !output) {
+    throw new Error(
+      "Scene: a pointer feed with events={false} receives nothing - the feed listens at the scene's root, which only the leaf's handlers reach; keep events on, or compose the leaf with output and spread scene.handlers on it",
+    )
+  }
   let leafNode: { id: number } | undefined
   // The built-in leaf's laid-out box in ITS units - what pointer
   // localX/localY report in and every handlersFor scales against. Fixed

package/src/components/spot-light.tsx

@@ -3,7 +3,7 @@ import type { VoidComponent } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import { syncNode } from "./node-props.ts"
 import type { TransformProps } from "./node-props.ts"
-import { add, remove } from "../node.ts"
+import { add, destroy } from "../node.ts"
 import { createSpotLight, setLight } from "../light.ts"
 import type { SpotLight as SpotLightNode, SpotShadowOptions } from "../light.ts"
 import type { Vec3 } from "../math.ts"
@@ -60,6 +60,6 @@ export let SpotLight: VoidComponent<SpotLightProps> = props => {
       setLight(light, { direction, color, intensity, distance, angle, penumbra, decay, castShadow, shadow }),
   )
   untrack(() => props.ref)?.(light)
-  onCleanup(() => remove(light))
+  onCleanup(() => destroy(light))
   return null
 }

package/src/components/sprite.tsx

@@ -3,7 +3,7 @@ import type { VoidComponent } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import type { TransformProps, PointerEventProps } from "./node-props.ts"
 import { syncMesh } from "./mesh.tsx"
-import { add, remove } from "../node.ts"
+import { add, destroy } from "../node.ts"
 import { createSprite } from "../mesh.ts"
 import type { Mesh as MeshNode } from "../mesh.ts"
 import type { ShaderParams } from "@solidrt/core/gpu"
@@ -33,6 +33,6 @@ export let Sprite: VoidComponent<SpriteProps> = props => {
   add(ctx.parent, mesh)
   syncMesh(mesh, props)
   untrack(() => props.ref)?.(mesh)
-  onCleanup(() => remove(mesh))
+  onCleanup(() => destroy(mesh))
   return null
 }

package/src/components/view3d.tsx

@@ -6,7 +6,7 @@ import type { ViewHandle, ViewOptions } from "../scene.ts"
 import type { CameraUpdate } from "../camera.ts"
 import type { ScenePointerProps } from "./scene.tsx"
 
-export type View3dProps = Pick<ViewOptions, "clearColor" | "label" | "overrideMaterial" | "fog" | "depth" | "samples" | "filter" | "wrap" | "into"> &
+export type View3dProps = Pick<ViewOptions, "clearColor" | "label" | "overrideMaterial" | "fog" | "depth" | "samples" | "filter" | "wrap" | "into" | "resolve" | "bloom"> &
   ScenePointerProps & {
   /** Target pixels, live: the view resizes, or its tile moves. Fixed
    * only, for now: a fill mode like Scene's is a later, additive step. */
@@ -83,6 +83,8 @@ export let View3d: ParentComponent<View3dProps> = props => {
       filter: props.filter,
       wrap: props.wrap,
       into: props.into,
+      resolve: props.resolve,
+      bloom: props.bloom,
     })
     if (props.camera) v.setCamera(props.camera)
     return v
@@ -107,6 +109,13 @@ export let View3d: ParentComponent<View3dProps> = props => {
     l => view.setLayers(l ?? 1),
     { defer: true },
   )
+  // A bloom prop that changes claims the view's own (undefined = off);
+  // one never given leaves the view following the scene's.
+  createEffect(
+    () => props.bloom,
+    b => view.setBloom(b ?? null),
+    { defer: true },
+  )
   untrack(() => props.ref)?.(view)
   onCleanup(() => view.dispose())
   // The pointer feed the app handed in (see Scene) listens at the view's
@@ -126,6 +135,14 @@ export let View3d: ParentComponent<View3dProps> = props => {
   )
   let output = untrack(() => props.output)
   let events = untrack(() => props.events) !== false
+  // A feed on a built-in leaf carrying no handlers listens at a root no
+  // event reaches: a contradiction, so it throws (the dev validation
+  // policy) instead of feeding nothing.
+  if (pointer !== null && !events && !output) {
+    throw new Error(
+      "View3d: a pointer feed with events={false} receives nothing - the feed listens at the view's root, which only the leaf's handlers reach; keep events on, or compose the leaf with output and spread view.handlers on it",
+    )
+  }
   return (
     <SceneContext value={{ scene: ctx.scene, parent: ctx.parent, viewport: view, pointer }}>
       {output ? (

package/src/environment.ts

@@ -262,14 +262,15 @@ export type Prefilter = {
   dispose(): void
 }
 
-/** The format of a rendered radiance cube (a probe's faces, its chain, a
- * baked sky): half float where the device renders it, so the range of a
- * sun or an emissive survives into reflections as in every engine's HDR
- * probe, else 8-bit and clamped - the picture degrades, the app runs. Not
- * a knob: the renderer decides for all probes (Godot), HDR by default
+/** The format of every buffer the scene renders light into - a scene's
+ * or view's buffer, a probe's faces, its chain, a baked sky: half float
+ * where the device renders it, so the range of a sun or an emissive
+ * survives into the resolve and into reflections as in every engine's HDR
+ * path, else 8-bit and clamped - the picture degrades, the app runs. Not
+ * a knob: the renderer decides for every target (Godot), HDR by default
  * (Unity). */
-export type ProbeFormat = "rgba8" | "rgba16f"
-export function probeFormat(): ProbeFormat {
+export type BufferFormat = "rgba8" | "rgba16f"
+export function bufferFormat(): BufferFormat {
   return limits.halfFloatRenderable ? "rgba16f" : "rgba8"
 }
 
@@ -282,7 +283,7 @@ export function probeFormat(): ProbeFormat {
  * convolution, on the same roughness-to-level rule as the .srte chain
  * (levelRoughness), so `standard` reads both alike.
  */
-export function createPrefilter(size: number, source: TextureId, format: ProbeFormat, label: string): Prefilter {
+export function createPrefilter(size: number, source: TextureId, format: BufferFormat, label: string): Prefilter {
   let pass: ReturnType<typeof facePipeline> | null = facePipeline(PREFILTER_FACE, label + "-prefilter")
   let cube = createCubeDrawTarget(size, null, { mipmap: true, format, autoFree: false, label })
   let entry = addDraw(cube, pass.pipeline, { uFace: 0, uRoughness: 0 }, { vertexCount: 3, textures: { uSource: source } })

package/src/first-person.ts

@@ -19,15 +19,25 @@
 // forward vector onto the ground plane at fixed height; flying moves
 // along the view direction.
 //
+// The pose moves on its own in one way only: toward a goal pose set by
+// glideTo, eased by update(dt) (motion.ts, the orbit camera's motion).
+// Any input drops the glide - a walker who touches the controls has the
+// camera back - and a pose write through set() lands at once and drops
+// it too. There is no damping here: this control's unbracketed delta is
+// mouse motion under pointer lock, and easing THAT is the thing a
+// first-person player will not forgive.
+//
 // Pose is plain mutable state; a nudge or a verb pushes it at once (a
 // mouse move under lock needs no frame loop), and update(dt) integrates
-// the rates from the app's own onFrame. Only `active` is reactive: the
-// frame-loop gate, true while any rate reads non-zero (a held key, a
-// deflected stick), so a still scene renders nothing new. update()
-// returns whether the pose changed since the previous update.
+// the rates and the glide from the app's own onFrame. Only `active` is
+// reactive: the frame-loop gate, true while any rate reads non-zero (a
+// held key, a deflected stick) or a glide is in flight, so a still scene
+// renders nothing new. update() returns whether the pose changed since
+// the previous update.
 //
 // Collision is deliberately absent: a camera control cannot know the
-// level. Clamp or reject positions through `clampPosition`.
+// level. Clamp or reject positions through `clampPosition`, which a
+// glide consults every frame as a walk does every step.
 //
 // Options are read where they apply, not copied out: `fly`, `moveSpeed`,
 // `lookSpeed`, the pitch clamps and `clampPosition` are re-read from the
@@ -37,11 +47,12 @@
 // control, not two mounts. Only the initial pose is copied at creation;
 // later pose changes go through set() and the verbs.
 
-import { untrack } from "@solidjs/signals"
+import { createMemo, createSignal, untrack } from "@solidjs/signals"
 import { createAxes } from "@solidrt/core/input"
 import type { Axes, Vec2 } from "@solidrt/core/input"
 import type { CameraUpdate } from "./camera.ts"
 import type { Vec3 } from "./math.ts"
+import { easeStep, GLIDE_EASE, GLIDE_EPSILON } from "./motion.ts"
 
 // One element height of drag sweeps this many turns of look (half a turn:
 // a drag across the screen turns the walker around).
@@ -57,18 +68,17 @@ const PITCH_LIMIT = Math.PI / 2 - 0.01
 /** What a first-person camera drives: a Scene, or one of its Views. */
 export type FirstPersonTarget = { setCamera(update: CameraUpdate): void }
 
+/** A full pose: what pose() returns. */
+export type FirstPersonPoseState = { position: Vec3; yaw: number; pitch: number }
+
+/** A partial pose: what set() and glideTo() take. */
+export type FirstPersonPose = Partial<FirstPersonPoseState>
+
 /** The pose fields (position, yaw, pitch) are initial values, copied at
  * creation and changed through set() afterwards. Every other field is
  * live: read from this object where it applies, so a change takes effect
  * on the next input or update. */
-export type FirstPersonCameraOptions = {
-  /** Initial eye position (default [0, 1.6, 0]: standing height at the
-   * origin). */
-  position?: Vec3
-  /** Initial look, radians. Yaw 0 faces -z (the camera default), positive
-   * turns left; pitch 0 is level, positive looks up. */
-  yaw?: number
-  pitch?: number
+export type FirstPersonCameraOptions = FirstPersonPose & {
   /** Pitch clamps, radians; the defaults stop just short of the poles. */
   minPitch?: number
   maxPitch?: number
@@ -85,17 +95,11 @@ export type FirstPersonCameraOptions = {
   /** Constrain where a move may put the eye: called with the eye the
    * move asks for and the eye it starts from (both fresh arrays), returns
    * the position to use - a level's bounds, a floor height, a collision
-   * controller's `moveAndSlide` over the difference. Look does not
-   * consult it. */
+   * controller's `moveAndSlide` over the difference. A glide consults it
+   * every frame. Look does not. */
   clampPosition?: (next: Vec3, current: Vec3) => Vec3
 }
 
-export type FirstPersonPose = {
-  position?: Vec3
-  yaw?: number
-  pitch?: number
-}
-
 export type FirstPersonAxes = { look: "vec2"; move: "vec2"; rise: "axis" }
 
 export type FirstPersonCamera = {
@@ -104,15 +108,22 @@ export type FirstPersonCamera = {
   /** Unit look direction for the current pose (a fresh array per call). */
   forward(): Vec3
   /** Pose snapshot - the shape debug commands return and set() takes. */
-  pose(): { position: Vec3; yaw: number; pitch: number }
-  /** Merge a pose in (clamps apply) and push it. */
+  pose(): FirstPersonPoseState
+  /** Merge a pose in (clamps apply) and push it: a snap, dropping a glide
+   * in flight when it writes a pose field. */
   set(pose: FirstPersonPose): void
-  /** Whether any axis rate reads non-zero - what a frame loop should run
-   * on. Reactive. */
+  /** Ease to a pose (the fields given, the rest as they are; the pitch
+   * clamp applies, `clampPosition` every frame) inside update(dt).
+   * Dropped by any input and by a set() that writes a pose field; a new
+   * glideTo retargets. Yaw eases to the number given, not the shortest
+   * turn: pass the turn you mean. */
+  glideTo(pose: FirstPersonPose): void
+  /** Whether update(dt) has work: any axis rate non-zero, or a glide in
+   * flight. The frame-loop gate, reactive. */
   active(): boolean
-  /** Integrate the axis rates over dt seconds and push any pose change;
-   * returns whether the pose changed since the previous update (nudges
-   * and verbs included). */
+  /** Integrate the axis rates and the glide over dt seconds and push any
+   * pose change; returns whether the pose changed since the previous
+   * update (nudges and verbs included). */
   update(dt: number): boolean
   /** The input abstraction: `look` (vec2, element heights of drag / turns
    * per second), `move` (vec2 [right, forward], forward = -y; world units
@@ -127,12 +138,25 @@ export type FirstPersonCamera = {
   moveBy(right: number, forward: number, up?: number): void
 }
 
+// The goal pose a glide eases toward (see the header).
+type Motion = FirstPersonPoseState & {
+  /** The fraction of the initial gap still open. */
+  remaining: number
+}
+
 let clampNum = (v: number, lo: number, hi: number) => Math.min(hi, Math.max(lo, v))
+let copy = (v: Vec3): Vec3 => [v[0], v[1], v[2]]
 
 function finite(what: string, v: number): void {
   if (!Number.isFinite(v)) throw new Error(`createFirstPersonCamera: ${what} must be a finite number, got ${v}`)
 }
 
+function checkPose(verb: string, pose: FirstPersonPose): void {
+  if (pose.yaw !== undefined) finite(`${verb} yaw`, pose.yaw)
+  if (pose.pitch !== undefined) finite(`${verb} pitch`, pose.pitch)
+  if (pose.position) for (let i = 0; i < 3; i++) finite(`${verb} position[${i}]`, pose.position[i]!)
+}
+
 /**
  * Create a first-person camera driving `camera`'s position and target,
  * where `camera` is a Scene or one of its Views (fov, near, and far stay
@@ -143,16 +167,31 @@ function finite(what: string, v: number): void {
  */
 export function createFirstPersonCamera(camera: FirstPersonTarget, options: FirstPersonCameraOptions = {}): FirstPersonCamera {
   if (!camera || typeof camera.setCamera !== "function") throw new Error("createFirstPersonCamera: the target needs setCamera() (a Scene or a View)")
-  let position: Vec3 = options.position ? [options.position[0], options.position[1], options.position[2]] : [0, 1.6, 0]
+  checkPose("initial", options)
+  let position: Vec3 = options.position ? copy(options.position) : [0, 1.6, 0]
   let yaw = options.yaw ?? 0
   let pitch = options.pitch ?? 0
   // Everything below the pose is read from `options` where it applies.
   let lookSpeed = () => options.lookSpeed ?? 1
   let moveSpeed = () => options.moveSpeed ?? MOVE_SPEED
+  let clampedPitch = (v: number) => clampNum(v, options.minPitch ?? -PITCH_LIMIT, options.maxPitch ?? PITCH_LIMIT)
   let clampPitch = () => {
-    pitch = clampNum(pitch, options.minPitch ?? -PITCH_LIMIT, options.maxPitch ?? PITCH_LIMIT)
+    pitch = clampedPitch(pitch)
   }
+  let clampedPosition = (next: Vec3): Vec3 => (options.clampPosition ? options.clampPosition(next, copy(position)) : next)
   let changed = false
+  // The glide in flight, and its half of active(): a signal every entry
+  // that starts or drops it refreshes (ownedWrite: entries run from
+  // component bodies and handlers alike).
+  let motion: Motion | null = null
+  let [motionActive, setMotionActive] = createSignal(false, { ownedWrite: true })
+  let notify = () => {
+    let now = motion !== null
+    if (now !== untrack(motionActive)) setMotionActive(now)
+  }
+  let interrupt = () => {
+    motion = null
+  }
 
   let forward = (): Vec3 => {
     let cp = Math.cos(pitch)
@@ -161,7 +200,7 @@ export function createFirstPersonCamera(camera: FirstPersonTarget, options: Firs
   let push = () => {
     changed = true
     let f = forward()
-    camera.setCamera({ position: [position[0], position[1], position[2]], target: [position[0] + f[0], position[1] + f[1], position[2] + f[2]] })
+    camera.setCamera({ position: copy(position), target: [position[0] + f[0], position[1] + f[1], position[2] + f[2]] })
   }
   let look = (dYaw: number, dPitch: number) => {
     yaw += dYaw
@@ -180,14 +219,36 @@ export function createFirstPersonCamera(camera: FirstPersonTarget, options: Firs
     let rx = Math.cos(yaw)
     let rz = -Math.sin(yaw)
     let rise = fly ? up : 0
-    let next: Vec3 = [position[0] + fx * ahead + rx * right, position[1] + fy * ahead + rise, position[2] + fz * ahead + rz * right]
-    position = options.clampPosition ? options.clampPosition(next, [position[0], position[1], position[2]]) : next
+    position = clampedPosition([position[0] + fx * ahead + rx * right, position[1] + fy * ahead + rise, position[2] + fz * ahead + rz * right])
+  }
+  // One frame of the glide: the ease closes the gap by the same fraction
+  // on every component, the last fraction snapping to the goal.
+  let glideStep = (dt: number) => {
+    let m = motion!
+    let k = easeStep(GLIDE_EASE, dt)
+    m.remaining *= 1 - k
+    if (m.remaining < GLIDE_EPSILON) {
+      yaw = m.yaw
+      pitch = m.pitch
+      position = clampedPosition(copy(m.position))
+      motion = null
+    } else {
+      yaw += (m.yaw - yaw) * k
+      pitch += (m.pitch - pitch) * k
+      position = clampedPosition([position[0] + (m.position[0] - position[0]) * k, position[1] + (m.position[1] - position[1]) * k, position[2] + (m.position[2] - position[2]) * k])
+    }
+    clampPitch()
   }
 
   let axes = createAxes<FirstPersonAxes>(
     { look: "vec2", move: "vec2", rise: "axis" },
     {
+      onBegin: () => {
+        interrupt()
+        notify()
+      },
       onNudge: (name, delta) => {
+        interrupt()
         if (name === "look") {
           let d = delta as Vec2
           let rel = DRAG_TURNS * 2 * Math.PI * lookSpeed()
@@ -199,26 +260,41 @@ export function createFirstPersonCamera(camera: FirstPersonTarget, options: Firs
           step(0, 0, delta as number)
         }
         push()
+        notify()
       },
     },
   )
+  let active = createMemo(() => motionActive() || axes.active())
 
   clampPitch()
   push()
   changed = false
 
   return {
-    eye: () => [position[0], position[1], position[2]],
+    eye: () => copy(position),
     forward,
-    pose: () => ({ position: [position[0], position[1], position[2]], yaw, pitch }),
-    active: axes.active,
+    pose: () => ({ position: copy(position), yaw, pitch }),
+    active,
     axes,
     set(pose) {
-      if (pose.position) position = [pose.position[0], pose.position[1], pose.position[2]]
+      checkPose("set", pose)
+      if (pose.position || pose.yaw !== undefined || pose.pitch !== undefined) interrupt()
+      if (pose.position) position = copy(pose.position)
       if (pose.yaw !== undefined) yaw = pose.yaw
       if (pose.pitch !== undefined) pitch = pose.pitch
       clampPitch()
       push()
+      notify()
+    },
+    glideTo(pose) {
+      checkPose("glideTo", pose)
+      motion = {
+        position: pose.position ? copy(pose.position) : copy(position),
+        yaw: pose.yaw ?? yaw,
+        pitch: clampedPitch(pose.pitch ?? pitch),
+        remaining: 1,
+      }
+      notify()
     },
     update(dt) {
       finite("update dt", dt)
@@ -226,6 +302,7 @@ export function createFirstPersonCamera(camera: FirstPersonTarget, options: Firs
       let [lx, ly] = untrack(() => axes.rate("look"))
       if (lx !== 0 || ly !== 0) {
         let rate = LOOK_RATE * 2 * Math.PI * lookSpeed() * dt
+        interrupt()
         look(-lx * rate, -ly * rate)
         moved = true
       }
@@ -233,10 +310,16 @@ export function createFirstPersonCamera(camera: FirstPersonTarget, options: Firs
       let rise = untrack(() => axes.rate("rise"))
       if (mx !== 0 || my !== 0 || rise !== 0) {
         let speed = moveSpeed() * dt
+        interrupt()
         step(mx * speed, -my * speed, rise * speed)
         moved = true
       }
+      if (motion !== null && dt > 0) {
+        glideStep(dt)
+        moved = true
+      }
       if (moved) push()
+      notify()
       let result = changed
       changed = false
       return result
@@ -244,15 +327,19 @@ export function createFirstPersonCamera(camera: FirstPersonTarget, options: Firs
     lookBy(dYaw, dPitch) {
       finite("lookBy yaw", dYaw)
       finite("lookBy pitch", dPitch)
+      interrupt()
       look(dYaw, dPitch)
       push()
+      notify()
     },
     moveBy(right, ahead, up = 0) {
       finite("moveBy right", right)
       finite("moveBy forward", ahead)
       finite("moveBy up", up)
+      interrupt()
       step(right, ahead, up)
       push()
+      notify()
     },
   }
 }