@smarterplan/ngx-smarterplan-core 1.4.20 → 1.4.21

package/esm2022/lib/services/matterport-object3d.service.mjs

@@ -1,6 +1,7 @@
 import { Injectable } from '@angular/core';
-import { PoiType } from '../types.service';
-import { Object3D } from 'three';
+import { Subject } from 'rxjs';
+import { PoiType, } from '../types.service';
+import { Box3, MathUtils, Object3D, Vector3 } from 'three';
 import { NestThermostat } from '../matterport-extensions/nest-thermostat/NestThermostat';
 import { PlaneRenderer } from '../matterport-extensions/nest-thermostat/PlaneRenderer';
 import { CanvasRenderer } from "../matterport-extensions/nest-thermostat/CanvasRenderer";
@@ -15,6 +16,28 @@ export class MatterportObject3DService {
     azimuthalCrown;
     threeJSScene;
     noLightForObjects = true;
+    /** Max time (ms) to wait for a model to be loaded by the SDK */
+    loadTimeoutMs = 15000;
+    /** Max distance (m) an object can travel from where a translate drag started */
+    maxDragDistance = 2;
+    /** Max vertical travel (m, up and down) during a translate drag, so an object cannot jump to another floor */
+    maxDragHeight = 1.5;
+    /** Emits on every gizmo change and on setObject3DTransform */
+    object3DTransformChanged$ = new Subject();
+    /** Security camera animators by object uuid (`securityCameraAnimator` stays the last loaded one) */
+    securityCameraAnimators = new Map();
+    viewFrustumVisible = new Map();
+    lastSecurityCameraUuid = null;
+    /** Loader component of each model (outputs.objectRoot is set once loaded) */
+    loaderComponents = new Map();
+    gizmos = new Map();
+    activeGizmoUuid = null;
+    gizmoSnap = null;
+    /** Sweeps disabled by setNavigationLocked(true), re-enabled on unlock */
+    sweepsDisabledByLock = [];
+    /** Sweeps re-enabled by the last unlock (the SDK may still report them disabled for a moment) */
+    sweepsEnabledByUnlock = [];
+    tmpBox = new Box3();
     constructor() { }
     async init3DObjectViewer(sdk) {
         const [sceneObject] = await sdk.Scene.createObjects(1);
@@ -25,112 +48,184 @@ export class MatterportObject3DService {
         this.objectControl = nodeControl.addComponent('mp.transformControls');
         nodeControl.start();
     }
-    async add3DObject(sdk, obj, mode) {
-        return new Promise(async (resolve) => {
-            const [sceneObject] = await sdk.Scene.createObjects(1);
-            let isAnimatedSecurityCamera = (obj.object === "security_camera");
-            let isNestThermostat = (obj.object === "nest_thermostat");
-            let isSmarterplanPromotionalVideo = (obj.object === 'video');
-            let isAzimuthalCrown = (obj.object === 'azimuth');
-            const modelNode = sceneObject.addNode();
-            let component = null;
-            const initial = {
-                url: `/assets/3Dobjects/objects/${obj.object}${obj.format.indexOf('.') === -1 ? '.' + obj.format : obj.format}`,
-                localRotation: { "x": 0, "y": 0, "z": 0 },
-                localPosition: { "x": 0, "y": 0, "z": 0 },
-                visible: true,
-                colliderEnabled: true
-            };
-            switch (obj.format) {
-                case '.obj':
-                case 'obj':
-                    component = modelNode.addComponent('mp.objLoader', initial);
-                    break;
-                case '.fbx':
-                case 'fbx':
-                    component = modelNode.addComponent('mp.fbxLoader', initial);
-                    break;
-                case '.gltf':
-                case 'gltf':
-                case '.glb':
-                case 'glb':
-                    component = modelNode.addComponent('mp.gltfLoader', initial);
-                    break;
-                case '.dae':
-                case 'dae':
-                    component = modelNode.addComponent('mp.daeLoader', initial);
-                    break;
-                default:
-                    console.log('Format not supported');
-                    break;
-            }
-            if (this.noLightForObjects) {
-                const lightsNode = sceneObject.addNode();
-                lightsNode.addComponent('mp.ambientLight', {
-                    intensity: 1,
-                    color: { r: 1.0, g: 1.0, b: 1.0 },
-                });
-                this.noLightForObjects = false;
-            }
-            modelNode.obj3D.position.set(obj.position.x, obj.position.y, obj.position.z);
-            modelNode.obj3D.rotation.set(obj.rotation.x, obj.rotation.y, obj.rotation.z);
-            modelNode.obj3D.scale.set(obj.scale.x, obj.scale.y, obj.scale.z);
-            if (isAzimuthalCrown) {
-                this.azimuthalCrown = modelNode;
-            }
-            if (mode && !isNestThermostat) {
-                this.attachGizmoControlTo3DObject(sdk, modelNode, sceneObject, mode, true, true).catch((e) => console.log(e));
-            }
-            if (this.lastObject3D && typeof this.lastObject3D.id === 'string') {
-                modelNode.obj3D.uuid = this.lastObject3D.id;
-            }
-            else if (obj.id) {
-                modelNode.obj3D.uuid = obj.id;
+    /** SDK loader component name for a model format, null when the format is not supported */
+    getLoaderComponentName(format) {
+        switch ((format || '').toLowerCase()) {
+            case '.obj':
+            case 'obj': return 'mp.objLoader';
+            case '.fbx':
+            case 'fbx': return 'mp.fbxLoader';
+            case '.gltf':
+            case 'gltf':
+            case '.glb':
+            case 'glb': return 'mp.gltfLoader';
+            case '.dae':
+            case 'dae': return 'mp.daeLoader';
+            default: return null;
+        }
+    }
+    /** Resolves once the loader component has produced its objectRoot, rejects after `timeoutMs` */
+    waitForModelLoaded(component, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const isLoaded = () => !!component?.outputs?.objectRoot;
+            if (isLoaded()) {
+                resolve();
+                return;
             }
-            this.lastObject3D = modelNode.obj3D;
-            this.dictionnaryObjects3D.set(modelNode.obj3D.uuid, modelNode);
-            this.dictionnarySceneObjects3D.set(modelNode.obj3D.uuid, sceneObject);
-            if (isAnimatedSecurityCamera) {
-                const animator = modelNode.addComponent('mp.securityCamera', {
-                    "nearPlane": 0.1, "farPlane": 10, "horizontalFOV": 52, "aspect": 1.7777777777777777,
-                    "localPosition": { "x": 0.3, "y": 0.18, "z": 0 },
-                    "localRotation": { "x": -15, "y": -90, "z": 0 },
-                    "color": 65280, "panPeriod": 5, "panAngle": -45
-                });
-                this.securityCameraAnimator = animator;
-                if (!obj.viewFrustum) {
-                    setTimeout(() => { animator.toggleViewFrustum(); }, 1000);
+            const poll = setInterval(() => {
+                if (isLoaded()) {
+                    clearInterval(poll);
+                    clearTimeout(timer);
+                    resolve();
                 }
-            }
-            if (isNestThermostat) {
-                const cv = new CanvasRenderer();
-                cv.onInit();
-                const plane = new PlaneRenderer();
-                plane.outputs = { objectRoot: new Object3D(), collider: new Object3D() };
-                const inputTexture = cv.outputs.texture;
-                plane.setRootScene(this.threeJSScene);
-                plane.onInit(modelNode, inputTexture);
-                const sc = new NestThermostat();
-                sc.setComponent(component, plane, cv);
-                sc.setRootScene(this.threeJSScene);
-                sc.onInit(modelNode, plane, inputTexture);
-                cv.setCanvasNestThermostatPainter(sc);
-                setTimeout(() => { sc.inputs.loadingState = "Loaded"; sc.onInputsUpdated(); }, 5000);
-            }
-            if (isSmarterplanPromotionalVideo) {
-                const sc = new TvPlayer();
-                sc.setComponent(component);
-                sc.onInit(modelNode);
-                setTimeout(() => { sc.inputs.loadingState = "Loaded"; sc.onInputsUpdated(); }, 5000);
-            }
-            sceneObject.start();
-            resolve(this.lastObject3D);
+            }, 50);
+            const timer = setTimeout(() => {
+                clearInterval(poll);
+                reject(new Error(`3D model not loaded after ${timeoutMs} ms`));
+            }, timeoutMs);
         });
     }
+    /**
+     * Adds a 3D model to the scene.
+     * The promise resolves with the three.js object once the model is actually loaded, and rejects
+     * (after cleaning the scene) when the format is unknown or the load times out.
+     * The position / rotation / scale of `obj` are applied to the model origin, as stored in DB.
+     */
+    async add3DObject(sdk, obj, mode) {
+        const loaderName = this.getLoaderComponentName(obj.format);
+        if (!loaderName) {
+            throw new Error(`3D object format not supported: ${obj.format}`);
+        }
+        const [sceneObject] = await sdk.Scene.createObjects(1);
+        const isAnimatedSecurityCamera = (!obj.url && obj.object === 'security_camera');
+        const isNestThermostat = (!obj.url && obj.object === 'nest_thermostat');
+        const isSmarterplanPromotionalVideo = (!obj.url && obj.object === 'video');
+        const isAzimuthalCrown = (!obj.url && obj.object === 'azimuth');
+        const modelNode = sceneObject.addNode();
+        const initial = {
+            url: obj.url || `/assets/3Dobjects/objects/${obj.object}${obj.format.indexOf('.') === -1 ? '.' + obj.format : obj.format}`,
+            localRotation: { 'x': 0, 'y': 0, 'z': 0 },
+            localPosition: { 'x': 0, 'y': 0, 'z': 0 },
+            visible: true,
+            colliderEnabled: true
+        };
+        const component = modelNode.addComponent(loaderName, initial);
+        if (this.noLightForObjects) {
+            const lightsNode = sceneObject.addNode();
+            lightsNode.addComponent('mp.ambientLight', {
+                intensity: 1,
+                color: { r: 1.0, g: 1.0, b: 1.0 },
+            });
+            this.noLightForObjects = false;
+        }
+        modelNode.obj3D.position.set(obj.position.x, obj.position.y, obj.position.z);
+        modelNode.obj3D.rotation.set(obj.rotation.x, obj.rotation.y, obj.rotation.z);
+        modelNode.obj3D.scale.set(obj.scale.x, obj.scale.y, obj.scale.z);
+        // The DB id replaces the three.js uuid. The id pre-set through setLastObject3D is only a fallback
+        // for callers without id: taking it first gave the same id to every object loaded meanwhile
+        // (several cameras or cubes loading while an add is starting), which then overwrote each other.
+        if (obj.id) {
+            modelNode.obj3D.uuid = obj.id;
+        }
+        else if (this.lastObject3D && typeof this.lastObject3D.id === 'string') {
+            modelNode.obj3D.uuid = this.lastObject3D.id;
+        }
+        const uuid = modelNode.obj3D.uuid;
+        this.lastObject3D = modelNode.obj3D;
+        this.dictionnaryObjects3D.set(uuid, modelNode);
+        this.dictionnarySceneObjects3D.set(uuid, sceneObject);
+        this.loaderComponents.set(uuid, component);
+        if (isAzimuthalCrown) {
+            this.azimuthalCrown = modelNode;
+        }
+        if (mode && !isNestThermostat) {
+            this.attachGizmo(uuid, mode).catch(() => { });
+        }
+        let animator = null;
+        if (isAnimatedSecurityCamera) {
+            animator = modelNode.addComponent('mp.securityCamera', {
+                'nearPlane': 0.1, 'farPlane': 10, 'horizontalFOV': 52, 'aspect': 1.7777777777777777,
+                'localPosition': { 'x': 0.3, 'y': 0.18, 'z': 0 },
+                'localRotation': { 'x': -15, 'y': -90, 'z': 0 },
+                'color': 65280, 'panPeriod': 5, 'panAngle': -45
+            });
+            this.securityCameraAnimator = animator;
+            this.securityCameraAnimators.set(uuid, animator);
+            this.viewFrustumVisible.set(uuid, true); // the component shows its frustum by default
+            this.lastSecurityCameraUuid = uuid;
+        }
+        if (isNestThermostat) {
+            const cv = new CanvasRenderer();
+            cv.onInit();
+            const plane = new PlaneRenderer();
+            plane.outputs = { objectRoot: new Object3D(), collider: new Object3D() };
+            const inputTexture = cv.outputs.texture;
+            plane.setRootScene(this.threeJSScene);
+            plane.onInit(modelNode, inputTexture);
+            const sc = new NestThermostat();
+            sc.setComponent(component, plane, cv);
+            sc.setRootScene(this.threeJSScene);
+            sc.onInit(modelNode, plane, inputTexture);
+            cv.setCanvasNestThermostatPainter(sc);
+            setTimeout(() => { sc.inputs.loadingState = 'Loaded'; sc.onInputsUpdated(); }, 5000);
+        }
+        if (isSmarterplanPromotionalVideo) {
+            const sc = new TvPlayer();
+            sc.setComponent(component);
+            sc.onInit(modelNode);
+            setTimeout(() => { sc.inputs.loadingState = 'Loaded'; sc.onInputsUpdated(); }, 5000);
+        }
+        sceneObject.start();
+        try {
+            await this.waitForModelLoaded(component, this.loadTimeoutMs);
+        }
+        catch (e) {
+            await this.deleteObject3D(uuid);
+            throw e;
+        }
+        if (animator && !obj.viewFrustum) {
+            // The camera component starts with the model node, so it is ready now that the model is loaded
+            this.applyViewFrustum(uuid, false);
+        }
+        return modelNode.obj3D;
+    }
+    /**
+     * Removes a 3D object for good: detaches its gizmo, stops its scene object and forgets it.
+     */
     async deleteObject3D(uuid) {
-        const obj = this.dictionnaryObjects3D.get(uuid);
-        if (obj)
-            obj.obj3D.visible = false;
+        this.detachGizmo(uuid);
+        const node = this.dictionnaryObjects3D.get(uuid);
+        const sceneObject = this.dictionnarySceneObjects3D.get(uuid);
+        if (node) {
+            try {
+                node.obj3D.visible = false;
+            }
+            catch { /* already destroyed */ }
+        }
+        if (sceneObject && typeof sceneObject.stop === 'function') {
+            try {
+                sceneObject.stop();
+            }
+            catch { /* already stopped */ }
+        }
+        this.dictionnaryObjects3D.delete(uuid);
+        this.dictionnarySceneObjects3D.delete(uuid);
+        this.loaderComponents.delete(uuid);
+        if (this.lastObject3D && (this.lastObject3D.uuid === uuid || this.lastObject3D.id === uuid)) {
+            this.lastObject3D = null;
+        }
+        if (node && this.azimuthalCrown === node) {
+            this.azimuthalCrown = null;
+        }
+        const animator = this.securityCameraAnimators.get(uuid);
+        if (animator && this.securityCameraAnimator === animator) {
+            this.securityCameraAnimator = null;
+        }
+        this.securityCameraAnimators.delete(uuid);
+        this.viewFrustumVisible.delete(uuid);
+        if (this.lastSecurityCameraUuid === uuid) {
+            this.lastSecurityCameraUuid = null;
+        }
     }
     getObject3DModelNodeFromDictionnary(uuid) {
         let obj = this.dictionnaryObjects3D.get(uuid);
@@ -150,10 +245,32 @@ export class MatterportObject3DService {
         let obj = this.dictionnaryObjects3D.get(objectId);
         return obj ? obj.obj3D.visible : false;
     }
+    /** Shows / hides a model (used by the placement preview) */
+    setObject3DVisible(uuid, visible) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        if (node)
+            node.obj3D.visible = visible;
+    }
+    /** Enables / disables the pointer collider of a model (disabled while it follows the cursor) */
+    setObject3DColliderEnabled(uuid, enabled) {
+        const component = this.loaderComponents.get(uuid);
+        if (component?.inputs) {
+            component.inputs.colliderEnabled = enabled;
+        }
+    }
+    /**
+     * Moves the camera next to a 3D object by creating a temporary tag on the object centre.
+     * @returns false when the object is unknown or no tag could be reached
+     */
     async pointCameraTo3DObject(sdk, objectId, createTagCallback, goToTagCallback, deleteLastTagCallback, getTagFromElementId) {
-        let obj = this.dictionnaryObjects3D.get(objectId);
+        const obj = this.dictionnaryObjects3D.get(objectId);
+        if (!obj)
+            return false;
+        // Tag on the bounding box centre (the model origin is a corner for most models)
+        const box = this.getObject3DBoundingBox(objectId);
+        const anchor = box ? box.center : this.toPoint(obj.obj3D.position);
         const poiObject = {
-            coordinate: JSON.stringify(obj.obj3D.position),
+            coordinate: JSON.stringify(anchor),
             type: PoiType.OBJECT3D,
             elementID: objectId,
         };
@@ -162,9 +279,16 @@ export class MatterportObject3DService {
             await createTagCallback(PoiType.OBJECT3D, objectDb, poiObject);
         }
         catch (err) { }
-        let result = getTagFromElementId(objectId);
-        await goToTagCallback(result.tag);
-        deleteLastTagCallback();
+        try {
+            const result = getTagFromElementId(objectId);
+            if (!result?.tag)
+                return false;
+            await goToTagCallback(result.tag);
+            return true;
+        }
+        finally {
+            deleteLastTagCallback();
+        }
     }
     getSceneNodeFromObject3DId(uuid) {
         return this.dictionnarySceneObjects3D.get(uuid);
@@ -174,49 +298,449 @@ export class MatterportObject3DService {
             this.azimuthalCrown.obj3D.position.set(poseCamera.position.x, poseCamera.position.y, poseCamera.position.z);
         }
     }
+    //
+    // ---------- Geometry helpers ----------
+    //
+    toPoint(v) {
+        return { x: v.x, y: v.y, z: v.z };
+    }
+    /**
+     * Geometry of the model itself (the loader output): the node also holds the helpers added by other
+     * components, like the view frustum of a security camera, which must not count in its size.
+     */
+    modelRoot(uuid, node) {
+        return this.loaderComponents.get(uuid)?.outputs?.objectRoot ?? node.obj3D;
+    }
+    /** World-space bounding box of the model, null when unknown or when nothing is loaded yet */
+    getObject3DBoundingBox(uuid) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        if (!node)
+            return null;
+        node.obj3D.updateWorldMatrix(true, true);
+        const box = this.tmpBox.setFromObject(this.modelRoot(uuid, node));
+        if (box.isEmpty())
+            return null;
+        const size = box.getSize(new Vector3());
+        const center = box.getCenter(new Vector3());
+        return {
+            min: this.toPoint(box.min),
+            max: this.toPoint(box.max),
+            size: this.toPoint(size),
+            center: this.toPoint(center),
+        };
+    }
+    /**
+     * Real dimensions of the model in meters (width x, height y, depth z), scale included but not
+     * its rotation: the world bounding box of a rotated object is larger than the object itself.
+     */
+    getObject3DDimensions(uuid) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        if (!node)
+            return null;
+        const rotation = node.obj3D.rotation.clone();
+        node.obj3D.rotation.set(0, 0, 0);
+        try {
+            node.obj3D.updateWorldMatrix(true, true);
+            const box = this.tmpBox.setFromObject(this.modelRoot(uuid, node));
+            return box.isEmpty() ? null : this.toPoint(box.getSize(new Vector3()));
+        }
+        finally {
+            node.obj3D.rotation.copy(rotation);
+            node.obj3D.updateWorldMatrix(true, true);
+        }
+    }
+    /**
+     * Uniform scale so that the largest bounding box dimension equals `targetSizeMeters`.
+     * The node position is untouched, so call placeObject3DOnSurface afterwards.
+     * @returns the new scale, null when the object is unknown / not loaded / `targetSizeMeters` invalid
+     */
+    normalizeObject3DSize(uuid, targetSizeMeters) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        const box = this.getObject3DBoundingBox(uuid);
+        if (!node || !box || !(targetSizeMeters > 0))
+            return null;
+        const largest = Math.max(box.size.x, box.size.y, box.size.z);
+        if (!(largest > 0))
+            return null;
+        const factor = targetSizeMeters / largest;
+        node.obj3D.scale.multiplyScalar(factor);
+        this.emitTransformChanged(uuid);
+        return this.toPoint(node.obj3D.scale);
+    }
+    /**
+     * Places the model on a surface point without touching its pivot: the node position is
+     * adjusted so that the bounding box bottom-center lies on `point`.
+     * - floor (normal pointing up, or no normal): bottom-center on the point
+     * - wall (mostly horizontal normal): model turned around Y so its +Z faces away from the wall,
+     *   and pushed along the normal by half its depth so it does not cut the wall
+     * - ceiling (normal pointing down): the model hangs, top-center on the point
+     * @returns the new transform, null when the object is unknown or not loaded
+     */
+    /**
+     * @param frontYawOffset rotation (radians, around Y) that turns the front of the model toward its +Z
+     *                       axis, for models whose front is another axis (e.g. -PI/2 when it is +X)
+     */
+    placeObject3DOnSurface(uuid, point, normal, frontYawOffset = 0) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        if (!node || !this.getObject3DBoundingBox(uuid))
+            return null;
+        const obj = node.obj3D;
+        const n = normal ? new Vector3(normal.x, normal.y, normal.z) : new Vector3(0, 1, 0);
+        if (n.lengthSq() === 0)
+            n.set(0, 1, 0);
+        n.normalize();
+        const isWall = Math.abs(n.y) < 0.5;
+        const isCeiling = !isWall && n.y < 0;
+        const target = new Vector3(point.x, point.y, point.z);
+        if (isWall) {
+            // Face away from the wall; the box has to be measured after the rotation
+            obj.rotation.y = Math.atan2(n.x, n.z) + frontYawOffset;
+        }
+        const box = this.getObject3DBoundingBox(uuid);
+        if (isWall) {
+            const horizontal = new Vector3(n.x, 0, n.z).normalize();
+            const halfDepth = 0.5 * (Math.abs(horizontal.x) * box.size.x + Math.abs(horizontal.z) * box.size.z);
+            target.addScaledVector(horizontal, halfDepth);
+        }
+        const anchorY = isCeiling ? box.max.y : box.min.y;
+        obj.position.x += target.x - box.center.x;
+        obj.position.y += target.y - anchorY;
+        obj.position.z += target.z - box.center.z;
+        this.emitTransformChanged(uuid);
+        return this.getObject3DTransform(uuid);
+    }
+    getObject3DTransform(uuid) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        if (!node)
+            return null;
+        const o = node.obj3D;
+        return {
+            position: this.toPoint(o.position),
+            rotation: { x: o.rotation.x, y: o.rotation.y, z: o.rotation.z },
+            scale: this.toPoint(o.scale),
+        };
+    }
+    /** Applies a (partial) transform. Rotation is in radians. */
+    setObject3DTransform(uuid, transform) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        if (!node)
+            return false;
+        const o = node.obj3D;
+        if (transform.position)
+            o.position.set(transform.position.x, transform.position.y, transform.position.z);
+        if (transform.rotation)
+            o.rotation.set(transform.rotation.x, transform.rotation.y, transform.rotation.z);
+        if (transform.scale)
+            o.scale.set(transform.scale.x, transform.scale.y, transform.scale.z);
+        this.emitTransformChanged(uuid);
+        return true;
+    }
+    emitTransformChanged(uuid) {
+        const transform = this.getObject3DTransform(uuid);
+        if (transform) {
+            this.object3DTransformChanged$.next({ uuid, ...transform });
+        }
+    }
+    //
+    // ---------- Gizmo ----------
+    //
+    /** Creates the mp.transformControls node of a model and wires it (events, snap) */
+    createGizmo(uuid, modelNode, sceneObject, mode, visible, node) {
+        const gizmoNode = node ?? sceneObject.addNode();
+        const component = gizmoNode.addComponent('mp.transformControls');
+        gizmoNode.start();
+        const tc = component.transformControls;
+        tc.visible = visible;
+        component.inputs.selection = modelNode;
+        component.inputs.mode = mode;
+        modelNode.obj3D.controls = component;
+        const entry = {
+            uuid,
+            node: gizmoNode,
+            component,
+            mode,
+            dragStart: null,
+            lastPosition: modelNode.obj3D.position.clone(),
+            onDraggingChanged: (event) => {
+                entry.dragStart = event?.value ? modelNode.obj3D.position.clone() : null;
+                entry.lastPosition = modelNode.obj3D.position.clone();
+            },
+            onObjectChange: () => this.onGizmoObjectChange(entry, modelNode),
+        };
+        if (typeof tc.addEventListener === 'function') {
+            tc.addEventListener('dragging-changed', entry.onDraggingChanged);
+            tc.addEventListener('objectChange', entry.onObjectChange);
+        }
+        this.applySnap(tc);
+        this.gizmos.set(uuid, entry);
+        this.activeGizmoUuid = uuid;
+        return entry;
+    }
+    /** Keeps a translate drag within maxDragDistance / maxDragHeight of where it started, then notifies */
+    onGizmoObjectChange(entry, modelNode) {
+        const pos = modelNode.obj3D.position;
+        if (entry.mode === 'translate') {
+            const start = entry.dragStart ?? entry.lastPosition;
+            const delta = pos.clone().sub(start);
+            delta.y = MathUtils.clamp(delta.y, -this.maxDragHeight, this.maxDragHeight);
+            const length = delta.length();
+            if (length > this.maxDragDistance) {
+                delta.multiplyScalar(this.maxDragDistance / length);
+            }
+            pos.copy(start).add(delta);
+        }
+        entry.lastPosition = pos.clone();
+        this.emitTransformChanged(entry.uuid);
+    }
+    applySnap(tc) {
+        if (!tc)
+            return;
+        const snap = this.gizmoSnap;
+        const translation = snap?.translation ?? null;
+        const rotation = snap?.rotationDeg != null ? MathUtils.degToRad(snap.rotationDeg) : null;
+        const scale = snap?.scale ?? null;
+        if (typeof tc.setTranslationSnap === 'function')
+            tc.setTranslationSnap(translation);
+        else
+            tc.translationSnap = translation;
+        if (typeof tc.setRotationSnap === 'function')
+            tc.setRotationSnap(rotation);
+        else
+            tc.rotationSnap = rotation;
+        if (typeof tc.setScaleSnap === 'function')
+            tc.setScaleSnap(scale);
+        else
+            tc.scaleSnap = scale;
+    }
+    /**
+     * Shows the transform gizmo on an object (any previous gizmo is detached first).
+     * Re-attaching to the object that already has the gizmo only changes its mode.
+     */
+    async attachGizmo(uuid, mode, sdk) {
+        const modelNode = this.dictionnaryObjects3D.get(uuid);
+        const sceneObject = this.dictionnarySceneObjects3D.get(uuid);
+        if (!modelNode || !sceneObject)
+            return false;
+        const existing = this.gizmos.get(uuid);
+        if (existing && this.activeGizmoUuid === uuid) {
+            this.setGizmoMode(mode);
+            return true;
+        }
+        // A started scene object refuses new nodes (addNode returns null): use a dedicated one
+        let node = sceneObject.addNode();
+        let gizmoSceneObject = null;
+        if (!node) {
+            if (!sdk?.Scene)
+                return false;
+            [gizmoSceneObject] = await sdk.Scene.createObjects(1);
+            node = gizmoSceneObject.addNode();
+        }
+        this.detachGizmo();
+        const entry = this.createGizmo(uuid, modelNode, sceneObject, mode, true, node);
+        entry.sceneObject = gizmoSceneObject;
+        this.lastObject3D = modelNode.obj3D;
+        return true;
+    }
+    /** Switches the active gizmo between translate / rotate / scale without re-attaching it */
+    setGizmoMode(mode) {
+        const entry = this.activeGizmoUuid ? this.gizmos.get(this.activeGizmoUuid) : null;
+        if (!entry)
+            return;
+        entry.mode = mode;
+        entry.dragStart = null;
+        entry.component.inputs.mode = mode;
+        const tc = entry.component.transformControls;
+        if (tc && typeof tc.setMode === 'function')
+            tc.setMode(mode);
+    }
+    /** Really removes the gizmo from the scene (default: the active one) */
+    detachGizmo(uuid) {
+        const id = uuid ?? this.activeGizmoUuid;
+        if (!id)
+            return;
+        const entry = this.gizmos.get(id);
+        if (!entry)
+            return;
+        const tc = entry.component?.transformControls;
+        if (tc) {
+            if (typeof tc.removeEventListener === 'function') {
+                tc.removeEventListener('dragging-changed', entry.onDraggingChanged);
+                tc.removeEventListener('objectChange', entry.onObjectChange);
+            }
+            tc.visible = false;
+            if (typeof tc.detach === 'function')
+                tc.detach();
+            if (typeof tc.dispose === 'function')
+                tc.dispose();
+            if (tc.parent && typeof tc.parent.remove === 'function')
+                tc.parent.remove(tc);
+        }
+        try {
+            entry.node.stop();
+        }
+        catch { /* already stopped */ }
+        try {
+            entry.sceneObject?.stop();
+        }
+        catch { /* already stopped */ }
+        const modelNode = this.dictionnaryObjects3D.get(id);
+        if (modelNode?.obj3D)
+            modelNode.obj3D.controls = null;
+        this.gizmos.delete(id);
+        if (this.activeGizmoUuid === id)
+            this.activeGizmoUuid = null;
+    }
+    isGizmoAttached(uuid) {
+        return uuid ? this.gizmos.has(uuid) : this.activeGizmoUuid !== null;
+    }
+    /** Snap steps for all gizmos (null / missing value = no snap) */
+    setGizmoSnap(snap) {
+        this.gizmoSnap = snap ? { ...snap } : null;
+        this.gizmos.forEach((entry) => this.applySnap(entry.component?.transformControls));
+    }
+    setGizmoMaxDragDistance(maxDistance, maxHeight) {
+        if (maxDistance > 0)
+            this.maxDragDistance = maxDistance;
+        if (maxHeight !== undefined && maxHeight > 0)
+            this.maxDragHeight = maxHeight;
+    }
+    /**
+     * Prevents camera navigation to other sweeps while a gizmo is edited.
+     * The SDK has no "freeze camera" switch, so every enabled sweep except the current one is
+     * disabled (Sweep.disable); exactly those sweeps are re-enabled on unlock. Sweeps already
+     * disabled (forbidden sweeps, edit mode) are never touched, and `keepDisabled` lists sweeps
+     * that must stay disabled on unlock.
+     * @returns false when the lock could not be applied (SDK without Sweep.disable, unknown current sweep)
+     */
+    async setNavigationLocked(sdk, locked, sweepCollection, currentSweepId, keepDisabled = []) {
+        if (!sdk?.Sweep || typeof sdk.Sweep.disable !== 'function' || typeof sdk.Sweep.enable !== 'function') {
+            return false;
+        }
+        if (locked) {
+            if (this.sweepsDisabledByLock.length > 0)
+                return true;
+            if (!sweepCollection || !currentSweepId)
+                return false;
+            // a sweep this lock re-enabled just before may still be reported disabled by the SDK
+            const ids = Object.keys(sweepCollection).filter((sid) => sid !== currentSweepId &&
+                (sweepCollection[sid]?.enabled !== false || this.sweepsEnabledByUnlock.includes(sid)));
+            if (ids.length === 0)
+                return true;
+            try {
+                await sdk.Sweep.disable(...ids);
+                this.sweepsDisabledByLock = ids;
+            }
+            catch {
+                // fall back to one call per sweep to know exactly which ones were disabled
+                const results = await Promise.allSettled(ids.map((sid) => sdk.Sweep.disable(sid)));
+                this.sweepsDisabledByLock = ids.filter((_, i) => results[i].status === 'fulfilled');
+            }
+            return true;
+        }
+        const toEnable = this.sweepsDisabledByLock.filter((sid) => !keepDisabled.includes(sid));
+        this.sweepsDisabledByLock = [];
+        this.sweepsEnabledByUnlock = toEnable;
+        if (toEnable.length > 0) {
+            try {
+                await sdk.Sweep.enable(...toEnable);
+            }
+            catch {
+                await Promise.allSettled(toEnable.map((sid) => sdk.Sweep.enable(sid)));
+            }
+        }
+        return true;
+    }
+    isNavigationLocked() {
+        return this.sweepsDisabledByLock.length > 0;
+    }
+    /** Sweeps currently disabled by the navigation lock */
+    getSweepsDisabledByLock() {
+        return [...this.sweepsDisabledByLock];
+    }
+    /**
+     * Legacy API: attaches a gizmo to a model node. Prefer attachGizmo(uuid, mode).
+     */
     async attachGizmoControlTo3DObject(sdk, modelNode, sceneObject, mode, visible, isNewObject) {
         let node = sceneObject.addNode();
         if (!node) {
             const [newSceneObject] = await sdk.Scene.createObjects(1);
             node = newSceneObject.addNode();
         }
-        const myControl = node.addComponent('mp.transformControls');
-        node.start();
-        myControl.transformControls.visible = visible;
-        myControl.inputs.selection = modelNode;
-        myControl.inputs.mode = mode;
-        modelNode.obj3D.controls = myControl;
-        if (isNewObject) {
-            if (!this.lastObject3D || !this.lastObject3D.controls) {
-                try {
-                    modelNode.obj3D.uuid = this.lastObject3D.uuid || this.lastObject3D.id;
-                }
-                catch (e) {
-                    console.log(`id obj in Scene was not assigned to id from DB`);
-                }
-                this.lastObject3D = modelNode.obj3D;
+        if (isNewObject && (!this.lastObject3D || !this.lastObject3D.controls)) {
+            try {
+                modelNode.obj3D.uuid = this.lastObject3D.uuid || this.lastObject3D.id;
+            }
+            catch (e) {
+                // lastObject3D is not set: the model keeps its own uuid
             }
         }
-        else {
-            this.lastObject3D = modelNode.obj3D;
-        }
+        this.detachGizmo();
+        this.createGizmo(modelNode.obj3D.uuid, modelNode, sceneObject, mode, visible, node);
+        this.lastObject3D = modelNode.obj3D;
         return modelNode;
     }
+    /** Removes the gizmo of the last added / edited object */
     removeGizmoFromLastObject() {
-        if (this.lastObject3D && this.lastObject3D.controls) {
-            this.lastObject3D.controls.transformControls.visible = false;
-            this.lastObject3D.controls.transformControls.dispose();
-            this.lastObject3D.controls = null;
+        const last = this.lastObject3D;
+        if (!last)
+            return;
+        const uuid = last.uuid ?? last.id;
+        if (uuid && this.gizmos.has(uuid)) {
+            this.detachGizmo(uuid);
+        }
+        else if (last.controls) {
+            // gizmo not created by this service: best effort
+            last.controls.transformControls.visible = false;
+            last.controls.transformControls.dispose();
+            last.controls = null;
         }
     }
-    toggleViewFrustum() {
-        if (this.securityCameraAnimator) {
+    //
+    // ---------- Security camera ----------
+    //
+    applyViewFrustum(uuid, visible) {
+        const animator = this.securityCameraAnimators.get(uuid);
+        if (!animator)
+            return false;
+        const current = this.viewFrustumVisible.get(uuid) ?? true;
+        if (current === visible)
+            return true;
+        try {
+            animator.toggleViewFrustum();
+        }
+        catch {
+            return false;
+        }
+        this.viewFrustumVisible.set(uuid, visible);
+        return true;
+    }
+    /** Shows / hides the view frustum of the security camera `uuid` */
+    setViewFrustum(uuid, visible) {
+        return this.applyViewFrustum(uuid, visible);
+    }
+    isViewFrustumVisible(uuid) {
+        return this.viewFrustumVisible.get(uuid) ?? false;
+    }
+    /** Toggles the frustum of `uuid`, or of the last loaded security camera when omitted */
+    toggleViewFrustum(uuid) {
+        const id = uuid ?? this.lastSecurityCameraUuid;
+        if (id && this.securityCameraAnimators.has(id)) {
+            this.applyViewFrustum(id, !(this.viewFrustumVisible.get(id) ?? true));
+        }
+        else if (!uuid && this.securityCameraAnimator) {
+            // animator set by hand (legacy)
             this.securityCameraAnimator.toggleViewFrustum();
         }
     }
     clear() {
+        Array.from(this.gizmos.keys()).forEach((id) => this.detachGizmo(id));
         this.dictionnaryObjects3D.clear();
         this.dictionnarySceneObjects3D.clear();
+        this.loaderComponents.clear();
+        this.securityCameraAnimators.clear();
+        this.viewFrustumVisible.clear();
+        this.lastSecurityCameraUuid = null;
+        this.sweepsDisabledByLock = [];
         this.lastObject3D = null;
         this.azimuthalCrown = null;
         this.securityCameraAnimator = null;
@@ -231,4 +755,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matterport-object3d.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/matterport-object3d.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { IObject3D, PoiType, POI, DbObjectType } from '../types.service';\nimport { Object3D } from 'three';\nimport { NestThermostat } from '../matterport-extensions/nest-thermostat/NestThermostat';\nimport { PlaneRenderer } from '../matterport-extensions/nest-thermostat/PlaneRenderer';\nimport { CanvasRenderer } from \"../matterport-extensions/nest-thermostat/CanvasRenderer\";\nimport { TvPlayer } from \"../matterport-extensions/tv-player/TvPlayer\";\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class MatterportObject3DService {\n  public dictionnaryObjects3D: Map<string, any> = new Map();\n  public dictionnarySceneObjects3D: Map<string, any> = new Map();\n  public lastObject3D: any; // Three JS object\n  public objectControl: any;\n  public securityCameraAnimator: any;\n  public azimuthalCrown: any;\n  public threeJSScene: any;\n  public noLightForObjects = true;\n\n  constructor() { }\n\n  async init3DObjectViewer(sdk: any): Promise<void> {\n    const [sceneObject] = await sdk.Scene.createObjects(1);\n    const node = sceneObject.addNode();\n    node.start();\n    this.threeJSScene = node.obj3D.parent;\n\n    const nodeControl = sceneObject.addNode();\n    this.objectControl = nodeControl.addComponent('mp.transformControls');\n    nodeControl.start();\n  }\n\n  async add3DObject(\n    sdk: any,\n    obj: IObject3D,\n    mode?: 'translate' | 'rotate'\n  ): Promise<any> {\n    return new Promise(async (resolve) => {\n      const [sceneObject] = await sdk.Scene.createObjects(1);\n\n      let isAnimatedSecurityCamera = (obj.object === \"security_camera\");\n      let isNestThermostat = (obj.object === \"nest_thermostat\");\n      let isSmarterplanPromotionalVideo = (obj.object === 'video');\n      let isAzimuthalCrown = (obj.object === 'azimuth');\n\n      const modelNode = sceneObject.addNode();\n      let component = null;\n      const initial = {\n        url: `/assets/3Dobjects/objects/${obj.object}${obj.format.indexOf('.') === -1 ? '.' + obj.format : obj.format}`,\n        localRotation: { \"x\": 0, \"y\": 0, \"z\": 0 },\n        localPosition: { \"x\": 0, \"y\": 0, \"z\": 0 },\n        visible: true,\n        colliderEnabled: true\n      };\n\n      switch (obj.format) {\n        case '.obj': case 'obj': component = modelNode.addComponent('mp.objLoader', initial); break;\n        case '.fbx': case 'fbx': component = modelNode.addComponent('mp.fbxLoader', initial); break;\n        case '.gltf': case 'gltf': case '.glb': case 'glb': component = modelNode.addComponent('mp.gltfLoader', initial); break;\n        case '.dae': case 'dae': component = modelNode.addComponent('mp.daeLoader', initial); break;\n        default: console.log('Format not supported'); break;\n      }\n\n      if (this.noLightForObjects) {\n        const lightsNode = sceneObject.addNode();\n        lightsNode.addComponent('mp.ambientLight', {\n          intensity: 1,\n          color: { r: 1.0, g: 1.0, b: 1.0 },\n        });\n        this.noLightForObjects = false;\n      }\n\n      modelNode.obj3D.position.set(obj.position.x, obj.position.y, obj.position.z);\n      modelNode.obj3D.rotation.set(obj.rotation.x, obj.rotation.y, obj.rotation.z);\n      modelNode.obj3D.scale.set(obj.scale.x, obj.scale.y, obj.scale.z);\n\n      if (isAzimuthalCrown) {\n        this.azimuthalCrown = modelNode;\n      }\n\n      if (mode && !isNestThermostat) {\n        this.attachGizmoControlTo3DObject(sdk, modelNode, sceneObject, mode, true, true).catch((e) => console.log(e));\n      }\n\n      if (this.lastObject3D && typeof this.lastObject3D.id === 'string') {\n        modelNode.obj3D.uuid = this.lastObject3D.id;\n      } else if (obj.id) {\n        modelNode.obj3D.uuid = obj.id;\n      }\n      this.lastObject3D = modelNode.obj3D;\n\n      this.dictionnaryObjects3D.set(modelNode.obj3D.uuid, modelNode);\n      this.dictionnarySceneObjects3D.set(modelNode.obj3D.uuid, sceneObject);\n\n      if (isAnimatedSecurityCamera) {\n        const animator = modelNode.addComponent('mp.securityCamera', {\n          \"nearPlane\": 0.1, \"farPlane\": 10, \"horizontalFOV\": 52, \"aspect\": 1.7777777777777777,\n          \"localPosition\": { \"x\": 0.3, \"y\": 0.18, \"z\": 0 },\n          \"localRotation\": { \"x\": -15, \"y\": -90, \"z\": 0 },\n          \"color\": 65280, \"panPeriod\": 5, \"panAngle\": -45\n        });\n        this.securityCameraAnimator = animator;\n        if (!obj.viewFrustum) {\n          setTimeout(() => { animator.toggleViewFrustum(); }, 1000);\n        }\n      }\n\n      if (isNestThermostat) {\n        const cv = new CanvasRenderer(); cv.onInit();\n        const plane = new PlaneRenderer();\n        plane.outputs = { objectRoot: new Object3D(), collider: new Object3D() };\n        const inputTexture = cv.outputs.texture;\n        plane.setRootScene(this.threeJSScene);\n        plane.onInit(modelNode, inputTexture);\n        const sc = new NestThermostat();\n        sc.setComponent(component, plane, cv);\n        sc.setRootScene(this.threeJSScene);\n        sc.onInit(modelNode, plane, inputTexture);\n        cv.setCanvasNestThermostatPainter(sc);\n        setTimeout(() => { sc.inputs.loadingState = \"Loaded\"; sc.onInputsUpdated(); }, 5000);\n      }\n\n      if (isSmarterplanPromotionalVideo) {\n        const sc = new TvPlayer(); sc.setComponent(component); sc.onInit(modelNode);\n        setTimeout(() => { sc.inputs.loadingState = \"Loaded\"; sc.onInputsUpdated(); }, 5000);\n      }\n\n      sceneObject.start();\n      resolve(this.lastObject3D);\n    });\n  }\n\n  async deleteObject3D(uuid: string): Promise<void> {\n    const obj = this.dictionnaryObjects3D.get(uuid);\n    if (obj) obj.obj3D.visible = false;\n  }\n\n  getObject3DModelNodeFromDictionnary(uuid: string): any {\n    let obj = this.dictionnaryObjects3D.get(uuid);\n    if (!obj) return null;\n    if (obj.obj3D.uuid != uuid) {\n      obj.obj3D.uuid = uuid;\n    }\n    return obj;\n  }\n\n  toggleObjectVisibility(objectId: any) {\n    let obj = this.dictionnaryObjects3D.get(objectId);\n    if (obj) obj.obj3D.visible = !obj.obj3D.visible;\n  }\n\n  isObjectVisible(objectId: any): boolean {\n    let obj = this.dictionnaryObjects3D.get(objectId);\n    return obj ? obj.obj3D.visible : false;\n  }\n\n  async pointCameraTo3DObject(sdk: any, objectId: any, createTagCallback: (tagType: PoiType, object: DbObjectType, poi: POI) => Promise<any>, goToTagCallback: (sid: string) => Promise<any>, deleteLastTagCallback: () => void, getTagFromElementId: (id: string) => { tag: string, sweep: string }) {\n    let obj = this.dictionnaryObjects3D.get(objectId);\n    const poiObject = {\n      coordinate: JSON.stringify(obj.obj3D.position),\n      type: PoiType.OBJECT3D,\n      elementID: objectId,\n    } as POI;\n    const objectDb = { id: objectId } as DbObjectType;\n    try {\n      await createTagCallback(PoiType.OBJECT3D, objectDb, poiObject);\n    } catch (err: any) { }\n\n    let result = getTagFromElementId(objectId);\n    await goToTagCallback(result.tag);\n    deleteLastTagCallback();\n  }\n\n  getSceneNodeFromObject3DId(uuid: string): any {\n    return this.dictionnarySceneObjects3D.get(uuid);\n  }\n\n  async displayAzimutalCrown(poseCamera: any) {\n    if (this.azimuthalCrown && poseCamera) {\n      this.azimuthalCrown.obj3D.position.set(poseCamera.position.x, poseCamera.position.y, poseCamera.position.z)\n    }\n  }\n\n  async attachGizmoControlTo3DObject(\n    sdk: any,\n    modelNode: any,\n    sceneObject: any,\n    mode: 'translate' | 'rotate' | 'scale',\n    visible: boolean,\n    isNewObject: boolean\n  ): Promise<any> {\n    let node = sceneObject.addNode();\n    if (!node) {\n      const [newSceneObject] = await sdk.Scene.createObjects(1);\n      node = newSceneObject.addNode();\n    }\n    const myControl = node.addComponent('mp.transformControls');\n    node.start();\n    myControl.transformControls.visible = visible;\n    myControl.inputs.selection = modelNode;\n    myControl.inputs.mode = mode;\n    modelNode.obj3D.controls = myControl;\n    if (isNewObject) {\n      if (!this.lastObject3D || !this.lastObject3D.controls) {\n        try {\n          modelNode.obj3D.uuid = this.lastObject3D.uuid || this.lastObject3D.id;\n        } catch (e) {\n          console.log(`id obj in Scene was not assigned to id from DB`);\n        }\n        this.lastObject3D = modelNode.obj3D;\n      }\n    } else {\n      this.lastObject3D = modelNode.obj3D;\n    }\n    return modelNode;\n  }\n\n  removeGizmoFromLastObject(): void {\n    if (this.lastObject3D && this.lastObject3D.controls) {\n      this.lastObject3D.controls.transformControls.visible = false;\n      this.lastObject3D.controls.transformControls.dispose();\n      this.lastObject3D.controls = null;\n    }\n  }\n\n  toggleViewFrustum(): void {\n    if (this.securityCameraAnimator) {\n      this.securityCameraAnimator.toggleViewFrustum();\n    }\n  }\n\n  clear() {\n    this.dictionnaryObjects3D.clear();\n    this.dictionnarySceneObjects3D.clear();\n    this.lastObject3D = null;\n    this.azimuthalCrown = null;\n    this.securityCameraAnimator = null;\n    this.noLightForObjects = true;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matterport-object3d.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/matterport-object3d.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport {\n  IObject3D,\n  PoiType,\n  POI,\n  DbObjectType,\n  GizmoMode,\n  GizmoSnap,\n  Object3DBoundingBox,\n  Object3DTransform,\n  Object3DTransformChange,\n  Point3D,\n} from '../types.service';\nimport { Box3, MathUtils, Object3D, Vector3 } from 'three';\nimport { NestThermostat } from '../matterport-extensions/nest-thermostat/NestThermostat';\nimport { PlaneRenderer } from '../matterport-extensions/nest-thermostat/PlaneRenderer';\nimport { CanvasRenderer } from \"../matterport-extensions/nest-thermostat/CanvasRenderer\";\nimport { TvPlayer } from \"../matterport-extensions/tv-player/TvPlayer\";\n\n/** Gizmo (mp.transformControls) bookkeeping for one object */\ninterface GizmoEntry {\n  uuid: string;\n  node: any;\n  /** dedicated scene object when the object's own one was already started */\n  sceneObject?: any;\n  component: any;\n  mode: GizmoMode;\n  /** position of the object when the current drag started */\n  dragStart: Vector3 | null;\n  /** position of the object at the last change (fallback when drag start was missed) */\n  lastPosition: Vector3;\n  onDraggingChanged: (event: any) => void;\n  onObjectChange: () => void;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class MatterportObject3DService {\n  public dictionnaryObjects3D: Map<string, any> = new Map();\n  public dictionnarySceneObjects3D: Map<string, any> = new Map();\n  public lastObject3D: any; // Three JS object\n  public objectControl: any;\n  public securityCameraAnimator: any;\n  public azimuthalCrown: any;\n  public threeJSScene: any;\n  public noLightForObjects = true;\n\n  /** Max time (ms) to wait for a model to be loaded by the SDK */\n  public loadTimeoutMs = 15000;\n  /** Max distance (m) an object can travel from where a translate drag started */\n  public maxDragDistance = 2;\n  /** Max vertical travel (m, up and down) during a translate drag, so an object cannot jump to another floor */\n  public maxDragHeight = 1.5;\n\n  /** Emits on every gizmo change and on setObject3DTransform */\n  public readonly object3DTransformChanged$ = new Subject<Object3DTransformChange>();\n\n  /** Security camera animators by object uuid (`securityCameraAnimator` stays the last loaded one) */\n  public securityCameraAnimators: Map<string, any> = new Map();\n  private viewFrustumVisible: Map<string, boolean> = new Map();\n  private lastSecurityCameraUuid: string | null = null;\n\n  /** Loader component of each model (outputs.objectRoot is set once loaded) */\n  private loaderComponents: Map<string, any> = new Map();\n\n  private gizmos: Map<string, GizmoEntry> = new Map();\n  private activeGizmoUuid: string | null = null;\n  private gizmoSnap: GizmoSnap | null = null;\n\n  /** Sweeps disabled by setNavigationLocked(true), re-enabled on unlock */\n  private sweepsDisabledByLock: string[] = [];\n  /** Sweeps re-enabled by the last unlock (the SDK may still report them disabled for a moment) */\n  private sweepsEnabledByUnlock: string[] = [];\n\n  private readonly tmpBox = new Box3();\n\n  constructor() { }\n\n  async init3DObjectViewer(sdk: any): Promise<void> {\n    const [sceneObject] = await sdk.Scene.createObjects(1);\n    const node = sceneObject.addNode();\n    node.start();\n    this.threeJSScene = node.obj3D.parent;\n\n    const nodeControl = sceneObject.addNode();\n    this.objectControl = nodeControl.addComponent('mp.transformControls');\n    nodeControl.start();\n  }\n\n  /** SDK loader component name for a model format, null when the format is not supported */\n  private getLoaderComponentName(format: string): string | null {\n    switch ((format || '').toLowerCase()) {\n      case '.obj': case 'obj': return 'mp.objLoader';\n      case '.fbx': case 'fbx': return 'mp.fbxLoader';\n      case '.gltf': case 'gltf': case '.glb': case 'glb': return 'mp.gltfLoader';\n      case '.dae': case 'dae': return 'mp.daeLoader';\n      default: return null;\n    }\n  }\n\n  /** Resolves once the loader component has produced its objectRoot, rejects after `timeoutMs` */\n  private waitForModelLoaded(component: any, timeoutMs: number): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      const isLoaded = () => !!component?.outputs?.objectRoot;\n      if (isLoaded()) {\n        resolve();\n        return;\n      }\n      const poll = setInterval(() => {\n        if (isLoaded()) {\n          clearInterval(poll);\n          clearTimeout(timer);\n          resolve();\n        }\n      }, 50);\n      const timer = setTimeout(() => {\n        clearInterval(poll);\n        reject(new Error(`3D model not loaded after ${timeoutMs} ms`));\n      }, timeoutMs);\n    });\n  }\n\n  /**\n   * Adds a 3D model to the scene.\n   * The promise resolves with the three.js object once the model is actually loaded, and rejects\n   * (after cleaning the scene) when the format is unknown or the load times out.\n   * The position / rotation / scale of `obj` are applied to the model origin, as stored in DB.\n   */\n  async add3DObject(\n    sdk: any,\n    obj: IObject3D,\n    mode?: GizmoMode\n  ): Promise<any> {\n    const loaderName = this.getLoaderComponentName(obj.format);\n    if (!loaderName) {\n      throw new Error(`3D object format not supported: ${obj.format}`);\n    }\n\n    const [sceneObject] = await sdk.Scene.createObjects(1);\n\n    const isAnimatedSecurityCamera = (!obj.url && obj.object === 'security_camera');\n    const isNestThermostat = (!obj.url && obj.object === 'nest_thermostat');\n    const isSmarterplanPromotionalVideo = (!obj.url && obj.object === 'video');\n    const isAzimuthalCrown = (!obj.url && obj.object === 'azimuth');\n\n    const modelNode = sceneObject.addNode();\n    const initial = {\n      url: obj.url || `/assets/3Dobjects/objects/${obj.object}${obj.format.indexOf('.') === -1 ? '.' + obj.format : obj.format}`,\n      localRotation: { 'x': 0, 'y': 0, 'z': 0 },\n      localPosition: { 'x': 0, 'y': 0, 'z': 0 },\n      visible: true,\n      colliderEnabled: true\n    };\n    const component = modelNode.addComponent(loaderName, initial);\n\n    if (this.noLightForObjects) {\n      const lightsNode = sceneObject.addNode();\n      lightsNode.addComponent('mp.ambientLight', {\n        intensity: 1,\n        color: { r: 1.0, g: 1.0, b: 1.0 },\n      });\n      this.noLightForObjects = false;\n    }\n\n    modelNode.obj3D.position.set(obj.position.x, obj.position.y, obj.position.z);\n    modelNode.obj3D.rotation.set(obj.rotation.x, obj.rotation.y, obj.rotation.z);\n    modelNode.obj3D.scale.set(obj.scale.x, obj.scale.y, obj.scale.z);\n\n    // The DB id replaces the three.js uuid. The id pre-set through setLastObject3D is only a fallback\n    // for callers without id: taking it first gave the same id to every object loaded meanwhile\n    // (several cameras or cubes loading while an add is starting), which then overwrote each other.\n    if (obj.id) {\n      modelNode.obj3D.uuid = obj.id;\n    } else if (this.lastObject3D && typeof this.lastObject3D.id === 'string') {\n      modelNode.obj3D.uuid = this.lastObject3D.id;\n    }\n    const uuid: string = modelNode.obj3D.uuid;\n    this.lastObject3D = modelNode.obj3D;\n\n    this.dictionnaryObjects3D.set(uuid, modelNode);\n    this.dictionnarySceneObjects3D.set(uuid, sceneObject);\n    this.loaderComponents.set(uuid, component);\n\n    if (isAzimuthalCrown) {\n      this.azimuthalCrown = modelNode;\n    }\n\n    if (mode && !isNestThermostat) {\n      this.attachGizmo(uuid, mode).catch(() => { /* no gizmo, the object is still loaded */ });\n    }\n\n    let animator: any = null;\n    if (isAnimatedSecurityCamera) {\n      animator = modelNode.addComponent('mp.securityCamera', {\n        'nearPlane': 0.1, 'farPlane': 10, 'horizontalFOV': 52, 'aspect': 1.7777777777777777,\n        'localPosition': { 'x': 0.3, 'y': 0.18, 'z': 0 },\n        'localRotation': { 'x': -15, 'y': -90, 'z': 0 },\n        'color': 65280, 'panPeriod': 5, 'panAngle': -45\n      });\n      this.securityCameraAnimator = animator;\n      this.securityCameraAnimators.set(uuid, animator);\n      this.viewFrustumVisible.set(uuid, true); // the component shows its frustum by default\n      this.lastSecurityCameraUuid = uuid;\n    }\n\n    if (isNestThermostat) {\n      const cv = new CanvasRenderer(); cv.onInit();\n      const plane = new PlaneRenderer();\n      plane.outputs = { objectRoot: new Object3D(), collider: new Object3D() };\n      const inputTexture = cv.outputs.texture;\n      plane.setRootScene(this.threeJSScene);\n      plane.onInit(modelNode, inputTexture);\n      const sc = new NestThermostat();\n      sc.setComponent(component, plane, cv);\n      sc.setRootScene(this.threeJSScene);\n      sc.onInit(modelNode, plane, inputTexture);\n      cv.setCanvasNestThermostatPainter(sc);\n      setTimeout(() => { sc.inputs.loadingState = 'Loaded'; sc.onInputsUpdated(); }, 5000);\n    }\n\n    if (isSmarterplanPromotionalVideo) {\n      const sc = new TvPlayer(); sc.setComponent(component); sc.onInit(modelNode);\n      setTimeout(() => { sc.inputs.loadingState = 'Loaded'; sc.onInputsUpdated(); }, 5000);\n    }\n\n    sceneObject.start();\n\n    try {\n      await this.waitForModelLoaded(component, this.loadTimeoutMs);\n    } catch (e) {\n      await this.deleteObject3D(uuid);\n      throw e;\n    }\n\n    if (animator && !obj.viewFrustum) {\n      // The camera component starts with the model node, so it is ready now that the model is loaded\n      this.applyViewFrustum(uuid, false);\n    }\n\n    return modelNode.obj3D;\n  }\n\n  /**\n   * Removes a 3D object for good: detaches its gizmo, stops its scene object and forgets it.\n   */\n  async deleteObject3D(uuid: string): Promise<void> {\n    this.detachGizmo(uuid);\n\n    const node = this.dictionnaryObjects3D.get(uuid);\n    const sceneObject = this.dictionnarySceneObjects3D.get(uuid);\n    if (node) {\n      try { node.obj3D.visible = false; } catch { /* already destroyed */ }\n    }\n    if (sceneObject && typeof sceneObject.stop === 'function') {\n      try { sceneObject.stop(); } catch { /* already stopped */ }\n    }\n\n    this.dictionnaryObjects3D.delete(uuid);\n    this.dictionnarySceneObjects3D.delete(uuid);\n    this.loaderComponents.delete(uuid);\n\n    if (this.lastObject3D && (this.lastObject3D.uuid === uuid || this.lastObject3D.id === uuid)) {\n      this.lastObject3D = null;\n    }\n    if (node && this.azimuthalCrown === node) {\n      this.azimuthalCrown = null;\n    }\n    const animator = this.securityCameraAnimators.get(uuid);\n    if (animator && this.securityCameraAnimator === animator) {\n      this.securityCameraAnimator = null;\n    }\n    this.securityCameraAnimators.delete(uuid);\n    this.viewFrustumVisible.delete(uuid);\n    if (this.lastSecurityCameraUuid === uuid) {\n      this.lastSecurityCameraUuid = null;\n    }\n  }\n\n  getObject3DModelNodeFromDictionnary(uuid: string): any {\n    let obj = this.dictionnaryObjects3D.get(uuid);\n    if (!obj) return null;\n    if (obj.obj3D.uuid != uuid) {\n      obj.obj3D.uuid = uuid;\n    }\n    return obj;\n  }\n\n  toggleObjectVisibility(objectId: any) {\n    let obj = this.dictionnaryObjects3D.get(objectId);\n    if (obj) obj.obj3D.visible = !obj.obj3D.visible;\n  }\n\n  isObjectVisible(objectId: any): boolean {\n    let obj = this.dictionnaryObjects3D.get(objectId);\n    return obj ? obj.obj3D.visible : false;\n  }\n\n  /** Shows / hides a model (used by the placement preview) */\n  setObject3DVisible(uuid: string, visible: boolean): void {\n    const node = this.dictionnaryObjects3D.get(uuid);\n    if (node) node.obj3D.visible = visible;\n  }\n\n  /** Enables / disables the pointer collider of a model (disabled while it follows the cursor) */\n  setObject3DColliderEnabled(uuid: string, enabled: boolean): void {\n    const component = this.loaderComponents.get(uuid);\n    if (component?.inputs) {\n      component.inputs.colliderEnabled = enabled;\n    }\n  }\n\n  /**\n   * Moves the camera next to a 3D object by creating a temporary tag on the object centre.\n   * @returns false when the object is unknown or no tag could be reached\n   */\n  async pointCameraTo3DObject(sdk: any, objectId: any, createTagCallback: (tagType: PoiType, object: DbObjectType, poi: POI) => Promise<any>, goToTagCallback: (sid: string) => Promise<any>, deleteLastTagCallback: () => void, getTagFromElementId: (id: string) => { tag: string, sweep: string }): Promise<boolean> {\n    const obj = this.dictionnaryObjects3D.get(objectId);\n    if (!obj) return false;\n\n    // Tag on the bounding box centre (the model origin is a corner for most models)\n    const box = this.getObject3DBoundingBox(objectId);\n    const anchor = box ? box.center : this.toPoint(obj.obj3D.position);\n    const poiObject = {\n      coordinate: JSON.stringify(anchor),\n      type: PoiType.OBJECT3D,\n      elementID: objectId,\n    } as POI;\n    const objectDb = { id: objectId } as DbObjectType;\n    try {\n      await createTagCallback(PoiType.OBJECT3D, objectDb, poiObject);\n    } catch (err: any) { }\n\n    try {\n      const result = getTagFromElementId(objectId);\n      if (!result?.tag) return false;\n      await goToTagCallback(result.tag);\n      return true;\n    } finally {\n      deleteLastTagCallback();\n    }\n  }\n\n  getSceneNodeFromObject3DId(uuid: string): any {\n    return this.dictionnarySceneObjects3D.get(uuid);\n  }\n\n  async displayAzimutalCrown(poseCamera: any) {\n    if (this.azimuthalCrown && poseCamera) {\n      this.azimuthalCrown.obj3D.position.set(poseCamera.position.x, poseCamera.position.y, poseCamera.position.z)\n    }\n  }\n\n  //\n  // ---------- Geometry helpers ----------\n  //\n  private toPoint(v: { x: number, y: number, z: number }): Point3D {\n    return { x: v.x, y: v.y, z: v.z };\n  }\n\n  /**\n   * Geometry of the model itself (the loader output): the node also holds the helpers added by other\n   * components, like the view frustum of a security camera, which must not count in its size.\n   */\n  private modelRoot(uuid: string, node: any): any {\n    return this.loaderComponents.get(uuid)?.outputs?.objectRoot ?? node.obj3D;\n  }\n\n  /** World-space bounding box of the model, null when unknown or when nothing is loaded yet */\n  getObject3DBoundingBox(uuid: string): Object3DBoundingBox | null {\n    const node = this.dictionnaryObjects3D.get(uuid);\n    if (!node) return null;\n    node.obj3D.updateWorldMatrix(true, true);\n    const box = this.tmpBox.setFromObject(this.modelRoot(uuid, node));\n    if (box.isEmpty()) return null;\n    const size = box.getSize(new Vector3());\n    const center = box.getCenter(new Vector3());\n    return {\n      min: this.toPoint(box.min),\n      max: this.toPoint(box.max),\n      size: this.toPoint(size),\n      center: this.toPoint(center),\n    };\n  }\n\n  /**\n   * Real dimensions of the model in meters (width x, height y, depth z), scale included but not\n   * its rotation: the world bounding box of a rotated object is larger than the object itself.\n   */\n  getObject3DDimensions(uuid: string): Point3D | null {\n    const node = this.dictionnaryObjects3D.get(uuid);\n    if (!node) return null;\n    const rotation = node.obj3D.rotation.clone();\n    node.obj3D.rotation.set(0, 0, 0);\n    try {\n      node.obj3D.updateWorldMatrix(true, true);\n      const box = this.tmpBox.setFromObject(this.modelRoot(uuid, node));\n      return box.isEmpty() ? null : this.toPoint(box.getSize(new Vector3()));\n    } finally {\n      node.obj3D.rotation.copy(rotation);\n      node.obj3D.updateWorldMatrix(true, true);\n    }\n  }\n\n  /**\n   * Uniform scale so that the largest bounding box dimension equals `targetSizeMeters`.\n   * The node position is untouched, so call placeObject3DOnSurface afterwards.\n   * @returns the new scale, null when the object is unknown / not loaded / `targetSizeMeters` invalid\n   */\n  normalizeObject3DSize(uuid: string, targetSizeMeters: number): Point3D | null {\n    const node = this.dictionnaryObjects3D.get(uuid);\n    const box = this.getObject3DBoundingBox(uuid);\n    if (!node || !box || !(targetSizeMeters > 0)) return null;\n    const largest = Math.max(box.size.x, box.size.y, box.size.z);\n    if (!(largest > 0)) return null;\n    const factor = targetSizeMeters / largest;\n    node.obj3D.scale.multiplyScalar(factor);\n    this.emitTransformChanged(uuid);\n    return this.toPoint(node.obj3D.scale);\n  }\n\n  /**\n   * Places the model on a surface point without touching its pivot: the node position is\n   * adjusted so that the bounding box bottom-center lies on `point`.\n   * - floor (normal pointing up, or no normal): bottom-center on the point\n   * - wall (mostly horizontal normal): model turned around Y so its +Z faces away from the wall,\n   *   and pushed along the normal by half its depth so it does not cut the wall\n   * - ceiling (normal pointing down): the model hangs, top-center on the point\n   * @returns the new transform, null when the object is unknown or not loaded\n   */\n  /**\n   * @param frontYawOffset rotation (radians, around Y) that turns the front of the model toward its +Z\n   *                       axis, for models whose front is another axis (e.g. -PI/2 when it is +X)\n   */\n  placeObject3DOnSurface(uuid: string, point: Point3D, normal?: Point3D, frontYawOffset = 0): Object3DTransform | null {\n    const node = this.dictionnaryObjects3D.get(uuid);\n    if (!node || !this.getObject3DBoundingBox(uuid)) return null;\n    const obj = node.obj3D;\n\n    const n = normal ? new Vector3(normal.x, normal.y, normal.z) : new Vector3(0, 1, 0);\n    if (n.lengthSq() === 0) n.set(0, 1, 0);\n    n.normalize();\n\n    const isWall = Math.abs(n.y) < 0.5;\n    const isCeiling = !isWall && n.y < 0;\n    const target = new Vector3(point.x, point.y, point.z);\n\n    if (isWall) {\n      // Face away from the wall; the box has to be measured after the rotation\n      obj.rotation.y = Math.atan2(n.x, n.z) + frontYawOffset;\n    }\n    const box = this.getObject3DBoundingBox(uuid)!;\n\n    if (isWall) {\n      const horizontal = new Vector3(n.x, 0, n.z).normalize();\n      const halfDepth = 0.5 * (Math.abs(horizontal.x) * box.size.x + Math.abs(horizontal.z) * box.size.z);\n      target.addScaledVector(horizontal, halfDepth);\n    }\n\n    const anchorY = isCeiling ? box.max.y : box.min.y;\n    obj.position.x += target.x - box.center.x;\n    obj.position.y += target.y - anchorY;\n    obj.position.z += target.z - box.center.z;\n\n    this.emitTransformChanged(uuid);\n    return this.getObject3DTransform(uuid);\n  }\n\n  getObject3DTransform(uuid: string): Object3DTransform | null {\n    const node = this.dictionnaryObjects3D.get(uuid);\n    if (!node) return null;\n    const o = node.obj3D;\n    return {\n      position: this.toPoint(o.position),\n      rotation: { x: o.rotation.x, y: o.rotation.y, z: o.rotation.z },\n      scale: this.toPoint(o.scale),\n    };\n  }\n\n  /** Applies a (partial) transform. Rotation is in radians. */\n  setObject3DTransform(uuid: string, transform: Partial<Object3DTransform>): boolean {\n    const node = this.dictionnaryObjects3D.get(uuid);\n    if (!node) return false;\n    const o = node.obj3D;\n    if (transform.position) o.position.set(transform.position.x, transform.position.y, transform.position.z);\n    if (transform.rotation) o.rotation.set(transform.rotation.x, transform.rotation.y, transform.rotation.z);\n    if (transform.scale) o.scale.set(transform.scale.x, transform.scale.y, transform.scale.z);\n    this.emitTransformChanged(uuid);\n    return true;\n  }\n\n  private emitTransformChanged(uuid: string): void {\n    const transform = this.getObject3DTransform(uuid);\n    if (transform) {\n      this.object3DTransformChanged$.next({ uuid, ...transform });\n    }\n  }\n\n  //\n  // ---------- Gizmo ----------\n  //\n  /** Creates the mp.transformControls node of a model and wires it (events, snap) */\n  private createGizmo(uuid: string, modelNode: any, sceneObject: any, mode: GizmoMode, visible: boolean, node?: any): GizmoEntry {\n    const gizmoNode = node ?? sceneObject.addNode();\n    const component = gizmoNode.addComponent('mp.transformControls');\n    gizmoNode.start();\n    const tc = component.transformControls;\n    tc.visible = visible;\n    component.inputs.selection = modelNode;\n    component.inputs.mode = mode;\n    modelNode.obj3D.controls = component;\n\n    const entry: GizmoEntry = {\n      uuid,\n      node: gizmoNode,\n      component,\n      mode,\n      dragStart: null,\n      lastPosition: modelNode.obj3D.position.clone(),\n      onDraggingChanged: (event: any) => {\n        entry.dragStart = event?.value ? modelNode.obj3D.position.clone() : null;\n        entry.lastPosition = modelNode.obj3D.position.clone();\n      },\n      onObjectChange: () => this.onGizmoObjectChange(entry, modelNode),\n    };\n    if (typeof tc.addEventListener === 'function') {\n      tc.addEventListener('dragging-changed', entry.onDraggingChanged);\n      tc.addEventListener('objectChange', entry.onObjectChange);\n    }\n    this.applySnap(tc);\n    this.gizmos.set(uuid, entry);\n    this.activeGizmoUuid = uuid;\n    return entry;\n  }\n\n  /** Keeps a translate drag within maxDragDistance / maxDragHeight of where it started, then notifies */\n  private onGizmoObjectChange(entry: GizmoEntry, modelNode: any): void {\n    const pos: Vector3 = modelNode.obj3D.position;\n    if (entry.mode === 'translate') {\n      const start = entry.dragStart ?? entry.lastPosition;\n      const delta = pos.clone().sub(start);\n      delta.y = MathUtils.clamp(delta.y, -this.maxDragHeight, this.maxDragHeight);\n      const length = delta.length();\n      if (length > this.maxDragDistance) {\n        delta.multiplyScalar(this.maxDragDistance / length);\n      }\n      pos.copy(start).add(delta);\n    }\n    entry.lastPosition = pos.clone();\n    this.emitTransformChanged(entry.uuid);\n  }\n\n  private applySnap(tc: any): void {\n    if (!tc) return;\n    const snap = this.gizmoSnap;\n    const translation = snap?.translation ?? null;\n    const rotation = snap?.rotationDeg != null ? MathUtils.degToRad(snap.rotationDeg) : null;\n    const scale = snap?.scale ?? null;\n    if (typeof tc.setTranslationSnap === 'function') tc.setTranslationSnap(translation); else tc.translationSnap = translation;\n    if (typeof tc.setRotationSnap === 'function') tc.setRotationSnap(rotation); else tc.rotationSnap = rotation;\n    if (typeof tc.setScaleSnap === 'function') tc.setScaleSnap(scale); else tc.scaleSnap = scale;\n  }\n\n  /**\n   * Shows the transform gizmo on an object (any previous gizmo is detached first).\n   * Re-attaching to the object that already has the gizmo only changes its mode.\n   */\n  async attachGizmo(uuid: string, mode: GizmoMode, sdk?: any): Promise<boolean> {\n    const modelNode = this.dictionnaryObjects3D.get(uuid);\n    const sceneObject = this.dictionnarySceneObjects3D.get(uuid);\n    if (!modelNode || !sceneObject) return false;\n\n    const existing = this.gizmos.get(uuid);\n    if (existing && this.activeGizmoUuid === uuid) {\n      this.setGizmoMode(mode);\n      return true;\n    }\n    // A started scene object refuses new nodes (addNode returns null): use a dedicated one\n    let node = sceneObject.addNode();\n    let gizmoSceneObject = null;\n    if (!node) {\n      if (!sdk?.Scene) return false;\n      [gizmoSceneObject] = await sdk.Scene.createObjects(1);\n      node = gizmoSceneObject.addNode();\n    }\n    this.detachGizmo();\n    const entry = this.createGizmo(uuid, modelNode, sceneObject, mode, true, node);\n    entry.sceneObject = gizmoSceneObject;\n    this.lastObject3D = modelNode.obj3D;\n    return true;\n  }\n\n  /** Switches the active gizmo between translate / rotate / scale without re-attaching it */\n  setGizmoMode(mode: GizmoMode): void {\n    const entry = this.activeGizmoUuid ? this.gizmos.get(this.activeGizmoUuid) : null;\n    if (!entry) return;\n    entry.mode = mode;\n    entry.dragStart = null;\n    entry.component.inputs.mode = mode;\n    const tc = entry.component.transformControls;\n    if (tc && typeof tc.setMode === 'function') tc.setMode(mode);\n  }\n\n  /** Really removes the gizmo from the scene (default: the active one) */\n  detachGizmo(uuid?: string): void {\n    const id = uuid ?? this.activeGizmoUuid;\n    if (!id) return;\n    const entry = this.gizmos.get(id);\n    if (!entry) return;\n    const tc = entry.component?.transformControls;\n    if (tc) {\n      if (typeof tc.removeEventListener === 'function') {\n        tc.removeEventListener('dragging-changed', entry.onDraggingChanged);\n        tc.removeEventListener('objectChange', entry.onObjectChange);\n      }\n      tc.visible = false;\n      if (typeof tc.detach === 'function') tc.detach();\n      if (typeof tc.dispose === 'function') tc.dispose();\n      if (tc.parent && typeof tc.parent.remove === 'function') tc.parent.remove(tc);\n    }\n    try { entry.node.stop(); } catch { /* already stopped */ }\n    try { entry.sceneObject?.stop(); } catch { /* already stopped */ }\n    const modelNode = this.dictionnaryObjects3D.get(id);\n    if (modelNode?.obj3D) modelNode.obj3D.controls = null;\n    this.gizmos.delete(id);\n    if (this.activeGizmoUuid === id) this.activeGizmoUuid = null;\n  }\n\n  isGizmoAttached(uuid?: string): boolean {\n    return uuid ? this.gizmos.has(uuid) : this.activeGizmoUuid !== null;\n  }\n\n  /** Snap steps for all gizmos (null / missing value = no snap) */\n  setGizmoSnap(snap: GizmoSnap | null): void {\n    this.gizmoSnap = snap ? { ...snap } : null;\n    this.gizmos.forEach((entry) => this.applySnap(entry.component?.transformControls));\n  }\n\n  setGizmoMaxDragDistance(maxDistance: number, maxHeight?: number): void {\n    if (maxDistance > 0) this.maxDragDistance = maxDistance;\n    if (maxHeight !== undefined && maxHeight > 0) this.maxDragHeight = maxHeight;\n  }\n\n  /**\n   * Prevents camera navigation to other sweeps while a gizmo is edited.\n   * The SDK has no \"freeze camera\" switch, so every enabled sweep except the current one is\n   * disabled (Sweep.disable); exactly those sweeps are re-enabled on unlock. Sweeps already\n   * disabled (forbidden sweeps, edit mode) are never touched, and `keepDisabled` lists sweeps\n   * that must stay disabled on unlock.\n   * @returns false when the lock could not be applied (SDK without Sweep.disable, unknown current sweep)\n   */\n  async setNavigationLocked(\n    sdk: any,\n    locked: boolean,\n    sweepCollection?: Record<string, any> | null,\n    currentSweepId?: string | null,\n    keepDisabled: string[] = []\n  ): Promise<boolean> {\n    if (!sdk?.Sweep || typeof sdk.Sweep.disable !== 'function' || typeof sdk.Sweep.enable !== 'function') {\n      return false;\n    }\n    if (locked) {\n      if (this.sweepsDisabledByLock.length > 0) return true;\n      if (!sweepCollection || !currentSweepId) return false;\n      // a sweep this lock re-enabled just before may still be reported disabled by the SDK\n      const ids = Object.keys(sweepCollection).filter((sid) =>\n        sid !== currentSweepId &&\n        (sweepCollection[sid]?.enabled !== false || this.sweepsEnabledByUnlock.includes(sid)));\n      if (ids.length === 0) return true;\n      try {\n        await sdk.Sweep.disable(...ids);\n        this.sweepsDisabledByLock = ids;\n      } catch {\n        // fall back to one call per sweep to know exactly which ones were disabled\n        const results = await Promise.allSettled(ids.map((sid) => sdk.Sweep.disable(sid)));\n        this.sweepsDisabledByLock = ids.filter((_, i) => results[i].status === 'fulfilled');\n      }\n      return true;\n    }\n    const toEnable = this.sweepsDisabledByLock.filter((sid) => !keepDisabled.includes(sid));\n    this.sweepsDisabledByLock = [];\n    this.sweepsEnabledByUnlock = toEnable;\n    if (toEnable.length > 0) {\n      try {\n        await sdk.Sweep.enable(...toEnable);\n      } catch {\n        await Promise.allSettled(toEnable.map((sid) => sdk.Sweep.enable(sid)));\n      }\n    }\n    return true;\n  }\n\n  isNavigationLocked(): boolean {\n    return this.sweepsDisabledByLock.length > 0;\n  }\n\n  /** Sweeps currently disabled by the navigation lock */\n  getSweepsDisabledByLock(): string[] {\n    return [...this.sweepsDisabledByLock];\n  }\n\n  /**\n   * Legacy API: attaches a gizmo to a model node. Prefer attachGizmo(uuid, mode).\n   */\n  async attachGizmoControlTo3DObject(\n    sdk: any,\n    modelNode: any,\n    sceneObject: any,\n    mode: GizmoMode,\n    visible: boolean,\n    isNewObject: boolean\n  ): Promise<any> {\n    let node = sceneObject.addNode();\n    if (!node) {\n      const [newSceneObject] = await sdk.Scene.createObjects(1);\n      node = newSceneObject.addNode();\n    }\n    if (isNewObject && (!this.lastObject3D || !this.lastObject3D.controls)) {\n      try {\n        modelNode.obj3D.uuid = this.lastObject3D.uuid || this.lastObject3D.id;\n      } catch (e) {\n        // lastObject3D is not set: the model keeps its own uuid\n      }\n    }\n    this.detachGizmo();\n    this.createGizmo(modelNode.obj3D.uuid, modelNode, sceneObject, mode, visible, node);\n    this.lastObject3D = modelNode.obj3D;\n    return modelNode;\n  }\n\n  /** Removes the gizmo of the last added / edited object */\n  removeGizmoFromLastObject(): void {\n    const last = this.lastObject3D;\n    if (!last) return;\n    const uuid = last.uuid ?? last.id;\n    if (uuid && this.gizmos.has(uuid)) {\n      this.detachGizmo(uuid);\n    } else if (last.controls) {\n      // gizmo not created by this service: best effort\n      last.controls.transformControls.visible = false;\n      last.controls.transformControls.dispose();\n      last.controls = null;\n    }\n  }\n\n  //\n  // ---------- Security camera ----------\n  //\n  private applyViewFrustum(uuid: string, visible: boolean): boolean {\n    const animator = this.securityCameraAnimators.get(uuid);\n    if (!animator) return false;\n    const current = this.viewFrustumVisible.get(uuid) ?? true;\n    if (current === visible) return true;\n    try {\n      animator.toggleViewFrustum();\n    } catch {\n      return false;\n    }\n    this.viewFrustumVisible.set(uuid, visible);\n    return true;\n  }\n\n  /** Shows / hides the view frustum of the security camera `uuid` */\n  setViewFrustum(uuid: string, visible: boolean): boolean {\n    return this.applyViewFrustum(uuid, visible);\n  }\n\n  isViewFrustumVisible(uuid: string): boolean {\n    return this.viewFrustumVisible.get(uuid) ?? false;\n  }\n\n  /** Toggles the frustum of `uuid`, or of the last loaded security camera when omitted */\n  toggleViewFrustum(uuid?: string): void {\n    const id = uuid ?? this.lastSecurityCameraUuid;\n    if (id && this.securityCameraAnimators.has(id)) {\n      this.applyViewFrustum(id, !(this.viewFrustumVisible.get(id) ?? true));\n    } else if (!uuid && this.securityCameraAnimator) {\n      // animator set by hand (legacy)\n      this.securityCameraAnimator.toggleViewFrustum();\n    }\n  }\n\n  clear() {\n    Array.from(this.gizmos.keys()).forEach((id) => this.detachGizmo(id));\n    this.dictionnaryObjects3D.clear();\n    this.dictionnarySceneObjects3D.clear();\n    this.loaderComponents.clear();\n    this.securityCameraAnimators.clear();\n    this.viewFrustumVisible.clear();\n    this.lastSecurityCameraUuid = null;\n    this.sweepsDisabledByLock = [];\n    this.lastObject3D = null;\n    this.azimuthalCrown = null;\n    this.securityCameraAnimator = null;\n    this.noLightForObjects = true;\n  }\n}\n"]}