@3driseai/3drise-viewer 0.1.1

package/dist/hooks/useMeshController.js

@@ -0,0 +1,168 @@
+import { createMeshByType, createTempId, MaterialRegistryAPI, ObjectManager, uniformConverter, } from '@3driseai/3drise-core';
+export function useMeshController() {
+    let defaultSettings = {
+        color: { value: '#ffffff' },
+        opacity: { value: 1 },
+        wireframe: { value: false },
+    };
+    // const createMeshes = (meshes: BaseMeshOptions[]): CreatedObjectSettings[] => {
+    //   console.log("Creating meshes with data:", meshes);
+    //   const createdObjectsSettings: CreatedObjectSettings[] = [];
+    //   // console.log("createMeshes...", meshes);
+    //   if (!Array.isArray(meshes)) return [];
+    //   meshes.forEach(mesh => {
+    //     try {
+    //       const id = mesh.id || createTempId();
+    //       const meshType = mesh.type || 'box';
+    //       const meshData: any = {
+    //         ...mesh,
+    //         id,
+    //         type: meshType
+    //       };
+    //       // console.log({ meshData });
+    //       // let createdObject: CreatedRef | null = ;
+    //       const createdObject: CreatedRef = {
+    //         id,
+    //         name: mesh.name || `mesh-${id}`,
+    //         object: createMeshByType(meshData) as Mesh
+    //       }
+    //       createdObject && ObjectManager.addObject(createdObject);
+    //       if (!createdObject) return;
+    //       // const materialType: MaterialType = meshData.materialType || 'basic';
+    //       const materialSettings = createMaterialSettings(meshData);
+    //       const meshSettings = ObjectManager.getMeshSettingsFromMesh(createdObject.object as Mesh);
+    //       let createdObjectSettings: CreatedObjectSettings = {
+    //         id: meshData.id,
+    //         name: meshData.name || createdObject.name || `mesh-${createdObject.id}`,
+    //         type: 'mesh',
+    //         meshSettings: {
+    //           ...meshSettings,
+    //           anchor: meshData.anchor ?? null,
+    //         },
+    //         materialSettings: materialSettings,
+    //         // animations: [],
+    //         // effects: effects,
+    //         config: meshData
+    //       };
+    //       if (meshData.animations && meshData.animations.length > 0) {
+    //         createdObjectSettings.animations = meshData.animations.map((animation: AnimationOptions) => ({
+    //           ...animation,
+    //           active: true
+    //         }));
+    //       }
+    //       // console.log("Created object settings:", createdObjectSettings);
+    //       createdObjectsSettings.push(createdObjectSettings);
+    //         console.log("Created mesh:", createdObject.name);
+    //     } catch (error) {
+    //       console.error(`Error creating mesh of type ${(mesh as any).type}:`, error);
+    //     }
+    //   });
+    //   return createdObjectsSettings;
+    // }
+    const createObjects = (objects) => {
+        console.log("Creating meshes with data:", objects);
+        const createdObjectsSettings = [];
+        // console.log("createMeshes...", meshes);
+        if (!Array.isArray(objects))
+            return [];
+        objects.forEach(object => {
+            if (object.type !== 'mesh') {
+                createdObjectsSettings.push(object);
+                return;
+            }
+            try {
+                const id = object.id || createTempId();
+                const objectType = object.config?.type || object.userData?.type || 'box';
+                const meshData = {
+                    ...object.meshSettings,
+                    ...object.config,
+                    ...object.userData,
+                    type: objectType,
+                    id,
+                };
+                console.log({ meshData });
+                // let createdObject: CreatedRef | null = ;
+                const meshCreationResult = createMeshByType(meshData);
+                if (!meshCreationResult)
+                    return;
+                const createdObject = {
+                    id,
+                    name: object.name || `mesh-${id}`,
+                    object: meshCreationResult.mesh
+                };
+                console.log("Created object:", createdObject);
+                createdObject && ObjectManager.addObject(createdObject);
+                if (!createdObject)
+                    return;
+                let createdObjectSettings = {
+                    ...object,
+                    config: meshCreationResult.config,
+                    // materialSettings: materialSettings,
+                    // animations: [],
+                    // effects: effects,
+                    // userData: meshData
+                };
+                if (object.animations) {
+                }
+                // console.log("Created object settings:", createdObjectSettings);
+                createdObjectsSettings.push(createdObjectSettings);
+                console.log("Created mesh:", createdObject.name);
+            }
+            catch (error) {
+                console.error(`Error creating mesh of type ${object.type}:`, error);
+            }
+        });
+        return createdObjectsSettings;
+    };
+    const createMaterialSettings = (meshData) => {
+        // let materialVariant = 'Standard';
+        // if (!meshData.material) {
+        //   console.warn("Mesh data is missing material property:", meshData);
+        //   // return;
+        // }
+        // if (!meshData.material.variant) {
+        //   console.warn("Mesh data is missing material variant:", meshData);
+        //   // return;
+        // }
+        const materialVariant = meshData.material &&
+            meshData.material.variant &&
+            MaterialRegistryAPI.getTypeFromVariantName(meshData.material.variant) ?
+            meshData.material.variant :
+            'Standard';
+        const materialType = MaterialRegistryAPI.getTypeFromVariantName(materialVariant) || 'basic';
+        if (materialType === 'advanced') {
+            const variant = MaterialRegistryAPI.getVariantDefinition(materialVariant);
+            if (variant && variant.defaultSettings) {
+                defaultSettings = variant.defaultSettings;
+            }
+        }
+        else {
+            const materialInstance = MaterialRegistryAPI.createMaterial(materialVariant);
+            // Extract current uniform values as default settings
+            defaultSettings = {
+                ...uniformConverter.convertToSettings(materialInstance.uniforms),
+                ...materialInstance.settings
+            };
+        }
+        // console.log("Default settings for material ", materialVariant, ":", defaultSettings);
+        Object.keys(meshData.material || {}).forEach(key => {
+            if (defaultSettings[key]) {
+                defaultSettings[key] = meshData.material[key];
+            }
+        });
+        const materialSettings = {
+            materialType,
+            materialVariant,
+            materialName: materialVariant,
+            ...defaultSettings,
+            // ...options
+        };
+        return materialSettings;
+    };
+    return {
+        // createMeshes,
+        createObjects,
+        createMaterialSettings,
+    };
+}
+export default useMeshController;

package/dist/hooks/useMouseHandlers.d.ts

@@ -0,0 +1,8 @@
+export declare const useMouseHandlers: () => {
+    getInterpolatedValue: (baseValue: any, minValue: any, maxValue: any, multiplier: number, sensitivity?: number) => any;
+    interpolateProperty: (baseValue: any, minValue: any, maxValue: any, pointer: {
+        x: number;
+        y: number;
+    }, axis?: "x" | "y" | "both", sensitivity?: number, inverted?: boolean) => any;
+};
+//# sourceMappingURL=useMouseHandlers.d.ts.map

package/dist/hooks/useMouseHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMouseHandlers.d.ts","sourceRoot":"","sources":["../../src/hooks/useMouseHandlers.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,gBAAgB,QAAO;IAC5B,oBAAoB,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,KAAK,GAAG,CAAC;IACtH,mBAAmB,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,OAAO,EAAE;QACzE,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;KACb,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,KAAK,GAAG,CAAC;CA8CtF,CAAC"}

package/dist/hooks/useMouseHandlers.js

@@ -0,0 +1,47 @@
+import { Color, MathUtils } from "three";
+export const useMouseHandlers = () => {
+    const getInterpolatedValue = (baseValue, minValue, maxValue, multiplier, sensitivity = 1) => {
+        // Normalize multiplier from [-1, 1] to [0, 1] for lerp
+        const normalizedMultiplier = (multiplier + 1) / 2;
+        const finalMultiplier = Math.max(0, Math.min(1, normalizedMultiplier * sensitivity));
+        // Handle Color objects or hex strings
+        if ((typeof minValue === 'string' && minValue.startsWith('#')) ||
+            (typeof maxValue === 'string' && maxValue.startsWith('#'))) {
+            const minColor = new Color(minValue);
+            const maxColor = new Color(maxValue);
+            const minArr = minColor.toArray();
+            const maxArr = maxColor.toArray();
+            const interpolated = minArr.map((min, index) => MathUtils.lerp(min, maxArr[index], finalMultiplier));
+            return new Color().fromArray(interpolated);
+        }
+        // Handle Vector3/Array [x, y, z]
+        if (Array.isArray(minValue) && Array.isArray(maxValue) && minValue.length === 3) {
+            return [
+                MathUtils.lerp(minValue[0], maxValue[0], finalMultiplier),
+                MathUtils.lerp(minValue[1], maxValue[1], finalMultiplier),
+                MathUtils.lerp(minValue[2], maxValue[2], finalMultiplier)
+            ];
+        }
+        // Handle numbers
+        if (typeof minValue === 'number' && typeof maxValue === 'number') {
+            return MathUtils.lerp(minValue, maxValue, finalMultiplier);
+        }
+        return baseValue;
+    };
+    const interpolateProperty = (baseValue, minValue, maxValue, pointer, axis = 'both', sensitivity = 1, inverted = false) => {
+        let multiplier = 0;
+        if (axis === 'x')
+            multiplier = pointer.x;
+        if (axis === 'y')
+            multiplier = pointer.y;
+        if (axis === 'both')
+            multiplier = (pointer.x + pointer.y) / 2;
+        if (inverted)
+            multiplier *= -1;
+        return getInterpolatedValue(baseValue, minValue, maxValue, multiplier, sensitivity);
+    };
+    return {
+        getInterpolatedValue,
+        interpolateProperty
+    };
+};

package/dist/hooks/useNumericAnimation.d.ts

@@ -0,0 +1,5 @@
+export type NumericValue = number | number[];
+export declare function useNumericAnimation(): {
+    animateNumeric: (from: Record<string, NumericValue>, to: Record<string, NumericValue>, onUpdate: (values: Record<string, NumericValue>) => void, onComplete: (values: Record<string, NumericValue>) => void, duration?: number) => void;
+};
+//# sourceMappingURL=useNumericAnimation.d.ts.map

package/dist/hooks/useNumericAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNumericAnimation.d.ts","sourceRoot":"","sources":["../../src/hooks/useNumericAnimation.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;AAc7C,wBAAgB,mBAAmB,IAAI;IAC/B,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,KAAK,IAAI,EAAE,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,KAAK,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC3O,CA2BJ"}

package/dist/hooks/useNumericAnimation.js

@@ -0,0 +1,42 @@
+import { useRef, useCallback } from 'react';
+import { useFrame } from '@react-three/fiber';
+function lerpValue(from, to, t) {
+    if (typeof to === 'number') {
+        const f = typeof from === 'number' ? from : to;
+        return f + (to - f) * t;
+    }
+    // array case
+    const fromArr = Array.isArray(from) ? from : [];
+    return to.map((toEl, i) => {
+        const fromEl = fromArr[i] ?? toEl;
+        return fromEl + (toEl - fromEl) * t;
+    });
+}
+export function useNumericAnimation() {
+    const animRef = useRef(null);
+    useFrame((_, delta) => {
+        if (!animRef.current)
+            return;
+        const anim = animRef.current;
+        anim.elapsed += delta;
+        const t = Math.min(1, anim.elapsed / anim.duration);
+        const st = t * t * (3 - 2 * t); // smoothstep
+        const update = {};
+        for (const key of Object.keys(anim.to)) {
+            const toVal = anim.to[key];
+            if (toVal === undefined)
+                continue;
+            const fromVal = anim.from[key];
+            update[key] = lerpValue(fromVal ?? toVal, toVal, st);
+        }
+        anim.onUpdate(update);
+        if (t >= 1) {
+            anim.onComplete(anim.to);
+            animRef.current = null;
+        }
+    });
+    const animateNumeric = useCallback((from, to, onUpdate, onComplete, duration = 3) => {
+        animRef.current = { from, to, duration, elapsed: 0, onUpdate, onComplete };
+    }, []);
+    return { animateNumeric };
+}

package/dist/hooks/useObjectAnimation.d.ts

@@ -0,0 +1,13 @@
+import type { CreatedObjectSettings } from '@3driseai/3drise-core';
+import type { UseContinuousEffectsResult } from './useContinuousEffects';
+import type { UseInteractionEffectsResult } from './useInteractionEffects';
+import { Object3D } from "three";
+interface UseObjectAnimationOptions {
+    enabled?: boolean;
+    hovered?: boolean;
+}
+interface UseObjectAnimationResult extends UseContinuousEffectsResult, UseInteractionEffectsResult {
+}
+export declare const useObjectAnimation: (objectSettings: CreatedObjectSettings | null, animateMaterial: boolean, options?: UseObjectAnimationOptions, ref?: Object3D) => UseObjectAnimationResult | null;
+export {};
+//# sourceMappingURL=useObjectAnimation.d.ts.map

package/dist/hooks/useObjectAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useObjectAnimation.d.ts","sourceRoot":"","sources":["../../src/hooks/useObjectAnimation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEnE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AAEzE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAE3E,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,UAAU,yBAAyB;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,UAAU,wBAAyB,SAAQ,0BAA0B,EAAE,2BAA2B;CACjG;AASD,eAAO,MAAM,kBAAkB,GAAI,gBAAgB,qBAAqB,GAAG,IAAI,EAAE,iBAAiB,OAAO,EAAE,UAAS,yBAA8B,EAAE,MAAM,QAAQ,KAAG,wBAAwB,GAAG,IAwB/L,CAAC"}

package/dist/hooks/useObjectAnimation.js

@@ -0,0 +1,35 @@
+import { findById } from '@3driseai/3drise-core';
+import { useContinuousEffects } from "./useContinuousEffects.js";
+import { useMouseMove } from "./useInteractionEffects.js";
+import { useSequenceAnimation } from "./useSequenceAnimation.js";
+const DEBUG_OBJECT_ANIMATION = false;
+const debugLog = (...args) => {
+    if (DEBUG_OBJECT_ANIMATION) {
+        console.log('[useObjectAnimation]', ...args);
+    }
+};
+export const useObjectAnimation = (objectSettings, animateMaterial, options = {}, ref) => {
+    const { enabled = true, hovered = false } = options;
+    const objectRef = ref || findById(objectSettings?.id);
+    // console.log(objectSettings?.id, objectRef);
+    // debugLog('hook run', {
+    //   objectId: objectSettings?.id,
+    //   hasRefArg: !!ref,
+    //   resolvedObject: objectRef ? { name: objectRef.name, id: objectRef.userData?.id } : null,
+    //   enabled,
+    //   hovered,
+    //   animateMaterial,
+    // });
+    if (!objectRef) {
+        debugLog('No object ref found, skipping animation setup', {
+            name: objectSettings?.meshSettings.name,
+            hasRefArg: !!ref,
+        });
+        // return null;
+    }
+    // console.log(hovered)
+    const continuousResult = useContinuousEffects(objectSettings, { enabled, animateMaterial, hovered }, objectRef);
+    const mouseMoveResult = useMouseMove(objectSettings, { enabled, animateMaterial }, objectRef);
+    useSequenceAnimation(objectSettings?.id, objectRef);
+    return { ...continuousResult, ...mouseMoveResult };
+};

package/dist/hooks/useObjectEdges.d.ts

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

package/dist/hooks/useObjectEdges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useObjectEdges.d.ts","sourceRoot":"","sources":["../../src/hooks/useObjectEdges.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAiKzD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,GAAG,IAAI,CAkCjF"}

package/dist/hooks/useObjectEdges.js

@@ -0,0 +1,199 @@
+import { useEffect, useMemo, useRef } from 'react';
+import { BoxGeometry, BufferGeometry, CylinderGeometry, EdgesGeometry, Group, LineSegments, Mesh, MeshBasicMaterial, Points, PointsMaterial, Quaternion, Vector3, Float32BufferAttribute, } from 'three';
+import { useFrame } from '@react-three/fiber';
+import { collectMeshes, computeThreshold, buildSubdividedEdgeGeometry, EDGES_GROUP_KEY, animateUniforms, cacheChildrenWithMaterials, findById } from '@3driseai/3drise-core';
+import { useMaterialApplication } from './useMaterialApplication.js';
+;
+// import { animateUniforms, cacheChildrenWithMaterials } from "~/utils/materialUtils";
+const DEFAULT_TUBE_RADIUS = 0.01;
+const DEFAULT_CUBE_SIZE = 0.02;
+// ─── Builders ────────────────────────────────────────────────────────────────
+function edgesGeoToQuadMesh(edgesGeo, thickness = 0.008) {
+    const src = edgesGeo.attributes.position;
+    const segCount = src.count / 2; // each segment = 2 vertices
+    const positions = [];
+    const uvs = [];
+    const indices = [];
+    const start = new Vector3();
+    const end = new Vector3();
+    const dir = new Vector3();
+    const up = new Vector3(0, 1, 0);
+    const right = new Vector3();
+    for (let i = 0; i < segCount; i++) {
+        start.fromBufferAttribute(src, i * 2);
+        end.fromBufferAttribute(src, i * 2 + 1);
+        dir.subVectors(end, start).normalize();
+        // Perpendicular axis — fallback to X if segment is vertical
+        right.crossVectors(dir, up).normalize();
+        if (right.lengthSq() < 0.0001) {
+            right.set(1, 0, 0);
+        }
+        const rx = right.x * thickness;
+        const ry = right.y * thickness;
+        const rz = right.z * thickness;
+        const base = i * 4;
+        // v0  start-bottom   uv(0,0)
+        positions.push(start.x - rx, start.y - ry, start.z - rz);
+        uvs.push(0, 0);
+        // v1  end-bottom     uv(1,0)
+        positions.push(end.x - rx, end.y - ry, end.z - rz);
+        uvs.push(1, 0);
+        // v2  start-top      uv(0,1)
+        positions.push(start.x + rx, start.y + ry, start.z + rz);
+        uvs.push(0, 1);
+        // v3  end-top        uv(1,1)
+        positions.push(end.x + rx, end.y + ry, end.z + rz);
+        uvs.push(1, 1);
+        indices.push(base, base + 1, base + 2);
+        indices.push(base + 1, base + 3, base + 2);
+    }
+    const geo = new BufferGeometry();
+    geo.setAttribute("position", new Float32BufferAttribute(positions, 3));
+    geo.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
+    geo.setIndex(indices);
+    geo.computeVertexNormals();
+    return new Mesh(geo);
+}
+function buildLineGroup(object, localParent) {
+    const g = new Group();
+    for (const { mesh, matrixRelativeToRoot } of collectMeshes(object, localParent)) {
+        const threshold = computeThreshold(mesh.geometry);
+        const edgesGeo = new EdgesGeometry(mesh.geometry, threshold);
+        const position = new Vector3();
+        const quaternion = new Quaternion();
+        const scale = new Vector3();
+        matrixRelativeToRoot.decompose(position, quaternion, scale);
+        const quadMesh = edgesGeoToQuadMesh(edgesGeo);
+        quadMesh.position.copy(position);
+        quadMesh.quaternion.copy(quaternion);
+        quadMesh.scale.copy(scale);
+        quadMesh.renderOrder = 1;
+        g.add(quadMesh);
+    }
+    return g;
+}
+function buildSegmentMeshGroup(object, localParent, geoFn) {
+    const g = new Group();
+    for (const { mesh, matrixRelativeToRoot } of collectMeshes(object, localParent)) {
+        const threshold = computeThreshold(mesh.geometry);
+        const edgesGeo = new EdgesGeometry(mesh.geometry, threshold);
+        const posAttr = edgesGeo.attributes.position;
+        const subGroup = new Group();
+        const position = new Vector3();
+        const quaternion = new Quaternion();
+        const scale = new Vector3();
+        matrixRelativeToRoot.decompose(position, quaternion, scale);
+        subGroup.position.copy(position);
+        subGroup.quaternion.copy(quaternion);
+        subGroup.scale.copy(scale);
+        for (let i = 0; i < posAttr.count; i += 2) {
+            const start = new Vector3(posAttr.getX(i), posAttr.getY(i), posAttr.getZ(i));
+            const end = new Vector3(posAttr.getX(i + 1), posAttr.getY(i + 1), posAttr.getZ(i + 1));
+            const dir = end.clone().sub(start);
+            const length = dir.length();
+            if (length < 0.0001)
+                continue;
+            const midpoint = start.clone().add(end).multiplyScalar(0.5);
+            const segQuat = new Quaternion().setFromUnitVectors(new Vector3(0, 1, 0), dir.normalize());
+            const m = new Mesh(geoFn(length), new MeshBasicMaterial());
+            m.position.copy(midpoint);
+            m.quaternion.copy(segQuat);
+            m.renderOrder = 1;
+            subGroup.add(m);
+        }
+        g.add(subGroup);
+        edgesGeo.dispose();
+    }
+    return g;
+}
+function buildTubeGroup(object, localParent, tubeRadius) {
+    return buildSegmentMeshGroup(object, localParent, (length) => new CylinderGeometry(tubeRadius, tubeRadius, length, 4));
+}
+function buildCubeGroup(object, localParent, cubeSize) {
+    return buildSegmentMeshGroup(object, localParent, (length) => new BoxGeometry(cubeSize, length, cubeSize));
+}
+function buildParticlesGroup(object, localParent) {
+    const g = new Group();
+    const geo = buildSubdividedEdgeGeometry(object, 30, localParent);
+    const points = new Points(geo, new PointsMaterial({ size: 0.02 }));
+    points.renderOrder = 1;
+    g.add(points);
+    return g;
+}
+function buildEdgesGroup(object, edgesSettings) {
+    // Compute the inverse of the object's current local matrix so that
+    // collectMeshes results are in object-local space. Without this, the
+    // transforms include the object's own matrix and get double-applied when
+    // the edges group is added as a child of the object.
+    object.updateMatrix();
+    const localParent = object.matrix.clone().invert();
+    const tubeRadius = edgesSettings.tubeRadius ?? DEFAULT_TUBE_RADIUS;
+    const cubeSize = edgesSettings.cubeSize ?? DEFAULT_CUBE_SIZE;
+    let g;
+    switch (edgesSettings.type) {
+        case 'tube':
+            g = buildTubeGroup(object, localParent, tubeRadius);
+            break;
+        case 'cube':
+            g = buildCubeGroup(object, localParent, cubeSize);
+            break;
+        case 'particles':
+            g = buildParticlesGroup(object, localParent);
+            break;
+        default: g = buildLineGroup(object, localParent);
+    }
+    g.userData[EDGES_GROUP_KEY] = true;
+    return g;
+}
+// ─── Cleanup ─────────────────────────────────────────────────────────────────
+function disposeGroup(group) {
+    if (!group)
+        return;
+    group.traverse((child) => {
+        if (child instanceof Mesh || child instanceof LineSegments || child instanceof Points) {
+            child.geometry.dispose();
+            if (Array.isArray(child.material)) {
+                child.material.forEach((m) => m.dispose());
+            }
+            else {
+                child.material.dispose?.();
+            }
+        }
+    });
+}
+// ─── Hook ─────────────────────────────────────────────────────────────────────
+export function useObjectEdges(objectId, edgesSettings) {
+    const childrenWithMaterialsRef = useRef([]);
+    const object = findById(objectId);
+    const edgesGroup = useMemo(() => {
+        if (!object || !edgesSettings.enabled)
+            return null;
+        return buildEdgesGroup(object, edgesSettings);
+        // Rebuild when geometry-affecting settings change
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [object, edgesSettings.type, edgesSettings.enabled, edgesSettings.tubeRadius, edgesSettings.cubeSize]);
+    // Attach edges to the live object so they move with it
+    useEffect(() => {
+        if (!object || !edgesGroup)
+            return;
+        object.add(edgesGroup);
+        return () => { object.remove(edgesGroup); };
+    }, [object, edgesGroup]);
+    // Dispose Three.js resources when group is rebuilt or hook unmounts
+    useEffect(() => {
+        return () => { disposeGroup(edgesGroup); };
+    }, [edgesGroup]);
+    // Cache edge meshes after the group is attached so useFrame has them on first frame
+    useEffect(() => {
+        childrenWithMaterialsRef.current = edgesGroup ? cacheChildrenWithMaterials(edgesGroup) : [];
+    }, [edgesGroup]);
+    // Apply material reactively — works for all three types since each child has .material
+    useMaterialApplication(edgesGroup, edgesSettings.materialSettings, edgesSettings.enabled);
+    useFrame((state, delta) => {
+        if (!edgesGroup)
+            return;
+        const time = state.clock.getElapsedTime();
+        const mouse = state.pointer;
+        animateUniforms(childrenWithMaterialsRef.current, time, mouse, state.camera.position);
+    });
+}

package/dist/hooks/useObjectEffects.d.ts

@@ -0,0 +1,23 @@
+import type { Object3D } from 'three';
+export interface ObjectEffectsState {
+    glowingObjects: Set<string>;
+    vanishedObjects: Set<string>;
+}
+export interface ObjectEffectsFunctions {
+    vanishObject: (object: Object3D, duration?: number, ease?: string) => void;
+    restoreVanishedObject: (object: Object3D, duration?: number, ease?: string) => void;
+    animateGlowEffect: (object: Object3D) => void;
+    removeGlow: (object: Object3D) => void;
+    isVanished: (objectUuid: string) => boolean;
+    isGlowing: (objectUuid: string) => boolean;
+}
+export interface UseObjectEffectsReturn extends ObjectEffectsFunctions {
+    glowingObjects: React.MutableRefObject<Set<string>>;
+    vanishedObjects: React.MutableRefObject<Set<string>>;
+}
+/**
+ * Hook for managing visual object effects
+ */
+export declare function useObjectEffects(): UseObjectEffectsReturn;
+export default useObjectEffects;
+//# sourceMappingURL=useObjectEffects.d.ts.map

package/dist/hooks/useObjectEffects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useObjectEffects.d.ts","sourceRoot":"","sources":["../../src/hooks/useObjectEffects.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC,MAAM,WAAW,kBAAkB;IAC/B,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,sBAAsB;IACnC,YAAY,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3E,qBAAqB,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACpF,iBAAiB,EAAE,CAAC,MAAM,EAAE,QAAQ,KAAK,IAAI,CAAC;IAC9C,UAAU,EAAE,CAAC,MAAM,EAAE,QAAQ,KAAK,IAAI,CAAC;IACvC,UAAU,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IAC5C,SAAS,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;CAC9C;AAED,MAAM,WAAW,sBAAuB,SAAQ,sBAAsB;IAClE,cAAc,EAAE,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACpD,eAAe,EAAE,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CACxD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,sBAAsB,CAoJzD;AACD,eAAe,gBAAgB,CAAC"}