@3driseai/3drise-viewer 0.1.40 → 0.1.42

package/dist/keyPad/keyPadMotion.js

@@ -0,0 +1,283 @@
+// =============================================================================
+// keyPadMotion — keyboard / KeyPad camera moves
+// =============================================================================
+//
+// What the mouse does to OrbitControls, driven by held keys instead. Two camera
+// styles; the control mode picks the default one and Alt switches to the other:
+//   orbit:  arrows       → orbit (left-drag)
+//   fly:    ↑ / ↓        → walk the camera forward / back (camera and orbit point
+//                          together — not a zoom)
+//           ← / →        → turn in place: the orbit point swings around the camera
+//   pan + arrows    → pan   (right-drag / ctrl-drag), in either style
+//   zoomIn/zoomOut  → dolly (wheel)
+//   zoom slider     → sets the orbit distance directly, between the zoom limits
+//   home            → main view
+//
+// Moves the live camera only — nothing is written to the store. Each move ends
+// with OrbitControls.update(), so the camera's own limits still clamp it, and
+// the controls' enableRotate / enablePan / enableZoom are respected like the
+// mouse respects them.
+//
+import { Spherical, Vector3 } from 'three';
+import { cameraManager } from '../utils/CameraSingleton.js';
+export const CONTROL_MODES = [
+    { value: 'none', label: 'No keyboard' },
+    { value: 'orbit', label: 'Orbit first' },
+    { value: 'fly', label: 'Fly first' },
+    { value: 'animation', label: 'Animation control' },
+];
+/** Fly style right now: the mode's default, flipped while Alt is held / latched. */
+export const isFlying = (mode, held) => (mode === 'fly') !== held.has('alt');
+/** Keys that move the camera while held (home is one-shot, pan is a modifier). */
+export const HELD_MOVE_KEYS = ['up', 'down', 'left', 'right', 'zoomIn', 'zoomOut'];
+/** Real keyboard → KeyPad key. Matched on KeyboardEvent.key. */
+export const KEYBOARD_MAP = {
+    ArrowUp: 'up',
+    ArrowDown: 'down',
+    ArrowLeft: 'left',
+    ArrowRight: 'right',
+    '+': 'zoomIn',
+    '=': 'zoomIn',
+    '-': 'zoomOut',
+    '_': 'zoomOut',
+    Control: 'pan',
+    Alt: 'alt',
+    Home: 'home',
+};
+/** Shown on the KeyPad buttons' tooltips. */
+export const KEY_HINTS = {
+    up: '↑',
+    down: '↓',
+    left: '←',
+    right: '→',
+    zoomIn: '+',
+    zoomOut: '−',
+    pan: 'Ctrl',
+    alt: 'Alt',
+    home: 'Home',
+};
+// Base rates at speed 1, per second.
+const ORBIT_RAD_PER_SEC = Math.PI / 2; // 90° a second
+const PAN_RADII_PER_SEC = 0.8; // fraction of the orbit distance
+const ZOOM_PER_SEC = 1.6; // distance × e^(±1.6) a second
+const _off = new Vector3();
+const _sph = new Spherical();
+const _right = new Vector3();
+const _up = new Vector3();
+const _worldUp = new Vector3(0, 1, 0);
+const _orbitSph = new Spherical();
+function liveRig() {
+    const cam = cameraManager.getCamera();
+    const oc = cameraManager.getControls();
+    return cam && oc && oc.enabled !== false ? { cam, oc } : null;
+}
+/** Orbit around the orbit point by (theta, phi) radians; the controls' limits clamp in update(). */
+export function orbitBy(dTheta, dPhi) {
+    const rig = liveRig();
+    if (!rig)
+        return;
+    _orbitSph.setFromVector3(_off.copy(rig.cam.position).sub(rig.oc.target));
+    _orbitSph.theta += dTheta;
+    _orbitSph.phi += dPhi;
+    _orbitSph.makeSafe();
+    rig.cam.position.copy(rig.oc.target).add(_off.setFromSpherical(_orbitSph));
+    rig.cam.lookAt(rig.oc.target);
+    rig.oc.update?.();
+}
+/** Slide camera + orbit point together in the view plane (x right, y up), in metres. */
+export function panBy(dx, dy) {
+    const rig = liveRig();
+    if (!rig || rig.oc.enablePan === false)
+        return;
+    rig.cam.updateMatrix();
+    _right.setFromMatrixColumn(rig.cam.matrix, 0).multiplyScalar(dx);
+    _up.setFromMatrixColumn(rig.cam.matrix, 1).multiplyScalar(dy);
+    _right.add(_up);
+    rig.cam.position.add(_right);
+    rig.oc.target.add(_right);
+    rig.oc.update?.();
+}
+/** Walk camera + orbit point along the view direction flattened onto the ground
+ *  (height kept). Looking straight down, "forward" is the top of the screen. */
+export function moveBy(d) {
+    const rig = liveRig();
+    if (!rig || rig.oc.enablePan === false)
+        return; // same rule as pan: it moves the orbit point
+    rig.cam.getWorldDirection(_right);
+    _right.y = 0;
+    if (_right.lengthSq() < 1e-8) {
+        rig.cam.updateMatrix();
+        _right.setFromMatrixColumn(rig.cam.matrix, 1);
+        _right.y = 0;
+    }
+    if (_right.lengthSq() < 1e-8)
+        return;
+    _right.normalize().multiplyScalar(d);
+    rig.cam.position.add(_right);
+    rig.oc.target.add(_right);
+    rig.oc.update?.();
+}
+// --- Zoom slider: distance ↔ 0…1 between the zoom limits --------------------------
+//
+// Log scale, like the wheel (each notch scales the distance), so the near end is
+// as usable as the far end. t = 0 is the closest (minDistance), 1 the farthest.
+/** maxDistance at / above this is the saved "no limit" (see CameraLimitsHelper). */
+const NO_LIMIT = 1e6;
+/** Far end of the slider when there is no max limit. */
+const UNLIMITED_FAR = 1000;
+const MIN_NEAR = 0.01;
+export function zoomRange() {
+    const rig = liveRig();
+    if (!rig)
+        return null;
+    const distance = orbitDistance();
+    const near = Math.max(Number(rig.oc.minDistance) || 0, MIN_NEAR);
+    const maxD = Number(rig.oc.maxDistance);
+    let far = Number.isFinite(maxD) && maxD < NO_LIMIT ? maxD : Math.max(UNLIMITED_FAR, distance);
+    if (far <= near)
+        far = near * 1.0001;
+    return { near, far, distance, enabled: rig.oc.enableZoom !== false };
+}
+export function distanceToT(d, r) {
+    const t = (Math.log(d) - Math.log(r.near)) / (Math.log(r.far) - Math.log(r.near));
+    return Math.max(0, Math.min(1, t));
+}
+export function tToDistance(t, r) {
+    return Math.exp(Math.log(r.near) + Math.max(0, Math.min(1, t)) * (Math.log(r.far) - Math.log(r.near)));
+}
+/** Put the camera at `d` from the orbit point, same direction. Limits clamp in update(). */
+export function setOrbitDistance(d) {
+    const rig = liveRig();
+    if (!rig || rig.oc.enableZoom === false)
+        return;
+    _off.copy(rig.cam.position).sub(rig.oc.target);
+    const len = _off.length();
+    if (len < 1e-9)
+        return;
+    rig.cam.position.copy(rig.oc.target).add(_off.multiplyScalar(d / len));
+    rig.oc.update?.();
+}
+/** Turn in place: swing the orbit point around the camera about world up (+ = right). */
+export function turnBy(a) {
+    const rig = liveRig();
+    if (!rig || rig.oc.enablePan === false)
+        return; // same rule as move: it moves the orbit point
+    _off.copy(rig.oc.target).sub(rig.cam.position).applyAxisAngle(_worldUp, -a);
+    rig.oc.target.copy(rig.cam.position).add(_off);
+    rig.cam.lookAt(rig.oc.target);
+    rig.oc.update?.();
+}
+/** Scale the distance to the orbit point (<1 = closer). Limits clamp in update(). */
+export function dollyBy(scale) {
+    const rig = liveRig();
+    if (!rig || rig.oc.enableZoom === false)
+        return;
+    _off.copy(rig.cam.position).sub(rig.oc.target);
+    _off.multiplyScalar(scale);
+    rig.cam.position.copy(rig.oc.target).add(_off);
+    rig.oc.update?.();
+}
+function orbitDistance() {
+    const rig = liveRig();
+    if (!rig)
+        return 0;
+    return _sph.setFromVector3(_off.copy(rig.cam.position).sub(rig.oc.target)).radius;
+}
+/**
+ * One frame of camera motion.
+ * @param held   keys down (modifiers included, latched or held)
+ * @param zoom   zoom rate -1 … 1 (±1 from the +/− keys)
+ * @param fly    fly style (else orbit) — see isFlying
+ * @param arrows false: the arrows drive something else (animation mode); zoom only
+ */
+export function stepKeyPad(held, zoom, dt, speed, fly, arrows = true) {
+    const rig = liveRig();
+    if (!rig)
+        return;
+    const x = arrows ? (held.has('right') ? 1 : 0) - (held.has('left') ? 1 : 0) : 0;
+    const y = arrows ? (held.has('up') ? 1 : 0) - (held.has('down') ? 1 : 0) : 0;
+    const z = zoom;
+    // Flying, the speed is the forward / back speed only: turn, pan and zoom keep
+    // their base rates. Orbiting, it scales everything.
+    const k = fly ? 1 : speed;
+    if (x || y) {
+        if (held.has('pan')) {
+            const d = orbitDistance() * PAN_RADII_PER_SEC * k * dt;
+            panBy(x * d, y * d);
+        }
+        else if (fly) {
+            // ↑ / ↓ walk, ← / → turn.
+            if (y)
+                moveBy(y * orbitDistance() * PAN_RADII_PER_SEC * speed * dt);
+            if (x)
+                turnBy(x * ORBIT_RAD_PER_SEC * dt);
+        }
+        else if (rig.oc.enableRotate !== false) {
+            // right → camera moves to its right around the orbit point (theta+),
+            // up → camera rises (phi−).
+            const a = ORBIT_RAD_PER_SEC * k * dt;
+            orbitBy(x * a, -y * a);
+        }
+    }
+    if (z)
+        dollyBy(Math.exp(-z * ZOOM_PER_SEC * k * dt));
+}
+/** The live camera as a view, or null before the camera is up. */
+export function captureView() {
+    const cam = cameraManager.getCamera();
+    const oc = cameraManager.getControls();
+    if (!cam || !oc)
+        return null;
+    const r = (n) => Math.round(n * 1000) / 1000;
+    return {
+        position: [r(cam.position.x), r(cam.position.y), r(cam.position.z)],
+        target: [r(oc.target.x), r(oc.target.y), r(oc.target.z)],
+    };
+}
+let viewRaf = 0;
+const _fromPos = new Vector3();
+const _fromTarget = new Vector3();
+const _toPos = new Vector3();
+const _toTarget = new Vector3();
+const easeInOut = (t) => (t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2);
+/** Glide camera and orbit point together to a view (a new glide replaces one in flight). */
+export function glideToView(view, duration = 0.9) {
+    const cam = cameraManager.getCamera();
+    const oc = cameraManager.getControls();
+    if (!cam || !oc)
+        return;
+    cancelAnimationFrame(viewRaf);
+    _fromPos.copy(cam.position);
+    _fromTarget.copy(oc.target);
+    _toPos.set(...view.position);
+    _toTarget.set(...view.target);
+    const start = performance.now();
+    const step = () => {
+        const c = cameraManager.getCamera();
+        const o = cameraManager.getControls();
+        if (!c || !o)
+            return;
+        const t = Math.min((performance.now() - start) / (duration * 1000), 1);
+        const k = easeInOut(t);
+        c.position.lerpVectors(_fromPos, _toPos, k);
+        o.target.lerpVectors(_fromTarget, _toTarget, k);
+        c.lookAt(o.target);
+        o.update?.();
+        viewRaf = t < 1 ? requestAnimationFrame(step) : 0;
+    };
+    viewRaf = requestAnimationFrame(step);
+}
+/** Main view: glide the camera to the project's saved camera position. */
+export function goToMainView(position) {
+    return cameraManager.animateCameraPosition(position);
+}
+/** Is this keyboard event aimed at a text field / editor, or already handled? */
+export function isTypingTarget(e) {
+    if (e.defaultPrevented)
+        return true;
+    const el = e.target;
+    if (!el || !(el instanceof HTMLElement))
+        return false;
+    const tag = el.tagName;
+    return tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT' || el.isContentEditable;
+}

package/dist/keyPad/keyPadStore.d.ts

@@ -0,0 +1,25 @@
+import type { KeyPadControlMode, KeyPadKey, KeyPadModifier } from './keyPadMotion';
+export interface KeyPadLiveState {
+    pressed: readonly KeyPadKey[];
+    /** A modifier latched on by clicking its pad button (Ctrl / Alt on the keyboard are momentary). */
+    latched: KeyPadModifier | null;
+    /** A control mode switched to by a key binding — over the saved one until changed again. */
+    modeOverride: KeyPadControlMode | null;
+}
+export declare const keyPadStore: {
+    get: () => KeyPadLiveState;
+    subscribe(fn: () => void): () => void;
+    press(key: KeyPadKey): void;
+    release(key: KeyPadKey): void;
+    /** Click on a modifier button: latch it, or unlatch it if it is the latched one. */
+    toggleModifier(m: KeyPadModifier): void;
+    /** Every key up (window blur, unmount). Keeps a latched modifier. */
+    releaseAll(): void;
+    /** Keys up and modifier unlatched (control mode changed). Keeps the mode override. */
+    reset(): void;
+    setModeOverride(mode: KeyPadControlMode | null): void;
+};
+export declare function useKeyPadState(): KeyPadLiveState;
+/** Held keys with the latched modifier folded in. */
+export declare function useKeyPadHeld(): ReadonlySet<KeyPadKey>;
+//# sourceMappingURL=keyPadStore.d.ts.map

package/dist/keyPad/keyPadStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyPadStore.d.ts","sourceRoot":"","sources":["../../src/keyPad/keyPadStore.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEnF,MAAM,WAAW,eAAe;IAC5B,OAAO,EAAE,SAAS,SAAS,EAAE,CAAC;IAC9B,mGAAmG;IACnG,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC;IAC/B,4FAA4F;IAC5F,YAAY,EAAE,iBAAiB,GAAG,IAAI,CAAC;CAC1C;AAYD,eAAO,MAAM,WAAW;eACX,eAAe;kBACV,MAAM,IAAI,GAAG,MAAM,IAAI;eAI1B,SAAS;iBAGP,SAAS;IAGtB,oFAAoF;sBAClE,cAAc;IAGhC,qEAAqE;;IAIrE,sFAAsF;;0BAEhE,iBAAiB,GAAG,IAAI;CAGjD,CAAC;AAEF,wBAAgB,cAAc,IAAI,eAAe,CAEhD;AAED,qDAAqD;AACrD,wBAAgB,aAAa,IAAI,WAAW,CAAC,SAAS,CAAC,CAOtD"}

package/dist/keyPad/keyPadStore.js

@@ -0,0 +1,63 @@
+// =============================================================================
+// keyPadStore — which keys are held right now (live, never saved)
+// =============================================================================
+//
+// One store for both sources: the real keyboard (KeyPadControls) and an on-screen
+// pad (the studio's KeyPad) press / release the same keys here, so a key held on
+// the keyboard lights its button and a button held on screen moves the camera
+// exactly like its key. Outside React state on purpose: the published viewer has
+// no Redux, and the studio and the viewer share this.
+//
+import { useMemo, useSyncExternalStore } from 'react';
+const EMPTY = { pressed: [], latched: null, modeOverride: null };
+let state = EMPTY;
+const listeners = new Set();
+function set(next) {
+    if (next === state)
+        return;
+    state = next;
+    listeners.forEach(fn => fn());
+}
+export const keyPadStore = {
+    get: () => state,
+    subscribe(fn) {
+        listeners.add(fn);
+        return () => { listeners.delete(fn); };
+    },
+    press(key) {
+        if (!state.pressed.includes(key))
+            set({ ...state, pressed: [...state.pressed, key] });
+    },
+    release(key) {
+        if (state.pressed.includes(key))
+            set({ ...state, pressed: state.pressed.filter(k => k !== key) });
+    },
+    /** Click on a modifier button: latch it, or unlatch it if it is the latched one. */
+    toggleModifier(m) {
+        set({ ...state, latched: state.latched === m ? null : m });
+    },
+    /** Every key up (window blur, unmount). Keeps a latched modifier. */
+    releaseAll() {
+        if (state.pressed.length)
+            set({ ...state, pressed: [] });
+    },
+    /** Keys up and modifier unlatched (control mode changed). Keeps the mode override. */
+    reset() { set({ ...EMPTY, modeOverride: state.modeOverride }); },
+    setModeOverride(mode) {
+        if (mode !== state.modeOverride)
+            set({ ...state, modeOverride: mode });
+    },
+};
+export function useKeyPadState() {
+    return useSyncExternalStore(keyPadStore.subscribe, keyPadStore.get, keyPadStore.get);
+}
+/** Held keys with the latched modifier folded in. */
+export function useKeyPadHeld() {
+    const s = useKeyPadState();
+    return useMemo(() => {
+        const held = new Set(s.pressed);
+        if (s.latched)
+            held.add(s.latched);
+        return held;
+    }, [s]);
+}

package/dist/keyPad/types.d.ts

@@ -0,0 +1,23 @@
+import type { KeyPadControlMode } from './keyPadMotion';
+import type { KeyBinding } from './keyBindings';
+/**
+ * A project's keyboard / KeyPad controller — saved as sceneSettings.keyPadSettings
+ * (scene_settings.key_pad_settings). Projects saved before it existed have none:
+ * read through resolveKeyPadSettings.
+ */
+export interface KeyPadSettings {
+    /** The on-screen KeyPad is shown (studio toolbar). */
+    visible: boolean;
+    /** What the keyboard drives — see KeyPadControlMode. */
+    mode: KeyPadControlMode;
+    /** General speed, 1–10 (× the base rates). Orbit: orbit / pan / zoom. Fly: forward / back only. Animation: playback. */
+    speed: number;
+    /** Animation control mode: the animations / clips the arrows drive (`seq:<id>` / `clip:<id>`). */
+    animations: string[];
+    /** Keys that run things (play, apply, effects, camera views, mode switches) — see keyBindings. */
+    bindings: KeyBinding[];
+}
+export declare const DEFAULT_KEYPAD_SETTINGS: KeyPadSettings;
+/** Saved settings (possibly missing / partial / null) over the defaults. */
+export declare const resolveKeyPadSettings: (s?: Partial<KeyPadSettings> | null) => KeyPadSettings;
+//# sourceMappingURL=types.d.ts.map

package/dist/keyPad/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/keyPad/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC3B,sDAAsD;IACtD,OAAO,EAAE,OAAO,CAAC;IACjB,wDAAwD;IACxD,IAAI,EAAE,iBAAiB,CAAC;IACxB,wHAAwH;IACxH,KAAK,EAAE,MAAM,CAAC;IACd,kGAAkG;IAClG,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,kGAAkG;IAClG,QAAQ,EAAE,UAAU,EAAE,CAAC;CAC1B;AAED,eAAO,MAAM,uBAAuB,EAAE,cAMrC,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,qBAAqB,GAAI,IAAI,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,KAAG,cACzB,CAAC"}

package/dist/keyPad/types.js

@@ -0,0 +1,9 @@
+export const DEFAULT_KEYPAD_SETTINGS = {
+    visible: false,
+    mode: 'orbit',
+    speed: 1,
+    animations: [],
+    bindings: [],
+};
+/** Saved settings (possibly missing / partial / null) over the defaults. */
+export const resolveKeyPadSettings = (s) => ({ ...DEFAULT_KEYPAD_SETTINGS, ...(s ?? {}) });

package/dist/operations/catalogue/visibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/visibility.ts"],"names":[],"mappings":";AAIA,wBAoBG"}
+{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/visibility.ts"],"names":[],"mappings":";AAiBA,wBA4BG"}

package/dist/operations/catalogue/visibility.js

@@ -1,9 +1,20 @@
+import { SceneActions } from '@3driseai/3drise-core';
 import { defineOperation } from '../types.js';
 const KEY = '__opVisible';
+/**
+ * A whole scene object (a CreatedObject root) is shown / hidden through its settings, the
+ * same way an action's `visible` change is: a runtime patch layer (no store write). Its
+ * visibility-linked effects then play in and out (usePresentedVisibility) — writing
+ * Object3D.visible here would cut them. A model part has no effects: set directly.
+ */
+const objectIdOf = (target) => target?.userData?.id && target.userData.objectType ? String(target.userData.id) : null;
+const layerOf = (id) => `op:visibility:${id}`;
+/** Objects shown / hidden through a layer, by id — not on the Object3D: hiding can re-render it. */
+const laid = new Set();
 export default defineOperation({
     value: 'visibility',
     label: 'Show / hide',
-    description: 'Hide (or show) the targets instantly',
+    description: 'Hide (or show) the targets instantly — an object with visibility-linked effects plays them in / out',
     channel: 'visual',
     multi: true,
     toggles: true,
@@ -12,11 +23,22 @@ export default defineOperation({
         mode: { type: 'select', label: 'Make it', default: 'hide', options: [{ value: 'hide', label: 'Hidden' }, { value: 'show', label: 'Visible' }] },
     },
     apply(target, p) {
+        const id = objectIdOf(target);
+        if (id) {
+            laid.add(id);
+            SceneActions.setLayer(layerOf(id), { [id]: { meshSettings: { visible: p.mode === 'show' } } });
+            return;
+        }
         if (target.userData[KEY] === undefined)
             target.userData[KEY] = target.visible;
         target.visible = p.mode === 'show';
     },
     revert(target) {
+        const id = objectIdOf(target);
+        if (id && laid.delete(id)) {
+            SceneActions.setLayer(layerOf(id), null);
+            return;
+        }
         if (target.userData[KEY] === undefined)
             return;
         target.visible = target.userData[KEY];

package/dist/shaders/clouds/CloudResolveMaterial.d.ts

@@ -7,7 +7,8 @@ export declare const CloudResolveMaterial: import("@react-three/fiber").Construc
     u_invProj: THREE.Matrix4;
     u_camWorld: THREE.Matrix4;
     u_camPos: THREE.Vector3;
-    u_texel: THREE.Vector2;
+    u_curSize: THREE.Vector2;
+    u_offset: THREE.Vector2;
     u_blend: number;
     u_proxyHeight: number;
     u_valid: number;

package/dist/shaders/clouds/CloudResolveMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CloudResolveMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/clouds/CloudResolveMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAkE9D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;CAehC,CAAA;AAID,OAAO,QAAQ,oBAAoB,CAAC;IAClC,UAAU,aAAa;QACrB,oBAAoB,EAAE,YAAY,CAAC,OAAO,oBAAoB,CAAC,CAAA;KAChE;CACF"}
+{"version":3,"file":"CloudResolveMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/clouds/CloudResolveMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AA0F9D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;CAgBhC,CAAA;AAID,OAAO,QAAQ,oBAAoB,CAAC;IAClC,UAAU,aAAa;QACrB,oBAAoB,EAAE,YAAY,CAAC,OAAO,oBAAoB,CAAC,CAAA;KAChE;CACF"}

package/dist/shaders/clouds/CloudResolveMaterial.js

@@ -2,9 +2,20 @@ import * as THREE from 'three';
 import { shaderMaterial } from '@react-three/drei';
 import { extend } from '@react-three/fiber';
 /**
- * Temporal resolve for the layer path. Blends this frame's half-resolution march with a
- * reprojected history buffer, so 96 march steps at quarter the pixel count converge to
- * something close to a full-resolution result over ~4 frames.
+ * Temporal reconstruction for the layer path.
+ *
+ * The march runs at a quarter of the cloud buffer's pixels: each frame, every march
+ * texel traces ONE of the four buffer pixels under it, cycling through all four over
+ * four frames. This pass rebuilds the full buffer from that:
+ *
+ *   - the pixel traced this frame takes the fresh sample, blended with its history
+ *     to average out the march's per-frame step jitter;
+ *   - the other three take their reprojected history, clamped to the neighbourhood
+ *     of this frame's samples so a stale value cannot ghost far.
+ *
+ * So every pixel is re-traced every fourth frame, and the march costs a quarter of
+ * what it did — the same scheme production volumetric clouds use, at a milder ratio
+ * (they trace one in sixteen).
  *
  * Reprojection runs against a proxy surface at the layer's mid-height rather than a
  * per-pixel cloud depth. That avoids a second render target for depth, and for a layer
@@ -20,18 +31,28 @@ precision highp float;
 in vec2 vUv;
 out vec4 outColor;
 
-uniform sampler2D u_current;
-uniform sampler2D u_history;
+uniform sampler2D u_current;   // the march, a quarter of this pass's pixels
+uniform sampler2D u_history;   // last frame's output, this pass's size
 uniform mat4 u_prevViewProj;
 uniform mat4 u_invProj, u_camWorld;
 uniform vec3 u_camPos;
-uniform vec2 u_texel;
-uniform float u_blend;
+uniform vec2 u_curSize;        // march buffer size in texels
+uniform vec2 u_offset;         // which of the 2x2 pixels was traced this frame (0 or 1 each)
+uniform float u_blend;         // history weight on the freshly traced pixel
 uniform float u_proxyHeight;
 uniform float u_valid;
 
 void main(){
-  vec4 cur = texture(u_current, vUv);
+  ivec2 p = ivec2(gl_FragCoord.xy);
+  ivec2 q = p / 2;
+  ivec2 qMax = ivec2(u_curSize) - 1;
+  bool fresh = (p - q * 2) == ivec2(u_offset);
+
+  // This frame's samples sit on the centres of the traced pixels, so in march texel
+  // space this pixel's centre is at (p - offset) / 2 + 0.5. Bilinear there is an exact
+  // fetch for the traced pixel and an interpolation for the other three.
+  vec2 cUv = ((vec2(p) - u_offset) * 0.5 + 0.5) / u_curSize;
+  vec4 cur = texture(u_current, cUv);
 
   if (u_valid < 0.5){ outColor = cur; return; }
 
@@ -53,13 +74,16 @@ void main(){
 
   vec4 hist = texture(u_history, pUv);
 
-  vec4 lo = cur, hi = cur;
+  // Neighbourhood of this frame's samples: the 3x3 march texels around the nearest one.
+  ivec2 n = clamp(ivec2(cUv * u_curSize), ivec2(0), qMax);
+  vec4 lo = vec4(1e9), hi = vec4(-1e9);
   for (int y = -1; y <= 1; y++)
   for (int x = -1; x <= 1; x++){
-    vec4 s = texture(u_current, vUv + vec2(float(x), float(y)) * u_texel);
+    vec4 s = texelFetch(u_current, clamp(n + ivec2(x, y), ivec2(0), qMax), 0);
     lo = min(lo, s); hi = max(hi, s);
   }
-  outColor = mix(cur, clamp(hist, lo, hi), u_blend);
+  vec4 h = clamp(hist, lo, hi);
+  outColor = fresh ? mix(cur, h, u_blend) : h;
 }
 `;
 export const CloudResolveMaterial = shaderMaterial({
@@ -69,7 +93,8 @@ export const CloudResolveMaterial = shaderMaterial({
     u_invProj: new THREE.Matrix4(),
     u_camWorld: new THREE.Matrix4(),
     u_camPos: new THREE.Vector3(),
-    u_texel: new THREE.Vector2(1, 1),
+    u_curSize: new THREE.Vector2(1, 1),
+    u_offset: new THREE.Vector2(0, 0),
     u_blend: 0.9,
     u_proxyHeight: 2400,
     u_valid: 0

package/dist/shaders/clouds/CloudVolumeMaterial.d.ts

@@ -72,6 +72,8 @@ export declare const cloudVolumeDefaults: {
     u_far: number;
     u_resolution: THREE.Vector2;
     u_screenSpace: number;
+    u_uvOffset: THREE.Vector2;
+    u_minStep: number;
 };
 export declare const CloudVolumeMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
     u_base: any;
@@ -142,6 +144,8 @@ export declare const CloudVolumeMaterial: import("@react-three/fiber").Construct
     u_far: number;
     u_resolution: THREE.Vector2;
     u_screenSpace: number;
+    u_uvOffset: THREE.Vector2;
+    u_minStep: number;
 }> & {
     key: string;
 };

package/dist/shaders/clouds/CloudVolumeMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CloudVolumeMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/clouds/CloudVolumeMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAuN9D,MAAM,WAAW,0BAA0B;IACzC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6E/B,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAA;AAIxF,OAAO,QAAQ,oBAAoB,CAAC;IAClC,UAAU,aAAa;QACrB,mBAAmB,EAAE,YAAY,CAAC,OAAO,mBAAmB,CAAC,CAAA;KAC9D;CACF"}
+{"version":3,"file":"CloudVolumeMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/clouds/CloudVolumeMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAiO9D,MAAM,WAAW,0BAA0B;IACzC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+E/B,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAA;AAIxF,OAAO,QAAQ,oBAAoB,CAAC;IAClC,UAAU,aAAa;QACrB,mBAAmB,EAAE,YAAY,CAAC,OAAO,mBAAmB,CAAC,CAAA;KAC9D;CACF"}

package/dist/shaders/clouds/CloudVolumeMaterial.js

@@ -40,6 +40,12 @@ uniform vec2  u_resolution;
 uniform int   u_steps;
 uniform float u_stepGrowth, u_maxSpan, u_fogDensity, u_detailFade;
 uniform float u_screenSpace;
+// Layer path only. The march runs at a quarter of the cloud buffer's pixels and each
+// frame picks one of the four half-res pixels under every march texel; this shifts the
+// ray onto that pixel's centre. The resolve pass rebuilds the full buffer from it.
+uniform vec2  u_uvOffset;
+// Floor on the fine step, in metres, from the detail noise size (see applyDeckUniforms).
+uniform float u_minStep;
 
 // Lightning. Declared here rather than in the shared cloudUniforms chunk so the
 // exported cloudField, which host apps pull into their own surface materials for
@@ -59,7 +65,7 @@ float ign(vec2 p){
 }
 
 void main(){
-  vec2 uv = (u_screenSpace > 0.5) ? vUv : (gl_FragCoord.xy / u_resolution);
+  vec2 uv = (u_screenSpace > 0.5) ? (vUv + u_uvOffset) : (gl_FragCoord.xy / u_resolution);
   vec2 ndc = uv * 2.0 - 1.0;
 
   vec4 vp = u_invProj * vec4(ndc, -1.0, 1.0);
@@ -98,7 +104,11 @@ void main(){
       // spans 100 km; dividing that by the step budget gives kilometre steps and every
       // feature dissolves into fog. Empty space is skipped 2.8x coarser, and the step
       // grows with distance to hold screen-space error roughly constant.
-      float dt0 = min(thick * 2.0 / float(u_steps), span / 8.0);
+      //
+      // The floor is the other half: a step much finer than the detail noise samples
+      // the same erosion feature many times over. On a shallow deck the depth-derived
+      // step can be a fraction of that, which costs samples and buys nothing visible.
+      float dt0 = min(max(thick * 2.0 / float(u_steps), u_minStep), span / 8.0);
       dt0 = max(dt0, thick * 0.004);
       float big = dt0 * 2.8;
 
@@ -279,7 +289,9 @@ export const cloudVolumeDefaults = {
     u_near: 1,
     u_far: 100000,
     u_resolution: new THREE.Vector2(1, 1),
-    u_screenSpace: 0
+    u_screenSpace: 0,
+    u_uvOffset: new THREE.Vector2(0, 0),
+    u_minStep: 0
 };
 export const CloudVolumeMaterial = shaderMaterial(cloudVolumeDefaults, vertex, fragment);
 extend({ CloudVolumeMaterial });

package/dist/triggers/kinds/gallery.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gallery.d.ts.map

package/dist/triggers/kinds/gallery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gallery.d.ts","sourceRoot":"","sources":["../../../src/triggers/kinds/gallery.ts"],"names":[],"mappings":""}