@nice2dev/ui-3d 1.0.0 → 1.0.3

package/dist/cjs/model/useModelViewer.js

@@ -0,0 +1,634 @@
+'use strict';
+
+var Ae = require('react');
+var THREE = require('three');
+var OrbitControls_js = require('three/examples/jsm/controls/OrbitControls.js');
+var FBXLoader_js = require('three/examples/jsm/loaders/FBXLoader.js');
+var GLTFLoader_js = require('three/examples/jsm/loaders/GLTFLoader.js');
+var OBJLoader_js = require('three/examples/jsm/loaders/OBJLoader.js');
+var ColladaLoader_js = require('three/examples/jsm/loaders/ColladaLoader.js');
+var STLLoader_js = require('three/examples/jsm/loaders/STLLoader.js');
+var PLYLoader_js = require('three/examples/jsm/loaders/PLYLoader.js');
+
+function _interopNamespaceDefault(e) {
+   var n = Object.create(null);
+   if (e) {
+      Object.keys(e).forEach(function (k) {
+         if (k !== 'default') {
+            var d = Object.getOwnPropertyDescriptor(e, k);
+            Object.defineProperty(n, k, d.get ? d : {
+               enumerable: true,
+               get: function () { return e[k]; }
+            });
+         }
+      });
+   }
+   n.default = e;
+   return Object.freeze(n);
+}
+
+var THREE__namespace = /*#__PURE__*/_interopNamespaceDefault(THREE);
+
+/**
+ * useModelViewer — lightweight hook for the view-only 3D model viewer.
+ *
+ * Unlike useModelEditor this hook provides NO editing — just loading,
+ * orbit/pan/zoom navigation, optional WASD first-person camera,
+ * gamepad support, VR mode, annotations and measurement tools.
+ *
+ * Designed for ERP real-estate / rental-space visualisation and
+ * product presentation.
+ */
+/* ═══════════════════════════════════════════
+   Quality presets
+   ═══════════════════════════════════════════ */
+const QUALITY_MAP = {
+    low: { pixelRatio: 0.75, shadowMapSize: 512, antialias: false },
+    medium: { pixelRatio: 1, shadowMapSize: 1024, antialias: true },
+    high: { pixelRatio: 1, shadowMapSize: 2048, antialias: true },
+    ultra: { pixelRatio: 2, shadowMapSize: 4096, antialias: true },
+};
+const TONE_MAP = {
+    linear: THREE__namespace.LinearToneMapping,
+    reinhard: THREE__namespace.ReinhardToneMapping,
+    cineon: THREE__namespace.CineonToneMapping,
+    aces: THREE__namespace.ACESFilmicToneMapping,
+    agx: THREE__namespace.AgXToneMapping,
+};
+/* ═══════════════════════════════════════════
+   Hook
+   ═══════════════════════════════════════════ */
+function useModelViewer(props = {}) {
+    const { src, format, navigationMode: initNavMode = 'orbit', quality = 'high', autoRotateSpeed: initAutoRotate = 0, backgroundColor = '#1a1a2e', showGrid: initShowGrid = true, shadows = true, gamepad = false, cameraPresets = [], annotations = [], hotspots = [], floorPlans = [], onHotspotClick, onAnnotationClick, onLoadProgress, onLoad, onError, clippingPlanes = [], measureMode: initMeasureMode = false, measurements = [], onMeasure, minDistance = 0.1, maxDistance = 1000, fov = 50, vr = false, walkSpeed = 5, ambientIntensity = 0.5, directionalIntensity = 0.8, antiAlias = true, toneMapping = 'aces', exposure = 1, } = props;
+    /* ── refs ── */
+    const mountRef = Ae.useRef(null);
+    const rendererRef = Ae.useRef(null);
+    const sceneRef = Ae.useRef(new THREE__namespace.Scene());
+    const cameraRef = Ae.useRef(new THREE__namespace.PerspectiveCamera(fov, 1, 0.01, 10000));
+    const orbitRef = Ae.useRef(null);
+    const clockRef = Ae.useRef(new THREE__namespace.Clock());
+    const mixerRef = Ae.useRef(null);
+    const rafRef = Ae.useRef(0);
+    const rootRef = Ae.useRef(null);
+    const gridRef = Ae.useRef(null);
+    const clipsRef = Ae.useRef([]);
+    const keysRef = Ae.useRef(new Set());
+    Ae.useRef(null);
+    const disposeRef = Ae.useRef(false);
+    /* ── state ── */
+    const [loading, setLoading] = Ae.useState(false);
+    const [loadProgress, setLoadProgress] = Ae.useState(0);
+    const [error, setError] = Ae.useState(null);
+    const [navMode, setNavMode] = Ae.useState(initNavMode);
+    const [projection, setProjection] = Ae.useState('perspective');
+    const [wireframe, setWireframe] = Ae.useState(false);
+    const [gridVisible, setGridVisible] = Ae.useState(initShowGrid);
+    const [autoRotate, setAutoRotate] = Ae.useState(initAutoRotate);
+    const [polyCount, setPolyCount] = Ae.useState(0);
+    const [meshCount, setMeshCount] = Ae.useState(0);
+    const [animNames, setAnimNames] = Ae.useState([]);
+    const [activeAnimIdx, setActiveAnimIdx] = Ae.useState(-1);
+    const [isPlaying, setIsPlaying] = Ae.useState(false);
+    const [animTime, setAnimTime] = Ae.useState(0);
+    const [animDuration, setAnimDuration] = Ae.useState(0);
+    const [animSpeed, setAnimSpeed] = Ae.useState(1);
+    const [isFullscreen, setIsFullscreen] = Ae.useState(false);
+    const [activeFloorPlanId, setActiveFloorPlanId] = Ae.useState(null);
+    const [annotationsVisible, setAnnotationsVisible] = Ae.useState(true);
+    const [clippingEnabled, setClippingEnabled] = Ae.useState(clippingPlanes.length > 0);
+    const [clippingPosition, setClippingPosition] = Ae.useState(0);
+    const [clippingAxis, setClippingAxis] = Ae.useState('y');
+    const [measureModeActive, setMeasureModeActive] = Ae.useState(initMeasureMode);
+    const [dimensions, setDimensions] = Ae.useState(null);
+    const [statusText, setStatusText] = Ae.useState('Ready');
+    /* ── scene setup ── */
+    Ae.useEffect(() => {
+        var _a;
+        const mount = mountRef.current;
+        if (!mount)
+            return;
+        disposeRef.current = false;
+        const q = QUALITY_MAP[quality];
+        const renderer = new THREE__namespace.WebGLRenderer({
+            antialias: q.antialias && antiAlias,
+            alpha: backgroundColor === 'transparent',
+            preserveDrawingBuffer: true,
+        });
+        renderer.setPixelRatio(Math.min(window.devicePixelRatio, q.pixelRatio));
+        renderer.setSize(mount.clientWidth, mount.clientHeight);
+        renderer.toneMapping = (_a = TONE_MAP[toneMapping]) !== null && _a !== void 0 ? _a : THREE__namespace.ACESFilmicToneMapping;
+        renderer.toneMappingExposure = exposure;
+        renderer.outputColorSpace = THREE__namespace.SRGBColorSpace;
+        if (shadows) {
+            renderer.shadowMap.enabled = true;
+            renderer.shadowMap.type = THREE__namespace.PCFSoftShadowMap;
+        }
+        mount.appendChild(renderer.domElement);
+        rendererRef.current = renderer;
+        const scene = sceneRef.current;
+        if (backgroundColor !== 'transparent') {
+            scene.background = new THREE__namespace.Color(backgroundColor);
+        }
+        // Lights
+        const amb = new THREE__namespace.AmbientLight(0xffffff, ambientIntensity);
+        scene.add(amb);
+        const dir = new THREE__namespace.DirectionalLight(0xffffff, directionalIntensity);
+        dir.position.set(5, 10, 7);
+        if (shadows) {
+            dir.castShadow = true;
+            dir.shadow.mapSize.setScalar(q.shadowMapSize);
+        }
+        scene.add(dir);
+        const hemi = new THREE__namespace.HemisphereLight(0xaaccff, 0x445522, 0.3);
+        scene.add(hemi);
+        // Grid
+        const grid = new THREE__namespace.GridHelper(50, 50, 0x444444, 0x333333);
+        grid.visible = initShowGrid;
+        scene.add(grid);
+        gridRef.current = grid;
+        // Camera
+        const camera = cameraRef.current;
+        camera.position.set(5, 4, 8);
+        camera.lookAt(0, 0, 0);
+        // OrbitControls
+        const orbit = new OrbitControls_js.OrbitControls(camera, renderer.domElement);
+        orbit.enableDamping = true;
+        orbit.dampingFactor = 0.08;
+        orbit.minDistance = minDistance;
+        orbit.maxDistance = maxDistance;
+        orbit.autoRotate = initAutoRotate > 0;
+        orbit.autoRotateSpeed = initAutoRotate;
+        orbitRef.current = orbit;
+        // Resize observer
+        const ro = new ResizeObserver(() => {
+            if (!mount || disposeRef.current)
+                return;
+            const w = mount.clientWidth;
+            const h = mount.clientHeight;
+            camera.aspect = w / h;
+            camera.updateProjectionMatrix();
+            renderer.setSize(w, h);
+        });
+        ro.observe(mount);
+        // Animation loop
+        const animate = () => {
+            var _a, _b, _c, _d, _e;
+            if (disposeRef.current)
+                return;
+            rafRef.current = requestAnimationFrame(animate);
+            const dt = clockRef.current.getDelta();
+            // Gamepad FPS-style nav
+            if (gamepad && navMode === 'fps') {
+                const pads = (_a = navigator.getGamepads) === null || _a === void 0 ? void 0 : _a.call(navigator);
+                const gp = (_b = pads === null || pads === void 0 ? void 0 : pads[0]) !== null && _b !== void 0 ? _b : null;
+                if (gp) {
+                    const lx = (_c = gp.axes[0]) !== null && _c !== void 0 ? _c : 0;
+                    const ly = (_d = gp.axes[1]) !== null && _d !== void 0 ? _d : 0;
+                    const rx = (_e = gp.axes[2]) !== null && _e !== void 0 ? _e : 0;
+                    const fwd = new THREE__namespace.Vector3();
+                    camera.getWorldDirection(fwd);
+                    fwd.y = 0;
+                    fwd.normalize();
+                    const right = new THREE__namespace.Vector3().crossVectors(fwd, camera.up).normalize();
+                    camera.position.addScaledVector(fwd, -ly * walkSpeed * dt);
+                    camera.position.addScaledVector(right, lx * walkSpeed * dt);
+                    orbit.target.addScaledVector(fwd, -ly * walkSpeed * dt);
+                    orbit.target.addScaledVector(right, lx * walkSpeed * dt);
+                    camera.rotateY(-rx * 2 * dt);
+                }
+            }
+            // Keyboard WASD
+            if (navMode === 'fps' || navMode === 'walkthrough') {
+                const fwd = new THREE__namespace.Vector3();
+                camera.getWorldDirection(fwd);
+                fwd.y = 0;
+                fwd.normalize();
+                const right = new THREE__namespace.Vector3().crossVectors(fwd, camera.up).normalize();
+                const speed = walkSpeed * dt;
+                if (keysRef.current.has('w') || keysRef.current.has('arrowup')) {
+                    camera.position.addScaledVector(fwd, speed);
+                    orbit.target.addScaledVector(fwd, speed);
+                }
+                if (keysRef.current.has('s') || keysRef.current.has('arrowdown')) {
+                    camera.position.addScaledVector(fwd, -speed);
+                    orbit.target.addScaledVector(fwd, -speed);
+                }
+                if (keysRef.current.has('a') || keysRef.current.has('arrowleft')) {
+                    camera.position.addScaledVector(right, -speed);
+                    orbit.target.addScaledVector(right, -speed);
+                }
+                if (keysRef.current.has('d') || keysRef.current.has('arrowright')) {
+                    camera.position.addScaledVector(right, speed);
+                    orbit.target.addScaledVector(right, speed);
+                }
+                if (keysRef.current.has('q')) {
+                    camera.position.y += speed;
+                    orbit.target.y += speed;
+                }
+                if (keysRef.current.has('e')) {
+                    camera.position.y -= speed;
+                    orbit.target.y -= speed;
+                }
+            }
+            if (mixerRef.current) {
+                mixerRef.current.update(dt);
+            }
+            orbit.update();
+            renderer.render(scene, camera);
+        };
+        animate();
+        // Keyboard listeners
+        const onKeyDown = (e) => keysRef.current.add(e.key.toLowerCase());
+        const onKeyUp = (e) => keysRef.current.delete(e.key.toLowerCase());
+        mount.addEventListener('keydown', onKeyDown);
+        mount.addEventListener('keyup', onKeyUp);
+        // Fullscreen
+        const onFSChange = () => setIsFullscreen(!!document.fullscreenElement);
+        document.addEventListener('fullscreenchange', onFSChange);
+        return () => {
+            disposeRef.current = true;
+            cancelAnimationFrame(rafRef.current);
+            ro.disconnect();
+            orbit.dispose();
+            renderer.dispose();
+            mount.removeEventListener('keydown', onKeyDown);
+            mount.removeEventListener('keyup', onKeyUp);
+            document.removeEventListener('fullscreenchange', onFSChange);
+            if (mount.contains(renderer.domElement)) {
+                mount.removeChild(renderer.domElement);
+            }
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    /* ── update grid visibility ── */
+    Ae.useEffect(() => {
+        if (gridRef.current)
+            gridRef.current.visible = gridVisible;
+    }, [gridVisible]);
+    /* ── update auto-rotate ── */
+    Ae.useEffect(() => {
+        if (orbitRef.current) {
+            orbitRef.current.autoRotate = autoRotate > 0;
+            orbitRef.current.autoRotateSpeed = autoRotate;
+        }
+    }, [autoRotate]);
+    /* ── wireframe toggle ── */
+    Ae.useEffect(() => {
+        if (!rootRef.current)
+            return;
+        rootRef.current.traverse((c) => {
+            if (c.isMesh) {
+                const mat = c.material;
+                const mats = Array.isArray(mat) ? mat : [mat];
+                mats.forEach((m) => {
+                    if ('wireframe' in m)
+                        m.wireframe = wireframe;
+                });
+            }
+        });
+    }, [wireframe]);
+    /* ── clipping ── */
+    Ae.useEffect(() => {
+        const renderer = rendererRef.current;
+        if (!renderer)
+            return;
+        if (clippingEnabled) {
+            const normal = new THREE__namespace.Vector3(clippingAxis === 'x' ? 1 : 0, clippingAxis === 'y' ? 1 : 0, clippingAxis === 'z' ? 1 : 0);
+            const plane = new THREE__namespace.Plane(normal, -clippingPosition);
+            renderer.clippingPlanes = [plane];
+        }
+        else {
+            renderer.clippingPlanes = [];
+        }
+    }, [clippingEnabled, clippingPosition, clippingAxis]);
+    /* ── counting helpers ── */
+    const countScene = Ae.useCallback(() => {
+        let tris = 0;
+        let meshes = 0;
+        sceneRef.current.traverse((c) => {
+            if (c.isMesh) {
+                meshes++;
+                const geo = c.geometry;
+                if (geo.index)
+                    tris += geo.index.count / 3;
+                else if (geo.attributes.position)
+                    tris += geo.attributes.position.count / 3;
+            }
+        });
+        setPolyCount(Math.round(tris));
+        setMeshCount(meshes);
+    }, []);
+    /* ── detect format from URL ── */
+    const detectFormat = Ae.useCallback((url, hint) => {
+        var _a, _b, _c;
+        if (hint)
+            return hint;
+        const ext = (_c = (_b = (_a = url.split('.').pop()) === null || _a === void 0 ? void 0 : _a.split('?')[0]) === null || _b === void 0 ? void 0 : _b.toLowerCase()) !== null && _c !== void 0 ? _c : '';
+        return ext;
+    }, []);
+    /* ── load model ── */
+    const loadModel = Ae.useCallback(async (url, fmt) => {
+        var _a, _b, _c;
+        setLoading(true);
+        setLoadProgress(0);
+        setError(null);
+        setStatusText('Loading…');
+        const detectedFmt = detectFormat(url, fmt);
+        const onProgress = (e) => {
+            if (e.lengthComputable) {
+                const p = e.loaded / e.total;
+                setLoadProgress(p);
+                onLoadProgress === null || onLoadProgress === void 0 ? void 0 : onLoadProgress(p);
+            }
+        };
+        try {
+            let obj = null;
+            let clips = [];
+            if (detectedFmt === 'fbx') {
+                const loader = new FBXLoader_js.FBXLoader();
+                const group = await loader.loadAsync(url, onProgress);
+                clips = (_a = group.animations) !== null && _a !== void 0 ? _a : [];
+                obj = group;
+            }
+            else if (detectedFmt === 'glb' || detectedFmt === 'gltf') {
+                const loader = new GLTFLoader_js.GLTFLoader();
+                const gltf = await loader.loadAsync(url, onProgress);
+                clips = (_b = gltf.animations) !== null && _b !== void 0 ? _b : [];
+                obj = gltf.scene;
+            }
+            else if (detectedFmt === 'obj') {
+                const loader = new OBJLoader_js.OBJLoader();
+                obj = await loader.loadAsync(url, onProgress);
+            }
+            else if (detectedFmt === 'dae') {
+                const loader = new ColladaLoader_js.ColladaLoader();
+                const result = await loader.loadAsync(url, onProgress);
+                if (result) {
+                    clips = (_c = result.scene.animations) !== null && _c !== void 0 ? _c : [];
+                    obj = result.scene;
+                }
+            }
+            else if (detectedFmt === 'stl') {
+                const loader = new STLLoader_js.STLLoader();
+                const geo = await loader.loadAsync(url, onProgress);
+                const mat = new THREE__namespace.MeshStandardMaterial({ color: 0xaaaaaa, metalness: 0.3, roughness: 0.6 });
+                const mesh = new THREE__namespace.Mesh(geo, mat);
+                mesh.castShadow = true;
+                mesh.receiveShadow = true;
+                obj = mesh;
+            }
+            else if (detectedFmt === 'ply') {
+                const loader = new PLYLoader_js.PLYLoader();
+                const geo = await loader.loadAsync(url, onProgress);
+                geo.computeVertexNormals();
+                const mat = new THREE__namespace.MeshStandardMaterial({ color: 0xaaaaaa, vertexColors: !!geo.attributes.color });
+                obj = new THREE__namespace.Mesh(geo, mat);
+            }
+            else {
+                throw new Error(`Unsupported format: ${detectedFmt}`);
+            }
+            if (obj) {
+                // Remove previous model
+                if (rootRef.current) {
+                    sceneRef.current.remove(rootRef.current);
+                }
+                // Enable shadows
+                obj.traverse((c) => {
+                    if (c.isMesh) {
+                        c.castShadow = true;
+                        c.receiveShadow = true;
+                    }
+                });
+                // Auto-scale to normalized size
+                const box = new THREE__namespace.Box3().setFromObject(obj);
+                const size = box.getSize(new THREE__namespace.Vector3());
+                const maxDim = Math.max(size.x, size.y, size.z);
+                if (maxDim > 0) {
+                    const target = 5;
+                    if (maxDim > target * 2 || maxDim < target * 0.1) {
+                        const scale = target / maxDim;
+                        obj.scale.multiplyScalar(scale);
+                    }
+                }
+                // Center model
+                const box2 = new THREE__namespace.Box3().setFromObject(obj);
+                const center = box2.getCenter(new THREE__namespace.Vector3());
+                obj.position.sub(center);
+                obj.position.y += box2.getSize(new THREE__namespace.Vector3()).y / 2;
+                sceneRef.current.add(obj);
+                rootRef.current = obj;
+                // Update dimensions
+                const finalBox = new THREE__namespace.Box3().setFromObject(obj);
+                const s = finalBox.getSize(new THREE__namespace.Vector3());
+                setDimensions({ width: +s.x.toFixed(2), height: +s.y.toFixed(2), depth: +s.z.toFixed(2) });
+                // Animations
+                clipsRef.current = clips;
+                setAnimNames(clips.map((c, i) => c.name || `Clip ${i + 1}`));
+                if (clips.length > 0) {
+                    const mixer = new THREE__namespace.AnimationMixer(obj);
+                    mixerRef.current = mixer;
+                }
+                countScene();
+                setStatusText(`Loaded – ${polyCount} tris, ${meshCount} meshes`);
+                onLoad === null || onLoad === void 0 ? void 0 : onLoad();
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            setError(msg);
+            setStatusText(`Error: ${msg}`);
+            onError === null || onError === void 0 ? void 0 : onError(err instanceof Error ? err : new Error(msg));
+        }
+        finally {
+            setLoading(false);
+            setLoadProgress(1);
+        }
+    }, [countScene, detectFormat, onLoad, onError, onLoadProgress, polyCount, meshCount]);
+    /* ── auto-load from src ── */
+    Ae.useEffect(() => {
+        if (src)
+            loadModel(src, format);
+    }, [src, format, loadModel]);
+    /* ── loadFile from disk ── */
+    const loadFile = Ae.useCallback(async (file) => {
+        var _a;
+        const url = URL.createObjectURL(file);
+        const ext = (_a = file.name.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        try {
+            await loadModel(url, ext);
+        }
+        finally {
+            URL.revokeObjectURL(url);
+        }
+    }, [loadModel]);
+    /* ── loadUrl ── */
+    const loadUrl = Ae.useCallback(async (url, fmt) => {
+        await loadModel(url, fmt);
+    }, [loadModel]);
+    /* ── animation controls ── */
+    const playAnimation = Ae.useCallback((index) => {
+        if (!mixerRef.current || index < 0 || index >= clipsRef.current.length)
+            return;
+        mixerRef.current.stopAllAction();
+        const clip = clipsRef.current[index];
+        const action = mixerRef.current.clipAction(clip);
+        action.reset().play();
+        setActiveAnimIdx(index);
+        setIsPlaying(true);
+        setAnimDuration(clip.duration);
+    }, []);
+    const togglePlay = Ae.useCallback(() => {
+        if (!mixerRef.current)
+            return;
+        if (isPlaying) {
+            mixerRef.current.timeScale = 0;
+            setIsPlaying(false);
+        }
+        else {
+            mixerRef.current.timeScale = animSpeed;
+            setIsPlaying(true);
+            if (activeAnimIdx < 0 && clipsRef.current.length > 0)
+                playAnimation(0);
+        }
+    }, [isPlaying, animSpeed, activeAnimIdx, playAnimation]);
+    const seekAnim = Ae.useCallback((t) => {
+        if (mixerRef.current)
+            mixerRef.current.setTime(t);
+        setAnimTime(t);
+    }, []);
+    /* ── camera presets ── */
+    const goToPreset = Ae.useCallback((preset) => {
+        const cam = cameraRef.current;
+        const orbit = orbitRef.current;
+        if (!orbit)
+            return;
+        cam.position.set(...preset.position);
+        orbit.target.set(...preset.target);
+        if (preset.fov)
+            cam.fov = preset.fov;
+        cam.updateProjectionMatrix();
+        orbit.update();
+    }, []);
+    const resetCamera = Ae.useCallback(() => {
+        const cam = cameraRef.current;
+        cam.position.set(5, 4, 8);
+        if (orbitRef.current) {
+            orbitRef.current.target.set(0, 0, 0);
+            orbitRef.current.update();
+        }
+    }, []);
+    const zoomToFit = Ae.useCallback(() => {
+        if (!rootRef.current)
+            return;
+        const box = new THREE__namespace.Box3().setFromObject(rootRef.current);
+        const center = box.getCenter(new THREE__namespace.Vector3());
+        const size = box.getSize(new THREE__namespace.Vector3());
+        const maxDim = Math.max(size.x, size.y, size.z);
+        const cam = cameraRef.current;
+        const dist = maxDim / (2 * Math.tan((cam.fov * Math.PI) / 360));
+        cam.position.copy(center).add(new THREE__namespace.Vector3(0, 0, dist * 1.5));
+        if (orbitRef.current) {
+            orbitRef.current.target.copy(center);
+            orbitRef.current.update();
+        }
+    }, []);
+    /* ── screenshot ── */
+    const screenshot = Ae.useCallback((width, height) => {
+        const renderer = rendererRef.current;
+        if (!renderer)
+            return '';
+        if (width && height) {
+            renderer.setSize(width, height);
+            cameraRef.current.aspect = width / height;
+            cameraRef.current.updateProjectionMatrix();
+        }
+        renderer.render(sceneRef.current, cameraRef.current);
+        const url = renderer.domElement.toDataURL('image/png');
+        if (width && height && mountRef.current) {
+            const w = mountRef.current.clientWidth;
+            const h = mountRef.current.clientHeight;
+            renderer.setSize(w, h);
+            cameraRef.current.aspect = w / h;
+            cameraRef.current.updateProjectionMatrix();
+        }
+        return url;
+    }, []);
+    /* ── fullscreen ── */
+    const toggleFullscreen = Ae.useCallback(() => {
+        if (!mountRef.current)
+            return;
+        if (document.fullscreenElement) {
+            document.exitFullscreen();
+        }
+        else {
+            mountRef.current.requestFullscreen();
+        }
+    }, []);
+    /* ── dispose ── */
+    const dispose = Ae.useCallback(() => {
+        var _a;
+        disposeRef.current = true;
+        cancelAnimationFrame(rafRef.current);
+        (_a = rendererRef.current) === null || _a === void 0 ? void 0 : _a.dispose();
+    }, []);
+    /* ── finalise status text ── */
+    Ae.useEffect(() => {
+        if (!loading && !error && polyCount > 0) {
+            setStatusText(`${polyCount.toLocaleString()} triangles · ${meshCount} meshes · ${animNames.length} animation(s)`);
+        }
+    }, [loading, error, polyCount, meshCount, animNames.length]);
+    return {
+        mountRef,
+        loading,
+        loadProgress,
+        error,
+        navigationMode: navMode,
+        setNavigationMode: setNavMode,
+        projection,
+        setProjection,
+        wireframe,
+        setWireframe,
+        showGrid: gridVisible,
+        setShowGrid: setGridVisible,
+        autoRotateSpeed: autoRotate,
+        setAutoRotateSpeed: setAutoRotate,
+        polyCount,
+        meshCount,
+        animations: animNames,
+        activeAnimIdx,
+        playAnimation,
+        togglePlay,
+        isPlaying,
+        animTime,
+        animDuration,
+        seekAnim,
+        animSpeed,
+        setAnimSpeed,
+        goToPreset,
+        resetCamera,
+        zoomToFit,
+        screenshot,
+        toggleFullscreen,
+        isFullscreen,
+        loadFile,
+        loadUrl,
+        activeFloorPlanId,
+        setActiveFloorPlanId,
+        annotationsVisible,
+        setAnnotationsVisible,
+        measureMode: measureModeActive,
+        setMeasureMode: setMeasureModeActive,
+        clippingEnabled,
+        setClippingEnabled,
+        clippingPosition,
+        setClippingPosition,
+        clippingAxis,
+        setClippingAxis,
+        dimensions,
+        statusText,
+        dispose,
+    };
+}
+
+exports.useModelViewer = useModelViewer;
+//# sourceMappingURL=useModelViewer.js.map