@ntalmagor/3drize-viewer 0.1.2

package/dist/shaders/effects/EffectsVertexFunctions.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const effectsVertexGLSL = "\n  // ============================================================================\n  // UNIFORMS - All effect uniforms\n  // ============================================================================\n  uniform float u_time;\n  uniform vec2 u_pointer;\n  uniform float uPointerEffectRadius;\n  \n  // General vortex effects\n  uniform bool uGeneralWaveEnabled;\n  uniform float uGeneralWaveIntensity;\n  uniform float uGeneralWaveFrequency;\n  uniform float uGeneralWaveSpeed;\n  uniform float uGeneralWaveDirection;\n  uniform bool uGeneralVortexEnabled;\n  uniform float uGeneralVortexIntensity;\n  uniform float uGeneralVortexSpeed;\n  uniform float uGeneralVortexCenterX;\n  uniform float uGeneralVortexCenterY;\n  uniform bool uGeneralRippleEnabled;\n  uniform float uGeneralRippleIntensity;\n  uniform float uGeneralRippleSpeed;\n  uniform float uGeneralRippleFrequency;\n  uniform float uGeneralRippleCenterX;\n  uniform float uGeneralRippleCenterY;\n  \n  // Pointer vortex effects\n  uniform bool uRippleEnabled;\n  uniform float uRippleIntensity;\n  uniform float uRippleSpeed;\n  uniform bool uDisplacementEnabled;\n  uniform float uDisplacementIntensity;\n  uniform bool uVortexEnabled;\n  uniform float uVortexIntensity;\n  uniform float uVortexSpeed;\n  uniform bool uWaveEnabled;\n  uniform float uWaveIntensity;\n  uniform float uWaveFrequency;\n  \n  // ============================================================================\n  // HELPER FUNCTIONS\n  // ============================================================================\n  \n  // Calculate smooth falloff from pointer position\n  float getPointerFalloff(vec3 position, vec2 pointer) {\n    float dist = distance(position.xy, pointer);\n    return smoothstep(uPointerEffectRadius, 0.0, dist);\n  }\n  \n  // ============================================================================\n  // GENERAL EFFECTS (Always active when enabled)\n  // ============================================================================\n  \n  vec3 applyGeneralWave(vec3 pos) {\n    float waveInput = 0.0;\n    if (uGeneralWaveDirection < 0.5) {\n      // Horizontal\n      waveInput = pos.x;\n    } else if (uGeneralWaveDirection < 1.5) {\n      // Vertical\n      waveInput = pos.y;\n    } else {\n      // Diagonal\n      waveInput = pos.x + pos.y;\n    }\n    pos.z += sin(waveInput * uGeneralWaveFrequency + u_time * uGeneralWaveSpeed) * uGeneralWaveIntensity;\n    return pos;\n  }\n  \n  vec3 applyGeneralVortex(vec3 pos) {\n    vec2 center = vec2(uGeneralVortexCenterX, uGeneralVortexCenterY);\n    vec2 toCenter = pos.xy - center;\n    float angle = uGeneralVortexIntensity * u_time * uGeneralVortexSpeed;\n    mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));\n    pos.xy = center + rotation * toCenter;\n    return pos;\n  }\n  \n  vec3 applyGeneralRipple(vec3 pos) {\n    vec2 center = vec2(uGeneralRippleCenterX, uGeneralRippleCenterY);\n    float rippleDist = distance(pos.xy, center);\n    float rippleWave = sin(rippleDist * uGeneralRippleFrequency - u_time * uGeneralRippleSpeed) * uGeneralRippleIntensity;\n    pos.z += rippleWave;\n    return pos;\n  }\n  \n  // ============================================================================\n  // POINTER EFFECTS (Interactive, based on pointer position)\n  // ============================================================================\n  \n  vec3 applyPointerRipple(vec3 pos, vec2 pointer) {\n    float falloff = getPointerFalloff(pos, pointer);\n    if (falloff > 0.0) {\n      float dist = distance(pos.xy, pointer);\n      float wave = sin(dist * 5.0 - u_time * uRippleSpeed) * uRippleIntensity;\n      pos.z += wave * falloff * 0.5;\n    }\n    return pos;\n  }\n  \n  vec3 applyPointerDisplacement(vec3 pos, vec2 pointer) {\n    float falloff = getPointerFalloff(pos, pointer);\n    if (falloff > 0.0) {\n      vec2 dir = normalize(pos.xy - pointer);\n      pos.xy += dir * uDisplacementIntensity * falloff * 2.0;\n    }\n    return pos;\n  }\n  \n  vec3 applyPointerVortex(vec3 pos, vec2 pointer) {\n    float falloff = getPointerFalloff(pos, pointer);\n    if (falloff > 0.0) {\n      vec2 toPointer = pos.xy - pointer;\n      float angle = uVortexIntensity * falloff * u_time * uVortexSpeed;\n      mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));\n      pos.xy = pointer + rotation * toPointer;\n    }\n    return pos;\n  }\n  \n  vec3 applyPointerWave(vec3 pos, vec2 pointer) {\n    float falloff = getPointerFalloff(pos, pointer);\n    if (falloff > 0.0) {\n      pos.z += sin(pos.x * uWaveFrequency + u_time) * uWaveIntensity * falloff * 0.5;\n    }\n    return pos;\n  }\n  \n  // ============================================================================\n  // APPLY ALL VERTEX EFFECTS\n  // ============================================================================\n  \n  vec3 applyAllVertexEffects(vec3 pos, vec2 pointer) {\n    // Apply general effects first (global, always active)\n    if (uGeneralWaveEnabled) {\n      pos = applyGeneralWave(pos);\n    }\n    \n    if (uGeneralVortexEnabled) {\n      pos = applyGeneralVortex(pos);\n    }\n    \n    if (uGeneralRippleEnabled) {\n      pos = applyGeneralRipple(pos);\n    }\n    \n    // Apply pointer effects (interactive)\n    if (uRippleEnabled) {\n      pos = applyPointerRipple(pos, pointer);\n    }\n    \n    if (uDisplacementEnabled) {\n      pos = applyPointerDisplacement(pos, pointer);\n    }\n    \n    if (uVortexEnabled) {\n      pos = applyPointerVortex(pos, pointer);\n    }\n    \n    if (uWaveEnabled) {\n      pos = applyPointerWave(pos, pointer);\n    }\n    \n    return pos;\n  }\n";
+//# sourceMappingURL=EffectsVertexFunctions.glsl.d.ts.map

package/dist/shaders/effects/EffectsVertexFunctions.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectsVertexFunctions.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/effects/EffectsVertexFunctions.glsl.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,iBAAiB,kiLAqK7B,CAAC"}

package/dist/shaders/effects/EffectsVertexFunctions.glsl.js

@@ -0,0 +1,167 @@
+// Shared vortex shader functions for all shader effects
+export const effectsVertexGLSL = /*glsl*/ `
+  // ============================================================================
+  // UNIFORMS - All effect uniforms
+  // ============================================================================
+  uniform float u_time;
+  uniform vec2 u_pointer;
+  uniform float uPointerEffectRadius;
+  
+  // General vortex effects
+  uniform bool uGeneralWaveEnabled;
+  uniform float uGeneralWaveIntensity;
+  uniform float uGeneralWaveFrequency;
+  uniform float uGeneralWaveSpeed;
+  uniform float uGeneralWaveDirection;
+  uniform bool uGeneralVortexEnabled;
+  uniform float uGeneralVortexIntensity;
+  uniform float uGeneralVortexSpeed;
+  uniform float uGeneralVortexCenterX;
+  uniform float uGeneralVortexCenterY;
+  uniform bool uGeneralRippleEnabled;
+  uniform float uGeneralRippleIntensity;
+  uniform float uGeneralRippleSpeed;
+  uniform float uGeneralRippleFrequency;
+  uniform float uGeneralRippleCenterX;
+  uniform float uGeneralRippleCenterY;
+  
+  // Pointer vortex effects
+  uniform bool uRippleEnabled;
+  uniform float uRippleIntensity;
+  uniform float uRippleSpeed;
+  uniform bool uDisplacementEnabled;
+  uniform float uDisplacementIntensity;
+  uniform bool uVortexEnabled;
+  uniform float uVortexIntensity;
+  uniform float uVortexSpeed;
+  uniform bool uWaveEnabled;
+  uniform float uWaveIntensity;
+  uniform float uWaveFrequency;
+  
+  // ============================================================================
+  // HELPER FUNCTIONS
+  // ============================================================================
+  
+  // Calculate smooth falloff from pointer position
+  float getPointerFalloff(vec3 position, vec2 pointer) {
+    float dist = distance(position.xy, pointer);
+    return smoothstep(uPointerEffectRadius, 0.0, dist);
+  }
+  
+  // ============================================================================
+  // GENERAL EFFECTS (Always active when enabled)
+  // ============================================================================
+  
+  vec3 applyGeneralWave(vec3 pos) {
+    float waveInput = 0.0;
+    if (uGeneralWaveDirection < 0.5) {
+      // Horizontal
+      waveInput = pos.x;
+    } else if (uGeneralWaveDirection < 1.5) {
+      // Vertical
+      waveInput = pos.y;
+    } else {
+      // Diagonal
+      waveInput = pos.x + pos.y;
+    }
+    pos.z += sin(waveInput * uGeneralWaveFrequency + u_time * uGeneralWaveSpeed) * uGeneralWaveIntensity;
+    return pos;
+  }
+  
+  vec3 applyGeneralVortex(vec3 pos) {
+    vec2 center = vec2(uGeneralVortexCenterX, uGeneralVortexCenterY);
+    vec2 toCenter = pos.xy - center;
+    float angle = uGeneralVortexIntensity * u_time * uGeneralVortexSpeed;
+    mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
+    pos.xy = center + rotation * toCenter;
+    return pos;
+  }
+  
+  vec3 applyGeneralRipple(vec3 pos) {
+    vec2 center = vec2(uGeneralRippleCenterX, uGeneralRippleCenterY);
+    float rippleDist = distance(pos.xy, center);
+    float rippleWave = sin(rippleDist * uGeneralRippleFrequency - u_time * uGeneralRippleSpeed) * uGeneralRippleIntensity;
+    pos.z += rippleWave;
+    return pos;
+  }
+  
+  // ============================================================================
+  // POINTER EFFECTS (Interactive, based on pointer position)
+  // ============================================================================
+  
+  vec3 applyPointerRipple(vec3 pos, vec2 pointer) {
+    float falloff = getPointerFalloff(pos, pointer);
+    if (falloff > 0.0) {
+      float dist = distance(pos.xy, pointer);
+      float wave = sin(dist * 5.0 - u_time * uRippleSpeed) * uRippleIntensity;
+      pos.z += wave * falloff * 0.5;
+    }
+    return pos;
+  }
+  
+  vec3 applyPointerDisplacement(vec3 pos, vec2 pointer) {
+    float falloff = getPointerFalloff(pos, pointer);
+    if (falloff > 0.0) {
+      vec2 dir = normalize(pos.xy - pointer);
+      pos.xy += dir * uDisplacementIntensity * falloff * 2.0;
+    }
+    return pos;
+  }
+  
+  vec3 applyPointerVortex(vec3 pos, vec2 pointer) {
+    float falloff = getPointerFalloff(pos, pointer);
+    if (falloff > 0.0) {
+      vec2 toPointer = pos.xy - pointer;
+      float angle = uVortexIntensity * falloff * u_time * uVortexSpeed;
+      mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
+      pos.xy = pointer + rotation * toPointer;
+    }
+    return pos;
+  }
+  
+  vec3 applyPointerWave(vec3 pos, vec2 pointer) {
+    float falloff = getPointerFalloff(pos, pointer);
+    if (falloff > 0.0) {
+      pos.z += sin(pos.x * uWaveFrequency + u_time) * uWaveIntensity * falloff * 0.5;
+    }
+    return pos;
+  }
+  
+  // ============================================================================
+  // APPLY ALL VERTEX EFFECTS
+  // ============================================================================
+  
+  vec3 applyAllVertexEffects(vec3 pos, vec2 pointer) {
+    // Apply general effects first (global, always active)
+    if (uGeneralWaveEnabled) {
+      pos = applyGeneralWave(pos);
+    }
+    
+    if (uGeneralVortexEnabled) {
+      pos = applyGeneralVortex(pos);
+    }
+    
+    if (uGeneralRippleEnabled) {
+      pos = applyGeneralRipple(pos);
+    }
+    
+    // Apply pointer effects (interactive)
+    if (uRippleEnabled) {
+      pos = applyPointerRipple(pos, pointer);
+    }
+    
+    if (uDisplacementEnabled) {
+      pos = applyPointerDisplacement(pos, pointer);
+    }
+    
+    if (uVortexEnabled) {
+      pos = applyPointerVortex(pos, pointer);
+    }
+    
+    if (uWaveEnabled) {
+      pos = applyPointerWave(pos, pointer);
+    }
+    
+    return pos;
+  }
+`;

package/dist/utils/CameraSingleton.d.ts

@@ -0,0 +1,35 @@
+import { PerspectiveCamera, Camera, Vector3, Euler } from 'three';
+import type { Vector3Array, AnchorPosition, AnchorOffset } from '@ntalmagor/3drize-core';
+declare class CameraSingleton {
+    private static instance;
+    private camera;
+    private callbacks;
+    private cameraMoveCallbacks;
+    private lastPosition;
+    private lastRotation;
+    private constructor();
+    static getInstance(): CameraSingleton;
+    animateCameraPosition(position: Vector3Array): Promise<void>;
+    setCamera(camera: PerspectiveCamera): void;
+    getCamera(): PerspectiveCamera | null;
+    getPosition(): Vector3;
+    getRotation(): Euler;
+    isSynced(position: Vector3Array, orientation: Vector3Array | [number, number, number, number]): boolean;
+    getWorldDirection(): Vector3;
+    getFOV(): number;
+    subscribe(callback: () => void): () => void;
+    private notifyCallbacks;
+    isAvailable(): boolean;
+    getDistanceToTarget(target: Vector3): number;
+    lookAt(target: Vector3): void;
+    calculateVisibleSize(targetDepth: number, cam?: Camera): {
+        width: number;
+        height: number;
+    };
+    getAnchorPosition(anchor: AnchorPosition, targetDepth?: number, offset?: AnchorOffset, padding?: number): Vector3;
+    onCameraMove(callback: (position: Vector3, rotation: Euler) => void): () => void;
+    checkCameraMovement(epsilon?: number): boolean;
+}
+export declare const cameraManager: CameraSingleton;
+export default cameraManager;
+//# sourceMappingURL=CameraSingleton.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CameraSingleton.d.ts","sourceRoot":"","sources":["../../src/utils/CameraSingleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAsB,MAAM,EAAE,OAAO,EAAE,KAAK,EAAc,MAAM,OAAO,CAAC;AAClG,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEzF,cAAM,eAAe;IACnB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAkB;IACzC,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,SAAS,CAA8B;IAC/C,OAAO,CAAC,mBAAmB,CAAgE;IAC3F,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,YAAY,CAAsB;IAE1C,OAAO;WAEO,WAAW,IAAI,eAAe;IAOrC,qBAAqB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAmB5D,SAAS,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAO1C,SAAS,IAAI,iBAAiB,GAAG,IAAI;IACrC,WAAW,IAAI,OAAO;IACtB,WAAW,IAAI,KAAK;IAEpB,QAAQ,CAAC,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO;IAyBvG,iBAAiB,IAAI,OAAO;IAK5B,MAAM,IAAI,MAAM;IAEhB,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAKlD,OAAO,CAAC,eAAe;IAIhB,WAAW,IAAI,OAAO;IAEtB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM;IAI5C,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAI7B,oBAAoB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;IAc1F,iBAAiB,CACtB,MAAM,EAAE,cAAc,EACtB,WAAW,GAAE,MAAU,EACvB,MAAM,CAAC,EAAE,YAAY,EACrB,OAAO,GAAE,MAAU,GAClB,OAAO;IA0BH,YAAY,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI;IAKhF,mBAAmB,CAAC,OAAO,GAAE,MAAc,GAAG,OAAO;CAkB7D;AAED,eAAO,MAAM,aAAa,iBAAgC,CAAC;AAC3D,eAAe,aAAa,CAAC"}

package/dist/utils/CameraSingleton.js

@@ -0,0 +1,178 @@
+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 = 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 };
+    }
+    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 '@ntalmagor/3drize-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":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAG3E,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,cAAc,GAAG,IAAI,GAAG,SAAS,EACzC,QAAQ;IAAE,QAAQ,EAAE;QAAE,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;IAAC,QAAQ,EAAE;QAAE,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAA;CAAE,EACtI,kBAAiB,YAAwB,KACxC,IAqBF,CAAC"}

package/dist/utils/anchorUtils.js

@@ -0,0 +1,13 @@
+import { cameraManager } from './CameraSingleton';
+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/frameAnimations.d.ts

@@ -0,0 +1,49 @@
+import { Object3D } from 'three';
+import type { TransformEffect, ColorEffect, EffectState } from '@ntalmagor/3drize-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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"}