@3driseai/3drise-viewer 0.1.1

package/dist/utils/CameraSingleton.js

@@ -0,0 +1,199 @@
+import { PerspectiveCamera, OrthographicCamera, Vector3, Euler, Quaternion } from 'three';
+class CameraSingleton {
+    static instance;
+    camera = null;
+    callbacks = new Set();
+    cameraMoveCallbacks = new Set();
+    lastPosition = new Vector3();
+    lastRotation = new Euler();
+    constructor() { }
+    static getInstance() {
+        if (!CameraSingleton.instance) {
+            CameraSingleton.instance = new CameraSingleton();
+        }
+        return CameraSingleton.instance;
+    }
+    animateCameraPosition(position) {
+        return new Promise((resolve) => {
+            if (!this.camera) {
+                resolve();
+                return;
+            }
+            const targetPosition = new Vector3(...position);
+            const duration = 1;
+            const startPosition = this.camera.position.clone();
+            const startTime = performance.now();
+            const animate = () => {
+                const elapsed = (performance.now() - startTime) / 1000;
+                const t = Math.min(elapsed / duration, 1);
+                this.camera.position.lerpVectors(startPosition, targetPosition, t);
+                this.notifyCallbacks();
+                if (t < 1)
+                    requestAnimationFrame(animate);
+                else
+                    resolve();
+            };
+            animate();
+        });
+    }
+    setCamera(camera) {
+        this.camera = camera;
+        this.lastPosition.copy(camera.position);
+        this.lastRotation.copy(camera.rotation);
+        this.notifyCallbacks();
+    }
+    getCamera() { return this.camera; }
+    getPosition() { return this.camera ? this.camera.position.clone() : new Vector3(); }
+    getRotation() { return this.camera ? this.camera.rotation.clone() : new Euler(); }
+    isSynced(position, orientation) {
+        if (!this.camera)
+            return true;
+        const camPos = this.camera.position;
+        const camRot = this.camera.rotation;
+        const posMatch = Math.abs(position[0] - camPos.x) < 0.001 &&
+            Math.abs(position[1] - camPos.y) < 0.001 &&
+            Math.abs(position[2] - camPos.z) < 0.001;
+        let rotMatch = false;
+        if (orientation.length === 3) {
+            rotMatch =
+                Math.abs(orientation[0] - camRot.x) < 0.001 &&
+                    Math.abs(orientation[1] - camRot.y) < 0.001 &&
+                    Math.abs(orientation[2] - camRot.z) < 0.001;
+        }
+        else {
+            const camQuat = new Quaternion().setFromEuler(camRot);
+            rotMatch =
+                Math.abs(orientation[0] - camQuat.x) < 0.001 &&
+                    Math.abs(orientation[1] - camQuat.y) < 0.001 &&
+                    Math.abs(orientation[2] - camQuat.z) < 0.001 &&
+                    Math.abs(orientation[3] - camQuat.w) < 0.001;
+        }
+        return posMatch && rotMatch;
+    }
+    getWorldDirection() {
+        const direction = new Vector3();
+        return this.camera ? this.camera.getWorldDirection(direction) : direction;
+    }
+    getFOV() { return this.camera ? this.camera.fov : 75; }
+    subscribe(callback) {
+        this.callbacks.add(callback);
+        return () => this.callbacks.delete(callback);
+    }
+    notifyCallbacks() {
+        this.callbacks.forEach((cb) => cb());
+    }
+    isAvailable() { return this.camera !== null; }
+    getDistanceToTarget(target) {
+        return this.camera ? this.camera.position.distanceTo(target) : 0;
+    }
+    lookAt(target) {
+        if (this.camera) {
+            this.camera.lookAt(target);
+            this.notifyCallbacks();
+        }
+    }
+    calculateVisibleSize(targetDepth, cam) {
+        const camera = cam || this.camera;
+        if (!camera)
+            return { width: 0, height: 0 };
+        if (camera instanceof PerspectiveCamera) {
+            const distance = targetDepth === undefined ? camera.near : Math.abs(targetDepth - camera.position.z);
+            const vFov = (camera.fov * Math.PI) / 180;
+            const height = 2 * Math.tan(vFov / 2) * distance;
+            return { width: height * camera.aspect, height };
+        }
+        else if (camera instanceof OrthographicCamera) {
+            return { width: Math.abs(camera.right - camera.left), height: Math.abs(camera.top - camera.bottom) };
+        }
+        return { width: 0, height: 0 };
+    }
+    getCurrentViewportBounds(cam) {
+        const camera = cam || this.camera;
+        const empty = new Vector3();
+        if (!camera) {
+            return {
+                topLeft: empty.clone(),
+                topRight: empty.clone(),
+                bottomLeft: empty.clone(),
+                bottomRight: empty.clone(),
+                center: empty.clone()
+            };
+        }
+        camera.updateMatrixWorld();
+        // NDC z=-1 is the near clipping plane for both perspective and orthographic cameras.
+        const topLeft = new Vector3(-1, 1, -1).unproject(camera);
+        const topRight = new Vector3(1, 1, -1).unproject(camera);
+        const bottomLeft = new Vector3(-1, -1, -1).unproject(camera);
+        const bottomRight = new Vector3(1, -1, -1).unproject(camera);
+        const center = new Vector3(0, 0, -1).unproject(camera);
+        return { topLeft, topRight, bottomLeft, bottomRight, center };
+    }
+    getAnchorPosition(anchor, targetDepth = 0, offset, padding = 0) {
+        if (!this.camera)
+            return new Vector3();
+        const { width, height } = this.calculateVisibleSize(targetDepth);
+        const halfWidth = width / 2;
+        const halfHeight = height / 2;
+        let localX = 0;
+        let localY = 0;
+        switch (anchor) {
+            case 'top-left':
+            case 'center-left':
+            case 'bottom-left':
+                localX = -halfWidth + padding;
+                break;
+            case 'top-right':
+            case 'center-right':
+            case 'bottom-right':
+                localX = halfWidth - padding;
+                break;
+        }
+        switch (anchor) {
+            case 'top-left':
+            case 'top-center':
+            case 'top-right':
+                localY = halfHeight - padding;
+                break;
+            case 'bottom-left':
+            case 'bottom-center':
+            case 'bottom-right':
+                localY = -halfHeight + padding;
+                break;
+        }
+        const localZ = -(Math.abs(targetDepth - this.camera.position.z));
+        const localPosition = new Vector3(localX, localY, localZ);
+        if (offset) {
+            if (offset.x !== undefined)
+                localPosition.x += offset.x;
+            if (offset.y !== undefined)
+                localPosition.y += offset.y;
+            if (offset.z !== undefined)
+                localPosition.z += offset.z;
+        }
+        this.camera.updateMatrixWorld();
+        return localPosition.applyMatrix4(this.camera.matrixWorld);
+    }
+    onCameraMove(callback) {
+        this.cameraMoveCallbacks.add(callback);
+        return () => this.cameraMoveCallbacks.delete(callback);
+    }
+    checkCameraMovement(epsilon = 0.001) {
+        if (!this.camera)
+            return false;
+        const positionChanged = Math.abs(this.lastPosition.x - this.camera.position.x) > epsilon ||
+            Math.abs(this.lastPosition.y - this.camera.position.y) > epsilon ||
+            Math.abs(this.lastPosition.z - this.camera.position.z) > epsilon;
+        const rotationChanged = Math.abs(this.lastRotation.x - this.camera.rotation.x) > epsilon ||
+            Math.abs(this.lastRotation.y - this.camera.rotation.y) > epsilon ||
+            Math.abs(this.lastRotation.z - this.camera.rotation.z) > epsilon;
+        if (positionChanged || rotationChanged) {
+            this.lastPosition.copy(this.camera.position);
+            this.lastRotation.copy(this.camera.rotation);
+            this.cameraMoveCallbacks.forEach((cb) => cb(this.camera.position.clone(), this.camera.rotation.clone()));
+            return true;
+        }
+        return false;
+    }
+}
+export const cameraManager = CameraSingleton.getInstance();
+export default cameraManager;

package/dist/utils/anchorUtils.d.ts

@@ -0,0 +1,10 @@
+import type { AnchorSettings, Vector3Array } from "@3driseai/3drise-core";
+export declare const applyAnchorSettings: (anchor: AnchorSettings | null | undefined, object: {
+    position: {
+        set: (x: number, y: number, z: number) => void;
+    };
+    rotation: {
+        set: (x: number, y: number, z: number) => void;
+    };
+}, initialRotation?: Vector3Array) => void;
+//# sourceMappingURL=anchorUtils.d.ts.map

package/dist/utils/anchorUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchorUtils.d.ts","sourceRoot":"","sources":["../../src/utils/anchorUtils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1E,eAAO,MAAM,mBAAmB,GAAI,QAAQ,cAAc,GAAG,IAAI,GAAG,SAAS,EAAE,QAAQ;IAC3E,QAAQ,EAAE;QACN,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;KAClD,CAAC;IACF,QAAQ,EAAE;QACN,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;KAClD,CAAC;CACL,EAAE,kBAAiB,YAAwB,KAAG,IAWtD,CAAC"}

package/dist/utils/anchorUtils.js

@@ -0,0 +1,13 @@
+import { cameraManager } from './CameraSingleton.js';
+export const applyAnchorSettings = (anchor, object, initialRotation = [0, 0, 0]) => {
+    if (!anchor || !anchor.enabled)
+        return;
+    if (anchor.fixedPosition) {
+        const p = cameraManager.getAnchorPosition(anchor.anchor || 'center', 0, anchor.offset || { y: 0, x: 0, z: 0 }, anchor.padding || 0);
+        object.position.set(p.x, p.y, p.z);
+    }
+    if (anchor.fixedRotation) {
+        const r = cameraManager.getRotation();
+        object.rotation.set(r.x + initialRotation[0], r.y + initialRotation[1], r.z + initialRotation[2]);
+    }
+};

package/dist/utils/cursorPicking.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import type { CursorPickMode } from "@3driseai/3drise-core";
+export interface CursorPickResult {
+    worldPos: THREE.Vector3;
+    hover: THREE.Intersection | null;
+}
+export declare function pickCursorWorldPos(mode: CursorPickMode, raycaster: THREE.Raycaster, scene: THREE.Scene, camera: THREE.Camera, pointer: THREE.Vector2, planeDistance: number, out: THREE.Vector3): CursorPickResult;
+//# sourceMappingURL=cursorPicking.d.ts.map

package/dist/utils/cursorPicking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursorPicking.d.ts","sourceRoot":"","sources":["../../src/utils/cursorPicking.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IACxB,KAAK,EAAE,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC;CACpC;AAUD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,OAAO,GAAG,gBAAgB,CA0BlN"}

package/dist/utils/cursorPicking.js

@@ -0,0 +1,35 @@
+import * as THREE from 'three';
+const tmpPlane = new THREE.Plane();
+const tmpNormal = new THREE.Vector3();
+const tmpHitPoint = new THREE.Vector3();
+function pickSceneHit(raycaster, scene) {
+    const hits = raycaster.intersectObjects(scene.children, true);
+    return hits.find(h => h.object.userData.interactible === true) ?? hits[0] ?? null;
+}
+export function pickCursorWorldPos(mode, raycaster, scene, camera, pointer, planeDistance, out) {
+    raycaster.setFromCamera(pointer, camera);
+    if (mode === 'raycast-scene') {
+        const hit = pickSceneHit(raycaster, scene);
+        if (hit) {
+            out.copy(hit.point);
+            return { worldPos: out, hover: hit };
+        }
+        // No hit → fall through to plane positioning, no hover.
+    }
+    // Build the screen-aligned plane in front of the camera.
+    camera.getWorldDirection(tmpNormal);
+    const planeOrigin = tmpHitPoint
+        .copy(camera.position)
+        .addScaledVector(tmpNormal, planeDistance);
+    tmpPlane.setFromNormalAndCoplanarPoint(tmpNormal, planeOrigin);
+    const hitPoint = raycaster.ray.intersectPlane(tmpPlane, out);
+    if (!hitPoint) {
+        out.copy(planeOrigin);
+    }
+    // raycast-plane still surfaces hover info from a separate scene query so
+    // cursor types (Comet, Sparkles, etc.) can react to objects they pass over
+    // while remaining positioned on the floating plane.
+    // `none` opts out entirely — cursor never reacts to scene contents.
+    const hover = mode === 'raycast-plane' ? pickSceneHit(raycaster, scene) : null;
+    return { worldPos: out, hover };
+}

package/dist/utils/extractOutline.d.ts

@@ -0,0 +1,18 @@
+import type { BufferGeometry } from 'three';
+export type OutlineMode = '2d' | '3d';
+export type Point3 = [number, number, number];
+/**
+ * 3D feature edges: every edge whose dihedral angle exceeds `angle` (degrees).
+ * Returns endpoints in segment order (pairs form independent segments).
+ */
+export declare function edges3D(geometry: BufferGeometry, angle: number): Point3[];
+/**
+ * 2D profile: the hard edges lying on the front (max-Z) plane, flattened to
+ * z = 0. For a Z-extruded solid this equals the projected silhouette, so the
+ * heart yields its bezier contour and the box yields a square.
+ *
+ * For a general (non-extruded) mesh the true 2D outline is a projected
+ * silhouette boolean — swap this implementation when generalizing.
+ */
+export declare function contour2D(geometry: BufferGeometry): Point3[];
+//# sourceMappingURL=extractOutline.d.ts.map

package/dist/utils/extractOutline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractOutline.d.ts","sourceRoot":"","sources":["../../src/utils/extractOutline.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAC5C,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,IAAI,CAAC;AAEtC,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE9C;;;GAGG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAKzE;AACD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,EAAE,CAoB5D"}

package/dist/utils/extractOutline.js

@@ -0,0 +1,47 @@
+import { EdgesGeometry } from 'three';
+/**
+ * 3D feature edges: every edge whose dihedral angle exceeds `angle` (degrees).
+ * Returns endpoints in segment order (pairs form independent segments).
+ */
+export function edges3D(geometry, angle) {
+    const edges = new EdgesGeometry(geometry, angle);
+    const pts = toPairs(edges.attributes.position.array);
+    edges.dispose();
+    return pts;
+}
+/**
+ * 2D profile: the hard edges lying on the front (max-Z) plane, flattened to
+ * z = 0. For a Z-extruded solid this equals the projected silhouette, so the
+ * heart yields its bezier contour and the box yields a square.
+ *
+ * For a general (non-extruded) mesh the true 2D outline is a projected
+ * silhouette boolean — swap this implementation when generalizing.
+ */
+export function contour2D(geometry) {
+    const edges = new EdgesGeometry(geometry, 1);
+    const a = edges.attributes.position.array;
+    let maxZ = -Infinity;
+    let minZ = Infinity;
+    for (let i = 2; i < a.length; i += 3) {
+        if (a[i] > maxZ)
+            maxZ = a[i];
+        if (a[i] < minZ)
+            minZ = a[i];
+    }
+    const eps = Math.max((maxZ - minZ) * 1e-3, 1e-4);
+    const out = [];
+    for (let i = 0; i < a.length; i += 6) {
+        if (Math.abs(a[i + 2] - maxZ) < eps && Math.abs(a[i + 5] - maxZ) < eps) {
+            out.push([a[i], a[i + 1], 0], [a[i + 3], a[i + 4], 0]);
+        }
+    }
+    edges.dispose();
+    return out;
+}
+function toPairs(arr) {
+    const out = [];
+    for (let i = 0; i < arr.length; i += 3) {
+        out.push([arr[i], arr[i + 1], arr[i + 2]]);
+    }
+    return out;
+}

package/dist/utils/frameAnimations.d.ts

@@ -0,0 +1,49 @@
+import type { Object3D } from 'three';
+import type { TransformEffect, ColorEffect, EffectState } from "@3driseai/3drise-core";
+export declare function shouldEffectBeActive(effect: TransformEffect | ColorEffect, hovered: boolean, clicked: boolean): boolean;
+export declare function getActiveEffects<T extends TransformEffect | ColorEffect>(effects: T[], hovered: boolean, clicked: boolean): T[];
+export declare function applyWaveEffect(object: Object3D, effect: TransformEffect, time: number, originalY: number): void;
+export declare function applyFloatEffect(object: Object3D, effect: TransformEffect, time: number, originalPosition: {
+    x: number;
+    y: number;
+    z: number;
+}): void;
+export declare function applyPulseEffect(object: Object3D, effect: TransformEffect, time: number, originalScale: {
+    x: number;
+    y: number;
+    z: number;
+}): void;
+export declare function applyShakeEffect(object: Object3D, effect: TransformEffect, originalPosition: {
+    x: number;
+    y: number;
+}): void;
+export declare function applyBounceEffect(object: Object3D, effect: TransformEffect, time: number, originalY: number): void;
+export declare function applyRotate3DEffect(object: Object3D, effect: TransformEffect, time: number, originalRotation: {
+    x: number;
+    y: number;
+    z: number;
+}): void;
+export declare function applyFadeEffect(effect: TransformEffect, time: number): number;
+export declare function applySpinEffect(object: Object3D, effect: TransformEffect, dt: number): void;
+export declare function applySwayEffect(object: Object3D, effect: TransformEffect, time: number, originalRotation: {
+    x: number;
+    y: number;
+    z: number;
+}): void;
+export declare function applyFlipEffect(object: Object3D, effect: TransformEffect, isActive: boolean, dt: number, originalRotation: {
+    x: number;
+    y: number;
+    z: number;
+}, sensitivity?: number): void;
+export declare function applyScaleEffect(object: Object3D, effect: TransformEffect, isActive: boolean, dt: number, originalScale: {
+    x: number;
+    y: number;
+    z: number;
+}, sensitivity?: number): void;
+export declare function applyTransformEffects(object: Object3D, effects: TransformEffect[], time: number, dt: number, state: EffectState, hovered: boolean, clicked: boolean, sensitivity?: number): {
+    opacity?: number;
+};
+export declare function applyColorTransitionEffect(object: Object3D, effect: ColorEffect, isActive: boolean, dt: number, baseColors: Record<string, string>, applyToChildren?: boolean, sensitivity?: number): void;
+export declare function applyPulseColorEffect(object: Object3D, effect: ColorEffect, time: number, baseColors: Record<string, string>, applyToChildren?: boolean): void;
+export declare function applyAllColorEffects(object: Object3D, effects: ColorEffect[], time: number, dt: number, baseColors: Record<string, string>, hovered: boolean, clicked: boolean, applyToChildren?: boolean, sensitivity?: number): void;
+//# sourceMappingURL=frameAnimations.d.ts.map

package/dist/utils/frameAnimations.d.ts.map

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

package/dist/utils/frameAnimations.js

@@ -0,0 +1,213 @@
+import { easing } from 'maath';
+import { Color } from 'three';
+export function shouldEffectBeActive(effect, hovered, clicked) {
+    if (!effect.enabled)
+        return false;
+    const mode = effect.triggerMode ?? 'always';
+    switch (mode) {
+        case 'always': return true;
+        case 'hover': return hovered;
+        case 'click': return clicked;
+        default: return true;
+    }
+}
+export function getActiveEffects(effects, hovered, clicked) {
+    return effects.filter(effect => shouldEffectBeActive(effect, hovered, clicked));
+}
+export function applyWaveEffect(object, effect, time, originalY) {
+    const options = effect.options;
+    const amplitude = options?.amplitude ?? 0.1;
+    const frequency = options?.frequency ?? 2;
+    object.position.y = originalY + Math.sin(time * frequency * (effect.speed ?? 1)) * amplitude * (effect.intensity ?? 1);
+}
+export function applyFloatEffect(object, effect, time, originalPosition) {
+    const options = effect.options;
+    const speed = effect.speed ?? 1;
+    const intensity = effect.intensity ?? 1;
+    object.position.x = originalPosition.x + Math.cos(time * speed * 0.5) * ((options?.amplitudeX ?? 0.05) * intensity);
+    object.position.y = originalPosition.y + Math.sin(time * speed) * ((options?.amplitudeY ?? 0.1) * intensity);
+    object.position.z = originalPosition.z + Math.sin(time * speed * 0.3) * ((options?.amplitudeZ ?? 0.03) * intensity);
+}
+export function applyPulseEffect(object, effect, time, originalScale) {
+    const options = effect.options;
+    const minScale = options?.minScale ?? 0.95;
+    const maxScale = options?.maxScale ?? 1.05;
+    const scaleFactor = minScale + (Math.sin(time * (effect.speed ?? 2)) + 1) * 0.5 * (maxScale - minScale);
+    object.scale.set(originalScale.x * scaleFactor, originalScale.y * scaleFactor, originalScale.z * scaleFactor);
+}
+export function applyShakeEffect(object, effect, originalPosition) {
+    const options = effect.options;
+    const intensity = effect.intensity ?? 1;
+    object.position.x = originalPosition.x + (Math.random() - 0.5) * ((options?.amplitudeX ?? 0.02) * intensity);
+    object.position.y = originalPosition.y + (Math.random() - 0.5) * ((options?.amplitudeY ?? 0.02) * intensity);
+}
+export function applyBounceEffect(object, effect, time, originalY) {
+    const options = effect.options;
+    object.position.y = originalY + Math.abs(Math.sin(time * (effect.speed ?? 3))) * (options?.bounceHeight ?? 0.2) * (effect.intensity ?? 1);
+}
+export function applyRotate3DEffect(object, effect, time, originalRotation) {
+    const options = effect.options;
+    const speed = effect.speed ?? 1;
+    const intensity = (effect.intensity ?? 1) * 0.1;
+    if (options?.axisX !== false)
+        object.rotation.x = originalRotation.x + Math.cos(time * speed * 0.7) * intensity * 0.5;
+    if (options?.axisY !== false)
+        object.rotation.y = originalRotation.y + Math.sin(time * speed) * intensity;
+    if (options?.axisZ)
+        object.rotation.z = originalRotation.z + Math.sin(time * speed * 0.5) * intensity * 0.3;
+}
+export function applyFadeEffect(effect, time) {
+    const options = effect.options;
+    const fadeMin = options?.fadeMin ?? 0.3;
+    const fadeMax = options?.fadeMax ?? 1;
+    return fadeMin + (Math.sin(time * (effect.speed ?? 1)) + 1) * 0.5 * (fadeMax - fadeMin);
+}
+export function applySpinEffect(object, effect, dt) {
+    const options = effect.options;
+    const axis = options?.axis ?? 'y';
+    object.rotation[axis] += dt * (effect.speed ?? 1);
+}
+export function applySwayEffect(object, effect, time, originalRotation) {
+    const options = effect.options;
+    const axis = options?.axis ?? 'z';
+    object.rotation[axis] = originalRotation[axis] + Math.sin(time * (effect.speed ?? 1)) * (options?.angle ?? 0.2) * (effect.intensity ?? 1);
+}
+export function applyFlipEffect(object, effect, isActive, dt, originalRotation, sensitivity = 0.5) {
+    const options = effect.options;
+    const axis = options?.axis ?? 'y';
+    const dampSpeed = (effect.speed ?? 0.3) * (1 - sensitivity * 0.5);
+    easing.damp(object.rotation, axis, isActive ? originalRotation[axis] + Math.PI : originalRotation[axis], dampSpeed, dt);
+}
+export function applyScaleEffect(object, effect, isActive, dt, originalScale, sensitivity = 0.5) {
+    const options = effect.options;
+    const targetScale = options?.targetScale ?? 1.2;
+    const dampSpeed = (effect.speed ?? 0.1) * (1 - sensitivity * 0.5);
+    const scale = isActive
+        ? [originalScale.x * targetScale, originalScale.y * targetScale, originalScale.z * targetScale]
+        : [originalScale.x, originalScale.y, originalScale.z];
+    easing.damp3(object.scale, scale, dampSpeed, dt);
+}
+export function applyTransformEffects(object, effects, time, dt, state, hovered, clicked, sensitivity = 0.5) {
+    const result = {};
+    for (const effect of effects) {
+        const isActive = shouldEffectBeActive(effect, hovered, clicked);
+        if (!isActive)
+            continue;
+        switch (effect.type) {
+            case 'wave':
+                applyWaveEffect(object, effect, time, state.originalPosition.y);
+                break;
+            case 'float':
+                applyFloatEffect(object, effect, time, state.originalPosition);
+                break;
+            case 'pulse':
+                applyPulseEffect(object, effect, time, state.originalScale);
+                break;
+            case 'shake':
+                applyShakeEffect(object, effect, state.originalPosition);
+                break;
+            case 'bounce':
+                applyBounceEffect(object, effect, time, state.originalPosition.y);
+                break;
+            case 'rotate3d':
+                applyRotate3DEffect(object, effect, time, state.originalRotation);
+                break;
+            case 'fade':
+                result.opacity = applyFadeEffect(effect, time);
+                break;
+            case 'spin':
+                applySpinEffect(object, effect, dt);
+                break;
+            case 'sway':
+                applySwayEffect(object, effect, time, state.originalRotation);
+                break;
+        }
+    }
+    for (const effect of effects) {
+        if (!effect.enabled)
+            continue;
+        const isActive = shouldEffectBeActive(effect, hovered, clicked);
+        switch (effect.type) {
+            case 'flip':
+                applyFlipEffect(object, effect, isActive, dt, state.originalRotation, sensitivity);
+                break;
+            case 'scale':
+                applyScaleEffect(object, effect, isActive, dt, state.originalScale, sensitivity);
+                break;
+        }
+    }
+    return result;
+}
+function getColorFromPath(material, path) {
+    let current = material;
+    for (const part of path.split('.')) {
+        if (current == null)
+            return null;
+        current = current[part];
+    }
+    if (current?.value instanceof Color)
+        return current.value;
+    if (current instanceof Color)
+        return current;
+    return null;
+}
+export function applyColorTransitionEffect(object, effect, isActive, dt, baseColors, applyToChildren = true, sensitivity = 0.5) {
+    const targetProperties = effect.targetProperties ?? ['color'];
+    const targetColor = isActive ? effect.targetColor : null;
+    const dampSpeed = 0.1 * (1 - sensitivity * 0.5);
+    const applyToMaterial = (material) => {
+        for (const propPath of targetProperties) {
+            const color = getColorFromPath(material, propPath);
+            if (color)
+                easing.dampC(color, targetColor || baseColors[propPath] || '#ffffff', dampSpeed, dt);
+        }
+    };
+    if (applyToChildren)
+        object.traverse((child) => { if (child.material)
+            applyToMaterial(child.material); });
+    else {
+        const mesh = object;
+        if (mesh.material)
+            applyToMaterial(mesh.material);
+    }
+}
+export function applyPulseColorEffect(object, effect, time, baseColors, applyToChildren = true) {
+    const targetProperties = effect.targetProperties ?? ['color'];
+    const blend = (Math.sin(time * (effect.speed ?? 1) * 2) + 1) * 0.5 * (effect.intensity ?? 1);
+    const baseColorObj = new Color();
+    const targetColorObj = new Color(effect.targetColor);
+    const resultColor = new Color();
+    const applyToMaterial = (material) => {
+        for (const propPath of targetProperties) {
+            const color = getColorFromPath(material, propPath);
+            if (color) {
+                baseColorObj.set(baseColors[propPath] || '#ffffff');
+                color.copy(resultColor.copy(baseColorObj).lerp(targetColorObj, blend));
+            }
+        }
+    };
+    if (applyToChildren)
+        object.traverse((child) => { if (child.material)
+            applyToMaterial(child.material); });
+    else {
+        const mesh = object;
+        if (mesh.material)
+            applyToMaterial(mesh.material);
+    }
+}
+export function applyAllColorEffects(object, effects, time, dt, baseColors, hovered, clicked, applyToChildren = true, sensitivity = 0.5) {
+    for (const effect of effects) {
+        if (!effect.enabled)
+            continue;
+        const isActive = shouldEffectBeActive(effect, hovered, clicked);
+        switch (effect.type) {
+            case 'color-transition':
+                applyColorTransitionEffect(object, effect, isActive, dt, baseColors, applyToChildren, sensitivity);
+                break;
+            case 'pulse-color':
+                if (isActive)
+                    applyPulseColorEffect(object, effect, time, baseColors, applyToChildren);
+                break;
+        }
+    }
+}

package/dist/utils/handleGenerativeEffectsAnimations.d.ts

@@ -0,0 +1,5 @@
+import * as THREE from 'three';
+import type { AnimationOptions } from "@3driseai/3drise-core";
+export declare const DEBUG_GENERATIVE_EFFECTS = false;
+export declare function applyGenerativeAnimations(materials: THREE.ShaderMaterial[], animations: AnimationOptions[] | undefined, startValuesCache: Record<string, any>, currentTime: number, hovered: boolean): void;
+//# sourceMappingURL=handleGenerativeEffectsAnimations.d.ts.map

package/dist/utils/handleGenerativeEffectsAnimations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGenerativeEffectsAnimations.d.ts","sourceRoot":"","sources":["../../src/utils/handleGenerativeEffectsAnimations.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAuG9D,eAAO,MAAM,wBAAwB,QAAQ,CAAC;AAkF9C,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,KAAK,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,SAAS,EAAE,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CA+D3M"}