@3driseai/3drise-viewer 0.1.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLightMouseMove.d.ts","sourceRoot":"","sources":["../../src/hooks/useLightMouseMove.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AACnC,MAAM,WAAW,wBAAwB;IACrC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gFAAgF;IAChF,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACrC;AAGD,eAAO,MAAM,iBAAiB,GAAI,UAAU,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,QAAQ,eAAe,GAAG,SAAS,EAAE,UAAS,wBAA6B,KAAG,IAclJ,CAAC;AACF,eAAe,iBAAiB,CAAC"}

package/dist/hooks/useLightMouseMove.js

@@ -0,0 +1,27 @@
+// =============================================================================
+// useLightMouseMove — drives pointer-based property updates on a THREE.Light
+// =============================================================================
+//
+// Sibling of useLightAnimation. Lights live in their own component tree
+// (LightObject's R3F primitives), so they don't pass through the main
+// useMouseMove inside useObjectAnimation. This hook closes that gap for the
+// 'light' domain of MouseMoveInteractions on a createdObject of type 'light'.
+//
+import { useFrame } from '@react-three/fiber';
+import { handleLightMouseMove } from '@3driseai/3drise-core';
+export const useLightMouseMove = (lightRef, domain, options = {}) => {
+    const { enabled = true, lightConfig } = options;
+    useFrame((state) => {
+        if (!enabled)
+            return;
+        const light = lightRef.current;
+        if (!light)
+            return;
+        if (!domain?.enabled)
+            return;
+        if (!domain.properties?.length)
+            return;
+        handleLightMouseMove({ light, lightConfig }, domain.properties, state.pointer);
+    });
+};
+export default useLightMouseMove;

package/dist/hooks/useLightShadow.d.ts

@@ -0,0 +1,6 @@
+import type { RefObject } from 'react';
+import type { DirectionalLight, PointLight, SpotLight } from "three";
+type ShadowLight = DirectionalLight | SpotLight | PointLight;
+export declare const useLightShadow: (lightRef: RefObject<ShadowLight | null>, shadow: Record<string, any> | undefined, enabledFallback?: boolean) => void;
+export {};
+//# sourceMappingURL=useLightShadow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLightShadow.d.ts","sourceRoot":"","sources":["../../src/hooks/useLightShadow.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACrE,KAAK,WAAW,GAAG,gBAAgB,GAAG,SAAS,GAAG,UAAU,CAAC;AAG7D,eAAO,MAAM,cAAc,GAAI,UAAU,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EAAE,QAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,EAAE,kBAAiB,OAAc,KAAG,IA6ClJ,CAAC"}

package/dist/hooks/useLightShadow.js

@@ -0,0 +1,63 @@
+// =============================================================================
+// useLightShadow — applies shadow settings to a Three.js light
+// =============================================================================
+//
+// Imperative shadow-property application for DirectionalLight / SpotLight /
+// PointLight. Mirrors the pattern used for the sun in LightsManager.
+//
+// Handles the mapSize change quirk: when mapSize changes after the shadow map
+// texture is created, the existing texture must be disposed and `light.shadow.map`
+// set to null so the renderer recreates it at the new resolution.
+//
+// All known fields across the three shadow-camera kinds are applied if defined
+// on the passed shadow object. Fields irrelevant to the actual light type
+// (e.g. cameraLeft on a SpotLight's perspective camera) are simply ignored by
+// Three.js, so it's safe to apply them defensively.
+//
+import { useEffect } from 'react';
+export const useLightShadow = (lightRef, shadow, enabledFallback = true) => {
+    useEffect(() => {
+        const light = lightRef.current;
+        if (!light)
+            return;
+        light.castShadow = shadow?.enabled ?? enabledFallback;
+        if (!shadow)
+            return;
+        if (shadow.mapSize !== undefined) {
+            const previous = light.shadow.mapSize.x;
+            light.shadow.mapSize.set(shadow.mapSize, shadow.mapSize);
+            if (previous !== shadow.mapSize && light.shadow.map) {
+                light.shadow.map.dispose();
+                light.shadow.map = null;
+            }
+        }
+        if (shadow.bias !== undefined)
+            light.shadow.bias = shadow.bias;
+        if (shadow.normalBias !== undefined)
+            light.shadow.normalBias = shadow.normalBias;
+        if (shadow.radius !== undefined)
+            light.shadow.radius = shadow.radius;
+        if (shadow.intensity !== undefined)
+            light.shadow.intensity = shadow.intensity;
+        const cam = light.shadow.camera;
+        if (shadow.cameraNear !== undefined)
+            cam.near = shadow.cameraNear;
+        if (shadow.cameraFar !== undefined)
+            cam.far = shadow.cameraFar;
+        // DirectionalLight uses an OrthographicCamera (ortho frustum bounds)
+        if (shadow.cameraLeft !== undefined)
+            cam.left = shadow.cameraLeft;
+        if (shadow.cameraRight !== undefined)
+            cam.right = shadow.cameraRight;
+        if (shadow.cameraTop !== undefined)
+            cam.top = shadow.cameraTop;
+        if (shadow.cameraBottom !== undefined)
+            cam.bottom = shadow.cameraBottom;
+        // SpotLight uses a PerspectiveCamera (fov + focus)
+        if (shadow.cameraFov !== undefined)
+            cam.fov = shadow.cameraFov;
+        if (shadow.focus !== undefined)
+            light.shadow.focus = shadow.focus;
+        cam.updateProjectionMatrix();
+    }, [lightRef, shadow]);
+};

package/dist/hooks/useMaterialApplication.d.ts

@@ -0,0 +1,4 @@
+import type { MaterialSettings } from '@3driseai/3drise-core';
+import { Object3D } from "three";
+export declare const useMaterialApplication: (obj: Object3D | null | undefined, materialSettings: MaterialSettings, shouldApply3driseMaterial?: boolean, onApplied?: () => void) => void;
+//# 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,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAIjC,eAAO,MAAM,sBAAsB,GAAI,KAAK,QAAQ,GAAG,IAAI,GAAG,SAAS,EAAE,kBAAkB,gBAAgB,EAAE,4BAA4B,OAAO,EAAE,YAAY,MAAM,IAAI,KAAG,IAiJ1K,CAAC"}

package/dist/hooks/useMaterialApplication.js

@@ -0,0 +1,157 @@
+// =============================================================================
+// 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, traverseSkippingEdgesAndEffects } from '@3driseai/3drise-core';
+// TEST: 0=raw defaults, 1=+DoubleSide, 2=+transparent, 3=+metalness/roughness
+const TEST_MATERIAL_MODE = 1;
+export const useMaterialApplication = (obj, materialSettings, shouldApply3driseMaterial, onApplied) => {
+    // Track all material instances we've created so we can release them on change/unmount
+    // const { getTypeByName } = useObjectTypes();
+    const activeInstancesRef = useRef([]);
+    const getOriginObject = (obj) => {
+        let found = null;
+        traverseSkippingEdgesAndEffects(obj, true, (child) => {
+            if (child.userData?.id) {
+                found = child;
+                return false; // Stop traversal
+            }
+        });
+        return found;
+    };
+    useEffect(() => {
+        if (!obj || !materialSettings || materialSettings.materialType === 'advanced' ||
+            materialSettings.materialVariant === '3dRiseShader' || (shouldApply3driseMaterial === false))
+            return;
+        handleSettingsChange(obj, materialSettings);
+        return () => {
+            releaseActiveInstances();
+        };
+    }, [materialSettings, obj]);
+    // Unmount-only cleanup: dispose everything once the mesh leaves the scene.
+    useEffect(() => {
+        return () => {
+            releaseActiveInstances();
+        };
+    }, []);
+    /**
+     * 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) => {
+        // console.log('Applying material with settings:', { obj, materialSettings });
+        if (!obj || !materialSettings || materialSettings.materialType === 'advanced')
+            return;
+        // console.log('Applying material with settings:',obj.name, obj);
+        // const originObject: Object3D | null = getOriginObject(obj);
+        const applyMaterial = materialSettings.apply !== undefined ? materialSettings.apply : true;
+        // console.log({applyMaterial});
+        // If apply is false, restore original materials
+        if (!applyMaterial) {
+            const objectId = obj.userData?.id;
+            // console.log({objectId})
+            if (objectId) {
+                releaseActiveInstances();
+                ObjectManager.restoreOriginalMaterials(objectId);
+                // console.log(`Restored original materials for object ID ${objectId}`);
+            }
+            onApplied?.();
+            return;
+        }
+        const materialType = MaterialRegistryAPI.getTypeDefinition(materialSettings.materialType);
+        // console.log('Material type definition:', materialType);
+        if (!materialType) {
+            console.error(`Material type "${materialSettings.materialType}" not found in registry.`);
+            return;
+        }
+        const firstVariant = Object.keys(materialType.variants)[0];
+        const variant = materialSettings.materialVariant || firstVariant;
+        // 1. Resolve textures using shared utility (registry-driven TextureResolver)
+        const resolvedSettings = await resolveTextures(variant, materialSettings);
+        // 2. Traverse the object tree and apply material to any child with .material.
+        const objectids = materialSettings.objectIds || [];
+        // console.log(originObject)
+        // console.log({ objectids });
+        if (obj) {
+            if (objectids.length > 0) {
+                let meshes = [];
+                // console.log('Applying material to specific object IDs:', objectids);
+                obj.traverse((child) => {
+                    if (child && child.name && objectids.includes(child.name)) {
+                        meshes.push(child);
+                    }
+                });
+                meshes.forEach(mesh => mesh.traverse((child) => {
+                    if (child && child.material) {
+                        // console.log('Applying material to child:', child.name);
+                        applyMaterialToChild(child, variant, resolvedSettings);
+                    }
+                }));
+                return;
+            }
+            traverseSkippingEdgesAndEffects(obj, true, (child) => {
+                // console.log('Traversing child:', child.name, child);
+                if (child && child.material) {
+                    // console.log('Applying material to child:');
+                    applyMaterialToChild(child, variant, resolvedSettings);
+                }
+            });
+        }
+        // traverseSkippingEdges(originObject!, true, (child: any) => {
+        //   if (child && child.material) {
+        //     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 {
+            // if (TEST_MATERIAL_MODE === 0) {
+            //   object.material = new MeshStandardMaterial();
+            //   return;
+            // } 
+            // else if (TEST_MATERIAL_MODE === 1) {
+            //   object.material = new MeshStandardMaterial({ side: FrontSide });
+            //   return;
+            // } 
+            // else if (TEST_MATERIAL_MODE === 2) {
+            //   object.material = new MeshStandardMaterial({ side: DoubleSide, transparent: true });
+            //   return;
+            // } 
+            // else if (TEST_MATERIAL_MODE === 3) {
+            //   object.material = new MeshStandardMaterial({ side: DoubleSide, transparent: true, metalness: 0.5, roughness: 0.5 });
+            //   return;
+            // }
+            // console.log(`Applying material to object ${object.name} with variant "${variant}" and settings:`, resolvedSettings);
+            const materialInstance = createAndApplyMaterial(variant, resolvedSettings);
+            // materialInstance.material.side = FrontSide; // Default to FrontSide; specific variants can override to DoubleSide in their defaultSettings
+            // 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);
+        }
+    };
+};

package/dist/hooks/useMaterialOptions.d.ts

@@ -0,0 +1,14 @@
+import { MaterialRegistryAPI } from '@3driseai/3drise-core';
+import type { CreatedObjectType, DisplayMode, MaterialSettings, SelectOptions } from '@3driseai/3drise-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, objectType?: CreatedObjectType, displayMode?: DisplayMode) => 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,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE7G,KAAK,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAEtG,MAAM,WAAW,wBAAwB;IACrC,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;CAClD;AAED,eAAO,MAAM,kBAAkB,GAAI,iBAAiB,gBAAgB,EAAE,mBAAmB,CAAC,WAAW,EAAE,gBAAgB,KAAK,IAAI,EAAE,aAAY,iBAA0B,EAAE,cAAa,WAAqB,KAAG,wBAkH9M,CAAC"}

package/dist/hooks/useMaterialOptions.js

@@ -0,0 +1,118 @@
+import { useState, useEffect } from 'react';
+import { MaterialRegistryAPI } from '@3driseai/3drise-core';
+import { FrontSide } from 'three';
+export const useMaterialOptions = (initialSettings, onSettingsChange, objectType = 'mesh', displayMode = 'solid') => {
+    // 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 (objectType === 'mesh') {
+            return allmaterialTypes.map((type) => ({
+                value: type,
+                label: type.charAt(0).toUpperCase() + type.slice(1)
+            }));
+        }
+        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,
+                side: variantDefaults.side || FrontSide, // Keep a copy of defaults for future resets
+            };
+            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;AAEhD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,GAAG;IAClE,WAAW,EAAE,MAAM,QAAQ,GAAG,IAAI,CAAC;IACnC,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IAClD,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACrD,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,IAAI,CAAC;IAC1D,cAAc,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,IAAI,CAAC;CAC5E,CAoFJ"}

package/dist/hooks/useMaterialUniforms.js

@@ -0,0 +1,96 @@
+import { useCallback } from 'react';
+import { applySingleProperty, applyColorProperty, createAndApplyMaterial, MATERIAL_INSTANCE_KEY, traverseSkippingEdgesAndEffects, MaterialRegistryAPI } from '@3driseai/3drise-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;
+        traverseSkippingEdgesAndEffects(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;
+        traverseSkippingEdgesAndEffects(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;
+        traverseSkippingEdgesAndEffects(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;
+        traverseSkippingEdgesAndEffects(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;
+        traverseSkippingEdgesAndEffects(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":"AACA,wBAAgB,iBAAiB,IAAI,GAAG,CAqKvC;AACD,eAAe,iBAAiB,CAAC"}