@woosh/meep-engine 3.60.4 → 3.60.6

package/src/shade/playground/water_refraction/README.md

@@ -51,18 +51,17 @@ wave/object checks. NSS uses the renderer's existing weight requirement and fall
 when weights have not been installed; this standalone page does not supply NSS weights.
 
 Inspection modes display prepared coverage, receiver UV, bounded path, classification/update count,
-surface radiance, residual, RGB throughput, shared front throughput and water's normalization term.
+surface radiance, RGB throughput, shared front throughput and water's normalization term.
 They replace presentation **after** shared resolve and temporal processing, so diagnostics show
 the current frame's measurements without TAA history. Internal-resolution measurements are
 displayed with nearest sampling at the output resolution.
-Shift-click requests one pixel from four prepared textures on the next frame; normal frames perform
+Shift-click requests one pixel from three prepared textures on the next frame; normal frames perform
 no readback. Arrays are `receiver=[u,v,path,status+updates/32]`,
-`transmission=[Tr,Tg,Tb,coverage]`, `radiance=[Wr,Wg,Wb,residual]`.
+`transmission=[Tr,Tg,Tb,coverage]`, `radiance=[Wr,Wg,Wb,0]`.
 Status 0 is a converged Newton hit; codes 8–13 are validated HZB hits, 16–21 undisplaced opaque fallbacks,
 24–29 bounded sky fallbacks, and 31 the below-interface control. The low three bits preserve the
 Newton miss reason: 0 none/not attempted, 1 bounds/clip, 2 sky, 3 parallel/invalid, 4 ray interval,
-5 exhausted budget/residual. The probe decodes these names and the update count. Residual is capped
-at 65504 for half-float storage. The status display uses green/cyan/purple/orange/pink for those
+5 exhausted budget/residual. The probe decodes these names and the update count. The status display uses green/cyan/purple/orange/pink for those
 five final classes; red increases with update count.
 
 Compile check compiles the production water modules on the active device. Rendering exercises
@@ -90,7 +89,7 @@ takes a validated receiver at its whole displacement, however near an object, th
 edge it lies; a pixel without one shows its own undisplaced background. It then performs one
 geometry-aware color lookup, derives water thickness from that lookup's local receiver plane and
 builds its complete optical event. Nothing fades between the two lookups: any point between them is
-one the ray never reached (see 2026-10-16 below). The raw receiver/residual displays show classified
+one the ray never reached (see 2026-10-16 below). The raw receiver display shows classified
 misses. Screen reflections fade near the ray origin and frame
 edges to avoid self-hit speckles, reusing the existing SSR back-face/thickness/vignette validation.
 As in the paper, a converged Newton root is final: screen bounds plus the one-pixel and distance

package/src/shade/playground/water_refraction/index.html

@@ -33,7 +33,7 @@ input[type=range]{width:135px}input[type=number]{width:84px}input,select,button,
 <label>Internal scale<select id="resolution"><option value="1">1×</option><option value=".75">0.75×</option><option value=".5">0.5×</option></select></label>
 <label>Opaque SSR<input id="ssr" type="checkbox"></label><label>Atmospheric fog<input id="fog" type="checkbox"></label>
 <label>Transparency<select id="transparency"><option value="avboit">AVBOIT</option><option value="mboit">MBOIT (water unavailable)</option></select></label>
-<h2>Inspect</h2><label>Display<select id="debug"><option value="0">Final composite</option><option value="1">Coverage</option><option value="2">Receiver UV</option><option value="3">Water path</option><option value="4">Trace status / updates</option><option value="5">Surface radiance</option><option value="6">Residual</option><option value="7">RGB throughput</option><option value="8">Shared front throughput</option><option value="9">Water normalization</option></select></label>
+<h2>Inspect</h2><label>Display<select id="debug"><option value="0">Final composite</option><option value="1">Coverage</option><option value="2">Receiver UV</option><option value="3">Water path</option><option value="4">Trace status / updates</option><option value="5">Surface radiance</option><option value="7">RGB throughput</option><option value="8">Shared front throughput</option><option value="9">Water normalization</option></select></label>
 <div class="row"><button id="compile">Compile check</button><button id="profile">Profile (T)</button></div><pre id="probe">Shift-click water to read a pixel.</pre>
 <h2>Reproduce a view</h2><div class="row"><button id="copy">Copy state</button><button id="apply">Apply state</button></div><textarea id="state" aria-label="Saved camera and settings"></textarea>
 <p>Rear transparent radiance is attenuated on its original screen path. Initial optics select one water interface; underwater transport and caustics are follow-on work. <a href="./README.md">Review guide</a></p>

package/src/shade/renderer/Renderer.d.ts

@@ -303,6 +303,17 @@ export class Renderer {
      * @returns {GPUTextureContext}
      */
     get texture_depth_previous(): GPUTextureContext;
+    /**
+     *
+     * @returns {GPUTextureContext}
+     */
+    get texture_normal_current(): GPUTextureContext;
+    /**
+     * At the size last frame was drawn at, as {@link texture_depth_previous} is.
+     *
+     * @returns {GPUTextureContext}
+     */
+    get texture_normal_previous(): GPUTextureContext;
     /**
      *
      * @param {number} ratio

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AAwJA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,wCAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD;;;;OAIG;IACH,eAFU,oBAAoB,CAEa;IAY3C;;;;;;;OAOG;IACH,mBAFU,qBAAqB,CAEkB;IAEjD;;;;;OAKG;IACH,mBAFU,oBAAoB,CAEgB;IAE9C;;;OAGG;IACH,QAFU,cAAc,CAEM;IAE9B;;;;;;;;;OASG;IACH,2BAFU,OAAO,CAEiB;IAElC,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAW1C,oCAIC;IAED,mCAEC;IAYD,oCAIC;IAED,mCAEC;IAED;;;;;;OAMG;IACH,6BAFU,OAAO,CAEmB;IAcpC;;OAEG;IACH,uCAEC;IAyBD,0CAIC;IAED,yCAEC;IAED;;;;;OAKG;IACH,yBAFU,MAAM,CAEY;IAW5B,8CAMC;IAED,6CAEC;IAUD,8CAMC;IAED,6CAEC;IAWD,mDAKC;IAED,kDAEC;IASD,+CAKC;IAED,8CAEC;IAED,+BAA6B;IAC7B,4CAA0C;IAkB1C,qCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;;;OAOG;IACH,oCAOC;IAnBD,mCAEC;IAmBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAYD;;OAEG;IACH,sCAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B;;;;;;;;;;OAUG;IACH,qBAA+B;IAgB/B;;;OAGG;IACH,yCAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,+BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,iBAAiB,GAAC,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,yBAHW,eAAe,GACb,eAAe,CA8B3B;IAED;;;;;OAKG;IACH,4BAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAUD;;;;;;;;;;;;;;;;;OAiBG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAsB7B;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAYnB;IAED;;OAEG;IACH,8BAFa,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,yBAHW,KAAK,GACJ,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAMC;IAiBD;;;;OAIG;IACH,gCAHW,KAAK,GACH,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,kBAFW,KAAK,QAyBf;IAiSD,oGAAoG;IACpG,kDAA2C;IAO3C;;;;OAIG;IACH,0BAEC;IAiBD;;;;;;OAMG;IACH,qBAHW,eAAe,GACb,iBAAiB,CAW7B;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAwFD;;;;;;;;OAQG;IACH;QAJsC,OAAO;QACd,MAAM;QACT,UAAU,GAA3B,MAAM;sBA8MhB;IAED;;;;;;;;;;;;;;OAcG;IACH,0BAFW,eAAe,QA8DzB;IAyDD;;;;;;;;;;;;;;;;;OAiBG;IACH,WAFa,IAAI,CA0ChB;IAgCD,4BAwBC;IAkID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAmFD,0CAMC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,eAZW,iBAAiB,SACjB,KAAK,uBACL,MAAM,GAIJ,OAAO,CAuCnB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBARW,iBAAiB,SACjB,KAAK,sBACL,MAAM,UACN,iBAAiB,GACf,OAAO,CAiBnB;;CAylCJ;+BA11GY,OAAO,8CAA8C,EAAE,gBAAgB;gCACvE,OAAO,+CAA+C,EAAE,iBAAiB;gCACzE,OAAO,+BAA+B,EAAE,iBAAiB;8BACzD,OAAO,gCAAgC,EAAE,eAAe;gCACxD,OAAO,gDAAgD,EAAE,iBAAiB;8BAC1E,OAAO,4BAA4B,EAAE,eAAe;oBACpD,OAAO,kBAAkB,EAAE,KAAK;6BAnChB,yBAAyB;0CACZ,gCAAgC;qCA7CrC,6DAA6D;sCA+C5D,4BAA4B;qCAD7B,2BAA2B;+BAEjC,6CAA6C;gCAC5C,sCAAsC;2BAhC3C,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAuD7C,uBAAuB;mCAChB,qCAAqC;gCAnExC,sBAAsB;oBAxDlC,4BAA4B;kCAuHd,gCAAgC;2BAvFvC,2BAA2B;iCAqFrB,0CAA0C;4CAnE/B,+DAA+D;yBA6ClF,yBAAyB;kCAChB,kCAAkC;kCAUlC,wBAAwB;oBAnCtC,0BAA0B;gCA1Dd,uCAAuC;uCAgDhC,sDAAsD"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/Renderer.js

@@ -39,6 +39,7 @@ import { PresentTarget } from "./extension/PresentTarget.js";
 import { RenderExtensionRegistry } from "./extension/RenderExtensionRegistry.js";
 import { SceneColor } from "./extension/SceneColor.js";
 import { ViewTextures } from "./extension/ViewTextures.js";
+import { G_BUFFER_COLOR_TARGETS } from "./gbuffer/G_BUFFER_COLOR_TARGETS.js";
 import { G_BUFFER_MIP_LEVELS } from "./gbuffer/G_BUFFER_MIP_LEVELS.js";
 import { shader_brick4_diffuse } from "./global_illumination/brick4/gpu/draw/shader_brick4_diffuse.js";
 import {
@@ -856,6 +857,34 @@ export class Renderer {
      */
     #textures_taa_history = new Array(2);
 
+    /**
+     * The G-buffer normal, ping-ponged as depth is: reprojection asks which surface a history texel was
+     * written on, and only last frame's normal says.
+     * @type {GPUTextureContext[]}
+     */
+    #textures_normal = new Array(2);
+
+    /**
+     *
+     * @returns {GPUTextureContext}
+     */
+    get texture_normal_current() {
+        const tx = this.#textures_normal;
+
+        return tx[this.#frame_count % tx.length];
+    }
+
+    /**
+     * At the size last frame was drawn at, as {@link texture_depth_previous} is.
+     *
+     * @returns {GPUTextureContext}
+     */
+    get texture_normal_previous() {
+        const tx = this.#textures_normal;
+
+        return tx[(this.#frame_count - 1 + tx.length) % tx.length];
+    }
+
     /**
      *
      * @returns {GPUTextureContext}
@@ -1820,6 +1849,14 @@ export class Renderer {
                 mipLevelCount: G_BUFFER_MIP_LEVELS,
                 usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC,
             }));
+
+            this.#textures_normal[i] = graphics.textures.contextFromDescriptor(TextureDescriptor.from({
+                label: `Normal ${i}`,
+                size: resolution_internal,
+                format: G_BUFFER_COLOR_TARGETS[1].format,
+                mipLevelCount: 1,
+                usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
+            }));
         }
 
 
@@ -2063,6 +2100,7 @@ export class Renderer {
     #destroy_render_targets() {
         const targets = [
             ...this.#textures_depth,
+            ...this.#textures_normal,
             ...this.#textures_taa_history,
             ...(this.#vis_render_target?.color_attachments ?? []),
         ];
@@ -2072,6 +2110,7 @@ export class Renderer {
         }
 
         this.#textures_depth.fill(undefined);
+        this.#textures_normal.fill(undefined);
         this.#textures_taa_history.fill(undefined);
 
         this.#vis_render_target = undefined;
@@ -2311,9 +2350,10 @@ export class Renderer {
         }
 
         // cycle depth attachment, then size the target this frame draws into. Previous depth is not
-        // attached, so it keeps the size it was drawn at.
+        // attached, so it keeps the size it was drawn at. The normal cycles with it, the same way.
         this.#vis_render_target.depth_attachment = this.texture_depth_current;
         this.#vis_render_target.resize(this.#internal_resolution.x, this.#internal_resolution.y);
+        this.texture_normal_current.resize(this.#internal_resolution.x, this.#internal_resolution.y);
         this.#postprocess.update(this.#frame_count);
 
         // Advance whichever upscaler we're going to ask for jitter on this
@@ -2749,6 +2789,7 @@ export class Renderer {
             view: view_ctx,
             texture_viz_mesh: gr_viz_buffer_mesh,
             texture_viz_triangle: gr_viz_buffer_triangle,
+            texture_normal: graph_import_texture(graph, this.texture_normal_current, "normal"),
         });
 
         // update texture references
@@ -2816,13 +2857,15 @@ export class Renderer {
          `GBufferTextures` is in/out at this phase, and frozen after it. An extension that wants to
          *change* surface properties — decals are the reason this exists — cannot blend into these
          targets: two of the four are integer formats, and one texture cannot be a render attachment
-         and a sampled source in the same pass. So it reads them, writes replacements, and publishes
-         the new handles. Everything downstream carries what it left.
+         and a sampled source in the same pass. So it reads a copy — of the targets, or of the part
+         it changes — and writes, and publishes the handles it wrote. Everything downstream carries
+         what it left.
 
-         Writing the originals in place would work by accident rather than by contract: a written
-         handle is a *renamed* clone of the same physical resource, so the change would land in the
+         Publishing is what makes it a contract. A written handle is a *renamed* clone of the same
+         physical resource, so a change written in place and not published would land in the
          texture the shading pass reads only because the graph happens to execute in insertion
-         order, with no dependency edge saying so. Threading the handles makes the edge real.
+         order, with no dependency edge saying so. Threading the handles makes the edge real,
+         whether they name replacements or the originals written through `write`.
         */
         gr_texture_pbr = record_gbuffer.pbr;
         gr_texture_normal = record_gbuffer.normal;
@@ -3033,6 +3076,7 @@ export class Renderer {
                 input_depth: gr_texture_depth_current,
                 input_velocity: gr_velocity,
                 input_normal: gr_texture_normal,
+                input_normal_previous: graph_import_texture(graph, this.texture_normal_previous, "normal previous"),
                 input_occlusion: gr_occlusion_clip,
                 input_hzb: gr_texture_hzb,
                 // NOTE: AO is blended into the G-buffer

package/src/shade/renderer/camera/orbital/OrbitalCameraController.d.ts

@@ -1,117 +1,77 @@
 /**
- * Smoothed orbital camera controller — a drop-in replacement for the legacy
- * {@link ../OrbitalCameraController.js} that adds frame-rate-independent inertia
- * via meep's critically-damped springs.
+ * Orbital camera for a Shade {@link PerspectiveCamera} outside the ECS: drag to orbit, right-drag to
+ * pan, wheel to zoom, W/A/S/D to fly the target along the view.
  *
- * It is a thin FACADE over two decoupled, independently-testable layers:
- *   - {@link OrbitalCameraRig}   — pure control core (springs + goals, no DOM/clock)
- *   - {@link OrbitalCameraInput} — input adapter (events → rig intents, no kinematics)
+ * The pose is a {@link TopDownCameraController} of its own, the same one an ECS camera carries, and
+ * an {@link OrbitalCameraRig} moves it with the feel every orbital camera in the engine shares. Each
+ * {@link update} writes the pose onto the camera's transform, and a transform moved by anyone else
+ * since is adopted as the new pose instead.
  *
- * The facade owns only the things that genuinely need the outside world: device
- * lifecycle, the frame `dt`, writing the result onto the camera's transform, and
- * the "camera moved outside our control" detection contract. The public surface
- * ({@link look}, {@link from_transform}, {@link pan}, {@link update},
- * `distanceLimits`, `movement_speed_scale`, `camera`) matches the legacy
- * controller so switching is a single import change.
- *
- * @author Alex Goldring (orbital rework)
+ * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
 export class OrbitalCameraController {
     /**
      * @param {import("../PerspectiveCamera.js").PerspectiveCamera} camera
      * @param {HTMLElement} domElement
-     * @param {Partial<import("./OrbitalCameraConfig.js").ORBITAL_CAMERA_FEEL_DEFAULTS>} [configOverrides]
      */
-    constructor(camera: import("../PerspectiveCamera.js").PerspectiveCamera, domElement: HTMLElement, configOverrides?: any);
+    constructor(camera: import("../PerspectiveCamera.js").PerspectiveCamera, domElement: HTMLElement);
+    /**
+     * Zoom range, world units. Mutate `.min`/`.max` or `set()`; it applies from the next
+     * {@link look} or {@link update}.
+     * @type {NumericInterval}
+     */
+    distanceLimits: NumericInterval;
+    /**
+     * W/A/S/D speed, world units a second with the camera at the near end of {@link distanceLimits},
+     * rising to twice that at the far end.
+     * @type {number}
+     */
+    movement_speed_scale: number;
+    /**
+     * @type {TopDownCameraController}
+     */
+    pose: TopDownCameraController;
     camera: import("../PerspectiveCamera.js").PerspectiveCamera;
     domElement: HTMLElement;
-    config: Readonly<{
-        momentumEnabled: true;
-        momentumDecayHalfLife: 0.1;
-        velocityWindow: 0.1;
-        momentumStopSpeed: 0.012;
-        rotateSpeed: 1;
-        panSpeed: 1;
-        zoomStep: 0.9;
-        invertWheel: false;
-        minPolar: 0.000001;
-        maxPolar: number;
-        flyToDuration: 0.35;
-        maxDt: 0.1;
-    }>;
+    rig: OrbitalCameraRig;
     pointer: PointerDevice;
     keyboard: KeyboardDevice;
-    rig: OrbitalCameraRig;
-    input: OrbitalCameraInput;
-    _lastRecorded: Transform64;
-    _lastUpdateTime: number;
-    _scratchEye: Vector3;
-    _scratchTarget: Vector3;
-    /** Zoom range, in world units (NumericInterval). Mutate `.min/.max` or `.set()`. */
-    get distanceLimits(): import("../../../../core/math/interval/NumericInterval.js").NumericInterval;
-    set movement_speed_scale(value: number);
-    /** Scene-relative WASD/keyboard move speed. */
-    get movement_speed_scale(): number;
-    /** Current smoothed orbit distance (radius). */
+    /** Orbit distance, world units. */
     get distance(): number;
-    /** Current smoothed target (shared scratch — copy if you need to retain it). */
+    /** Orbit target, live: copy it to keep it. */
     get target(): Vector3;
     /**
-     * Point the camera at `to` from `from`, immediately (no animation).
+     * Point the camera at `to` from `from`, at once, stopping any throw.
      * @param {Vector3} from
      * @param {Vector3} to
      */
     look(from: Vector3, to: Vector3): void;
     /**
-     * Eased "fly to" framing: glide to the new pose over {@link config}.flyToHalfLife
-     * instead of snapping. The normal update() loop animates it.
-     * @param {Vector3} from
-     * @param {Vector3} to
-     */
-    flyTo(from: Vector3, to: Vector3): void;
-    /**
-     * Adopt an external camera transform as the new orbit pose (target is placed
-     * `distance` ahead along its forward).
+     * Adopt a camera transform as the pose, the target the current orbit distance ahead of it.
      *
-     * Read component-wise rather than through `Vector3.copy`, because a
-     * {@link Transform64} answers `forward` and `translation` with raw
-     * `Float64Array`s — no `.x`, and a `copy` of one silently sets three
-     * undefineds. Those two arrays are also freshly allocated per access, so
-     * each is read once into a scratch that outlives the call.
+     * Read by component, because a {@link Transform64} answers `forward` with a raw `Float64Array`,
+     * allocated on each access.
      *
      * @param {Transform64} transform
      */
     from_transform(transform: Transform64): void;
     /**
-     * Screen-space pan of the orbit target, in pointer pixels (legacy signature).
-     * @param {number} delta_x
-     * @param {number} delta_y
-     */
-    pan(delta_x: number, delta_y: number): void;
-    /**
-     * Advance one frame and write the result onto the camera transform.
+     * Advance one frame and write the pose onto the camera transform.
      *
-     * @param {number} [dt] frame time in seconds. STRONGLY preferred — pass the
-     *   value `create_frame_loop` already hands the callback. Omit to fall back
-     *   to an internal clock (clamped, so no first-frame teleport).
+     * @param {number} [dt] frame time in seconds; `create_frame_loop` hands it to its callback. Omit
+     * it to measure the time since the last call instead.
      */
     update(dt?: number): void;
-    /** Detach input subscriptions and stop the devices. */
+    /** Detach input and stop the devices. */
     dispose(): void;
-    /**
-     * Resolve and sanitize the frame dt. Prefers the supplied value; otherwise
-     * derives it from an internal clock. Always clamped to [0, maxDt] so a tab
-     * refocus / GC hitch can't make the springs jump.
-     * @param {number} [dt]
-     * @returns {number}
-     */
-    _resolveDt(dt?: number): number;
+    #private;
 }
+import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
+import TopDownCameraController from "../../../../engine/graphics/ecs/camera/topdown/TopDownCameraController.js";
+import { OrbitalCameraRig } from "../../../../engine/graphics/camera/orbital/OrbitalCameraRig.js";
 import { PointerDevice } from "../../../../engine/input/devices/PointerDevice.js";
 import KeyboardDevice from "../../../../engine/input/devices/KeyboardDevice.js";
-import { OrbitalCameraRig } from "./OrbitalCameraRig.js";
-import { OrbitalCameraInput } from "./OrbitalCameraInput.js";
-import { Transform64 } from "../../../../engine/ecs/transform/Transform64.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
+import { Transform64 } from "../../../../engine/ecs/transform/Transform64.js";
 //# sourceMappingURL=OrbitalCameraController.d.ts.map

package/src/shade/renderer/camera/orbital/OrbitalCameraController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OrbitalCameraController.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/camera/orbital/OrbitalCameraController.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;OAIG;IACH,oBAJW,OAAO,yBAAyB,EAAE,iBAAiB,cACnD,WAAW,yBAwCrB;IApCG,4DAAoB;IACpB,wBAA4B;IAE5B;;;;;;;;;;;;;OAAwD;IAGxD,uBAA4C;IAI5C,yBAA8C;IAK9C,sBAAwD;IAExD,0BAOE;IAIF,2BAAsC;IAEtC,wBAAgD;IAChD,qBAAgC;IAChC,wBAAmC;IAUvC,oFAAoF;IACpF,kGAEC;IAOD,wCAEC;IAPD,+CAA+C;IAC/C,mCAEC;IAMD,gDAAgD;IAChD,uBAEC;IAED,gFAAgF;IAChF,sBAEC;IAED;;;;OAIG;IACH,WAHW,OAAO,MACP,OAAO,QAUjB;IAED;;;;;OAKG;IACH,YAHW,OAAO,MACP,OAAO,QAUjB;IAED;;;;;;;;;;;OAWG;IACH,0BAFW,WAAW,QAoBrB;IAED;;;;OAIG;IACH,aAHW,MAAM,WACN,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,YAJW,MAAM,QAuBhB;IAED,uDAAuD;IACvD,gBAIC;IAMD;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAelB;CACJ;8BArO6B,mDAAmD;2BADtD,oDAAoD;iCAE9C,uBAAuB;mCACrB,yBAAyB;4BALhC,iDAAiD;oBAFzD,kCAAkC"}
+{"version":3,"file":"OrbitalCameraController.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/camera/orbital/OrbitalCameraController.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;GAWG;AACH;IAwCI;;;OAGG;IACH,oBAHW,OAAO,yBAAyB,EAAE,iBAAiB,cACnD,WAAW,EA4BrB;IArED;;;;OAIG;IACH,gBAFU,eAAe,CAEuB;IAEhD;;;;OAIG;IACH,sBAFU,MAAM,CAES;IAEzB;;OAEG;IACH,MAFU,uBAAuB,CAEI;IA2BjC,4DAAoB;IACpB,wBAA4B;IAK5B,sBAME;IAEF,uBAA4C;IAO5C,yBAA8C;IAMlD,mCAAmC;IACnC,uBAEC;IAED,8CAA8C;IAC9C,sBAEC;IAED;;;;OAIG;IACH,WAHW,OAAO,MACP,OAAO,QAiBjB;IAED;;;;;;;OAOG;IACH,0BAFW,WAAW,QAoBrB;IAED;;;;;OAKG;IACH,YAHW,MAAM,QAsBhB;IAED,yCAAyC;IACzC,gBAQC;;CAgFJ;gCA5R+B,mDAAmD;oCAW5E,2EAA2E;iCAJjD,gEAAgE;8BAOnE,mDAAmD;2BAFtD,oDAAoD;oBAb3D,kCAAkC;4BAO1B,iDAAiD"}