@shapediver/viewer.features.drawing-tools 3.13.20 → 3.14.0

package/dist/business/implementation/managers/interaction/strategies/DesktopStrategy.js

@@ -10,12 +10,71 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _DesktopStrategy_drawingToolsManager, _DesktopStrategy_geometryMathManager, _DesktopStrategy_insertionInteractionHandler, _DesktopStrategy_interactionManager, _DesktopStrategy_interactionManagerHelper, _DesktopStrategy_midPointInteractionHandler, _DesktopStrategy_restrictionManager, _DesktopStrategy_viewport, _DesktopStrategy_cameraFreezeFlag, _DesktopStrategy_lastEvent, _DesktopStrategy_onDownPointer;
+var _DesktopStrategy_instances, _DesktopStrategy_drawingToolsManager, _DesktopStrategy_geometryMathManager, _DesktopStrategy_insertionInteractionHandler, _DesktopStrategy_interactionManager, _DesktopStrategy_interactionManagerHelper, _DesktopStrategy_midPointInteractionHandler, _DesktopStrategy_restrictionManager, _DesktopStrategy_selectionBox, _DesktopStrategy_viewport, _DesktopStrategy_boxHoveredPoints, _DesktopStrategy_cameraFreezeFlag, _DesktopStrategy_isBoxSelecting, _DesktopStrategy_lastEvent, _DesktopStrategy_lastMoveEvent, _DesktopStrategy_onDownPointer, _DesktopStrategy_updateAllPointMaterials;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DesktopStrategy = void 0;
+const viewer_rendering_engine_intersection_engine_1 = require("@shapediver/viewer.rendering-engine.intersection-engine");
 const viewer_shared_types_1 = require("@shapediver/viewer.shared.types");
+const gl_matrix_1 = require("gl-matrix");
+const IDrawingToolsManager_1 = require("../../../../interfaces/IDrawingToolsManager");
+/**
+ * ## Quick Reference - Main Event Flow:
+ *
+ * **Mouse Down** → Initiate interaction (box selection, insertion, point selection)
+ * **Mouse Move** → Update previews, handle dragging, provide feedback
+ * **Mouse Up** → Finalize operations, apply changes, cleanup state
+ * **Mouse Out** → Pause operations, cleanup visual feedback
+ * **Key Down** → Execute commands (insert, confirm, cancel, delete)
+ *
+ * ## Interaction State Priority:
+ * 1. **Box Selection** (Alt + drag) - Highest priority, blocks other interactions
+ * 2. **Active Insertion** - Continuous point placement mode
+ * 3. **Point Dragging** - Moving selected points
+ * 4. **Point Selection** - Single/multi-point selection
+ * 5. **Mid-point Insertion** - Insert between existing points
+ * 6. **Hover Detection** - Visual feedback only
+ *
+ * See DesktopStrategy.md for detailed workflow documentation.
+ */
+/**
+ * DesktopStrategy - Handles desktop mouse and keyboard interactions for drawing tools
+ *
+ * This class implements the Strategy pattern to provide desktop-specific interaction handling
+ * for drawing tools. It manages various interaction modes including point insertion, selection,
+ * dragging, and box selection.
+ *
+ * ## Main Interaction Workflows:
+ *
+ * ### 1. Point Insertion Workflow:
+ * - User clicks to start insertion mode
+ * - Mouse movements update the insertion preview
+ * - Click again to finalize point placement
+ * - Supports auto-start for empty drawings
+ *
+ * ### 2. Point Selection & Dragging Workflow:
+ * - Click on existing points to select them
+ * - Drag selected points to move them
+ * - Multiple selection support with modifier keys
+ *
+ * ### 3. Box Selection Workflow:
+ * - Alt + drag to create selection box
+ * - Shift = additive selection, Ctrl = removal selection
+ * - All points within box are selected/deselected
+ *
+ * ### 4. Mid-point Insertion Workflow:
+ * - Hover over line segments to show mid-point preview
+ * - Click to insert point between existing points
+ *
+ * ## Key Features:
+ * - Camera freeze during interactions
+ * - Visual feedback through cursor changes
+ * - Material updates for hover/selection states
+ * - Keyboard shortcuts for common operations
+ * - Restriction-based point placement
+ */
 class DesktopStrategy {
     constructor(drawingToolsManager, interactionManager) {
+        _DesktopStrategy_instances.add(this);
         _DesktopStrategy_drawingToolsManager.set(this, void 0);
         _DesktopStrategy_geometryMathManager.set(this, void 0);
         _DesktopStrategy_insertionInteractionHandler.set(this, void 0);
@@ -23,9 +82,13 @@ class DesktopStrategy {
         _DesktopStrategy_interactionManagerHelper.set(this, void 0);
         _DesktopStrategy_midPointInteractionHandler.set(this, void 0);
         _DesktopStrategy_restrictionManager.set(this, void 0);
+        _DesktopStrategy_selectionBox.set(this, void 0);
         _DesktopStrategy_viewport.set(this, void 0);
+        _DesktopStrategy_boxHoveredPoints.set(this, []);
         _DesktopStrategy_cameraFreezeFlag.set(this, "");
+        _DesktopStrategy_isBoxSelecting.set(this, false);
         _DesktopStrategy_lastEvent.set(this, void 0);
+        _DesktopStrategy_lastMoveEvent.set(this, void 0);
         _DesktopStrategy_onDownPointer.set(this, void 0);
         __classPrivateFieldSet(this, _DesktopStrategy_drawingToolsManager, drawingToolsManager, "f");
         __classPrivateFieldSet(this, _DesktopStrategy_interactionManager, interactionManager, "f");
@@ -35,142 +98,202 @@ class DesktopStrategy {
         __classPrivateFieldSet(this, _DesktopStrategy_insertionInteractionHandler, __classPrivateFieldGet(this, _DesktopStrategy_interactionManager, "f").insertionInteractionHandler, "f");
         __classPrivateFieldSet(this, _DesktopStrategy_midPointInteractionHandler, __classPrivateFieldGet(this, _DesktopStrategy_interactionManager, "f").midPointInteractionHandler, "f");
         __classPrivateFieldSet(this, _DesktopStrategy_interactionManagerHelper, __classPrivateFieldGet(this, _DesktopStrategy_interactionManager, "f").interactionManagerHelper, "f");
+        __classPrivateFieldSet(this, _DesktopStrategy_selectionBox, new viewer_rendering_engine_intersection_engine_1.SelectionBox(__classPrivateFieldGet(this, _DesktopStrategy_viewport, "f").canvas), "f");
     }
     get cameraFreezeFlag() {
         return __classPrivateFieldGet(this, _DesktopStrategy_cameraFreezeFlag, "f");
     }
+    /**
+     * Handles mouse/pointer down events - Entry point for most interaction workflows
+     *
+     * ## Workflow Priority:
+     * 1. **Box Selection** (Alt + Click): Initiates rectangular selection mode
+     * 2. **Insertion Finalization**: If insertion is active, finalizes current point and starts new insertion
+     * 3. **Point Interaction**: Handles hover detection, selection, and dragging initiation
+     * 4. **Right Click**: Cancels current operation
+     *
+     * ## State Changes:
+     * - Sets camera freeze flag for dragging/box selection
+     * - Updates selection state
+     * - Triggers mid-point insertion completion
+     * - Starts dragging mode for selected points
+     *
+     * @param event - Pointer event containing mouse button and modifier key information
+     * @param ray - 3D ray from camera through mouse position for intersection testing
+     */
     onDown(event, ray) {
         if (event.button === 0) {
             __classPrivateFieldSet(this, _DesktopStrategy_onDownPointer, event, "f");
             __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").moving = false;
-            /**
-             * IF INSERT KEY IS PRESSED
-             * FINALIZE INSERTION AND START A NEW ONE
-             */
-            if (__classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").insertionActive === true) {
-                const result = __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").finalizeInsertion();
-                const distances = __classPrivateFieldGet(this, _DesktopStrategy_geometryMathManager, "f").checkPointDistances(ray, __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray);
-                __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").checkHover(distances, ray);
-                if (result) {
-                    __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").update();
-                    return;
-                }
-                else {
-                    __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").startInsertion(event);
-                    return;
-                }
+            // Handle box selection initiation
+            if (this.handleBoxSelectionStart(event)) {
+                return;
             }
-            const distances = __classPrivateFieldGet(this, _DesktopStrategy_geometryMathManager, "f").checkPointDistances(ray, __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray);
-            /**
-             * IF MID POINT INSERTION IS ACTIVE
-             * FINISH MID POINT INSERTION IF THE CURRENT INDEX IS THE MID POINT INSERTION INDEX
-             */
-            if (__classPrivateFieldGet(this, _DesktopStrategy_midPointInteractionHandler, "f").midPointInsertionActive ===
-                true) {
-                __classPrivateFieldGet(this, _DesktopStrategy_midPointInteractionHandler, "f").finishMidPointInsertion(distances);
-                __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").midPointInserted = true;
+            // Handle insertion finalization and restart
+            if (this.handleInsertionFinalization(event, ray)) {
+                return;
             }
-            /**
-             * CHECK HOVERED POINT
-             */
+            // Calculate point distances for hover and selection logic
+            const distances = __classPrivateFieldGet(this, _DesktopStrategy_geometryMathManager, "f").checkPointDistances(ray, __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray);
+            // Handle mid-point insertion
+            this.handleMidPointInsertion(distances);
+            // Check hover state
             __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").checkHover(distances, ray);
-            /**
-             * IF THERE IS A POINT CLOSE TO THE RAY
-             */
-            __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").selectPoint(distances);
-            /**
-             * IF THE CURRENTLY HOVERED POINT IS SELECTED
-             * START DRAGGING
-             */
-            const draggingStarted = __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").startDragging();
-            if (draggingStarted && !__classPrivateFieldGet(this, _DesktopStrategy_cameraFreezeFlag, "f"))
-                __classPrivateFieldSet(this, _DesktopStrategy_cameraFreezeFlag, __classPrivateFieldGet(this, _DesktopStrategy_viewport, "f").addFlag(viewer_shared_types_1.FLAG_TYPE.CAMERA_FREEZE), "f");
+            // Handle point selection and dragging
+            this.handlePointSelection(distances);
         }
         else if (event.button === 2) {
-            /**
-             * WHEN RIGHT MOUSE BUTTON IS PRESSED
-             */
+            // Right mouse button - cancel current operation
             this.onOut();
         }
     }
     /**
-     * On mouse move, move the selected point if there is one
+     * Handles keyboard input for drawing tool controls
      *
-     * @param event
-     * @param ray
+     * ## Supported Operations:
+     *
+     * ### Confirm Key (typically Enter):
+     * - **During Insertion**: Finalizes insertion and updates drawing
+     * - **Normal Mode**: Updates/commits current drawing state
+     *
+     * ### Cancel Key (typically Escape):
+     * - **During Insertion**: Stops insertion mode
+     * - **Normal Mode**: Cancels entire drawing operation
+     *
+     * ### Insert Key (typically Space):
+     * - Starts insertion mode at current mouse position
+     * - Shows restriction visualization
+     *
+     * ### Delete Key (typically Delete/Backspace):
+     * - Removes currently selected points from drawing
+     *
+     * ## Workflow Integration:
+     * These keyboard shortcuts provide alternative ways to control the drawing workflow
+     * without relying solely on mouse interactions.
      */
-    onMove(event, ray) {
-        let currentRestrictedPoint;
-        // if there are no points, start with the insertion right away
-        if (__classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").settings.general.autoStart &&
-            __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").insertionActive === false &&
-            __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").getPointsData().length === 0) {
-            __classPrivateFieldSet(this, _DesktopStrategy_lastEvent, event, "f");
-            currentRestrictedPoint =
-                this.startInsertion() || currentRestrictedPoint;
+    onKeyDown() {
+        const keys = this.getKeyStates();
+        // Handle confirm key
+        if (keys.confirm) {
+            if (__classPrivateFieldGet(this, _DesktopStrategy_interactionManager, "f").insertionInteractionHandler
+                .insertionActive) {
+                this.stopInsertion();
+                __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").update();
+            }
+            else {
+                __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").update();
+            }
         }
-        // if the insertion was paused, try to start it again
-        // it might not start if the ray is not intersecting with the restriction
-        if (__classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").insertionPaused) {
-            __classPrivateFieldSet(this, _DesktopStrategy_lastEvent, event, "f");
-            currentRestrictedPoint =
-                this.startInsertion() || currentRestrictedPoint;
+        // Handle cancel key
+        if (keys.cancel) {
+            if (__classPrivateFieldGet(this, _DesktopStrategy_interactionManager, "f").insertionInteractionHandler
+                .insertionActive) {
+                this.stopInsertion();
+            }
+            else {
+                __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").cancel();
+            }
         }
-        const distanceSquared = __classPrivateFieldGet(this, _DesktopStrategy_onDownPointer, "f")
-            ? Math.pow(event.clientX - __classPrivateFieldGet(this, _DesktopStrategy_onDownPointer, "f").clientX, 2) +
-                Math.pow(event.clientY - __classPrivateFieldGet(this, _DesktopStrategy_onDownPointer, "f").clientY, 2)
-            : Infinity;
-        const clickThresholdSquared = 25;
-        const pointerMoved = distanceSquared > clickThresholdSquared;
+        // Handle insert key
+        if (keys.insert) {
+            this.startInsertion();
+        }
+        // Handle delete key
+        if (keys.delete) {
+            __classPrivateFieldGet(this, _DesktopStrategy_interactionManager, "f").deleteSelection();
+        }
+    }
+    /**
+     * Handles mouse/pointer movement - Core interaction processing for all movement-based workflows
+     *
+     * ## Primary Workflows:
+     *
+     * ### 1. Box Selection Mode (when #isBoxSelecting = true):
+     * - Updates selection rectangle bounds
+     * - Provides real-time hover feedback for points within selection
+     * - Respects modifier keys (Shift=add, Ctrl=remove)
+     *
+     * ### 2. Insertion Workflows:
+     * - **Auto-start**: Automatically begins insertion for empty drawings
+     * - **Resume**: Restarts paused insertions when mouse re-enters valid area
+     * - **Active insertion**: Updates insertion preview position
+     * - **Pause**: Pauses insertion when mouse leaves restricted area
+     *
+     * ### 3. Point Manipulation:
+     * - **Dragging**: Moves selected points when dragging is active
+     * - **Hover detection**: Updates hover state for visual feedback
+     * - **Mid-point insertion**: Shows preview for inserting points between existing ones
+     *
+     * ### 4. Visual Feedback:
+     * - **Cursor updates**: Changes cursor based on interaction state (grab, pointer, default)
+     * - **Material updates**: Updates point colors for hover/selection states
+     * - **Text visualization**: Updates position indicator text
+     *
+     * ## Movement Detection:
+     * Uses CLICK_THRESHOLD_SQUARED to distinguish between clicks and drags,
+     * preventing accidental dragging on small mouse movements.
+     *
+     * @param event - Pointer event with current mouse position and modifier keys
+     * @param ray - 3D ray for intersection testing and point placement
+     */
+    onMove(event, ray) {
+        // Track the last move event for modifier key states
+        __classPrivateFieldSet(this, _DesktopStrategy_lastMoveEvent, event, "f");
+        // Handle box selection movement
+        if (__classPrivateFieldGet(this, _DesktopStrategy_isBoxSelecting, "f")) {
+            // Pass the current shift/ctrl state to determine selection behavior
+            const isAdditive = event.shiftKey;
+            const isRemoval = event.ctrlKey;
+            __classPrivateFieldGet(this, _DesktopStrategy_selectionBox, "f").onMove(event, isAdditive, isRemoval);
+            // Update hover effects for points inside the selection box
+            this.updateBoxSelectionHover();
+            return;
+        }
+        let currentRestrictedPoint;
+        // Handle automatic start and insertion resume
+        currentRestrictedPoint =
+            this.handleAutoStart(event) || currentRestrictedPoint;
+        currentRestrictedPoint =
+            this.handleInsertionResume(event) || currentRestrictedPoint;
+        const pointerMoved = this.hasPointerMoved(event);
         __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").moving = pointerMoved;
         if (pointerMoved) {
             __classPrivateFieldSet(this, _DesktopStrategy_lastEvent, event, "f");
-            /**
-             * IF WE ARE DRAGGING A POINT
-             * MOVE THE SELECTED POINTS
-             */
+            // Handle point dragging
             currentRestrictedPoint =
                 __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").moveSelectedPoints(ray) ||
                     currentRestrictedPoint;
         }
+        // Check point distances and hover state
         const distances = __classPrivateFieldGet(this, _DesktopStrategy_geometryMathManager, "f").checkPointDistances(ray, __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray);
         __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").checkHover(distances, ray);
         if (pointerMoved) {
-            /**
-             * IF INSERT KEY IS PRESSED
-             * ADD POINT AT RAY INTERSECTION IF THERE IS NONE WAS ADDED
-             * MOVE LAST ADDED POINT IF THERE IS ONE
-             */
+            // Handle insertion movement
             currentRestrictedPoint =
-                __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").onMove(ray) ||
-                    currentRestrictedPoint;
-            /**
-             * IF INSERT KEY IS NOT PRESSED AND DRAGGING IS NOT ACTIVE
-             * CHECK IF THERE IS A LINE CLOSE TO THE RAY AND ADD A MID POINT TO IT
-             */
-            if (__classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").insertionActive === false &&
-                __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").dragging === false &&
-                __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").selectedPointIndices.length === 0) {
-                __classPrivateFieldGet(this, _DesktopStrategy_midPointInteractionHandler, "f").onMove(ray, __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").hoveredPoint);
-            }
-        }
-        if (__classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").dragging) {
-            document.body.style.cursor = "grabbing";
-        }
-        else if (__classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").hoveredPoint !== undefined) {
-            document.body.style.cursor = "pointer";
-        }
-        else {
-            document.body.style.cursor = "default";
+                this.handleInsertionMove(ray) || currentRestrictedPoint;
+            // Handle mid-point insertion
+            this.handleMidPointMove(ray);
         }
-        // if the insertion is active, but the current point is not restricted, pause the insertion
-        if (!currentRestrictedPoint &&
-            __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").insertionActive)
-            __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").pauseInsertion();
+        // Update cursor and handle insertion pause
+        this.updateCursor();
+        this.handleInsertionPause(currentRestrictedPoint);
         __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").textVisualizationManager.updatePointerPosition(currentRestrictedPoint);
     }
     /**
-     * On mouse out, deselect the hovered point and remove the stop dragging
+     * Handles mouse leave/out events - Cleanup and state reset
+     *
+     * ## Cleanup Operations:
+     * - **Restriction visualization**: Hides visual guides for point placement restrictions
+     * - **Insertion pause**: Temporarily stops insertion mode (can be resumed on mouse re-enter)
+     * - **Hover state**: Clears any hovered point indicators
+     * - **General reset**: Calls reset() to clean up interaction state
+     *
+     * ## Use Cases:
+     * - Mouse leaves the drawing area/viewport
+     * - Right-click cancellation
+     * - Focus loss events
+     *
+     * This ensures the UI returns to a clean state when interaction is interrupted.
      */
     onOut() {
         __classPrivateFieldGet(this, _DesktopStrategy_restrictionManager, "f").showRestrictionVisualization = false;
@@ -178,11 +301,304 @@ class DesktopStrategy {
         __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").onOut();
         this.reset();
     }
-    onUp() {
+    /**
+     * Handles mouse/pointer up events - Finalization of click/drag operations
+     *
+     * ## Primary Operations:
+     *
+     * ### Box Selection Completion:
+     * When box selection is active (#isBoxSelecting = true):
+     * 1. **Finalize selection**: Ends the selection rectangle operation
+     * 2. **Process intersections**: Determines which points are within the selection box
+     * 3. **Apply selection logic**: Handles modifier keys for add/remove/toggle selection
+     * 4. **Visual cleanup**: Updates material indices and resets hover states
+     * 5. **State reset**: Clears box selection flags and data
+     *
+     * ### General Cleanup:
+     * For all other operations:
+     * - **End dragging**: Stops any active point dragging operations
+     * - **Camera unfreeze**: Removes camera movement restrictions
+     * - **State reset**: Returns to default interaction state
+     *
+     * ## Workflow Integration:
+     * This method completes the interaction cycle started by onDown(),
+     * ensuring proper cleanup and state transitions for all operation types.
+     *
+     * @param event - Pointer event with final mouse position and modifier key states
+     */
+    onUp(event) {
+        // Handle box selection completion
+        if (__classPrivateFieldGet(this, _DesktopStrategy_isBoxSelecting, "f")) {
+            __classPrivateFieldGet(this, _DesktopStrategy_selectionBox, "f").onEnd(event);
+            this.handleBoxSelection(event);
+            // Clear box hovered points, last move event, and update material indices for all points
+            __classPrivateFieldSet(this, _DesktopStrategy_boxHoveredPoints, [], "f");
+            __classPrivateFieldGet(this, _DesktopStrategy_instances, "m", _DesktopStrategy_updateAllPointMaterials).call(this);
+            __classPrivateFieldSet(this, _DesktopStrategy_lastMoveEvent, undefined, "f");
+            __classPrivateFieldSet(this, _DesktopStrategy_isBoxSelecting, false, "f");
+            __classPrivateFieldGet(this, _DesktopStrategy_selectionBox, "f").reset();
+        }
         __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").onUp();
         this.reset();
     }
+    /**
+     * Convert position array to array of vec3 points
+     */
+    convertPositionArrayToPoints() {
+        if (!__classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray ||
+            __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray.length === 0) {
+            return [];
+        }
+        const points = [];
+        for (let i = 0; i < __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray.length; i += DesktopStrategy.COORDINATE_STEP) {
+            points.push(gl_matrix_1.vec3.fromValues(__classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray[i], __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray[i + 1], __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray[i + 2]));
+        }
+        return points;
+    }
+    /**
+     * Get the current state of control keys
+     */
+    getKeyStates() {
+        return {
+            insert: __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").keyPressed(__classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").settings.controls.insert),
+            cancel: __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").keyPressed(__classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").settings.controls.cancel),
+            confirm: __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").keyPressed(__classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").settings.controls.confirm),
+            delete: __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").keyPressed(__classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").settings.controls.delete),
+        };
+    }
+    /**
+     * Enables automatic insertion start for empty drawings to improve user experience
+     *
+     * ## Auto-start Conditions:
+     * 1. **Setting enabled**: `autoStart` setting must be enabled
+     * 2. **No active insertion**: Insertion mode is not currently active
+     * 3. **Empty drawing**: No points exist in the current drawing
+     *
+     * ## Workflow Benefits:
+     * - Eliminates need to press insert key for first point
+     * - Creates smoother initial user experience
+     * - Reduces friction for starting new drawings
+     *
+     * @param event - Pointer event to cache for insertion start
+     * @returns Restricted point position if insertion started, undefined otherwise
+     */
+    handleAutoStart(event) {
+        if (__classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").settings.general.autoStart &&
+            __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").insertionActive === false &&
+            __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").getPointsData().length === 0) {
+            __classPrivateFieldSet(this, _DesktopStrategy_lastEvent, event, "f");
+            return this.startInsertion();
+        }
+        return undefined;
+    }
+    /**
+     * Processes box selection completion and applies selection logic based on modifier keys
+     *
+     * ## Selection Logic Workflow:
+     * 1. **Point conversion**: Converts position array to 3D points for intersection testing
+     * 2. **Intersection calculation**: Determines which points are within the selection box
+     * 3. **Modifier key handling**:
+     *    - **Shift**: Additive selection (adds points to existing selection)
+     *    - **Ctrl**: Removal selection (removes points from existing selection)
+     *    - **None**: Toggle selection (default behavior - toggles each point's selection state)
+     *
+     * ## Integration with Selection System:
+     * - Uses InteractionManagerHelper methods for consistent selection behavior
+     * - Maintains selection state across different interaction modes
+     * - Respects existing selection when using modifier keys
+     *
+     * @param event - Optional pointer event for modifier key state (fallback to last move event)
+     */
+    handleBoxSelection(event) {
+        const points = this.convertPositionArrayToPoints();
+        if (points.length === 0) {
+            return;
+        }
+        // Get intersected point indices
+        const intersectedIndices = __classPrivateFieldGet(this, _DesktopStrategy_selectionBox, "f").intersectPoints(points);
+        // Use the last move event for modifier key state, fallback to provided event
+        const currentEvent = __classPrivateFieldGet(this, _DesktopStrategy_lastMoveEvent, "f") || event;
+        // Handle selection based on modifier keys from the last move event
+        if (currentEvent === null || currentEvent === void 0 ? void 0 : currentEvent.shiftKey) {
+            // Shift key: add to selection
+            intersectedIndices.forEach((index) => {
+                __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").selectPoint([
+                    { index, distance: 0 },
+                ]);
+            });
+        }
+        else if (currentEvent === null || currentEvent === void 0 ? void 0 : currentEvent.ctrlKey) {
+            // Ctrl key: remove from selection
+            intersectedIndices.forEach((index) => {
+                __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").deselectPoint(index);
+            });
+        }
+        else {
+            // No modifier key: replace selection (default behavior)
+            intersectedIndices.forEach((index) => {
+                __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").toggleSelection(index);
+            });
+        }
+    }
+    /**
+     * Initiates box selection mode when Alt key is pressed during mouse down
+     *
+     * ## Workflow:
+     * 1. **Validation**: Checks if Alt key is pressed
+     * 2. **State setup**: Sets box selection flag and initializes selection box
+     * 3. **Camera control**: Freezes camera to prevent viewport movement during selection
+     * 4. **Event binding**: Connects selection box to camera projection for accurate 3D selection
+     *
+     * ## Visual Feedback:
+     * - Selection rectangle appears on screen
+     * - Camera movement is disabled
+     * - Cursor indicates selection mode
+     *
+     * @param event - Pointer event to check for Alt key modifier
+     * @returns true if box selection was initiated, false otherwise
+     */
+    handleBoxSelectionStart(event) {
+        if (!event.altKey)
+            return false;
+        __classPrivateFieldSet(this, _DesktopStrategy_isBoxSelecting, true, "f");
+        if (__classPrivateFieldGet(this, _DesktopStrategy_viewport, "f").camera) {
+            __classPrivateFieldGet(this, _DesktopStrategy_selectionBox, "f").onDown(event, __classPrivateFieldGet(this, _DesktopStrategy_viewport, "f").camera.project.bind(__classPrivateFieldGet(this, _DesktopStrategy_viewport, "f").camera));
+        }
+        if (!__classPrivateFieldGet(this, _DesktopStrategy_cameraFreezeFlag, "f")) {
+            __classPrivateFieldSet(this, _DesktopStrategy_cameraFreezeFlag, __classPrivateFieldGet(this, _DesktopStrategy_viewport, "f").addFlag(viewer_shared_types_1.FLAG_TYPE.CAMERA_FREEZE), "f");
+        }
+        return true;
+    }
+    /**
+     * Manages the insertion workflow when insertion mode is already active
+     *
+     * ## Insertion Finalization Workflow:
+     * 1. **Completion attempt**: Tries to finalize the current insertion point
+     * 2. **Success path**: If successful, updates the drawing and exits
+     * 3. **Continuation path**: If not finalized, starts a new insertion at click location
+     * 4. **Hover management**: Updates hover state after point distance calculations
+     *
+     * ## Use Cases:
+     * - User clicks while in insertion mode to place a point
+     * - Handles both successful point placement and insertion continuation
+     * - Maintains smooth insertion workflow for multiple point placement
+     *
+     * @param event - Pointer event for the new insertion location
+     * @param ray - 3D ray for intersection testing and point placement
+     * @returns true if insertion was processed, false if insertion mode is not active
+     */
+    handleInsertionFinalization(event, ray) {
+        if (!__classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").insertionActive)
+            return false;
+        const result = __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").finalizeInsertion();
+        const distances = __classPrivateFieldGet(this, _DesktopStrategy_geometryMathManager, "f").checkPointDistances(ray, __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray);
+        __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").checkHover(distances, ray);
+        if (result) {
+            __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").update();
+            return true;
+        }
+        else {
+            __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").startInsertion(event);
+            return true;
+        }
+    }
+    /**
+     * Handle mouse move during insertion mode
+     */
+    handleInsertionMove(ray) {
+        return __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").onMove(ray);
+    }
+    /**
+     * Handle insertion pause when point is not restricted
+     */
+    handleInsertionPause(currentRestrictedPoint) {
+        if (!currentRestrictedPoint &&
+            __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").insertionActive) {
+            __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").pauseInsertion();
+        }
+    }
+    /**
+     * Handle resuming paused insertion
+     */
+    handleInsertionResume(event) {
+        if (__classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").insertionPaused) {
+            __classPrivateFieldSet(this, _DesktopStrategy_lastEvent, event, "f");
+            return this.startInsertion();
+        }
+        return undefined;
+    }
+    /**
+     * Handle mid-point insertion completion
+     */
+    handleMidPointInsertion(distances) {
+        if (__classPrivateFieldGet(this, _DesktopStrategy_midPointInteractionHandler, "f").midPointInsertionActive &&
+            distances) {
+            __classPrivateFieldGet(this, _DesktopStrategy_midPointInteractionHandler, "f").finishMidPointInsertion(distances);
+            __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").midPointInserted = true;
+        }
+    }
+    /**
+     * Handle mid-point insertion logic during movement
+     */
+    handleMidPointMove(ray) {
+        if (__classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").insertionActive === false &&
+            __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").dragging === false &&
+            __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").selectedPointIndices.length === 0) {
+            __classPrivateFieldGet(this, _DesktopStrategy_midPointInteractionHandler, "f").onMove(ray, __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").hoveredPoint);
+        }
+    }
+    /**
+     * Handle point selection and dragging initiation
+     */
+    handlePointSelection(distances) {
+        if (!distances)
+            return;
+        __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").selectPoint(distances);
+        const draggingStarted = __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").startDragging();
+        if (draggingStarted && !__classPrivateFieldGet(this, _DesktopStrategy_cameraFreezeFlag, "f")) {
+            __classPrivateFieldSet(this, _DesktopStrategy_cameraFreezeFlag, __classPrivateFieldGet(this, _DesktopStrategy_viewport, "f").addFlag(viewer_shared_types_1.FLAG_TYPE.CAMERA_FREEZE), "f");
+        }
+    }
+    /**
+     * Check if pointer has moved beyond the click threshold
+     */
+    hasPointerMoved(event) {
+        const distanceSquared = __classPrivateFieldGet(this, _DesktopStrategy_onDownPointer, "f")
+            ? Math.pow(event.clientX - __classPrivateFieldGet(this, _DesktopStrategy_onDownPointer, "f").clientX, 2) +
+                Math.pow(event.clientY - __classPrivateFieldGet(this, _DesktopStrategy_onDownPointer, "f").clientY, 2)
+            : Infinity;
+        return distanceSquared > DesktopStrategy.CLICK_THRESHOLD_SQUARED;
+    }
+    /**
+     * Comprehensive state reset for interaction cleanup
+     *
+     * ## Reset Workflow:
+     * ```
+     * Box Selection Reset → Insertion State Check → Camera Unfreeze → Helper Reset
+     *         ↓                      ↓                    ↓               ↓
+     *   Clear box flags      Check if insertion    Remove freeze     Reset selection
+     *   Reset hover states   is still active       flag if safe      and drag states
+     *   Clear tracking       Keep freeze if        Restore camera    Clean temp data
+     *   ```
+     *
+     * ## Safety Measures:
+     * - Only unfreezes camera if insertion is not active
+     * - Properly cleans up visual states for all tracked points
+     * - Ensures no orphaned state remains after interactions
+     */
     reset() {
+        // Reset box selection if active
+        if (__classPrivateFieldGet(this, _DesktopStrategy_isBoxSelecting, "f")) {
+            __classPrivateFieldSet(this, _DesktopStrategy_isBoxSelecting, false, "f");
+            __classPrivateFieldGet(this, _DesktopStrategy_selectionBox, "f").reset();
+            __classPrivateFieldSet(this, _DesktopStrategy_lastMoveEvent, undefined, "f");
+            // Clear hover effects from box hovered points
+            __classPrivateFieldGet(this, _DesktopStrategy_boxHoveredPoints, "f").forEach((index) => {
+                const isSelected = __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").selectedPointIndices.includes(index);
+                this.updatePointMaterial(index, isSelected, false);
+            });
+            __classPrivateFieldSet(this, _DesktopStrategy_boxHoveredPoints, [], "f");
+        }
         if (__classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").insertionActive === false) {
             __classPrivateFieldGet(this, _DesktopStrategy_restrictionManager, "f").showRestrictionVisualization = false;
             __classPrivateFieldGet(this, _DesktopStrategy_viewport, "f").removeFlag(__classPrivateFieldGet(this, _DesktopStrategy_cameraFreezeFlag, "f"));
@@ -190,67 +606,135 @@ class DesktopStrategy {
         }
         __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").reset();
     }
+    /**
+     * Initiates insertion mode with proper state setup
+     *
+     * ## Insertion Start Workflow:
+     * ```
+     * Enable Restrictions → Stop Mid-point → Start Insertion → Return Position
+     *         ↓                    ↓               ↓               ↓
+     *   Show visual       Clear any existing   Begin insertion    Validate and
+     *   guides for        mid-point preview    at cached event    return position
+     *   valid placement   operations           location           or undefined
+     * ```
+     *
+     * @returns Restricted point position if insertion started successfully, undefined if restricted
+     */
     startInsertion() {
         __classPrivateFieldGet(this, _DesktopStrategy_restrictionManager, "f").showRestrictionVisualization = true;
         __classPrivateFieldGet(this, _DesktopStrategy_midPointInteractionHandler, "f").stopMidPointInsertion();
         return __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").startInsertion(__classPrivateFieldGet(this, _DesktopStrategy_lastEvent, "f"));
     }
+    /**
+     * Cleanly exits insertion mode with proper cleanup
+     *
+     * ## Insertion Stop Workflow:
+     * ```
+     * Hide Restrictions → Stop Insertion → Unfreeze Camera → Clear Flags
+     *         ↓                 ↓               ↓               ↓
+     *   Remove visual     End insertion     Restore camera    Reset freeze
+     *   guides and        handler state     movement         flag state
+     *   feedback                            capability
+     * ```
+     */
     stopInsertion() {
         __classPrivateFieldGet(this, _DesktopStrategy_restrictionManager, "f").showRestrictionVisualization = false;
         __classPrivateFieldGet(this, _DesktopStrategy_insertionInteractionHandler, "f").stopInsertion();
         __classPrivateFieldGet(this, _DesktopStrategy_viewport, "f").removeFlag(__classPrivateFieldGet(this, _DesktopStrategy_cameraFreezeFlag, "f"));
         __classPrivateFieldSet(this, _DesktopStrategy_cameraFreezeFlag, "", "f");
     }
-    onKeyDown() {
-        const insertKeyPressed = __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").keyPressed(__classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").settings.controls.insert);
-        const cancelKeyPressed = __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").keyPressed(__classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").settings.controls.cancel);
-        const confirmKeyPressed = __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").keyPressed(__classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").settings.controls.confirm);
-        const deleteKeyPressed = __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").keyPressed(__classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").settings.controls.delete);
-        /**
-         * IF CONFIRM KEY IS PRESSED
-         * - IF INSERTION IS ACTIVE, STOP INSERTION
-         * - IF INSERTION IS NOT ACTIVE, UPDATE DRAWING TOOL
-         */
-        if (confirmKeyPressed) {
-            if (__classPrivateFieldGet(this, _DesktopStrategy_interactionManager, "f").insertionInteractionHandler
-                .insertionActive) {
-                this.stopInsertion();
-                __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").update();
-            }
-            else {
-                __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").update();
-            }
+    /**
+     * Provides real-time visual feedback during box selection by updating hover states
+     *
+     * ## Dynamic Hover Management:
+     * 1. **Current intersection**: Calculates which points are currently in the selection box
+     * 2. **Hover removal**: Points that left the box lose their hover effect
+     * 3. **Hover addition**: Points that entered the box gain hover effect
+     * 4. **State preservation**: Maintains existing selection states while adding hover effects
+     *
+     * ## Visual Feedback:
+     * - Points inside selection box show hover material (different color/highlight)
+     * - Selected + hovered points show combined visual state
+     * - Provides immediate feedback during box drag operation
+     *
+     * ## Performance Optimization:
+     * - Only updates materials for points that changed state
+     * - Tracks previous hover state to minimize unnecessary updates
+     */
+    updateBoxSelectionHover() {
+        const points = this.convertPositionArrayToPoints();
+        if (points.length === 0) {
+            return;
         }
-        /**
-         * IF CANCEL KEY IS PRESSED
-         * - IF INSERTION IS ACTIVE, STOP INSERTION
-         * - IF INSERTION IS NOT ACTIVE, CANCEL DRAWING TOOL
-         */
-        if (cancelKeyPressed) {
-            if (__classPrivateFieldGet(this, _DesktopStrategy_interactionManager, "f").insertionInteractionHandler
-                .insertionActive) {
-                this.stopInsertion();
-            }
-            else {
-                __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").cancel();
-            }
+        // Get current intersected point indices
+        const currentBoxIntersectedIndices = __classPrivateFieldGet(this, _DesktopStrategy_selectionBox, "f").intersectPoints(points);
+        // Find points that were previously hovered but are no longer in the box
+        const pointsToUnhover = __classPrivateFieldGet(this, _DesktopStrategy_boxHoveredPoints, "f").filter((index) => !currentBoxIntersectedIndices.includes(index));
+        // Find points that are newly in the box
+        const pointsToHover = currentBoxIntersectedIndices.filter((index) => !__classPrivateFieldGet(this, _DesktopStrategy_boxHoveredPoints, "f").includes(index));
+        // Remove hover effect from points no longer in the box
+        pointsToUnhover.forEach((index) => {
+            const isSelected = __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").selectedPointIndices.includes(index);
+            this.updatePointMaterial(index, isSelected, false);
+        });
+        // Add hover effect to points newly in the box
+        pointsToHover.forEach((index) => {
+            const isSelected = __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").selectedPointIndices.includes(index);
+            this.updatePointMaterial(index, isSelected, true);
+        });
+        // Update the tracked hovered points
+        __classPrivateFieldSet(this, _DesktopStrategy_boxHoveredPoints, currentBoxIntersectedIndices, "f");
+    }
+    /**
+     * Update cursor based on current interaction state
+     */
+    updateCursor() {
+        if (__classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").dragging) {
+            document.body.style.cursor = "grabbing";
         }
-        /**
-         * IF INSERT KEY IS PRESSED
-         * - START INSERTION
-         */
-        if (insertKeyPressed) {
-            this.startInsertion();
+        else if (__classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").hoveredPoint !== undefined) {
+            document.body.style.cursor = "pointer";
         }
-        /**
-         * IF DELETE KEY IS PRESSED
-         * - DELETE SELECTION
-         */
-        if (deleteKeyPressed) {
-            __classPrivateFieldGet(this, _DesktopStrategy_interactionManager, "f").deleteSelection();
+        else {
+            document.body.style.cursor = "default";
         }
     }
+    /**
+     * Update material index for a single point based on its state
+     */
+    updatePointMaterial(index, isSelected, isHovered) {
+        let materialIndex;
+        if (isSelected && isHovered) {
+            materialIndex = IDrawingToolsManager_1.MATERIAL_INDEX.SELECTED_HOVERED;
+        }
+        else if (isSelected) {
+            materialIndex = IDrawingToolsManager_1.MATERIAL_INDEX.SELECTED;
+        }
+        else if (isHovered) {
+            materialIndex = IDrawingToolsManager_1.MATERIAL_INDEX.HOVERED;
+        }
+        else {
+            materialIndex = IDrawingToolsManager_1.MATERIAL_INDEX.DEFAULT;
+        }
+        __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").updateMaterialIndex(index, materialIndex);
+    }
 }
 exports.DesktopStrategy = DesktopStrategy;
-_DesktopStrategy_drawingToolsManager = new WeakMap(), _DesktopStrategy_geometryMathManager = new WeakMap(), _DesktopStrategy_insertionInteractionHandler = new WeakMap(), _DesktopStrategy_interactionManager = new WeakMap(), _DesktopStrategy_interactionManagerHelper = new WeakMap(), _DesktopStrategy_midPointInteractionHandler = new WeakMap(), _DesktopStrategy_restrictionManager = new WeakMap(), _DesktopStrategy_viewport = new WeakMap(), _DesktopStrategy_cameraFreezeFlag = new WeakMap(), _DesktopStrategy_lastEvent = new WeakMap(), _DesktopStrategy_onDownPointer = new WeakMap();
+_DesktopStrategy_drawingToolsManager = new WeakMap(), _DesktopStrategy_geometryMathManager = new WeakMap(), _DesktopStrategy_insertionInteractionHandler = new WeakMap(), _DesktopStrategy_interactionManager = new WeakMap(), _DesktopStrategy_interactionManagerHelper = new WeakMap(), _DesktopStrategy_midPointInteractionHandler = new WeakMap(), _DesktopStrategy_restrictionManager = new WeakMap(), _DesktopStrategy_selectionBox = new WeakMap(), _DesktopStrategy_viewport = new WeakMap(), _DesktopStrategy_boxHoveredPoints = new WeakMap(), _DesktopStrategy_cameraFreezeFlag = new WeakMap(), _DesktopStrategy_isBoxSelecting = new WeakMap(), _DesktopStrategy_lastEvent = new WeakMap(), _DesktopStrategy_lastMoveEvent = new WeakMap(), _DesktopStrategy_onDownPointer = new WeakMap(), _DesktopStrategy_instances = new WeakSet(), _DesktopStrategy_updateAllPointMaterials = function _DesktopStrategy_updateAllPointMaterials() {
+    if (!__classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray ||
+        __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray.length === 0) {
+        return;
+    }
+    const pointCount = __classPrivateFieldGet(this, _DesktopStrategy_drawingToolsManager, "f").positionArray.length /
+        DesktopStrategy.COORDINATE_STEP;
+    const selectedIndices = __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").selectedPointIndices;
+    const hoveredPoint = __classPrivateFieldGet(this, _DesktopStrategy_interactionManagerHelper, "f").hoveredPoint;
+    for (let i = 0; i < pointCount; i++) {
+        const isSelected = selectedIndices.includes(i);
+        const isHovered = hoveredPoint === i;
+        this.updatePointMaterial(i, isSelected, isHovered);
+    }
+};
+DesktopStrategy.CLICK_THRESHOLD_SQUARED = 25; // 5px threshold squared
+DesktopStrategy.COORDINATE_STEP = 3; // Number of coordinates per point (x, y, z)
 //# sourceMappingURL=DesktopStrategy.js.map