@3driseai/3drise-viewer 0.1.25 → 0.1.27

package/dist/operations/runtime.d.ts

@@ -0,0 +1,60 @@
+import type { Object3D } from 'three';
+import type { ActionSequence, OperationEffect, OperationName } from '@3driseai/3drise-core';
+import type { OperationDefinition, OperationParams, OperationTools } from './types';
+/** Register the mounted scene's tools. Returns the unregister. */
+export declare function registerOperationTools(t: OperationTools): () => void;
+export declare function isOperationOn(op: OperationName, target: Object3D): boolean;
+export declare function applyOperation(def: OperationDefinition, target: Object3D, params: OperationParams, self?: Object3D | null, opts?: {
+    bare?: boolean;
+}): boolean;
+/** The last run (apply or revert) of an op on a target — resolves when it has really finished. */
+export declare const runOf: (op: OperationName, target: Object3D) => Promise<void>;
+/**
+ * Undo an operation that is on. `params` overrides the ones it was applied with
+ * (e.g. a zero duration to take it off at once); `bare` runs it with no scene tools.
+ */
+export declare function revertOperation(def: OperationDefinition, target: Object3D, opts?: {
+    params?: Partial<OperationParams>;
+    bare?: boolean;
+}): boolean;
+/**
+ * Undo an operation's effect on a target even when the runtime no longer tracks
+ * it as on (its scene tools were unregistered first, on unmount). Reverts of
+ * operations that are not on do nothing.
+ */
+export declare function forceRevert(def: OperationDefinition, target: Object3D, params: OperationParams): void;
+/** The objects an effect acts on: 'self', object ids, narrowed to model nodes. */
+export declare function resolveEffectTargets(effect: OperationEffect, self?: Object3D | null): Object3D[];
+/**
+ * Run one effect.
+ *   trigger  interactions: toggle when the operation toggles, else apply
+ *   apply / revert / toggle  explicit
+ */
+export declare function runEffect(effect: OperationEffect, mode: 'trigger' | 'apply' | 'revert' | 'toggle', self?: Object3D | null): void;
+/**
+ * Play an effect for the studio and put everything back: apply, wait for the run
+ * to REALLY finish (it may first compile its shaders in the background), hold a
+ * moment, revert and wait for that too. One-shot operations (spin, jelly, flip)
+ * just play; orbit plays and flies home. An effect that is already on is replayed
+ * (revert, then apply) so the scene ends as it was.
+ * Pressing play again on the same row — also after switching its operation —
+ * replaces the running preview: the old one is put back and the new one plays.
+ */
+export declare function previewEffect(effect: OperationEffect, self?: Object3D | null): Promise<boolean>;
+/** Preview several effects together (an interaction's "Try it"). */
+export declare function previewEffects(effects: OperationEffect[], self?: Object3D | null): Promise<boolean>;
+export declare const isPreviewing: (effectId: string) => boolean;
+/**
+ * Compile an effect's shaders ahead of time, without showing anything, so its
+ * first real play starts instantly. Visual effects only (the others have no
+ * shaders). Runs one at a time, in the background; each (effect, target) once.
+ * Used when an effect is picked in the editor and, for every effect a scene's
+ * interactions and actions use, when the scene loads.
+ */
+export declare function prewarmEffect(effect: OperationEffect, self?: Object3D | null): Promise<void>;
+/** Apply or undo an action's effects directly (the editor's "Try it"). */
+export declare function runActionEffects(action: ActionSequence, mode: 'apply' | 'revert'): void;
+export declare const areActionEffectsOn: (actionId: string) => boolean;
+/** Subscribe to action-effects on/off changes (studio badges). */
+export declare function subscribeActionEffects(fn: () => void): () => void;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/operations/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/operations/runtime.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,aAAa,EAAgB,MAAM,uBAAuB,CAAC;AAI1G,OAAO,KAAK,EAAoB,mBAAmB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAwCtG,kEAAkE;AAClE,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,cAAc,GAAG,MAAM,IAAI,CAQpE;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAE1E;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,mBAAmB,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,EAAE,IAAI,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAkB9J;AAcD,kGAAkG;AAClG,eAAO,MAAM,KAAK,GAAI,IAAI,aAAa,EAAE,QAAQ,QAAQ,kBAAqD,CAAC;AAE/G;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,mBAAmB,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAUjJ;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,mBAAmB,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAIrG;AAED,kFAAkF;AAClF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,QAAQ,EAAE,CAahG;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,EAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CAWhI;AASD;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAoCrG;AAED,oEAAoE;AACpE,wBAAsB,cAAc,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAGzG;AAED,eAAO,MAAM,YAAY,GAAI,UAAU,MAAM,YAA2B,CAAC;AASzE;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB5F;AAQD,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,IAAI,CAQvF;AAED,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,YAAkC,CAAC;AAEtF,kEAAkE;AAClE,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAGjE"}

package/dist/operations/runtime.js

@@ -0,0 +1,317 @@
+import { SceneActions, findNodesByName } from '@3driseai/3drise-core';
+import { findById } from '../utils/sceneQuery.js';
+import { getOperation, resolveParams } from './registry.js';
+import { warmMode } from './catalogue/warmup.js';
+const active = new Map(); // `${op}:${uuid}`
+const slots = new Map(); // exclusive group → active key
+const toolsStack = [];
+let cameraHome = null;
+const keyOf = (op, target) => `${op}:${target.uuid}`;
+const tools = () => toolsStack[toolsStack.length - 1];
+/**
+ * Stand-in tools for object effects that run before (or after) a scene has
+ * registered its tools — visual state effects only read the camera pose (for a
+ * left / right sweep), and fall back to world axes without one.
+ */
+const BARE_TOOLS = {
+    animateCamera: async () => undefined,
+    cameraPose: () => null,
+    orbitCamera: async () => undefined,
+    moveToFront: () => undefined,
+    restoreTransform: () => undefined,
+};
+function context(self, bare = false) {
+    const t = tools() ?? (bare ? BARE_TOOLS : undefined);
+    if (!t)
+        return null;
+    return {
+        tools: t,
+        self,
+        saveCameraHome: () => { if (!cameraHome)
+            cameraHome = t.cameraPose(); },
+        restoreCameraHome: (duration, ease) => {
+            const home = cameraHome;
+            cameraHome = null;
+            if (home)
+                void t.animateCamera({ position: home.position }, duration, ease, home.target);
+        },
+    };
+}
+/** Register the mounted scene's tools. Returns the unregister. */
+export function registerOperationTools(t) {
+    toolsStack.push(t);
+    ensureActionsSubscription();
+    return () => {
+        const i = toolsStack.lastIndexOf(t);
+        if (i >= 0)
+            toolsStack.splice(i, 1);
+        if (toolsStack.length === 0) {
+            active.clear();
+            slots.clear();
+            cameraHome = null;
+        }
+    };
+}
+export function isOperationOn(op, target) {
+    return active.has(keyOf(op, target));
+}
+export function applyOperation(def, target, params, self, opts) {
+    const ctx = context(self, opts?.bare);
+    if (!ctx)
+        return false;
+    const key = keyOf(def.value, target);
+    if (def.exclusive) {
+        const prevKey = slots.get(def.exclusive.group);
+        if (prevKey && prevKey !== key) {
+            const prev = active.get(prevKey);
+            active.delete(prevKey);
+            const prevDef = prev && getOperation(prev.op);
+            // `revert` puts the previous one back; `handover` leaves it to the new one.
+            if (prev && prevDef?.revert && def.exclusive.release === 'revert')
+                prevDef.revert(prev.target, prev.params, ctx);
+        }
+        slots.set(def.exclusive.group, key);
+    }
+    runs.set(key, finished(def.apply(target, params, ctx), params));
+    if (def.revert)
+        active.set(key, { op: def.value, target, params });
+    return true;
+}
+// ---------------------------------------------------------------- run completion
+/** The last run (apply or revert) of each op on each target — resolves when it has really finished. */
+const runs = new Map();
+const wait = (s) => new Promise(r => setTimeout(r, Math.max(0, s) * 1000));
+const durationOf = (params) => (Number.isFinite(Number(params.duration)) ? Number(params.duration) : 1);
+/** Visual transitions return their run; others (transform / camera tweens) take their duration. */
+function finished(res, params) {
+    return res && typeof res.then === 'function'
+        ? res.then(() => undefined, () => undefined)
+        : wait(durationOf(params));
+}
+/** The last run (apply or revert) of an op on a target — resolves when it has really finished. */
+export const runOf = (op, target) => runs.get(keyOf(op, target)) ?? Promise.resolve();
+/**
+ * Undo an operation that is on. `params` overrides the ones it was applied with
+ * (e.g. a zero duration to take it off at once); `bare` runs it with no scene tools.
+ */
+export function revertOperation(def, target, opts) {
+    const key = keyOf(def.value, target);
+    const entry = active.get(key);
+    const ctx = context(undefined, opts?.bare);
+    if (!entry || !ctx || !def.revert)
+        return false;
+    active.delete(key);
+    if (def.exclusive && slots.get(def.exclusive.group) === key)
+        slots.delete(def.exclusive.group);
+    const params = opts?.params ? { ...entry.params, ...opts.params } : entry.params;
+    runs.set(key, finished(def.revert(target, params, ctx), params));
+    return true;
+}
+/**
+ * Undo an operation's effect on a target even when the runtime no longer tracks
+ * it as on (its scene tools were unregistered first, on unmount). Reverts of
+ * operations that are not on do nothing.
+ */
+export function forceRevert(def, target, params) {
+    if (revertOperation(def, target, { bare: true, params }) || !def.revert)
+        return;
+    const ctx = context(undefined, true);
+    runs.set(keyOf(def.value, target), finished(def.revert(target, params, ctx), params));
+}
+/** The objects an effect acts on: 'self', object ids, narrowed to model nodes. */
+export function resolveEffectTargets(effect, self) {
+    const out = [];
+    for (const t of effect.targets ?? []) {
+        const root = t === 'self' ? self : findById(t);
+        if (!root)
+            continue;
+        const names = t === 'self' ? undefined : effect.meshNames?.[t];
+        if (names?.length) {
+            for (const name of names)
+                out.push(...findNodesByName(root, name).filter(n => n !== root));
+        }
+        else {
+            out.push(root);
+        }
+    }
+    return out;
+}
+/**
+ * Run one effect.
+ *   trigger  interactions: toggle when the operation toggles, else apply
+ *   apply / revert / toggle  explicit
+ */
+export function runEffect(effect, mode, self) {
+    const def = getOperation(effect.operation);
+    if (!def)
+        return;
+    const targets = resolveEffectTargets(effect, self);
+    const params = resolveParams(def, effect.params);
+    for (const target of def.multi ? targets : targets.slice(0, 1)) {
+        const on = isOperationOn(def.value, target);
+        const m = mode === 'trigger' ? (def.toggles ? 'toggle' : 'apply') : mode;
+        if (m === 'revert' || (m === 'toggle' && on))
+            revertOperation(def, target);
+        else if (m === 'apply' || m === 'toggle')
+            applyOperation(def, target, params, self);
+    }
+}
+// ---------------------------------------------------------------- preview
+const PREVIEW_HOLD = 0.7; // s the finished state is held before it comes back
+/** The running preview of each effect row (by effect id): a newer one replaces it. */
+const previews = new Map();
+/**
+ * Play an effect for the studio and put everything back: apply, wait for the run
+ * to REALLY finish (it may first compile its shaders in the background), hold a
+ * moment, revert and wait for that too. One-shot operations (spin, jelly, flip)
+ * just play; orbit plays and flies home. An effect that is already on is replayed
+ * (revert, then apply) so the scene ends as it was.
+ * Pressing play again on the same row — also after switching its operation —
+ * replaces the running preview: the old one is put back and the new one plays.
+ */
+export async function previewEffect(effect, self) {
+    const def = getOperation(effect.operation);
+    if (!def || !tools())
+        return false;
+    const targets = resolveEffectTargets(effect, self);
+    if (!targets.length)
+        return false;
+    const list = def.multi ? targets : targets.slice(0, 1);
+    const prev = previews.get(effect.id);
+    if (prev) {
+        const pd = getOperation(prev.op);
+        if (pd)
+            for (const t of prev.targets)
+                if (isOperationOn(pd.value, t))
+                    revertOperation(pd, t);
+    }
+    const token = (prev?.token ?? 0) + 1;
+    previews.set(effect.id, { token, op: def.value, targets: list });
+    const alive = () => previews.get(effect.id)?.token === token;
+    const params = resolveParams(def, effect.params);
+    const applyAll = () => Promise.all(list.map(t => { applyOperation(def, t, params, self); return runOf(def.value, t); }));
+    const revertAll = () => Promise.all(list.map(t => { revertOperation(def, t); return runOf(def.value, t); }));
+    try {
+        const wasOn = list.some(t => isOperationOn(def.value, t));
+        if (wasOn) {
+            await revertAll();
+            if (!alive())
+                return true;
+            await wait(PREVIEW_HOLD);
+            if (!alive())
+                return true;
+            await applyAll();
+        }
+        else {
+            await applyAll();
+            if (!alive())
+                return true;
+            await wait(PREVIEW_HOLD);
+            if (!alive())
+                return true;
+            if (def.revert)
+                await revertAll();
+        }
+        return true;
+    }
+    finally {
+        if (alive())
+            previews.delete(effect.id);
+    }
+}
+/** Preview several effects together (an interaction's "Try it"). */
+export async function previewEffects(effects, self) {
+    const results = await Promise.all(effects.map(e => previewEffect(e, self)));
+    return results.some(Boolean);
+}
+export const isPreviewing = (effectId) => previews.has(effectId);
+// ---------------------------------------------------------------- pre-warm
+/** Visual operations with no shaders of their own — nothing to warm (and a warm-only run would show). */
+const NO_SHADERS = new Set(['glow', 'fade', 'visibility', 'displayImage']);
+const warmed = new Set();
+let warmQueue = Promise.resolve();
+/**
+ * Compile an effect's shaders ahead of time, without showing anything, so its
+ * first real play starts instantly. Visual effects only (the others have no
+ * shaders). Runs one at a time, in the background; each (effect, target) once.
+ * Used when an effect is picked in the editor and, for every effect a scene's
+ * interactions and actions use, when the scene loads.
+ */
+export function prewarmEffect(effect, self) {
+    const def = getOperation(effect.operation);
+    if (!def || def.channel !== 'visual' || !def.revert || NO_SHADERS.has(def.value))
+        return Promise.resolve();
+    const params = resolveParams(def, effect.params);
+    const job = async () => {
+        const ctx = context(self);
+        if (!ctx)
+            return;
+        const targets = resolveEffectTargets(effect, self);
+        for (const t of def.multi ? targets : targets.slice(0, 1)) {
+            const k = `${def.value}:${t.uuid}`;
+            if (warmed.has(k) || isOperationOn(def.value, t))
+                continue;
+            warmed.add(k);
+            // a warm-only run: stages and compiles everything, animates nothing…
+            warmMode.on = true;
+            let res;
+            try {
+                res = def.apply(t, params, ctx);
+            }
+            finally {
+                warmMode.on = false;
+            }
+            await finished(res, { duration: 0 });
+            // …then quietly take it off again, unless the user started it meanwhile
+            if (!isOperationOn(def.value, t))
+                await finished(def.revert(t, { ...params, duration: 0.001 }, ctx), { duration: 0 });
+        }
+    };
+    warmQueue = warmQueue.then(job, job);
+    return warmQueue;
+}
+// ---------------------------------------------------------------- actions
+const actionEffectsOn = new Set();
+const listeners = new Set();
+const notify = () => listeners.forEach(l => { try {
+    l();
+}
+catch { /* listener error */ } });
+/** Apply or undo an action's effects directly (the editor's "Try it"). */
+export function runActionEffects(action, mode) {
+    const on = actionEffectsOn.has(action.id);
+    if (mode === 'apply' && on)
+        return;
+    if (mode === 'revert' && !on)
+        return;
+    for (const effect of action.effects ?? [])
+        runEffect(effect, mode);
+    if (mode === 'apply')
+        actionEffectsOn.add(action.id);
+    else
+        actionEffectsOn.delete(action.id);
+    notify();
+}
+export const areActionEffectsOn = (actionId) => actionEffectsOn.has(actionId);
+/** Subscribe to action-effects on/off changes (studio badges). */
+export function subscribeActionEffects(fn) {
+    listeners.add(fn);
+    return () => { listeners.delete(fn); };
+}
+let unsubscribeActions = null;
+function ensureActionsSubscription() {
+    if (unsubscribeActions)
+        return;
+    unsubscribeActions = SceneActions.onEvent((e) => {
+        if (e.type === 'applied') {
+            if (e.runEffects)
+                runActionEffects(e.action, 'apply');
+        }
+        else if (e.type === 'reverted') {
+            runActionEffects(e.action, 'revert');
+        }
+        else if (e.type === 'reset') {
+            e.actions.forEach(a => runActionEffects(a, 'revert'));
+        }
+    });
+}

package/dist/operations/types.d.ts

@@ -0,0 +1,122 @@
+import type { Object3D } from 'three';
+import type { OperationChannel, OperationName, OperationParamValue, Vector3Array } from '@3driseai/3drise-core';
+/** A parameter the studio shows under the effect, with its default. */
+export type OperationParamSpec = {
+    type: 'number';
+    label: string;
+    default: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+    hint?: string;
+} | {
+    type: 'color';
+    label: string;
+    default: string;
+    hint?: string;
+} | {
+    type: 'select';
+    label: string;
+    default: string;
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+    hint?: string;
+} | {
+    type: 'boolean';
+    label: string;
+    default: boolean;
+    hint?: string;
+};
+export type OperationParams = Record<string, OperationParamValue>;
+/** interaction / action: triggered. object: layered on the object (CreatedObject.effects), switched on / off. */
+export type OperationSource = 'interaction' | 'action' | 'object';
+/** Scene tools the runtime hands an operation (built from the viewer's hooks). */
+export interface OperationTools {
+    /** Animate the camera; `lookAt` moves the orbit target. */
+    animateCamera: (to: {
+        position?: Vector3Array;
+    }, duration: number, ease: string, lookAt?: Vector3Array) => Promise<void>;
+    /** Where the camera is and looks right now. */
+    cameraPose: () => {
+        position: Vector3Array;
+        target: Vector3Array;
+    } | null;
+    /**
+     * Circle the camera around `center` (world Y axis) by `degrees`, keeping its
+     * distance and height; the orbit target eases onto `center` on the way.
+     */
+    orbitCamera: (center: Vector3Array, degrees: number, duration: number, ease: string) => Promise<void>;
+    moveToFront: (object: Object3D, options: {
+        distance: number;
+        scale: [number, number];
+        duration: number;
+        ease: string;
+    }) => void;
+    restoreTransform: (object: Object3D, options: {
+        duration: number;
+        ease: string;
+    }) => void;
+}
+export interface OperationContext {
+    tools: OperationTools;
+    /** The object an interaction is on (interactions only). */
+    self?: Object3D | null;
+    /** Remember the camera pose once, before the first camera operation. */
+    saveCameraHome: () => void;
+    /** Fly back to the remembered pose and forget it. */
+    restoreCameraHome: (duration: number, ease: string) => void;
+}
+export interface OperationDefinition {
+    value: OperationName;
+    label: string;
+    /** One line for the studio (tooltip). */
+    description: string;
+    /** What it acts on — an interaction holds one effect per channel (see OperationChannel). */
+    channel: OperationChannel;
+    /** More than one target allowed. */
+    multi: boolean;
+    /** An interaction triggered again undoes it. */
+    toggles: boolean;
+    /** Where the operation can be used. */
+    usableIn: OperationSource[];
+    /** Only on gallery objects. */
+    galleryOnly?: boolean;
+    /**
+     * One target of this group is "on" at a time, scene-wide. Applying another:
+     * `revert` undoes the previous one first (bring to front), `handover` just
+     * takes over (camera moves — the remembered home pose stays).
+     */
+    exclusive?: {
+        group: string;
+        release: 'revert' | 'handover';
+    };
+    params?: Record<string, OperationParamSpec>;
+    /**
+     * Object effects only: parameters forced to these values (the studio hides
+     * them), e.g. a hologram that must stay visible.
+     */
+    objectParams?: OperationParams;
+    /**
+     * Object effects only: one effect of a stack per object — `surface` effects
+     * replace the whole look of the surface (frost, metalize, petrify), so two
+     * never run together. Effects without a stack add on top of anything.
+     */
+    stack?: 'surface';
+    /** Visual transitions return a promise that resolves when the run has finished. */
+    apply: (target: Object3D, params: OperationParams, ctx: OperationContext) => void | Promise<void>;
+    /** No revert = one-way (applies only). */
+    revert?: (target: Object3D, params: OperationParams, ctx: OperationContext) => void | Promise<void>;
+}
+/** Type helper for catalogue files. */
+export declare const defineOperation: (def: OperationDefinition) => OperationDefinition;
+export declare const DEFAULT_EASE = "power2.out";
+/** The channels in studio order, with their labels. */
+export declare const OPERATION_CHANNELS: Array<{
+    value: OperationChannel;
+    label: string;
+    description: string;
+}>;
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/operations/types.js

@@ -0,0 +1,9 @@
+/** Type helper for catalogue files. */
+export const defineOperation = (def) => def;
+export const DEFAULT_EASE = 'power2.out';
+/** The channels in studio order, with their labels. */
+export const OPERATION_CHANNELS = [
+    { value: 'transform', label: 'Transform', description: "Moves, turns or scales the object itself" },
+    { value: 'visual', label: 'Visual', description: 'Changes how the object looks — never where it is' },
+    { value: 'camera', label: 'Camera', description: 'Moves or turns the camera' },
+];

package/dist/operations/useObjectEffectLayers.d.ts

@@ -0,0 +1,4 @@
+import type { Object3D } from 'three';
+import type { ObjectEffect } from '@3driseai/3drise-core';
+export declare function useObjectEffectLayers(ref: React.RefObject<Object3D | null>, effects: ObjectEffect[] | undefined): void;
+//# sourceMappingURL=useObjectEffectLayers.d.ts.map

package/dist/operations/useObjectEffectLayers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useObjectEffectLayers.d.ts","sourceRoot":"","sources":["../../src/operations/useObjectEffectLayers.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAM1D,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,KAAK,CAAC,SAAS,CAAC,QAAQ,GAAG,IAAI,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,SAAS,QAkC/G"}

package/dist/operations/useObjectEffectLayers.js

@@ -0,0 +1,42 @@
+// Runs an object's effects (CreatedObject.effects) on its group — see ./objectEffects.ts.
+import { useEffect, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { ObjectEffectsController, surfaceSignature } from './objectEffects.js';
+/** How often (frames) the object's meshes / materials are checked for replacement. */
+const CHECK_EVERY = 20;
+export function useObjectEffectLayers(ref, effects) {
+    const ctrl = useRef(null);
+    const signature = useRef('');
+    const latest = useRef(effects);
+    latest.current = effects;
+    const has = !!effects?.length;
+    // Changes after the first sync play their transitions; the first lands at once.
+    useEffect(() => {
+        const root = ref.current;
+        if (!root)
+            return;
+        if (!ctrl.current) {
+            if (!has)
+                return;
+            ctrl.current = new ObjectEffectsController(root);
+            signature.current = surfaceSignature(root);
+            ctrl.current.sync(effects, 'instant');
+            return;
+        }
+        ctrl.current.sync(effects, 'animate');
+    }, [effects, has, ref]);
+    useEffect(() => () => { ctrl.current?.dispose(); ctrl.current = null; }, []);
+    // A model that finished loading, a material swapped by an edit: move the effects over.
+    const frame = useRef(0);
+    useFrame(() => {
+        const c = ctrl.current;
+        const root = ref.current;
+        if (!c || !root || ++frame.current % CHECK_EVERY)
+            return;
+        const sig = surfaceSignature(root);
+        if (sig === signature.current)
+            return;
+        signature.current = sig;
+        void c.refresh();
+    });
+}

package/dist/operations/useOperationsRuntime.d.ts

@@ -0,0 +1,3 @@
+import type { CameraState } from '@3driseai/3drise-core';
+export declare function useOperationsRuntime(cameraSettings: CameraState): void;
+//# sourceMappingURL=useOperationsRuntime.d.ts.map

package/dist/operations/useOperationsRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOperationsRuntime.d.ts","sourceRoot":"","sources":["../../src/operations/useOperationsRuntime.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,uBAAuB,CAAC;AAQvE,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,WAAW,QAsD/D"}

package/dist/operations/useOperationsRuntime.js

@@ -0,0 +1,69 @@
+// Mounts the operations runtime on the scene: builds the scene tools from the
+// viewer's hooks and registers them. Called once, in ObjectsRenderer.
+import { useEffect, useRef } from 'react';
+import { gsap } from 'gsap';
+import { Vector3 } from 'three';
+import cameraManager from '../utils/CameraSingleton.js';
+import useCameraAnimation from '../hooks/useCameraAnimation.js';
+import { useFrameAnimations } from '../hooks/useFrameAnimations.js';
+import { useOrbitControls } from '../hooks/useOrbitControls.js';
+import { registerOperationTools } from './runtime.js';
+export function useOperationsRuntime(cameraSettings) {
+    const { animateCamera, killAnimation } = useCameraAnimation({ autoAnimate: false, defaultDuration: 1, defaultEase: 'power2.out' });
+    const { moveToFront, restoreOriginalTransform } = useFrameAnimations(cameraSettings);
+    const controls = useOrbitControls();
+    // Latest hook functions, read at call time (the registration itself is stable).
+    const latest = useRef({ animateCamera, killAnimation, moveToFront, restoreOriginalTransform, controls, cameraSettings });
+    latest.current = { animateCamera, killAnimation, moveToFront, restoreOriginalTransform, controls, cameraSettings };
+    // One camera move at a time: a new move stops a running orbit, an orbit stops a running move.
+    const orbit = useRef(null);
+    const stopOrbit = () => { orbit.current?.kill(); orbit.current = null; };
+    useEffect(() => registerOperationTools({
+        animateCamera: (to, duration, ease, lookAt) => { stopOrbit(); return latest.current.animateCamera(to, duration, ease, lookAt); },
+        orbitCamera: (center, degrees, duration, ease) => {
+            const cam = cameraManager.getCamera();
+            const controls = latest.current.controls;
+            if (!cam)
+                return Promise.resolve();
+            stopOrbit();
+            latest.current.killAnimation();
+            const c = new Vector3(...center);
+            const offset = cam.position.clone().sub(c);
+            const fromTarget = controls?.target?.clone() ?? c.clone();
+            const up = new Vector3(0, 1, 0);
+            const total = (degrees * Math.PI) / 180;
+            const proxy = { t: 0 };
+            return new Promise((resolve) => {
+                orbit.current = gsap.to(proxy, {
+                    t: 1, duration, ease,
+                    onUpdate: () => {
+                        cam.position.copy(c).add(offset.clone().applyAxisAngle(up, total * proxy.t));
+                        // the look-at point settles on the centre over the first third
+                        const k = Math.min(1, proxy.t * 3);
+                        const s = k * k * (3 - 2 * k);
+                        if (controls?.target) {
+                            controls.target.lerpVectors(fromTarget, c, s);
+                            controls.update?.();
+                        }
+                        else
+                            cam.lookAt(c);
+                    },
+                    onComplete: () => { orbit.current = null; resolve(); },
+                    onInterrupt: () => resolve(),
+                });
+            });
+        },
+        cameraPose: () => {
+            const pos = cameraManager.getPosition();
+            if (!pos)
+                return null;
+            const t = latest.current.controls?.target;
+            const target = t
+                ? [t.x, t.y, t.z]
+                : latest.current.cameraSettings?.controls?.target ?? [0, 0, 0];
+            return { position: [pos.x, pos.y, pos.z], target };
+        },
+        moveToFront: (object, o) => latest.current.moveToFront(object, o),
+        restoreTransform: (object, o) => latest.current.restoreOriginalTransform(object, o),
+    }), []);
+}

package/dist/presets/landscapePresets.d.ts

@@ -1,4 +1,4 @@
-import type { LandscapeConfig, LandscapeSurface } from '../types/landscapeConfigs';
+import type { LandscapeConfig, LandscapeSurface } from '@3driseai/3drise-core';
 /**
  * Starter landscapes.
  *