@ntalmagor/3drize-viewer 0.1.2

package/dist/hooks/useMaterialApplication.d.ts

@@ -0,0 +1,9 @@
+import { Object3D } from 'three';
+import { MaterialInstance, MaterialSettings } from '@ntalmagor/3drize-core';
+export declare const useMaterialApplication: (obj: Object3D | null | undefined, materialSettings: MaterialSettings, shouldApply3driseMaterial?: boolean, onApplied?: () => void) => void;
+/**
+ * Standalone utility: Apply material to a single object (for use outside the hook).
+ * Uses shared utilities for texture resolution and material creation.
+ */
+export declare const applyMaterialToObject: (object: any, materialSettings: MaterialSettings) => Promise<MaterialInstance | undefined>;
+//# sourceMappingURL=useMaterialApplication.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMaterialApplication.d.ts","sourceRoot":"","sources":["../../src/hooks/useMaterialApplication.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,EAAiD,gBAAgB,EAAuB,gBAAgB,EAAwE,MAAM,wBAAwB,CAAC;AAEtN,eAAO,MAAM,sBAAsB,GACjC,KAAK,QAAQ,GAAG,IAAI,GAAG,SAAS,EAChC,kBAAkB,gBAAgB,EAClC,4BAA4B,OAAO,EACnC,YAAY,MAAM,IAAI,SAsGvB,CAAC;AAGF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAU,QAAQ,GAAG,EAAE,kBAAkB,gBAAgB,0CAgB1F,CAAC"}

package/dist/hooks/useMaterialApplication.js

@@ -0,0 +1,113 @@
+// =============================================================================
+// useMaterialApplication — React Hook for Material Application
+// =============================================================================
+//
+// Watches materialSettings changes and imperatively applies materials to a
+// Three.js object. Uses shared utilities from materialApplicationUtils.
+//
+import { useEffect, useRef } from 'react';
+import { createAndApplyMaterial, MATERIAL_INSTANCE_KEY, MaterialRegistryAPI, ObjectManager, resolveTextures, traverseSkippingEdges } from '@ntalmagor/3drize-core';
+export const useMaterialApplication = (obj, materialSettings, shouldApply3driseMaterial, onApplied) => {
+    const prevSettingsRef = useRef(null);
+    // Track all material instances we've created so we can release them on change/unmount
+    const activeInstancesRef = useRef([]);
+    useEffect(() => {
+        if (!obj || !materialSettings || materialSettings.materialType === 'advanced' || (shouldApply3driseMaterial === false))
+            return;
+        const currentSettings = JSON.stringify(materialSettings);
+        prevSettingsRef.current = currentSettings;
+        handleSettingsChange(obj, materialSettings);
+        // Cleanup: release materials when settings change or component unmounts
+        return () => {
+            releaseActiveInstances();
+        };
+    }, [materialSettings, obj]);
+    /**
+     * Release all material instances we've created.
+     */
+    const releaseActiveInstances = () => {
+        for (const instance of activeInstancesRef.current) {
+            try {
+                MaterialRegistryAPI.releaseMaterial(instance);
+            }
+            catch (e) {
+                // Silently ignore release errors during cleanup
+            }
+        }
+        activeInstancesRef.current = [];
+    };
+    const handleSettingsChange = async (obj, materialSettings) => {
+        if (!obj || !materialSettings || materialSettings.materialType === 'advanced' || !materialSettings.materialVariant)
+            return;
+        const applyMaterial = materialSettings.apply !== undefined ? materialSettings.apply : true;
+        // console.log({
+        //   obj,
+        //   applyMaterial
+        // })
+        // If apply is false, restore original materials
+        if (!applyMaterial) {
+            const objectId = obj.userData?.id;
+            if (objectId) {
+                releaseActiveInstances();
+                ObjectManager.restoreOriginalMaterials(objectId);
+            }
+            onApplied?.();
+            return;
+        }
+        const variant = materialSettings.materialVariant || 'Standard';
+        // 1. Resolve textures using shared utility (registry-driven TextureResolver)
+        const resolvedSettings = await resolveTextures(variant, materialSettings);
+        // console.log('Resolved material settings with textures:', resolvedSettings);
+        // 2. Release previous material instances before creating new ones
+        releaseActiveInstances();
+        // 3. Traverse the object tree and apply material to any child with .material.
+        //    Skips edges subtrees (EDGES_GROUP_KEY) so they keep their own material,
+        //    unless obj itself is the edges group (then we apply normally).
+        traverseSkippingEdges(obj, true, (child) => {
+            if (child.material) {
+                // Only skip children with ORIGINAL baked textures (e.g., from loaded GLTF models).
+                // If we previously applied a 3drise material to this child, always allow re-application.
+                // console.log(child)
+                const hasBakedTexture = child.material.map && !child.userData[MATERIAL_INSTANCE_KEY];
+                // if (hasBakedTexture && !resolvedSettings.map) return;
+                applyMaterialToChild(child, variant, resolvedSettings);
+            }
+        });
+        onApplied?.();
+    };
+    /**
+     * Create a fresh material instance and apply resolved settings to a single child object.
+     * Uses shared createAndApplyMaterial utility.
+     */
+    const applyMaterialToChild = (object, variant, resolvedSettings) => {
+        try {
+            const materialInstance = createAndApplyMaterial(variant, resolvedSettings);
+            // Assign to the object
+            object.material = materialInstance.material;
+            // Track the instance for cleanup
+            activeInstancesRef.current.push(materialInstance);
+            // Also store on userData for external access if needed
+            object.userData[MATERIAL_INSTANCE_KEY] = materialInstance;
+        }
+        catch (error) {
+            console.error(`Failed to apply material "${variant}" to object:`, error);
+        }
+    };
+};
+/**
+ * Standalone utility: Apply material to a single object (for use outside the hook).
+ * Uses shared utilities for texture resolution and material creation.
+ */
+export const applyMaterialToObject = async (object, materialSettings) => {
+    if (!object || !materialSettings)
+        return;
+    const variant = materialSettings.materialVariant || 'Standard';
+    // Resolve textures via shared utility
+    const resolvedSettings = await resolveTextures(variant, materialSettings);
+    // Create and apply via shared utility
+    const materialInstance = createAndApplyMaterial(variant, resolvedSettings);
+    object.material = materialInstance.material;
+    // Store instance on userData for potential cleanup
+    object.userData[MATERIAL_INSTANCE_KEY] = materialInstance;
+    return materialInstance;
+};

package/dist/hooks/useMaterialOptions.d.ts

@@ -0,0 +1,13 @@
+import { MaterialRegistryAPI, MaterialSettings, SelectOptions } from '@ntalmagor/3drize-core';
+type RegistryMaterialType = Exclude<Parameters<typeof MaterialRegistryAPI.getVariants>[0], undefined>;
+export interface UseMaterialOptionsReturn {
+    selectedType: RegistryMaterialType;
+    selectedVariant: string;
+    materialTypeOptions: SelectOptions;
+    variantOptions: SelectOptions;
+    handleTypeChange: (type: RegistryMaterialType) => void;
+    handleVariantChange: (variant: string) => void;
+}
+export declare const useMaterialOptions: (initialSettings: MaterialSettings, onSettingsChange?: (newSettings: MaterialSettings) => void) => UseMaterialOptionsReturn;
+export {};
+//# sourceMappingURL=useMaterialOptions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMaterialOptions.d.ts","sourceRoot":"","sources":["../../src/hooks/useMaterialOptions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE9F,KAAK,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAGtG,MAAM,WAAW,wBAAwB;IACvC,YAAY,EAAE,oBAAoB,CAAC;IACnC,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,aAAa,CAAC;IACnC,cAAc,EAAE,aAAa,CAAC;IAC9B,gBAAgB,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACvD,mBAAmB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAChD;AAED,eAAO,MAAM,kBAAkB,GAC7B,iBAAiB,gBAAgB,EACjC,mBAAmB,CAAC,WAAW,EAAE,gBAAgB,KAAK,IAAI,KACzD,wBA8HF,CAAC"}

package/dist/hooks/useMaterialOptions.js

@@ -0,0 +1,110 @@
+import { useState, useEffect } from 'react';
+import { MaterialRegistryAPI } from '@ntalmagor/3drize-core';
+export const useMaterialOptions = (initialSettings, onSettingsChange) => {
+    // Ensure we always have a valid material type
+    const validType = (initialSettings.materialType || 'basic');
+    const [selectedType, setSelectedType] = useState(validType);
+    const availableVariantsForInit = MaterialRegistryAPI.getVariants(validType);
+    const initialVariant = initialSettings.materialVariant || availableVariantsForInit[0] || '';
+    const [selectedVariant, setSelectedVariant] = useState(initialVariant);
+    // Sync internal state when the external settings change (e.g. Redux-driven
+    // updates or edge-type resets). Without this, the dropdowns stay stale after
+    // any external materialType / materialVariant change.
+    useEffect(() => {
+        // console.log('useMaterialOptions - syncing with new initialSettings:', initialSettings);
+        const newType = initialSettings.materialType || 'basic';
+        setSelectedType(newType);
+        const variants = MaterialRegistryAPI.getVariants(newType);
+        setSelectedVariant(initialSettings.materialVariant || variants[0] || '');
+    }, [initialSettings.materialType, initialSettings.materialVariant]);
+    const allmaterialTypes = MaterialRegistryAPI.getTypes();
+    const is3dRiseShaderMaterial = initialSettings.materialType === 'particles' || initialSettings.materialType === 'custom';
+    const isLineMaterial = initialSettings.materialType === 'line';
+    const meshMaterialTypes = allmaterialTypes.filter(type => type !== 'particles' && type !== 'custom' && type !== 'line');
+    const lineMaterialTypes = allmaterialTypes.filter(type => type === 'line');
+    const dRiseShaderMaterialTypes = allmaterialTypes.filter(type => type === 'particles' || type === 'custom');
+    const materialTypeOptions = () => {
+        if (is3dRiseShaderMaterial) {
+            return dRiseShaderMaterialTypes.map((type) => ({
+                value: type,
+                label: type.charAt(0).toUpperCase() + type.slice(1)
+            }));
+        }
+        if (isLineMaterial) {
+            return lineMaterialTypes.map((type) => ({
+                value: type,
+                label: type.charAt(0).toUpperCase() + type.slice(1)
+            }));
+        }
+        return meshMaterialTypes.map((type) => ({
+            value: type,
+            label: type.charAt(0).toUpperCase() + type.slice(1)
+        }));
+    };
+    // is3dRiseShaderMaterial ?
+    // dRiseShaderMaterialTypes.map((type: string) => ({
+    //   value: type,
+    //   label: type.charAt(0).toUpperCase() + type.slice(1)
+    // })) : 
+    // meshMaterialTypes.map((type: string) => ({
+    //     value: type,
+    //     label: type.charAt(0).toUpperCase() + type.slice(1)
+    //   }));
+    // Variant options for current type - with safety check
+    const availableVariants = selectedType ? MaterialRegistryAPI.getVariants(selectedType) : [];
+    const variantOptions = availableVariants.map(variant => ({
+        value: variant,
+        label: variant
+    }));
+    const handleTypeChange = (type) => {
+        // console.log('Material type changed to:', type);
+        setSelectedType(type);
+        const availableVariants = MaterialRegistryAPI.getVariants(type);
+        const defaultVariant = availableVariants[0];
+        // console.log({defaultVariant})
+        setSelectedVariant(defaultVariant);
+        // Auto-select first variant when type changes
+        if (defaultVariant) {
+            handleMaterialUpdate(type, defaultVariant);
+        }
+    };
+    const handleVariantChange = (variant) => {
+        console.log('Material variant changed to:', variant);
+        setSelectedVariant(variant);
+        handleMaterialUpdate(selectedType, variant);
+    };
+    const handleMaterialUpdate = (type, variant) => {
+        if (!onSettingsChange)
+            return;
+        try {
+            const variantDefinition = MaterialRegistryAPI.getVariantDefinition(variant);
+            if (!variantDefinition) {
+                console.warn(`Variant definition for "${variant}" not found.`);
+                return;
+            }
+            // Start fresh from the new variant's defaults — this ensures
+            // texture properties from the previous variant are cleared (reset to null).
+            const variantDefaults = variantDefinition.defaultSettings || {};
+            const newSettings = {
+                apply: true,
+                materialType: type,
+                materialVariant: variant,
+                // Preserve handlers from previous settings if they exist
+                // ...(initialSettings.handlers ? { handlers: initialSettings.handlers } : {}),
+                ...variantDefaults,
+            };
+            onSettingsChange(newSettings);
+        }
+        catch (error) {
+            console.error('Error updating material:', error);
+        }
+    };
+    return {
+        selectedType,
+        selectedVariant,
+        materialTypeOptions: materialTypeOptions(),
+        variantOptions,
+        handleTypeChange,
+        handleVariantChange
+    };
+};

package/dist/hooks/useMaterialUniforms.d.ts

@@ -0,0 +1,18 @@
+import type { Material, Object3D } from 'three';
+/**
+ * Hook for direct material manipulation on a scene object ref.
+ *
+ * Usage pattern (like SkyControllerUi):
+ * - On slider drag → updateProperty(key, value) — instant visual feedback, no Redux
+ * - On slider end  → updateProperty(key, value) + dispatch to Redux
+ * - On color change → updateColor(key, hex) + dispatch to Redux
+ * - On variant change → changeMaterial(variant, settings) + dispatch to Redux
+ */
+export declare function useMaterialUniforms(object: Object3D | null | undefined): {
+    getMaterial: () => Material | null;
+    updateProperty: (key: string, value: any) => void;
+    updateColor: (key: string, hexValue: string) => void;
+    applyAllSettings: (settings: Record<string, any>) => void;
+    changeMaterial: (variant: string, settings: Record<string, any>) => void;
+};
+//# sourceMappingURL=useMaterialUniforms.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMaterialUniforms.d.ts","sourceRoot":"","sources":["../../src/hooks/useMaterialUniforms.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAWhD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS;uBAKjC,QAAQ,GAAG,IAAI;0BAkBV,MAAM,SAAS,GAAG;uBAYrB,MAAM,YAAY,MAAM;iCAad,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;8BAatB,MAAM,YAAY,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;EAsBnF"}

package/dist/hooks/useMaterialUniforms.js

@@ -0,0 +1,96 @@
+import { useCallback } from 'react';
+import { applySingleProperty, applyColorProperty, createAndApplyMaterial, MATERIAL_INSTANCE_KEY, traverseSkippingEdges, MaterialRegistryAPI } from '@ntalmagor/3drize-core';
+/**
+ * Hook for direct material manipulation on a scene object ref.
+ *
+ * Usage pattern (like SkyControllerUi):
+ * - On slider drag → updateProperty(key, value) — instant visual feedback, no Redux
+ * - On slider end  → updateProperty(key, value) + dispatch to Redux
+ * - On color change → updateColor(key, hex) + dispatch to Redux
+ * - On variant change → changeMaterial(variant, settings) + dispatch to Redux
+ */
+export function useMaterialUniforms(object) {
+    /**
+     * Get the material from the first non-edges child mesh that has one.
+     */
+    const getMaterial = useCallback(() => {
+        if (!object)
+            return null;
+        if (object.material)
+            return object.material;
+        let found = null;
+        traverseSkippingEdges(object, true, (child) => {
+            if (!found && child.material) {
+                found = child.material;
+            }
+        });
+        return found;
+    }, [object]);
+    /**
+     * Update a single numeric property on the material (instant feedback).
+     * Does NOT persist to Redux — caller should do that on slider end.
+     */
+    const updateProperty = useCallback((key, value) => {
+        if (!object)
+            return;
+        traverseSkippingEdges(object, true, (child) => {
+            if (child.material) {
+                applySingleProperty(child.material, key, value);
+            }
+        });
+    }, [object]);
+    /**
+     * Update a color property on the material (instant feedback).
+     */
+    const updateColor = useCallback((key, hexValue) => {
+        if (!object)
+            return;
+        traverseSkippingEdges(object, true, (child) => {
+            if (child.material) {
+                applyColorProperty(child.material, key, hexValue);
+            }
+        });
+    }, [object]);
+    /**
+     * Apply a full set of settings to the current material.
+     * Used for randomize or batch updates.
+     */
+    const applyAllSettings = useCallback((settings) => {
+        if (!object)
+            return;
+        traverseSkippingEdges(object, true, (child) => {
+            if (child.material) {
+                MaterialRegistryAPI.applySettings(child.material, settings);
+            }
+        });
+    }, [object]);
+    /**
+     * Change the material variant entirely.
+     * Creates a new material instance and assigns it to all non-edges children.
+     */
+    const changeMaterial = useCallback((variant, settings) => {
+        if (!object)
+            return;
+        traverseSkippingEdges(object, true, (child) => {
+            if (child.material) {
+                const oldInstance = child.userData[MATERIAL_INSTANCE_KEY];
+                if (oldInstance) {
+                    try {
+                        MaterialRegistryAPI.releaseMaterial(oldInstance);
+                    }
+                    catch (_) { }
+                }
+                const instance = createAndApplyMaterial(variant, settings);
+                child.material = instance.material;
+                child.userData[MATERIAL_INSTANCE_KEY] = instance;
+            }
+        });
+    }, [object]);
+    return {
+        getMaterial,
+        updateProperty,
+        updateColor,
+        applyAllSettings,
+        changeMaterial,
+    };
+}

package/dist/hooks/useMeshController.d.ts

@@ -0,0 +1,3 @@
+export declare function useMeshController(): any;
+export default useMeshController;
+//# sourceMappingURL=useMeshController.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMeshController.d.ts","sourceRoot":"","sources":["../../src/hooks/useMeshController.ts"],"names":[],"mappings":"AAkBA,wBAAgB,iBAAiB,IAAI,GAAG,CA0KvC;AAED,eAAe,iBAAiB,CAAC"}

package/dist/hooks/useMeshController.js

@@ -0,0 +1,152 @@
+import { createMeshByType, createTempId, MaterialRegistryAPI, ObjectManager, uniformConverter, } from '@ntalmagor/3drize-core';
+export function useMeshController() {
+    let defaultSettings = {
+        color: { value: '#ffffff' },
+        opacity: { value: 1 },
+        wireframe: { value: false },
+    };
+    const createMeshes = (meshes) => {
+        const createdObjectsSettings = [];
+        // 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 = {
+                    ...mesh,
+                    id,
+                    type: meshType
+                };
+                // console.log({ meshData });
+                // let createdObject: CreatedRef | null = ;
+                const createdObject = {
+                    id,
+                    name: mesh.name || `mesh-${id}`,
+                    object: createMeshByType(meshData)
+                };
+                createdObject && ObjectManager.addObject(createdObject);
+                if (!createdObject)
+                    return;
+                // const materialType: MaterialType = meshData.materialType || 'basic';
+                const materialSettings = createMaterialSettings(meshData);
+                const meshSettings = ObjectManager.getMeshSettingsFromMesh(createdObject.object);
+                // const effects: Use3driseShaderEffects = {
+                //   general: {
+                //     wave: { enabled: false, intensity: 0.3, frequency: 3.0, speed: 1.0, direction: 'horizontal' },
+                //     vortex: { enabled: false, intensity: 0.5, speed: 0.5, centerX: 0, centerY: 0 },
+                //     ripple: { enabled: false, intensity: 0.3, speed: 2.0, centerX: 0, centerY: 0, frequency: 5.0 },
+                //     grayscale: {
+                //       enabled: false,
+                //       mode: 'static',
+                //       intensity: 1.0,
+                //       contrast: 1.0,
+                //       brightness: 0.0,
+                //       waveFrequency: 3.0,
+                //       waveSpeed: 1.0,
+                //       waveDirection: 'horizontal',
+                //       pulseSpeed: 2.0,
+                //       rippleSpeed: 2.0,
+                //       rippleCenterX: 0,
+                //       rippleCenterY: 0,
+                //     },
+                //   },
+                //   pointer: {
+                //     global: { radius: 2.5 },
+                //     vertex: {
+                //       ripple: { enabled: false, intensity: 0.5, speed: 2.0, frequency: 5.0 },
+                //       displacement: { enabled: false, intensity: 0.5 },
+                //       scale: { enabled: false, intensity: 0.5, minScale: 0.5, maxScale: 2.0 },
+                //       vortex: { enabled: false, intensity: 0.5, speed: 1.0 },
+                //       wave: { enabled: false, intensity: 0.5, frequency: 5.0, speed: 1.0, direction: 'horizontal' },
+                //     },
+                //     fragment: {
+                //       glow: { enabled: false, intensity: 0.5, color: '#ffffff' },
+                //       colorShift: { enabled: false, intensity: 0.5, targetColor: '#ff6600' },
+                //       brightness: { enabled: false, intensity: 0.5 },
+                //       pulse: { enabled: false, intensity: 0.5, speed: 2.0 },
+                //       grayscale: { enabled: false, intensity: 1.0, contrast: 1.0, brightness: 0.0 },
+                //     },
+                //   },
+                // }
+                let 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,
+                    userData: meshData
+                };
+                if (meshData.animations && meshData.animations.length > 0) {
+                    createdObjectSettings.animations = meshData.animations.map((animation) => ({
+                        ...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.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,
+        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":"AAGA,eAAO,MAAM,gBAAgB;sCAEV,GAAG,YACJ,GAAG,YACH,GAAG,cACD,MAAM,gBACL,MAAM,KACpB,GAAG;qCAuCS,GAAG,YACJ,GAAG,YACH,GAAG,WACJ;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,SAC3B,GAAG,GAAG,GAAG,GAAG,MAAM,gBACX,MAAM,aACT,OAAO;CAgBxB,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/useObjectAnimation.d.ts

@@ -0,0 +1,13 @@
+import { Object3D } from "three";
+import { type CreatedObjectSettings } from '@ntalmagor/3drize-core';
+import { type UseContinuousEffectsResult } from "./useContinuousEffects";
+import { type UseInteractionEffectsResult } from "./useInteractionEffects";
+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":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,EAAE,KAAK,qBAAqB,EAAY,MAAM,wBAAwB,CAAC;AAC9E,OAAO,EAAwB,KAAK,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AAC/F,OAAO,EAAyB,KAAK,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAGlG,UAAU,yBAAyB;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,UAAU,wBAAyB,SAAQ,0BAA0B,EAAE,2BAA2B;CAAG;AAErG,eAAO,MAAM,kBAAkB,GAC7B,gBAAgB,qBAAqB,GAAG,IAAI,EAC5C,iBAAiB,OAAO,EACxB,UAAS,yBAA8B,EACvC,MAAM,QAAQ,KACb,wBAAwB,GAAG,IAQ7B,CAAC"}

package/dist/hooks/useObjectAnimation.js

@@ -0,0 +1,11 @@
+import { findById } from '@ntalmagor/3drize-core';
+import { useContinuousEffects } from "./useContinuousEffects";
+import { useInteractionEffects } from "./useInteractionEffects";
+export const useObjectAnimation = (objectSettings, animateMaterial, options = {}, ref) => {
+    const { enabled = true, hovered = false } = options;
+    const objectRef = ref || findById(objectSettings?.id);
+    // console.log(objectRef)
+    const continuousResult = useContinuousEffects(objectSettings, { enabled, animateMaterial, hovered }, objectRef);
+    const interactionResult = useInteractionEffects(objectSettings, { enabled, animateMaterial }, objectRef);
+    return { ...continuousResult, ...interactionResult };
+};

package/dist/hooks/useObjectEdges.d.ts

@@ -0,0 +1,4 @@
+import type { Object3D } from 'three';
+import type { ObjectEdges } from '@ntalmagor/3drize-core';
+export declare function useObjectEdges(object: Object3D | null | undefined, 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":"AAkBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAGtC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAqM1D,wBAAgB,cAAc,CAC1B,MAAM,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,EACnC,aAAa,EAAE,WAAW,QAyC7B"}