@3driseai/3drise-viewer 0.1.25 → 0.1.27

package/dist/animationsV2/ClipPlayer.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { ActionSequence } from '@3driseai/3drise-core';
+import type { AnimationClip, AnimationSequence } from './types';
+export interface ClipPlayerProps {
+    getSettings: (state: string) => any;
+    /** The project's actions, for sequence cues (by id). */
+    getAction?: (id: string) => ActionSequence | undefined;
+    /** Start the sequences flagged `autoplay` (published viewer). The studio leaves this off. */
+    autoplay?: {
+        sequences: AnimationSequence[];
+        clips: AnimationClip[];
+    };
+}
+declare const ClipPlayer: React.FC<ClipPlayerProps>;
+export default ClipPlayer;
+//# sourceMappingURL=ClipPlayer.d.ts.map

package/dist/animationsV2/ClipPlayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClipPlayer.d.ts","sourceRoot":"","sources":["../../src/animationsV2/ClipPlayer.tsx"],"names":[],"mappings":"AAwBA,OAAO,KAA4B,MAAM,OAAO,CAAC;AAIjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEhE,MAAM,WAAW,eAAe;IAC5B,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,GAAG,CAAC;IACpC,wDAAwD;IACxD,SAAS,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,cAAc,GAAG,SAAS,CAAC;IACvD,6FAA6F;IAC7F,QAAQ,CAAC,EAAE;QAAE,SAAS,EAAE,iBAAiB,EAAE,CAAC;QAAC,KAAK,EAAE,aAAa,EAAE,CAAA;KAAE,CAAC;CACzE;AAcD,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAoJzC,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/animationsV2/ClipPlayer.js

@@ -0,0 +1,199 @@
+// =============================================================================
+// ClipPlayer — drives ClipsRuntime from the R3F frame loop, and feeds it input.
+// =============================================================================
+//
+// Mount inside the Canvas AFTER the objects and the environment: R3F runs
+// same-priority frame callbacks in subscription order, so clips write after the
+// objects' own per-frame animation. Priority stays 0 — a positive priority would
+// take rendering over from R3F (see CLAUDE.md on the cloud pass).
+//
+// `getSettings(state)` returns an element's authored settings (action patches
+// included) — the value a stopped track restores. The studio reads it from Redux,
+// the published viewer from the loaded project (resolveElementSettings).
+//
+// Input drivers (sequence.driver):
+//   mouseX / mouseY  the pointer's position over the canvas is the progress (0–1).
+//   mouseWheel       the wheel moves the progress (sensitivity); touch: vertical drag.
+//                    While one runs, OrbitControls zoom is off. At either end the wheel
+//                    is let through, so the host page can scroll on.
+// Listeners sit on window and check the canvas rect: studio overlays above the
+// canvas would otherwise swallow the events.
+//
+// `autoplay` (published viewer): sequences flagged autoplay start on mount; time-driven
+// ones hold at their start until the objects they animate are loaded.
+//
+import { useEffect, useRef } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import ClipsRuntime from './ClipsRuntime.js';
+import { clipMap } from './sequenceUtils.js';
+/** Wheel delta in pixels, whatever the device reports. */
+const wheelPixels = (e) => e.deltaMode === 1 ? e.deltaY * 16 : e.deltaMode === 2 ? e.deltaY * window.innerHeight : e.deltaY;
+/** Diagnostics switch: `?animdebug=1` or localStorage '3drise.animdebug' = '1'. */
+function animDebugOn() {
+    try {
+        if (typeof window === 'undefined')
+            return false;
+        return new URLSearchParams(window.location.search).has('animdebug') || window.localStorage.getItem('3drise.animdebug') === '1';
+    }
+    catch {
+        return false;
+    }
+}
+const ClipPlayer = ({ getSettings, getAction, autoplay }) => {
+    // Before any other effect, so the first calls are logged too.
+    if (!ClipsRuntime.debug && animDebugOn()) {
+        ClipsRuntime.debug = true;
+        window.__clipsRuntime = ClipsRuntime;
+    }
+    useEffect(() => {
+        ClipsRuntime.dlog('ClipPlayer mounted', { published: !!autoplay });
+        return () => ClipsRuntime.dlog('ClipPlayer unmounted', { published: !!autoplay });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const camera = useThree((s) => s.camera);
+    const controls = useThree((s) => s.controls);
+    const gl = useThree((s) => s.gl);
+    // Read at restore time through a ref, so the context object stays stable.
+    const settingsRef = useRef(getSettings);
+    settingsRef.current = getSettings;
+    const actionRef = useRef(getAction);
+    actionRef.current = getAction;
+    useEffect(() => {
+        ClipsRuntime.setContext({
+            camera, controls,
+            getSettings: (state) => settingsRef.current(state),
+            getAction: (id) => actionRef.current?.(id),
+        });
+        return () => ClipsRuntime.setContext(null);
+    }, [camera, controls]);
+    // --- autoplay (published viewer) --------------------------------------------------
+    // Each sequence flagged autoplay starts when the scene mounts — driven ones too (a
+    // wheel-driven sequence is "playing" = listening to the wheel from the start). A
+    // time-driven one holds at its start until its objects are loaded (waitForTargets).
+    // Already-running sequences are left alone, so a re-render or remount never restarts
+    // one. Leaving the scene clears the runtime: nothing carries over to another route.
+    useEffect(() => {
+        if (!autoplay)
+            return;
+        const lookup = clipMap(autoplay.clips);
+        ClipsRuntime.dlog('autoplay effect', {
+            clips: autoplay.clips.length,
+            sequences: autoplay.sequences.map(s => ({ name: s.name, autoplay: s.autoplay, driver: s.driver, active: ClipsRuntime.isSequenceActive(s.id) })),
+        });
+        for (const seq of autoplay.sequences) {
+            if (!seq.autoplay || ClipsRuntime.isSequenceActive(seq.id))
+                continue;
+            ClipsRuntime.playSequence(seq, lookup, { waitForTargets: true });
+        }
+    }, [autoplay?.sequences, autoplay?.clips]);
+    const isPublished = !!autoplay;
+    useEffect(() => () => { if (isPublished)
+        ClipsRuntime.reset(); }, [isPublished]);
+    // --- input drivers ----------------------------------------------------------------
+    useEffect(() => {
+        const canvas = gl.domElement;
+        const inside = (x, y) => {
+            const r = canvas.getBoundingClientRect();
+            return x >= r.left && x <= r.right && y >= r.top && y <= r.bottom ? r : null;
+        };
+        /** Progress along the wheel-driven sequences; true when any of them moved. */
+        const nudgeWheel = (pixels) => {
+            let moved = false;
+            for (const d of ClipsRuntime.getDrivenSequences()) {
+                if (d.driver !== 'mouseWheel')
+                    continue;
+                const dir = d.settings?.invert ? -1 : 1;
+                const delta = pixels * dir * Math.max(0.01, d.settings?.sensitivity ?? 1) / 1000;
+                if (ClipsRuntime.nudgeSequenceProgress(d.id, delta))
+                    moved = true;
+            }
+            return moved;
+        };
+        let touchY = null;
+        const onPointerMove = (e) => {
+            const r = inside(e.clientX, e.clientY);
+            if (!r)
+                return;
+            for (const d of ClipsRuntime.getDrivenSequences()) {
+                if (d.driver !== 'mouseX' && d.driver !== 'mouseY')
+                    continue;
+                const raw = d.driver === 'mouseX' ? (e.clientX - r.left) / r.width : (e.clientY - r.top) / r.height;
+                ClipsRuntime.setSequenceProgress(d.id, d.settings?.invert ? 1 - raw : raw);
+            }
+            // Touch has no wheel: a vertical drag stands in for it (drag up = forward).
+            if (e.pointerType === 'touch' && touchY !== null) {
+                nudgeWheel(touchY - e.clientY);
+                touchY = e.clientY;
+            }
+        };
+        const onPointerDown = (e) => {
+            if (e.pointerType === 'touch' && inside(e.clientX, e.clientY))
+                touchY = e.clientY;
+        };
+        const onPointerUp = () => { touchY = null; };
+        const onWheel = (e) => {
+            if (!inside(e.clientX, e.clientY))
+                return;
+            // Only swallow the wheel while it moved something; at either end the page scrolls.
+            if (nudgeWheel(wheelPixels(e)))
+                e.preventDefault();
+        };
+        window.addEventListener('pointermove', onPointerMove);
+        window.addEventListener('pointerdown', onPointerDown);
+        window.addEventListener('pointerup', onPointerUp);
+        window.addEventListener('pointercancel', onPointerUp);
+        window.addEventListener('wheel', onWheel, { passive: false });
+        return () => {
+            window.removeEventListener('pointermove', onPointerMove);
+            window.removeEventListener('pointerdown', onPointerDown);
+            window.removeEventListener('pointerup', onPointerUp);
+            window.removeEventListener('pointercancel', onPointerUp);
+            window.removeEventListener('wheel', onWheel);
+        };
+    }, [gl]);
+    // --- zoom: OrbitControls must not zoom while the wheel drives a sequence -----------
+    const zoomRestore = useRef(null);
+    useEffect(() => () => {
+        const z = zoomRestore.current;
+        if (z?.controls)
+            z.controls.enableZoom = z.enableZoom;
+        zoomRestore.current = null;
+    }, []);
+    // --- camera: OrbitControls sit out while an animation drives the camera ------------
+    // Their update (damping residue, min / max distance and angle limits, auto-rotate)
+    // would otherwise pull the camera back every frame. Handed back afterwards with
+    // the authored setting (so the Controls "enabled" switch always wins).
+    const cameraHeld = useRef(null);
+    useEffect(() => () => {
+        const c = cameraHeld.current;
+        if (c)
+            c.enabled = settingsRef.current('camera')?.controls?.enabled ?? true;
+        cameraHeld.current = null;
+    }, []);
+    useFrame((_state, delta) => {
+        ClipsRuntime.tick(delta);
+        const driving = ClipsRuntime.isDrivingCamera();
+        if (driving && controls) {
+            if (cameraHeld.current !== controls)
+                cameraHeld.current = controls;
+            controls.enabled = false;
+        }
+        else if (cameraHeld.current) {
+            cameraHeld.current.enabled = settingsRef.current('camera')?.controls?.enabled ?? true;
+            cameraHeld.current = null;
+        }
+        const wheelActive = ClipsRuntime.getDrivenSequences().some(d => d.driver === 'mouseWheel');
+        const z = zoomRestore.current;
+        if (wheelActive && controls && !z) {
+            zoomRestore.current = { controls, enableZoom: controls.enableZoom !== false };
+            controls.enableZoom = false;
+        }
+        else if ((!wheelActive || z?.controls !== controls) && z) {
+            if (z.controls)
+                z.controls.enableZoom = z.enableZoom;
+            zoomRestore.current = null;
+        }
+    });
+    return null;
+};
+export default ClipPlayer;

package/dist/animationsV2/ClipsRuntime.d.ts

@@ -0,0 +1,150 @@
+import type { AnimationClip, AnimationSequence, KeyValue, Track } from './types';
+import { type ApplyContext } from './appliers';
+import { type ClipLookup, type ScheduledClip } from './sequenceUtils';
+/** A driven sequence as the input layer sees it. */
+export interface DrivenSequence {
+    id: string;
+    driver: AnimationSequence['driver'];
+    settings: AnimationSequence['driverSettings'];
+    /** 0–1 along the sequence's own direction (reverse flips it). */
+    progress: number;
+}
+export type RuntimeEventType = 'start' | 'end' | 'loop';
+export interface RuntimeEvent {
+    type: RuntimeEventType;
+    kind: 'clip' | 'sequence';
+    id: string;
+}
+/** @deprecated name kept for existing imports */
+export type ClipEvent = RuntimeEvent;
+declare class ClipsRuntime {
+    private clips;
+    private sequences;
+    private ctx;
+    private order;
+    private version;
+    private listeners;
+    /** Coarse: play / pause / stop / start / end / reset / data edits — never per frame. */
+    private stateVersion;
+    private stateListeners;
+    private eventListeners;
+    /** tracks whose authored value must be written back on the next tick */
+    private pendingRestore;
+    /** last written value per property (targetKey -> JSON) */
+    private written;
+    debug: boolean;
+    private logAt;
+    dlog(...args: unknown[]): void;
+    /** At most once per `ms` per key. */
+    private dlogEvery;
+    private caller;
+    setContext(ctx: ApplyContext | null): void;
+    /**
+     * Every change, including each frame's time while anything plays. For UI that
+     * follows the playhead, write through refs in the listener — never re-render React
+     * per frame (the timeline panels would re-render ~60×/s on the render thread).
+     */
+    subscribe(listener: () => void): () => void;
+    getVersion(): number;
+    /** State changes only (play / pause / stop / start / end / reset / edits) — safe for React. */
+    subscribeState(listener: () => void): () => void;
+    getStateVersion(): number;
+    on(listener: (e: RuntimeEvent) => void): () => void;
+    /**
+     * Forget every instance without writing anything back — a new scene is loading
+     * (the singleton outlives a route change: whatever the studio was playing must not
+     * carry into the published view).
+     */
+    reset(): void;
+    play(clip: AnimationClip, opts?: {
+        from?: number;
+        speed?: number;
+        reverse?: boolean;
+    }): void;
+    pause(clipId: string): void;
+    resume(clipId: string): void;
+    /** Stop and put the clip's properties back to their authored values. */
+    stop(clipId: string): void;
+    /** Hold the clip at t (seconds) — the editor playhead, or seek() from outside. */
+    pose(clip: AnimationClip, t: number): void;
+    /** The clip data changed (editor edit): keep time and play state, use the new tracks. */
+    updateClip(clip: AnimationClip): void;
+    getTime(clipId: string): number;
+    isPlaying(clipId: string): boolean;
+    isActive(clipId: string): boolean;
+    /** Value of a track at the clip's current time (the panel's value column). */
+    sampleAt(clip: AnimationClip, track: Track): KeyValue | undefined;
+    /**
+     * Play a sequence. `reverse` defaults to the sequence's own; `from` is sequence
+     * seconds (defaults to the current time, or the start edge of the run).
+     */
+    playSequence(seq: AnimationSequence, clips: ClipLookup, opts?: {
+        from?: number;
+        speed?: number;
+        reverse?: boolean;
+        waitForTargets?: boolean;
+    }): void;
+    /** Driven sequences that are running — what the input layer (ClipPlayer) feeds. */
+    getDrivenSequences(): DrivenSequence[];
+    /**
+     * Set a sequence's position, 0–1 along its own direction (reverse flips it). A
+     * driven sequence eases there (its smoothing); any other is posed there at once.
+     */
+    setSequenceProgress(seqId: string, progress: number): boolean;
+    /**
+     * Move a driven sequence's target by `delta` of its length (the wheel). Returns
+     * false when it is already at that end — the caller then lets the event through
+     * (page scroll), so a visitor is never trapped inside the canvas.
+     */
+    nudgeSequenceProgress(seqId: string, delta: number): boolean;
+    getSequenceProgress(seqId: string): number;
+    private progressOf;
+    private timeOf;
+    pauseSequence(seqId: string): void;
+    resumeSequence(seqId: string): void;
+    /** Stop and put every property the sequence drove back to its authored value. */
+    stopSequence(seqId: string): void;
+    /** Hold the sequence at T (sequence seconds) — the panel's scrub, or seek(). */
+    poseSequence(seq: AnimationSequence, clips: ClipLookup, T: number): void;
+    /** The sequence or one of its clips changed: re-resolve, keep time and play state. */
+    updateSequence(seq: AnimationSequence, clips: ClipLookup): void;
+    /**
+     * Whether a PLAYING clip or sequence writes the camera right now. The player then
+     * holds OrbitControls off so its own update (damping, distance / angle limits,
+     * auto-rotate) doesn't fight the animation. A posed (paused) one doesn't count —
+     * in the editor you can still orbit around a held pose.
+     */
+    isDrivingCamera(): boolean;
+    getSequenceTime(seqId: string): number;
+    getSequenceDuration(seqId: string): number;
+    isSequencePlaying(seqId: string): boolean;
+    isSequenceActive(seqId: string): boolean;
+    tick(delta: number): void;
+    /** Objects / nodes the sequence animates — or its cued actions touch — that aren't in the scene yet. */
+    private missingTargets;
+    /** Apply / revert the actions whose cue state changed since the last tick. */
+    private syncCues;
+    /** Revert every action the sequence applied (stop / close). */
+    private releaseActions;
+    /** Every driver's values for this frame, lowest priority first. */
+    private proposals;
+    private runRestores;
+    /** Whether any active driver still has a track on (state, node, path). */
+    private isDriven;
+    private advanceClip;
+    private finishClip;
+    /**
+     * Same edge rules as a clip, on the sequence clock. "Forward" is the run's base
+     * direction: a reversed run starts at the end and finishes at 0.
+     */
+    private advanceSequence;
+    private finishSequence;
+    private emit;
+    private bump;
+    /** A state change: notifies both kinds of subscribers. */
+    private bumpState;
+}
+export type { ScheduledClip };
+declare const clipsRuntime: ClipsRuntime;
+export default clipsRuntime;
+//# sourceMappingURL=ClipsRuntime.d.ts.map

package/dist/animationsV2/ClipsRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClipsRuntime.d.ts","sourceRoot":"","sources":["../../src/animationsV2/ClipsRuntime.ts"],"names":[],"mappings":"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"}