@solidrt/3d 0.0.56 → 0.0.58

package/examples/scene-views.tsx

@@ -1,20 +1,21 @@
 // One scene, three renderings: the built-in leaf from a perspective
-// camera, plus two `scene.createView` targets - a top-down ORTHOGRAPHIC
-// map (`ortho` on setCamera) and a side silhouette drawn with an
+// camera, plus two `<View3d>`s - a top-down ORTHOGRAPHIC map (`ortho` in
+// the view's `camera`) and a side silhouette drawn with an
 // `overrideMaterial`. The group spins from ONE signal: each mesh is one
 // core node whose flush writes its world matrix into every target's entry
 // at once, so the extra views cost the app nothing per frame (and the
 // light set fans out to them too - the map is lit like the main view).
-// Views die with the scene.
+// A view is a Scene child: it renders its own `<texture>` leaf where it
+// sits, so the two stack in the column beside the scene's leaf, and it
+// dies with the scene.
 //
 // Layers and per-view fog: the marker disc is on layer bit 2, so the
 // main render (mask 1) and the silhouette never draw it - only the map,
-// whose mask admits both bits. The scene is fogged; `fog: null` on the
+// whose mask admits both bits. The scene is fogged; `fog={null}` on the
 // map keeps the top-down view clear (its fog names are view-owned, so
 // scene-wide fog writes never clobber them).
 import { createSignal, onFrame, pct, render } from "@solidrt/core"
-import { box, circle, DirectionalLight, Group, HemisphereLight, lit, Mesh, PerspectiveCamera, plane, Scene, sphere, unlit } from "@solidrt/3d"
-import type { SceneHandle } from "@solidrt/3d"
+import { box, circle, DirectionalLight, Group, HemisphereLight, lit, Mesh, PerspectiveCamera, plane, Scene, sphere, unlit, View3d } from "@solidrt/3d"
 
 // Layer bits: the world everything defaults to, and the map-only markers.
 const WORLD_LAYER = 1
@@ -31,67 +32,16 @@ function App() {
   let floor = plane({ width: 6, height: 6, label: "floor" })
   let ball = sphere({ radius: 0.35 })
   let marker = circle({ radius: 0.3, label: "marker" })
-  // `ref` runs before `output`, so the handle is set when the views are
-  // created there; both callbacks run once, untracked - no signals needed.
-  let scene!: SceneHandle
 
   return (
     <window>
-      <view width={pct(100)} height={pct(100)} designSize={[MAIN + SIDE, MAIN]}>
+      <view width={pct(100)} height={pct(100)} designSize={[MAIN + SIDE, MAIN]} flexDirection="row">
         <Scene
           width={MAIN}
           height={MAIN}
           clearColor={[0.07, 0.07, 0.1, 1]}
           fog={{ color: [0.07, 0.07, 0.1], near: 2.5, far: 9 }}
           label="scene-views"
-          ref={s => (scene = s)}
-          output={tex => {
-            // The map: straight down from y = 10, world -z toward the top of
-            // the leaf, seven world units across at any depth. Its mask also
-            // admits the marker layer, and `fog: null` keeps it clear while
-            // the main view fades to the horizon.
-            let map = scene.createView({
-              width: SIDE,
-              height: SIDE,
-              clearColor: [0.05, 0.08, 0.06, 1],
-              layers: WORLD_LAYER | MARKER_LAYER,
-              fog: null,
-              label: "map",
-            })
-            map.setCamera({
-              position: [0, 10, 0],
-              target: [0, 0, 0],
-              up: [0, 0, -1],
-              ortho: { left: -3.5, right: 3.5, top: 3.5, bottom: -3.5 },
-              near: 0.1,
-              far: 20,
-            })
-            // The silhouette: every mesh drawn flat amber, from the side. The
-            // floor is edge-on here, a single line at the bottom.
-            let side = scene.createView({
-              width: SIDE,
-              height: SIDE,
-              clearColor: [0.1, 0.06, 0.05, 1],
-              overrideMaterial: unlit({ color: [0.95, 0.75, 0.3] }),
-              label: "silhouette",
-            })
-            side.setCamera({
-              position: [6, 1, 0],
-              target: [0, 0.6, 0],
-              ortho: { left: -2.4, right: 2.4, top: 2.4, bottom: -2.4 },
-              near: 0.1,
-              far: 20,
-            })
-            return (
-              <view flexDirection="row" width={MAIN + SIDE} height={MAIN}>
-                <texture src={tex} width={MAIN} height={MAIN} />
-                <view flexDirection="column" width={SIDE} height={MAIN}>
-                  <texture src={map.texture} width={SIDE} height={SIDE} />
-                  <texture src={side.texture} width={SIDE} height={SIDE} />
-                </view>
-              </view>
-            )
-          }}
         >
           <PerspectiveCamera fov={55} position={[0, 1.6, 3.6]} lookAt={[0, 0.3, 0]} />
           <HemisphereLight sky={[0.6, 0.7, 0.9]} ground={[0.25, 0.2, 0.15]} intensity={0.6} />
@@ -115,6 +65,47 @@ function App() {
               rotation={[-Math.PI / 2, 0, 0]}
             />
           </Group>
+          {/* The two views' leaves stack beside the scene's: a laid-out
+              element among Scene children renders where it sits, and the
+              views inside it stay Scene children through context. */}
+          <view flexDirection="column" width={SIDE} height={MAIN}>
+            {/* The map: straight down from y = 10, world -z toward the top
+                of the leaf, seven world units across at any depth. Its mask
+                also admits the marker layer, and `fog={null}` keeps it clear
+                while the main view fades to the horizon. */}
+            <View3d
+              width={SIDE}
+              height={SIDE}
+              clearColor={[0.05, 0.08, 0.06, 1]}
+              layers={WORLD_LAYER | MARKER_LAYER}
+              fog={null}
+              label="map"
+              camera={{
+                position: [0, 10, 0],
+                target: [0, 0, 0],
+                up: [0, 0, -1],
+                ortho: { left: -3.5, right: 3.5, top: 3.5, bottom: -3.5 },
+                near: 0.1,
+                far: 20,
+              }}
+            />
+            {/* The silhouette: every mesh drawn flat amber, from the side.
+                The floor is edge-on here, a single line at the bottom. */}
+            <View3d
+              width={SIDE}
+              height={SIDE}
+              clearColor={[0.1, 0.06, 0.05, 1]}
+              overrideMaterial={unlit({ color: [0.95, 0.75, 0.3] })}
+              label="silhouette"
+              camera={{
+                position: [6, 1, 0],
+                target: [0, 0.6, 0],
+                ortho: { left: -2.4, right: 2.4, top: 2.4, bottom: -2.4 },
+                near: 0.1,
+                far: 20,
+              }}
+            />
+          </view>
         </Scene>
       </view>
     </window>

package/examples/sky-lit.tsx

@@ -9,9 +9,9 @@
 // gradient. The sky is a scene param (uSunDir), so the bake sees the same
 // sun the backdrop draws. Drag to look around.
 
-import { pct, render } from "@solidrt/core"
+import { createInputMap, createPointerFeed, gamepad, pct, render } from "@solidrt/core"
 import { glsl } from "@solidrt/core/gpu"
-import { Mesh, OrbitCamera, Scene, sphere, standard } from "@solidrt/3d"
+import { Mesh, OrbitCamera, orbitActions, orbitBindings, Scene, sphere, standard } from "@solidrt/3d"
 import type { SceneHandle } from "@solidrt/3d"
 import { normalize } from "@solidrt/3d/math"
 import type { Vec3 } from "@solidrt/3d/math"
@@ -55,6 +55,12 @@ const SKY = glsl`
 `
 
 function App() {
+  // The camera's input: the scene leaf's gestures and any pad, bound to the
+  // orbit control's actions - the app wires devices, the component takes
+  // the map (ARCHITECTURE.md).
+  let pointer = createPointerFeed()
+  let input = createInputMap(orbitActions)
+  input.bind(orbitBindings({ pointer, gamepad: gamepad() }))
   let spheres: { position: Vec3; material: ReturnType<typeof standard> }[] = []
   for (let i = 0; i < COUNT; i++) {
     let roughness = i / (COUNT - 1)
@@ -72,8 +78,8 @@ function App() {
   return (
     <window>
       <view width={pct(100)} height={pct(100)}>
-        <Scene background={SKY} toneMapping="aces" samples={4} label="sky-lit" ref={lit}>
-          <OrbitCamera target={[0, 0, 0]} azimuth={0.3} elevation={0.15} distance={7} />
+        <Scene background={SKY} toneMapping="aces" samples={4} label="sky-lit" ref={lit} pointer={pointer}>
+          <OrbitCamera input={input} target={[0, 0, 0]} azimuth={0.3} elevation={0.15} distance={7} />
           {spheres.map(s => (
             <Mesh geometry={geometry} material={s.material} position={s.position} />
           ))}

package/examples/skybox.tsx

@@ -11,9 +11,9 @@
 // equirectToCube on a panorama. The sky turns slowly and the sun light
 // turns with it: `rotation` is a reactive prop the scene updates in
 // place, no recompile. Drag to look around, wheel to zoom.
-import { createSignal, onFrame, pct, render } from "@solidrt/core"
+import { createInputMap, createPointerFeed, createSignal, gamepad, onFrame, pct, render } from "@solidrt/core"
 import { createCubeTexture } from "@solidrt/core/gpu"
-import { box, DirectionalLight, HemisphereLight, lit, Mesh, OrbitCamera, plane, Scene, sphere, torusKnot } from "@solidrt/3d"
+import { box, DirectionalLight, HemisphereLight, lit, Mesh, OrbitCamera, orbitActions, orbitBindings, plane, Scene, sphere, torusKnot } from "@solidrt/3d"
 import { normalize } from "@solidrt/3d/math"
 import type { Vec3 } from "@solidrt/3d/math"
 
@@ -92,6 +92,12 @@ function turnedSun(angle: number): Vec3 {
 }
 
 function App() {
+  // The camera's input: the scene leaf's gestures and any pad, bound to the
+  // orbit control's actions - the app wires devices, the component takes
+  // the map (ARCHITECTURE.md).
+  let pointer = createPointerFeed()
+  let input = createInputMap(orbitActions)
+  input.bind(orbitBindings({ pointer, gamepad: gamepad() }))
   let cube = createCubeTexture(bakeSky(), FACE, { format: "rgba8-srgb", mipmap: true, label: "sky" })
   let [turn, setTurn] = createSignal(0)
   let last = 0
@@ -111,8 +117,8 @@ function App() {
   return (
     <window>
       <view width={pct(100)} height={pct(100)}>
-        <Scene background={{ cube, rotation: turn() }} environment={{ cube, rotation: turn() }} label="skybox-demo">
-          <OrbitCamera azimuth={0.4} elevation={0.12} distance={7} />
+        <Scene background={{ cube, rotation: turn() }} environment={{ cube, rotation: turn() }} label="skybox-demo" pointer={pointer}>
+          <OrbitCamera input={input} azimuth={0.4} elevation={0.12} distance={7} />
           <HemisphereLight sky={[0.5, 0.6, 0.8]} ground={[0.3, 0.27, 0.24]} />
           <DirectionalLight direction={[-sun()[0], -sun()[1], -sun()[2]]} color={SUN_COLOR} intensity={0.9} />
           <Mesh geometry={plane({ width: 12, height: 12 })} material={ground} rotation={[-Math.PI / 2, 0, 0]} />

package/examples/standard.tsx

@@ -12,9 +12,9 @@
 // Light intensities read as lit's: 1 lights a white matte surface to 1.
 // Drag to look around.
 
-import { pct, render } from "@solidrt/core"
+import { createInputMap, createPointerFeed, gamepad, pct, render } from "@solidrt/core"
 import { createCubeTexture } from "@solidrt/core/gpu"
-import { DirectionalLight, HemisphereLight, Mesh, OrbitCamera, plane, Scene, sphere, standard } from "@solidrt/3d"
+import { DirectionalLight, HemisphereLight, Mesh, OrbitCamera, orbitActions, orbitBindings, plane, Scene, sphere, standard } from "@solidrt/3d"
 import { normalize } from "@solidrt/3d/math"
 import type { Vec3 } from "@solidrt/3d/math"
 
@@ -91,6 +91,12 @@ function bakeSky(): Uint8Array[] {
 }
 
 function App() {
+  // The camera's input: the scene leaf's gestures and any pad, bound to the
+  // orbit control's actions - the app wires devices, the component takes
+  // the map (ARCHITECTURE.md).
+  let pointer = createPointerFeed()
+  let input = createInputMap(orbitActions)
+  input.bind(orbitBindings({ pointer, gamepad: gamepad() }))
   let cube = createCubeTexture(bakeSky(), FACE, { format: "rgba8-srgb", mipmap: true, label: "sky" })
   let ball = sphere({ radius: RADIUS, widthSegments: 48, heightSegments: 32 })
   let ground = standard({ color: [0.32, 0.33, 0.3], roughness: 0.9 })
@@ -109,8 +115,8 @@ function App() {
   return (
     <window>
       <view width={pct(100)} height={pct(100)}>
-        <Scene background={{ cube }} environment={{ cube }} samples={4} label="standard-demo">
-          <OrbitCamera target={center} azimuth={0.25} elevation={0.15} distance={9} />
+        <Scene background={{ cube }} environment={{ cube }} samples={4} label="standard-demo" pointer={pointer}>
+          <OrbitCamera input={input} target={center} azimuth={0.25} elevation={0.15} distance={9} />
           <HemisphereLight sky={[0.5, 0.6, 0.8]} ground={[0.3, 0.27, 0.24]} intensity={0.5} />
           <DirectionalLight
             position={[SUN[0] * SUN_DISTANCE, SUN[1] * SUN_DISTANCE, SUN[2] * SUN_DISTANCE]}

package/examples/wireframe.tsx

@@ -0,0 +1,107 @@
+// The rover drawn solid, as a wireframe or as its feature edges. Both line
+// forms are GEOMETRY: wireframeGeometry lists every edge of a triangle
+// geometry once, edgesGeometry only the edges where two faces meet at the
+// threshold angle or more (plus the open borders), each as a "lines"
+// geometry over the source's OWN vertex array. The topology rides on the
+// geometry, so the plain unlit material draws it as lines, and the vertex
+// upload is shared, so a mode costs an index buffer, not a second model.
+// The swap is setGeometry + setMaterial on the live mesh: the node, its
+// transform and its pointer handlers are untouched. Space, a tap on the
+// rover or the `wire` debug command ({ mode }) cycles the modes.
+
+import { createSignal, onFrame, pct, render } from "@solidrt/core"
+import { createTexture } from "@solidrt/core/gpu"
+import type { TextureId } from "@solidrt/core/gpu"
+import { registerDebug } from "srt:dev"
+import { add, createModel, DirectionalLight, edgesGeometry, equirectToCube, Group, parseGltf, PerspectiveCamera, Scene, setGeometry, setMaterial, unlit, wireframeGeometry } from "@solidrt/3d"
+import type { SceneNode } from "@solidrt/3d"
+import modelBytes from "./model.glb" with { type: "binary" }
+
+const MODES = ["solid", "wireframe", "edges"] as const
+type Mode = (typeof MODES)[number]
+// Feature-edge threshold in degrees: above the facet angle of the rover's
+// rounded parts, so their seams stay hidden and only rims and creases draw.
+const EDGE_ANGLE = 20
+const LINE_COLOR: [number, number, number] = [0.85, 0.95, 1]
+// Face edge of the gradient environment cube: a gradient needs no detail.
+const ENV_FACE = 16
+// The gradient, zenith to nadir, sRGB bytes: sky, horizon, ground, below.
+const ENV_ROWS: [number, number, number][] = [
+  [96, 122, 168],
+  [176, 190, 210],
+  [120, 105, 90],
+  [60, 52, 45],
+]
+
+// A tiny equirectangular panorama turned into the cube the solid rover's
+// standard materials light by (see model.tsx).
+function gradientEnvironment(): TextureId {
+  let px = new Uint8Array(2 * ENV_ROWS.length * 4)
+  ENV_ROWS.forEach((c, y) => {
+    for (let x = 0; x < 2; x++) px.set([c[0], c[1], c[2], 255], (y * 2 + x) * 4)
+  })
+  let panorama = createTexture(px, 2, ENV_ROWS.length, { format: "rgba8-srgb", filter: "linear" })
+  return equirectToCube(panorama, ENV_FACE, { format: "rgba8-srgb", mipmap: true, label: "gradient-env" })
+}
+
+function App() {
+  let cube = gradientEnvironment()
+  let [t, setT] = createSignal(0)
+  onFrame(tick => setT(tick / 1000))
+
+  let model = createModel(parseGltf(modelBytes), { label: "rover" })
+  let b = model.bounds
+  let center: [number, number, number] = [(b[0]! + b[3]!) / 2, (b[1]! + b[4]!) / 2, (b[2]! + b[5]!) / 2]
+  let radius = Math.hypot(b[3]! - b[0]!, b[4]! - b[1]!, b[5]! - b[2]!) / 2
+
+  // One line material for every part and both line modes. Per part, what
+  // each mode swaps in: the line geometries share the solid's vertices,
+  // so building both up front costs their index buffers only.
+  let lines = unlit({ color: LINE_COLOR })
+  let looks = model.parts.map(part => ({
+    mesh: part.mesh,
+    solid: { geometry: part.mesh.geometry, material: part.mesh.material },
+    wireframe: wireframeGeometry(part.mesh.geometry),
+    edges: edgesGeometry(part.mesh.geometry, EDGE_ANGLE),
+  }))
+  let mode: Mode = "solid"
+  let apply = (next: Mode): void => {
+    mode = next
+    for (let look of looks) {
+      // Each call rebuilds the draw entry, so the intermediate state is
+      // always the line material over the solid's triangles - a pipeline
+      // unlit has anyway - never the solid material over lines.
+      if (next === "solid") {
+        setGeometry(look.mesh, look.solid.geometry)
+        setMaterial(look.mesh, look.solid.material)
+      } else {
+        setMaterial(look.mesh, lines)
+        setGeometry(look.mesh, look[next])
+      }
+    }
+  }
+  let cycle = (): void => apply(MODES[(MODES.indexOf(mode) + 1) % MODES.length]!)
+  for (let part of model.parts) part.mesh.onTap = cycle
+  registerDebug("wire", (args?: Record<string, unknown>) => {
+    if (typeof args?.mode === "string" && (MODES as readonly string[]).includes(args.mode)) apply(args.mode as Mode)
+    else cycle()
+  })
+
+  return (
+    <window
+      onKeyDown={e => {
+        if (e.key === " ") cycle()
+      }}
+    >
+      <view width={pct(100)} height={pct(100)}>
+        <Scene clearColor={[0.1, 0.11, 0.14, 1]} environment={{ cube }} samples={4} label="wireframe">
+          <PerspectiveCamera fov={40} position={[center[0] + radius * 1.4, center[1] + radius * 1.1, center[2] + radius * 2.2]} lookAt={center} />
+          <DirectionalLight direction={[0.5, -0.8, 0.3]} color={[1, 0.95, 0.85]} intensity={0.9} />
+          <Group rotation={[0, t() / 3, 0]} ref={(g: SceneNode) => add(g, model)} />
+        </Scene>
+      </view>
+    </window>
+  )
+}
+
+render(() => <App />)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/3d",
-  "version": "0.0.56",
+  "version": "0.0.58",
   "license": "MIT",
   "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",
@@ -19,6 +19,6 @@
   ],
   "peerDependencies": {
     "@solidjs/signals": "2.0.0-rc.6",
-    "@solidrt/core": "0.0.56"
+    "@solidrt/core": "0.0.58"
   }
 }

package/src/collision.ts

@@ -1,199 +1,20 @@
-// A kinematic character move over the scene's volume queries: Godot's
-// CharacterBody3D.move_and_slide and Unity's CharacterController.Move as
-// one pure function. Sweep the body along its motion, stop a skin short
-// of the first contact, slide the rest along the contact plane, repeat a
-// few times - with the two passes both engines wrap around that loop: a
-// depenetration first (a body that starts inside something is pushed out
-// before it moves) and a floor snap after (a body walking down a ramp is
-// pulled back onto it instead of stepping into the air). Per body per
-// frame that is the input read and this one call; the geometry runs in
-// the spatial core.
-//
-// Pure on purpose: no node, no velocity state. It takes a volume where the
-// body IS and the motion it WANTS, and returns the motion it gets plus
-// what it touched - the first-person camera (which has no node) composes
-// it in clampPosition, and a node-driven body applies the result with
-// setTransform. Gravity is the caller's: fold it into `motion`; a walkable
-// floor absorbs the vertical part (a body does not creep down a slope it
-// can stand on), a steep one slides it.
-
+// The kinematic character move, Godot's CharacterBody3D.move_and_slide
+// and Unity's CharacterController.Move as one pure function: no node, no
+// velocity state. It takes a volume where the body IS and the motion it
+// WANTS, and returns the motion it gets plus what it touched - the
+// first-person camera (which has no node) composes it in clampPosition,
+// a node-driven body applies the result with setTransform. The loop
+// itself (depenetration, sweep, slide, floor snap) runs in the spatial
+// core as scene.moveAndSlide; this is its free-function spelling.
+
+import type { MoveOptions, MoveResult, Scene, Volume } from "./scene.ts"
 import type { Vec3 } from "./math.ts"
-import type { Impact, QueryOptions, Scene, Volume } from "./scene.ts"
-
-/** Gap the body keeps from every surface, world units (Unity's skinWidth,
- * Godot's safe_margin): what keeps float error from sinking a resting body
- * into its floor. */
-const SKIN = 0.01
-/** Contacts within this angle of `up` are floor: 45 degrees, Godot's
- * floor_max_angle and Unity's slopeLimit. */
-const FLOOR_MAX_ANGLE = Math.PI / 4
-/** Most contacts one call slides along before it stops where it is
- * (Godot's max_slides). */
-const MAX_SLIDES = 6
-/** How far below the body a floor is pulled to while it is not rising
- * (Godot's floor_snap_length). */
-const FLOOR_SNAP = 0.1
-/** Passes of the depenetration loop, one contact set pushed out per pass
- * (Godot's recovery attempts). */
-const MAX_RECOVERIES = 4
-/** Motion below which a slide stops: nothing left worth sweeping. */
-const MIN_MOVE = 1e-6
-/** Floor of the approach cosine the skin is divided by to retreat along
- * the motion: a grazing contact retreats a few skins, not the whole step. */
-const SKIN_MIN_COS = 0.1
-
-const UP: Vec3 = [0, 1, 0]
 
 /** What moveAndSlide needs of a scene. */
-export type MoveScene = Pick<Scene, "sweep" | "overlap">
-
-export type MoveOptions = QueryOptions & {
-  /** The direction floors face (default [0, 1, 0]). */
-  up?: Vec3
-  /** Largest angle (radians) between a contact normal and `up` that still
-   * counts as floor (default 45 degrees). Steeper contacts are walls, and
-   * the body slides down them. */
-  floorMaxAngle?: number
-  /** Most contacts one call slides along (default 6). */
-  maxSlides?: number
-  /** Gap kept from every surface, world units (default 0.01). */
-  skin?: number
-  /** How far below the body a floor is pulled to when the motion does not
-   * rise (default 0.1; 0 disables): what keeps a walker on a ramp going
-   * down, and what decides `floor` at the end of the move - a body that
-   * ends higher than this above its floor is airborne, whatever it
-   * touched on the way. A rising motion (a jump) never snaps. */
-  floorSnap?: number
-}
+export type MoveScene = Pick<Scene, "moveAndSlide">
 
-export type MoveResult = {
-  /** The displacement the body gets: add it to the body's position. */
-  motion: Vec3
-  /** The unit normal of the floor the body ends the move on - within
-   * `floorSnap` below it, snapped onto - else null (airborne, or on a
-   * slope too steep to stand on). With `floorSnap: 0` it is a floor met
-   * during the move instead. */
-  floor: Vec3 | null
-  /** Whether a wall (a contact steeper than a floor and flatter than a
-   * ceiling) or a ceiling was met. */
-  wall: boolean
-  ceiling: boolean
-  /** Every contact met, in order, the floor snap's last. */
-  hits: Impact[]
-}
-
-/**
- * Move a body `motion` through the scene's colliders, sliding along what
- * it hits (Godot's move_and_slide, Unity's CharacterController.Move): a
- * capsule for a character, a sphere for a ball, a box for a crate. The
- * body first pushes out of anything it starts inside, then sweeps and
- * slides up to `maxSlides` times, then, unless the motion rises, snaps
- * down onto a floor within `floorSnap` - the floor it reports is the one
- * it ends on. Colliders are whatever `opts`
- * selects (`layers`/`meshes`, as for sweep): pass the collision layer,
- * or the body's own mesh answers for its own walls.
- *
- * Gravity is the caller's: fold the fall into `motion` each frame, zero
- * it while `floor` is set (the snap keeps reporting the floor while the
- * body stands still), and a walkable floor absorbs the vertical part -
- * `motion` only ever moves the body along a floor it stands on, never
- * down it.
- */
+/** Move a body `motion` through the scene's colliders, sliding along what
+ * it hits: scene.moveAndSlide as a function (see it for the contract). */
 export function moveAndSlide(scene: MoveScene, volume: Volume, motion: Vec3, opts: MoveOptions = {}): MoveResult {
-  let up = opts.up ?? UP
-  let floorCos = Math.cos(opts.floorMaxAngle ?? FLOOR_MAX_ANGLE)
-  let maxSlides = opts.maxSlides ?? MAX_SLIDES
-  let skin = opts.skin ?? SKIN
-  let snap = opts.floorSnap ?? FLOOR_SNAP
-  let query: QueryOptions = { layers: opts.layers, meshes: opts.meshes }
-  let offset: Vec3 = [0, 0, 0]
-  let hits: Impact[] = []
-  let floor: Vec3 | null = null
-  let wall = false
-  let ceiling = false
-
-  // Depenetration: every contact's push-out, each only as far as the
-  // pushes so far have not already covered along its normal, so two
-  // walls of a corner do not push twice.
-  for (let pass = 0; pass < MAX_RECOVERIES; pass++) {
-    let push: Vec3 = [0, 0, 0]
-    let any = false
-    for (let c of scene.overlap(shifted(volume, offset), query)) {
-      if (c.depth <= 0) continue
-      any = true
-      let extra = c.depth + skin - dot(push, c.normal)
-      if (extra > 0) push = add(push, scale(c.normal, extra))
-    }
-    if (!any) break
-    offset = add(offset, push)
-  }
-
-  let remaining: Vec3 = [motion[0], motion[1], motion[2]]
-  for (let slide = 0; slide < maxSlides; slide++) {
-    let len = Math.hypot(remaining[0], remaining[1], remaining[2])
-    if (len < MIN_MOVE) break
-    let hit = scene.sweep(shifted(volume, offset), remaining, query)[0]
-    if (hit === undefined) {
-      offset = add(offset, remaining)
-      break
-    }
-    hits.push(hit)
-    let dir = scale(remaining, 1 / len)
-    let n = hit.normal
-    // Stop where the gap to the surface, measured along its normal, is
-    // one skin; the sweep guarantees the approach is positive.
-    let retreat = skin / Math.max(-dot(dir, n), SKIN_MIN_COS)
-    let advance = Math.max(hit.time * len - retreat, 0)
-    offset = add(offset, scale(dir, advance))
-    remaining = scale(dir, len - advance)
-    let rise = dot(n, up)
-    if (rise >= floorCos) {
-      // A floor takes the vertical part (the fall, a landing) and passes
-      // the horizontal part along its plane.
-      floor = n
-      let level = sub(remaining, scale(up, dot(remaining, up)))
-      remaining = sub(level, scale(n, dot(level, n)))
-    } else {
-      if (rise <= -floorCos) ceiling = true
-      else wall = true
-      remaining = sub(remaining, scale(n, dot(remaining, n)))
-    }
-  }
-
-  // Where the body ends decides the floor: a contact met on the way
-  // (a ramp's top before a big step past its crest) is not one to stand
-  // on unless it is still within reach below.
-  if (snap > 0 && dot(motion, up) <= 0) {
-    floor = null
-    let hit = scene.sweep(shifted(volume, offset), scale(up, -snap), query)[0]
-    if (hit !== undefined && dot(hit.normal, up) >= floorCos) {
-      hits.push(hit)
-      let retreat = skin / Math.max(dot(hit.normal, up), SKIN_MIN_COS)
-      offset = add(offset, scale(up, -Math.max(hit.time * snap - retreat, 0)))
-      floor = hit.normal
-    }
-  }
-  return { motion: offset, floor, wall, ceiling, hits }
-}
-
-/** The volume displaced by `d`. */
-function shifted(volume: Volume, d: Vec3): Volume {
-  if ("center" in volume) return { ...volume, center: add(volume.center, d) }
-  return { ...volume, a: add(volume.a, d), b: add(volume.b, d) }
-}
-
-function add(a: Vec3, b: Vec3): Vec3 {
-  return [a[0] + b[0], a[1] + b[1], a[2] + b[2]]
-}
-
-function sub(a: Vec3, b: Vec3): Vec3 {
-  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]]
-}
-
-function scale(v: Vec3, s: number): Vec3 {
-  return [v[0] * s, v[1] * s, v[2] * s]
-}
-
-function dot(a: Vec3, b: Vec3): number {
-  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+  return scene.moveAndSlide(volume, motion, opts)
 }

package/src/components/context.tsx

@@ -0,0 +1,35 @@
+import { createContext, useContext } from "@solidrt/core"
+import type { Element, PointerFeed } from "@solidrt/core"
+import type { SceneNode } from "../node.ts"
+import type { Scene as SceneHandle } from "../scene.ts"
+import type { CameraState, CameraUpdate } from "../camera.ts"
+
+/** The camera state a camera control drives: the scene, or a view (both
+ * expose setCamera and camera()). */
+export type CameraTarget = { setCamera(update: CameraUpdate): void; camera(): CameraState }
+
+export type SceneCtx = { scene: SceneHandle; parent: SceneNode; viewport: CameraTarget; pointer: PointerFeed | null }
+export let SceneContext = createContext<SceneCtx>()
+
+/**
+ * The enclosing scene, parent node, viewport and pointer feed - the
+ * imperative escape hatch inside a component subtree (throws outside a
+ * `<Scene>`). `viewport` and `pointer` are the nearest OWNER's: the
+ * scene, or inside a `<View3d>` that view - what the camera-control
+ * components drive, and the feed the owner's `pointer` prop handed in
+ * (null when none was: the owner's leaf then feeds no gestures). The
+ * same shape as @solidrt/2d's useSpriteLayer.
+ */
+export function useScene(): SceneCtx {
+  return useContext(SceneContext)
+}
+
+// The scene context for a node component's children. Solid's provider is
+// a root and two memos over the children, paid even when there are none,
+// so it is built only when the JSX has children: the compiler emits the
+// `children` getter only then, so the test is structural, not a read
+// (probes/3d-instance-mount-bench.tsx has the per-row cost).
+export function provide(ctx: SceneCtx, parent: SceneNode, props: { children?: Element }): Element | undefined {
+  if (!("children" in props)) return undefined
+  return <SceneContext value={{ scene: ctx.scene, parent, viewport: ctx.viewport, pointer: ctx.pointer }}>{props.children}</SceneContext>
+}