@3driseai/3drise-core 1.0.1

package/dist/utils/handleLightAnimations.d.ts

@@ -0,0 +1,18 @@
+import type { Light } from 'three';
+import type { AnimationOptions } from "../types";
+export interface LightAnimationContext {
+    light: Light;
+    startValuesCache: Record<string, any>;
+}
+export declare const DEBUG_LIGHT_ANIMATIONS = false;
+/**
+ * Process all active light animations for a single light instance.
+ *
+ * @param ctx         - Animation context (light + start-value cache)
+ * @param animations  - AnimationOptions[] from animations.light.animations (or
+ *                       SceneLightConfig.ambient.animations / .sun.animations)
+ * @param currentTime - Current timestamp (Date.now())
+ * @param hovered     - Whether the light is currently hovered (for triggerMode='hover')
+ */
+export declare function handleLightAnimations(ctx: LightAnimationContext, animations: AnimationOptions[], currentTime: number, hovered: boolean): void;
+//# sourceMappingURL=handleLightAnimations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleLightAnimations.d.ts","sourceRoot":"","sources":["../../src/utils/handleLightAnimations.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAGnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACjD,MAAM,WAAW,qBAAqB;IAClC,KAAK,EAAE,KAAK,CAAC;IACb,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACzC;AAMD,eAAO,MAAM,sBAAsB,QAAQ,CAAC;AAsF5C;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,qBAAqB,EAAE,UAAU,EAAE,gBAAgB,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAQ7I"}

package/dist/utils/handleLightAnimations.js

@@ -0,0 +1,123 @@
+// =============================================================================
+// HANDLE LIGHT ANIMATIONS — Keyframe animations on a THREE.Light
+// =============================================================================
+//
+// Reads AnimationOptions[] and applies interpolated values directly to a light
+// instance. Properties are written to the light itself (intensity, color) or
+// to type-specific fields (distance, decay on PointLight/SpotLight; angle,
+// penumbra on SpotLight). Unknown properties are skipped silently.
+//
+// Sibling of handleTransformAnimations / handleMaterialAnimations /
+// handleEdgesAnimations. Same interpolation primitives (calculateTimeProgress,
+// applyEasing, interpolateValue) so easing / loop / yoyo semantics match.
+//
+import { Color } from 'three';
+import { applyEasing, gsapEasingMap } from './easingUtils.js';
+import { calculateTimeProgress, interpolateValue } from './materialUtils.js';
+// =============================================================================
+// DEBUG
+// =============================================================================
+export const DEBUG_LIGHT_ANIMATIONS = false;
+const log = (message, ...args) => {
+    if (DEBUG_LIGHT_ANIMATIONS) {
+        console.log(`[LightAnimations] ${message}`, ...args);
+    }
+};
+// Properties that can be animated per-frame on a light.
+const ANIMATABLE_LIGHT_PROPERTIES = new Set([
+    'intensity',
+    'color',
+    'distance',
+    'decay',
+    'angle',
+    'penumbra',
+]);
+// =============================================================================
+// HELPERS
+// =============================================================================
+function readLightProperty(light, property) {
+    if (property === 'color') {
+        return `#${light.color?.getHexString?.() ?? 'ffffff'}`;
+    }
+    return light[property];
+}
+function applyLightProperty(light, property, value) {
+    if (property === 'color') {
+        const target = light.color;
+        if (!target)
+            return;
+        if (value instanceof Color) {
+            target.copy(value);
+        }
+        else {
+            target.set(value);
+        }
+        return;
+    }
+    // Numeric properties — only assign if the light actually has the field.
+    if (property in light) {
+        light[property] = value;
+    }
+}
+function getStartValue(ctx, property, animation) {
+    if (animation.from !== undefined)
+        return animation.from;
+    if (property in ctx.startValuesCache)
+        return ctx.startValuesCache[property];
+    const value = readLightProperty(ctx.light, property);
+    ctx.startValuesCache[property] = value;
+    return value;
+}
+// =============================================================================
+// SINGLE PROPERTY ANIMATION
+// =============================================================================
+function animateLightProperty(ctx, animation, currentTime, hovered) {
+    const { property, to, duration, ease, loop = false, yoyo = false, active, triggerMode = 'always' } = animation;
+    if (!active || to === undefined)
+        return;
+    if (triggerMode === 'hover' && !hovered)
+        return;
+    if (!ANIMATABLE_LIGHT_PROPERTIES.has(property)) {
+        log('skipping non-animatable light property', { property });
+        return;
+    }
+    // Type-specific properties: only apply if this light actually has them.
+    if ((property === 'distance' || property === 'decay' || property === 'angle' || property === 'penumbra') && !(property in ctx.light)) {
+        log('skipping property not present on this light type', { property, lightType: ctx.light.type });
+        return;
+    }
+    const from = getStartValue(ctx, property, animation);
+    if (from === null || from === undefined) {
+        log('skipping — no start value', { property });
+        return;
+    }
+    let timeProgress = calculateTimeProgress(currentTime, duration, yoyo, loop);
+    if (ease) {
+        const fn = gsapEasingMap[ease] || ease;
+        timeProgress = applyEasing(fn, timeProgress);
+    }
+    const interpolated = interpolateValue(property, from, to, timeProgress);
+    applyLightProperty(ctx.light, property, interpolated);
+    log('animated light property', { property, from, to, interpolated, progress: timeProgress });
+}
+// =============================================================================
+// MAIN HANDLER
+// =============================================================================
+/**
+ * Process all active light animations for a single light instance.
+ *
+ * @param ctx         - Animation context (light + start-value cache)
+ * @param animations  - AnimationOptions[] from animations.light.animations (or
+ *                       SceneLightConfig.ambient.animations / .sun.animations)
+ * @param currentTime - Current timestamp (Date.now())
+ * @param hovered     - Whether the light is currently hovered (for triggerMode='hover')
+ */
+export function handleLightAnimations(ctx, animations, currentTime, hovered) {
+    if (animations.length === 0)
+        return;
+    for (const animation of animations) {
+        if (!animation.active)
+            continue;
+        animateLightProperty(ctx, animation, currentTime, hovered);
+    }
+}

package/dist/utils/handleLightMouseMove.d.ts

@@ -0,0 +1,13 @@
+import type { Light } from 'three';
+import type { MouseMoveProperty } from "../types/objectSettings";
+export interface LightMouseMoveContext {
+    light: Light;
+    /** Optional base values (e.g. config.intensity) used as fallback if we can't
+     *  read the property off the live light. */
+    lightConfig?: Record<string, any>;
+}
+export declare function handleLightMouseMove(ctx: LightMouseMoveContext, properties: MouseMoveProperty[], pointer: {
+    x: number;
+    y: number;
+}): void;
+//# sourceMappingURL=handleLightMouseMove.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleLightMouseMove.d.ts","sourceRoot":"","sources":["../../src/utils/handleLightMouseMove.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAEnC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,MAAM,WAAW,qBAAqB;IAClC,KAAK,EAAE,KAAK,CAAC;IACb;gDAC4C;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACrC;AA0BD,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,qBAAqB,EAAE,UAAU,EAAE,iBAAiB,EAAE,EAAE,OAAO,EAAE;IAC/F,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACb,GAAG,IAAI,CAkBf"}

package/dist/utils/handleLightMouseMove.js

@@ -0,0 +1,51 @@
+// =============================================================================
+// HANDLE LIGHT MOUSE MOVE — pointer-driven light property updates
+// =============================================================================
+//
+// Sibling of handleLightAnimations. Same allowlist + per-light-type guards.
+// Writes directly to the Three.js light instance.
+//
+import { Color } from 'three';
+import { interpolateMouseMoveProperty } from './mouseMoveUtils.js';
+const ANIMATABLE = new Set(['intensity', 'color', 'distance', 'decay', 'angle', 'penumbra']);
+function readBase(light, property, config) {
+    if (property === 'color') {
+        return `#${light.color?.getHexString?.() ?? config?.color?.replace?.('#', '') ?? 'ffffff'}`;
+    }
+    const live = light[property];
+    return live ?? config?.[property];
+}
+function applyLightProperty(light, property, value) {
+    if (property === 'color') {
+        const target = light.color;
+        if (!target)
+            return;
+        if (value instanceof Color)
+            target.copy(value);
+        else
+            target.set(value);
+        return;
+    }
+    if (property in light) {
+        light[property] = value;
+    }
+}
+export function handleLightMouseMove(ctx, properties, pointer) {
+    if (!properties.length)
+        return;
+    const { light, lightConfig } = ctx;
+    for (const { property, enabled, propertySettings } of properties) {
+        if (!property || !enabled)
+            continue;
+        if (!ANIMATABLE.has(property))
+            continue;
+        if ((property === 'distance' || property === 'decay' || property === 'angle' || property === 'penumbra') && !(property in light))
+            continue;
+        const { axis = 'both', sensitivity = 1, inverted = false, min, max } = propertySettings || {};
+        const baseValue = readBase(light, property, lightConfig);
+        if (baseValue === undefined)
+            continue;
+        const next = interpolateMouseMoveProperty(baseValue, min, max, pointer, axis, sensitivity, inverted);
+        applyLightProperty(light, property, next);
+    }
+}

package/dist/utils/handleMaterialEffects.d.ts

@@ -0,0 +1,32 @@
+import { Object3D } from "three";
+import { AnimationOptions, ColorEffectV2, EffectState, MaterialSettings } from "../types";
+export interface MaterialAnimationContext {
+    object: Object3D;
+    materialSettings: MaterialSettings;
+    /** Cache of start values for animations (property -> value) */
+    startValuesCache: Record<string, any>;
+}
+export declare const DEBUG_MATERIAL_EFFECTS = false;
+/**
+ * Animate a single material property.
+ * Supports any material property type (number, color, vector2, etc.)
+ */
+export declare function animateMaterialProperty(ctx: MaterialAnimationContext, animation: AnimationOptions, currentTime: number, hovered: boolean): void;
+/**
+ * Process all active material animations for an object.
+ * Supports any material property (color, opacity, roughness, metalness, emissive, etc.)
+ */
+export declare function handleMaterialAnimations(ctx: MaterialAnimationContext, animations: AnimationOptions[], currentTime: number, hovered: boolean): void;
+/**
+ * Apply continuous color effects (pulse-color, transition, gradient, etc.).
+ * @param object - The 3D object to apply effects to
+ * @param effects - Array of color effects
+ * @param time - Elapsed time for animation
+ * @param delta - Frame delta time
+ * @param effectStateRef - Reference to effect state (will be initialized if null)
+ * @param applyToChildren - Whether to traverse and apply to children
+ */
+export declare function handleMaterialEffects(object: Object3D, effects: ColorEffectV2[], time: number, delta: number, effectStateRef: {
+    current: EffectState | null;
+}, applyToChildren?: boolean): void;
+//# sourceMappingURL=handleMaterialEffects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleMaterialEffects.d.ts","sourceRoot":"","sources":["../../src/utils/handleMaterialEffects.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC1F,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE,QAAQ,CAAC;IACjB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,+DAA+D;IAC/D,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACzC;AAMD,eAAO,MAAM,sBAAsB,QAAQ,CAAC;AAmC5C;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,wBAAwB,EAAE,SAAS,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CA6B/I;AAID;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,wBAAwB,EAAE,UAAU,EAAE,gBAAgB,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAWnJ;AAID;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE;IACnH,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;CAC/B,EAAE,eAAe,GAAE,OAAe,GAAG,IAAI,CAcjD"}

package/dist/utils/handleMaterialEffects.js

@@ -0,0 +1,130 @@
+// =============================================================================
+// HANDLE MATERIAL EFFECTS — Material Animations & Effects Handler
+// =============================================================================
+//
+// Pure functions for handling material-related animations and effects.
+// Supports animating any material property (color, opacity, roughness, metalness, etc.)
+// Uses getType for property type detection and applySingleProperty for application.
+//
+import { calculateTimeProgress, getMaterialPropertyValue, interpolateValue, applyMaterialPropertyToObject, } from "./materialUtils.js";
+import { applyEasing, gsapEasingMap } from "./animationsUtils.js";
+import { createDefaultEffectState, } from "./utils.js";
+import { applyAllColorEffects } from "./frameAnimations.js";
+// =============================================================================
+// DEBUG
+// =============================================================================
+export const DEBUG_MATERIAL_EFFECTS = false;
+const log = (message, ...args) => {
+    if (DEBUG_MATERIAL_EFFECTS) {
+        console.log(`[MaterialEffects] ${message}`, ...args);
+    }
+};
+// =============================================================================
+// MATERIAL PROPERTY ANIMATION
+// =============================================================================
+/**
+ * Get the start value for a material animation.
+ * Priority: animation.from > startValuesCache > materialSettings > current material value
+ */
+function getStartValue(ctx, animation) {
+    const { object, materialSettings, startValuesCache } = ctx;
+    const property = animation.property;
+    // 1. Explicit 'from' value in animation
+    if (animation.from !== undefined) {
+        return animation.from;
+    }
+    // 2. Check cache (already computed start value)
+    if (property in startValuesCache) {
+        return startValuesCache[property];
+    }
+    // 3. Check materialSettings
+    if (property in materialSettings) {
+        const value = materialSettings[property];
+        startValuesCache[property] = value;
+        return value;
+    }
+    // 4. Get from current material (fallback)
+    const currentValue = getMaterialPropertyValue(object, property);
+    startValuesCache[property] = currentValue;
+    return currentValue;
+}
+/**
+ * Animate a single material property.
+ * Supports any material property type (number, color, vector2, etc.)
+ */
+export function animateMaterialProperty(ctx, animation, currentTime, hovered) {
+    // console.log("Animating material property:", {
+    //     ctx,
+    //     animation,
+    // });
+    const { object } = ctx;
+    const { property, to, duration, ease, loop = false, yoyo = false, active, } = animation;
+    if (!active || to === undefined)
+        return;
+    if (animation.triggerMode === "hover" && !hovered)
+        return;
+    // Get start value
+    const from = getStartValue(ctx, animation);
+    if (from === null || from === undefined) {
+        log("skipping animation - no start value", { property });
+        return;
+    }
+    // Calculate animation progress
+    let timeProgress = calculateTimeProgress(currentTime, duration, yoyo, loop);
+    // Apply easing if specified
+    if (ease) {
+        const easingFunctionName = gsapEasingMap[ease] || ease;
+        timeProgress = applyEasing(easingFunctionName, timeProgress);
+    }
+    // Interpolate value based on property type
+    const interpolated = interpolateValue(property, from, to, timeProgress);
+    // Apply to object (handles shader uniforms + standard materials)
+    applyMaterialPropertyToObject(object, property, interpolated);
+    log("animated property", { property, from, to, interpolated, progress: timeProgress });
+}
+// =============================================================================
+// HANDLE MATERIAL ANIMATIONS
+// =============================================================================
+/**
+ * Process all active material animations for an object.
+ * Supports any material property (color, opacity, roughness, metalness, emissive, etc.)
+ */
+export function handleMaterialAnimations(ctx, animations, currentTime, hovered) {
+    animations.forEach((animation) => {
+        if (!animation.active)
+            return;
+        // Skip transform properties (handled by handleTransformEffects)
+        const property = animation.property;
+        if (property === "position" || property === "rotation" || property === "scale") {
+            return;
+        }
+        animateMaterialProperty(ctx, animation, currentTime, hovered);
+    });
+}
+// =============================================================================
+// HANDLE MATERIAL EFFECTS (COLOR EFFECTS)
+// =============================================================================
+/**
+ * Apply continuous color effects (pulse-color, transition, gradient, etc.).
+ * @param object - The 3D object to apply effects to
+ * @param effects - Array of color effects
+ * @param time - Elapsed time for animation
+ * @param delta - Frame delta time
+ * @param effectStateRef - Reference to effect state (will be initialized if null)
+ * @param applyToChildren - Whether to traverse and apply to children
+ */
+export function handleMaterialEffects(object, effects, time, delta, effectStateRef, applyToChildren = false) {
+    const enabledEffects = effects.filter((e) => e.enabled);
+    if (enabledEffects.length === 0)
+        return;
+    // Initialize effect state if needed
+    if (!effectStateRef.current) {
+        effectStateRef.current = createDefaultEffectState(object);
+    }
+    log("applying color effects", { count: enabledEffects.length });
+    applyAllColorEffects(object, enabledEffects, time, delta, {}, // baseColors
+    false, // hovered (not relevant for continuous)
+    false, // clicked (not relevant for continuous)
+    applyToChildren, 1 // sensitivity: full intensity for continuous effects
+    );
+}

package/dist/utils/handleMaterialMouseMove.d.ts

@@ -0,0 +1,11 @@
+import { Object3D } from "three";
+import type { MouseMoveProperty } from "../types/objectSettings";
+export interface MaterialMouseMoveContext {
+    object: Object3D;
+    materialSettings?: Record<string, any>;
+}
+export declare function handleMaterialMouseMove(ctx: MaterialMouseMoveContext, properties: MouseMoveProperty[], pointer: {
+    x: number;
+    y: number;
+}): void;
+//# sourceMappingURL=handleMaterialMouseMove.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleMaterialMouseMove.d.ts","sourceRoot":"","sources":["../../src/utils/handleMaterialMouseMove.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE,QAAQ,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC1C;AAGD,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,wBAAwB,EAAE,UAAU,EAAE,iBAAiB,EAAE,EAAE,OAAO,EAAE;IACrG,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACb,GAAG,IAAI,CAcf"}

package/dist/utils/handleMaterialMouseMove.js

@@ -0,0 +1,20 @@
+// =============================================================================
+// HANDLE MATERIAL MOUSE MOVE — pointer-driven material property updates
+// =============================================================================
+import { applyMaterialPropertyToObject } from './materialUtils.js';
+import { interpolateMouseMoveProperty } from './mouseMoveUtils.js';
+export function handleMaterialMouseMove(ctx, properties, pointer) {
+    if (!properties.length)
+        return;
+    const { object, materialSettings } = ctx;
+    for (const { property, enabled, propertySettings } of properties) {
+        if (!property || !enabled)
+            continue;
+        const { axis = 'both', sensitivity = 1, inverted = false, min, max } = propertySettings || {};
+        const baseValue = materialSettings?.[property];
+        if (baseValue === undefined)
+            continue;
+        const next = interpolateMouseMoveProperty(baseValue, min, max, pointer, axis, sensitivity, inverted);
+        applyMaterialPropertyToObject(object, property, next);
+    }
+}

package/dist/utils/handleTransformEffects.d.ts

@@ -0,0 +1,31 @@
+import type { Object3D } from 'three';
+import type { AnimationOptions, Vector3Array } from "../types/scene3d";
+import type { TransformEffectV2 } from "../types/objectSettings";
+import type { EffectState } from "../types/effects";
+export interface TransformAnimationContext {
+    object: Object3D;
+    meshSettings: any;
+    pathIsActive: boolean;
+}
+export declare const DEBUG_TRANSFORM_EFFECTS = false;
+/**
+ * Animate a single transform property (position, rotation, scale).
+ */
+export declare function animateTransformProperty(object: Object3D, property: "position" | "rotation" | "scale", start: Vector3Array, to: Vector3Array, timeProgress: number, animationType: string, animationSpeed: number): void;
+/**
+ * Process all active transform animations for an object.
+ * Handles position, rotation, and scale animations.
+ */
+export declare function handleTransformAnimations(ctx: TransformAnimationContext, animations: AnimationOptions[], currentTime: number, hovered: boolean): void;
+/**
+ * Apply continuous transform effect (wave, float, spin, etc.).
+ * @param object - The 3D object to apply effects to
+ * @param effect - The transform effect configuration (single or array)
+ * @param time - Elapsed time for animation
+ * @param delta - Frame delta time
+ * @param effectStateRef - Reference to effect state (will be initialized if null)
+ */
+export declare function handleTransformEffect(object: Object3D, effect: TransformEffectV2 | TransformEffectV2[] | undefined, time: number, delta: number, effectStateRef: {
+    current: EffectState | null;
+}, hovered: boolean): void;
+//# sourceMappingURL=handleTransformEffects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleTransformEffects.d.ts","sourceRoot":"","sources":["../../src/utils/handleTransformEffects.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAKtC,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,MAAM,WAAW,yBAAyB;IACtC,MAAM,EAAE,QAAQ,CAAC;IACjB,YAAY,EAAE,GAAG,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;CACzB;AAMD,eAAO,MAAM,uBAAuB,QAAQ,CAAC;AAS7C;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAmBxN;AAID;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,yBAAyB,EAAE,UAAU,EAAE,gBAAgB,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAoDrJ;AAID;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,iBAAiB,GAAG,iBAAiB,EAAE,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE;IACtJ,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;CAC/B,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAqBjC"}

package/dist/utils/handleTransformEffects.js

@@ -0,0 +1,140 @@
+// =============================================================================
+// HANDLE TRANSFORM EFFECTS — Transform Animations & Effects Handler
+// =============================================================================
+//
+// Pure functions for handling transform-related animations and effects.
+// Extracted from useContinuousEffects for better separation of concerns.
+//
+import { MathUtils } from "three";
+import { applyEasing, gsapEasingMap } from "./animationsUtils.js";
+import { applyTransformEffects } from "../utils/frameAnimations.js";
+import { calculateTimeProgress } from "./materialUtils.js";
+import { createDefaultEffectState } from "./utils.js";
+// =============================================================================
+// DEBUG
+// =============================================================================
+export const DEBUG_TRANSFORM_EFFECTS = false;
+const log = (message, ...args) => {
+    if (DEBUG_TRANSFORM_EFFECTS) {
+        console.log(`[TransformEffects] ${message}`, ...args);
+    }
+};
+// =============================================================================
+// TRANSFORM PROPERTY ANIMATION
+// =============================================================================
+/**
+ * Animate a single transform property (position, rotation, scale).
+ */
+export function animateTransformProperty(object, property, start, to, timeProgress, animationType, animationSpeed) {
+    if (animationType === "keyframe") {
+        // Keyframe mode: add incremental change
+        const currentValue = object[property].toArray();
+        const newValue = [
+            currentValue[0] + to[0] * animationSpeed * 0.001,
+            currentValue[1] + to[1] * animationSpeed * 0.001,
+            currentValue[2] + to[2] * animationSpeed * 0.001,
+        ];
+        object[property].set(...newValue);
+    }
+    else {
+        // Interpolation mode: lerp from start to target
+        const interpolated = start.map((startValue, index) => {
+            const targetValue = to[index];
+            return MathUtils.lerp(startValue, targetValue, timeProgress);
+        });
+        object[property].set(interpolated[0], interpolated[1], interpolated[2]);
+    }
+}
+// =============================================================================
+// HANDLE TRANSFORM ANIMATIONS
+// =============================================================================
+/**
+ * Process all active transform animations for an object.
+ * Handles position, rotation, and scale animations.
+ */
+export function handleTransformAnimations(ctx, animations, currentTime, hovered) {
+    const { object, meshSettings, pathIsActive } = ctx;
+    // console.log("handleTransformAnimations called with animations:", animations);
+    animations.forEach((animation) => {
+        const { property, ease, duration, loop = false, to, yoyo = false, active, type = "interpolation", objectIds, triggerMode = "always", } = animation;
+        if (!active)
+            return;
+        if (triggerMode === "hover" && !hovered)
+            return;
+        // Skip position/rotation if path animation is active (path controls these)
+        if (pathIsActive &&
+            (property === "position" || property === "rotation") &&
+            (!objectIds || objectIds.length === 0)) {
+            return;
+        }
+        // Only handle transform properties
+        if (property !== "position" && property !== "rotation" && property !== "scale") {
+            return;
+        }
+        // Calculate animation progress
+        let timeProgress = calculateTimeProgress(currentTime, duration, yoyo, loop);
+        // Apply easing if specified
+        if (ease) {
+            const easingFunctionName = gsapEasingMap[ease] || ease;
+            timeProgress = applyEasing(easingFunctionName, timeProgress);
+        }
+        const animationSpeed = 1000 / duration;
+        // Determine which objects to animate
+        const targetsToAnimate = [];
+        if (objectIds && objectIds.length > 0) {
+            // Animate specific children by name
+            objectIds.forEach((name) => {
+                const child = object.getObjectByName(name);
+                if (child) {
+                    targetsToAnimate.push(child);
+                }
+            });
+            log("animating specific targets", { objectIds, found: targetsToAnimate.length });
+        }
+        else {
+            // Animate the parent object
+            targetsToAnimate.push(object);
+        }
+        // Get start value from meshSettings
+        const start = meshSettings[property];
+        if (!start || !to)
+            return;
+        // Apply animation to each target
+        targetsToAnimate.forEach((target) => {
+            animateTransformProperty(target, property, start, to, timeProgress, type, animationSpeed);
+        });
+    });
+}
+// =============================================================================
+// HANDLE TRANSFORM EFFECT
+// =============================================================================
+/**
+ * Apply continuous transform effect (wave, float, spin, etc.).
+ * @param object - The 3D object to apply effects to
+ * @param effect - The transform effect configuration (single or array)
+ * @param time - Elapsed time for animation
+ * @param delta - Frame delta time
+ * @param effectStateRef - Reference to effect state (will be initialized if null)
+ */
+export function handleTransformEffect(object, effect, time, delta, effectStateRef, hovered) {
+    // console.log("handleTransformEffect called with effect:", object);
+    if (!effect)
+        return;
+    // Normalize to array
+    const effects = Array.isArray(effect) ? effect : [effect];
+    // Filter to enabled effects
+    const enabledEffects = effects.filter(e => e.enabled);
+    if (enabledEffects.length === 0)
+        return;
+    // Initialize effect state if needed
+    if (!effectStateRef.current) {
+        effectStateRef.current = createDefaultEffectState(object);
+    }
+    // log("applying transform effects", { count: enabledEffects.length, types: enabledEffects.map(e => e.type) });
+    // Apply transform effects
+    applyTransformEffects(object, enabledEffects, // applyTransformEffects expects array
+    time, delta, effectStateRef.current, hovered, // hovered (relevant for hover-based effects)
+    false, // clicked (not relevant for continuous)
+    1 // sensitivity: full intensity for continuous effects
+    );
+}

package/dist/utils/handleTransformMouseMove.d.ts

@@ -0,0 +1,13 @@
+import { Object3D } from "three";
+import type { MouseMoveProperty } from "../types/objectSettings";
+export interface TransformMouseMoveContext {
+    object: Object3D;
+    meshSettings?: Record<string, any>;
+}
+export declare const TRANSFORM_PROPS: readonly ["position", "rotation", "scale"];
+export declare function isTransformProperty(property: string): boolean;
+export declare function handleTransformMouseMove(ctx: TransformMouseMoveContext, properties: MouseMoveProperty[], pointer: {
+    x: number;
+    y: number;
+}): void;
+//# sourceMappingURL=handleTransformMouseMove.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleTransformMouseMove.d.ts","sourceRoot":"","sources":["../../src/utils/handleTransformMouseMove.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,MAAM,WAAW,yBAAyB;IACtC,MAAM,EAAE,QAAQ,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACtC;AAGD,eAAO,MAAM,eAAe,EAAE,SAAS,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,CAAqC,CAAC;AAC7G,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAG7D;AAkBD,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,yBAAyB,EAAE,UAAU,EAAE,iBAAiB,EAAE,EAAE,OAAO,EAAE;IACvG,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACb,GAAG,IAAI,CAiBf"}