@shapediver/viewer.features.drawing-tools 3.1.0

package/src/business/implementation/managers/interaction/InteractionManager.ts

@@ -0,0 +1,268 @@
+import { addListener, FLAG_TYPE, IViewportApi } from '@shapediver/viewer';
+import { DeletionInteractionHandler } from './handlers/DeletionInteractionHandler';
+import { DrawingToolsEventResponseMapping } from '../../../interfaces/events/EventResponseMapping';
+import { DrawingToolsManager } from '../../DrawingToolsManager';
+import { EVENTTYPE_DRAWING_TOOLS, IEvent } from '@shapediver/viewer.shared.services';
+import { GeometryMathManager } from '../geometry/GeometryMathManager';
+import { IManager } from '../../../interfaces/IManager';
+import { InsertionInteractionHandler } from './handlers/InsertionInteractionHandler';
+import { InteractionManagerHelper } from './helpers/InteractionManagerHelper';
+import { IRay } from '@shapediver/viewer.features.interaction';
+import { MidPointInteractionHandler } from './handlers/MidPointInteractionHandler';
+import { RestrictionManager } from './RestrictionManager';
+
+export class InteractionManager implements IManager {
+    // #region Properties (11)
+
+    readonly #deletionInteractionHandler: DeletionInteractionHandler;
+    readonly #drawingToolsManager: DrawingToolsManager;
+    readonly #geometryMathManager: GeometryMathManager;
+    readonly #insertionInteractionHandler: InsertionInteractionHandler;
+    readonly #interactionManagerHelper: InteractionManagerHelper;
+    readonly #midPointInteractionHandler: MidPointInteractionHandler;
+    readonly #restrictionManager: RestrictionManager;
+    readonly #viewport: IViewportApi;
+
+    #cameraFreezeFlag: string = '';
+    #lastEvent?: PointerEvent;
+    #onDownPointer?: PointerEvent;
+
+    // #endregion Properties (11)
+
+    // #region Constructors (1)
+
+    constructor(drawingToolsManager: DrawingToolsManager) {
+        this.#drawingToolsManager = drawingToolsManager;
+        this.#viewport = drawingToolsManager.viewport;
+        this.#geometryMathManager = this.#drawingToolsManager.geometryMathManager;
+
+        this.#restrictionManager = new RestrictionManager(this.#drawingToolsManager);
+
+        this.#deletionInteractionHandler = new DeletionInteractionHandler(this.#drawingToolsManager, this);
+        this.#insertionInteractionHandler = new InsertionInteractionHandler(this.#drawingToolsManager, this);
+        this.#midPointInteractionHandler = new MidPointInteractionHandler(this.#drawingToolsManager, this);
+
+        this.#interactionManagerHelper = new InteractionManagerHelper(this.#drawingToolsManager, this);
+
+        addListener(EVENTTYPE_DRAWING_TOOLS.ADDED, (e: IEvent) => {
+            const event = e as DrawingToolsEventResponseMapping[EVENTTYPE_DRAWING_TOOLS.ADDED];
+            this.addPoint(event.index!);
+        });
+
+        addListener(EVENTTYPE_DRAWING_TOOLS.REMOVED, (e: IEvent) => {
+            const event = e as DrawingToolsEventResponseMapping[EVENTTYPE_DRAWING_TOOLS.REMOVED];
+            this.removePoint(event.index!);
+        });
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Getters And Setters (4)
+
+    public get deletionInteractionHandler(): DeletionInteractionHandler {
+        return this.#deletionInteractionHandler;
+    }
+
+    public get insertionInteractionHandler(): InsertionInteractionHandler {
+        return this.#insertionInteractionHandler;
+    }
+
+    public get midPointInteractionHandler(): MidPointInteractionHandler {
+        return this.#midPointInteractionHandler;
+    }
+
+    public get restrictionManager(): RestrictionManager {
+        return this.#restrictionManager;
+    }
+
+    // #endregion Public Getters And Setters (4)
+
+    // #region Public Methods (10)
+
+    public addPoint(insertionIndex: number): void {
+        this.#interactionManagerHelper.addPoint(insertionIndex);
+    }
+
+    public close(): void {
+        this.#interactionManagerHelper.close();
+        this.#restrictionManager.close();
+    }
+
+    public deleteSelection(): void {
+        this.#deletionInteractionHandler.deleteSelection(this.#interactionManagerHelper.selectedPointIndices);
+    }
+
+    public onDown(event: PointerEvent, ray: IRay): void {
+        if (this.#drawingToolsManager.closed) return;
+
+        if(event.button === 0) {
+            this.#onDownPointer = event;
+            this.#interactionManagerHelper.moving = false;
+    
+            /**
+             * IF INSERT KEY IS PRESSED
+             * FINALIZE INSERTION AND START A NEW ONE
+             */
+            if (this.#insertionInteractionHandler.insertionActive === true) {
+                const result = this.#insertionInteractionHandler.finalizeInsertion();
+                const distances = this.#geometryMathManager.checkPointDistances(ray);
+                this.#interactionManagerHelper.checkHover(distances, ray);
+                if(result) {
+                    this.#drawingToolsManager.update();
+                    return;
+                } else {
+                    this.#insertionInteractionHandler.startInsertion(event);
+                    return;
+                }
+            }
+            const distances = this.#geometryMathManager.checkPointDistances(ray);
+    
+            /**
+             * IF MID POINT INSERTION IS ACTIVE
+             * FINISH MID POINT INSERTION IF THE CURRENT INDEX IS THE MID POINT INSERTION INDEX
+             */
+            if (this.#midPointInteractionHandler.midPointInsertionActive === true) {
+                this.#midPointInteractionHandler.finishMidPointInsertion(distances);
+                this.#interactionManagerHelper.midPointInserted = true;
+            }
+    
+            /**
+             * CHECK HOVERED POINT
+             */
+            this.#interactionManagerHelper.checkHover(distances, ray);
+    
+            /**
+             * IF THERE IS A POINT CLOSE TO THE RAY
+             */
+            this.#interactionManagerHelper.selectPoint(distances);
+    
+            /**
+             * IF THE CURRENTLY HOVERED POINT IS SELECTED
+             * START DRAGGING
+             */
+            const draggingStarted = this.#interactionManagerHelper.startDragging(ray);
+            if (draggingStarted && !this.#cameraFreezeFlag)
+                this.#cameraFreezeFlag = this.#viewport.addFlag(FLAG_TYPE.CAMERA_FREEZE);
+        } else if(event.button === 2) {
+            /**
+             * WHEN RIGHT MOUSE BUTTON IS PRESSED
+             */
+            this.onOut();
+        }
+    }
+
+    /**
+     * On mouse move, move the selected point if there is one
+     * 
+     * @param event 
+     * @param ray 
+     */
+    public onMove(event: PointerEvent, ray: IRay): void {
+        if (this.#drawingToolsManager.closed) return;
+
+        // if there are no points, start with the insertion right away
+        if (this.#drawingToolsManager.settings.general.autoStart && this.#insertionInteractionHandler.insertionActive === false && this.#drawingToolsManager.getPointsData().length === 0) {
+            this.#lastEvent = event;
+            this.startInsertion();
+        }
+
+        const distanceSquared = this.#onDownPointer ? Math.pow(event.clientX - this.#onDownPointer.clientX, 2) + Math.pow(event.clientY - this.#onDownPointer.clientY, 2) : Infinity;
+        const clickThresholdSquared = 25;
+        const pointerMoved = distanceSquared > clickThresholdSquared;
+
+        this.#interactionManagerHelper.moving = pointerMoved;
+
+        if (pointerMoved) {
+            this.#lastEvent = event;
+            /**
+             * IF WE ARE DRAGGING A POINT
+             * MOVE THE SELECTED POINTS
+             */
+            this.#interactionManagerHelper.moveSelectedPoints(ray);
+        }
+
+        const distances = this.#geometryMathManager.checkPointDistances(ray);
+        this.#interactionManagerHelper.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
+             */
+            this.#insertionInteractionHandler.onMove(ray);
+
+            /**
+             * 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 (this.#insertionInteractionHandler.insertionActive === false && this.#interactionManagerHelper.dragging === false && this.#interactionManagerHelper.selectedPointIndices.length === 0) {
+                this.#midPointInteractionHandler.onMove(ray, this.#interactionManagerHelper.hoveredPoint);
+            }
+        }
+        
+        if (this.#interactionManagerHelper.dragging) {
+            document.body.style.cursor = 'grabbing';
+        } else if(this.#interactionManagerHelper.hoveredPoint !== undefined) {
+            document.body.style.cursor = 'pointer';
+        } else {
+            document.body.style.cursor = 'default';
+        }
+    }
+
+    /**
+     * On mouse out, deselect the hovered point and remove the stop dragging
+     */
+    public onOut(): void {
+        this.#restrictionManager.showRestrictionVisualization = false;
+        this.#insertionInteractionHandler.stopInsertion();
+        this.#interactionManagerHelper.onOut();
+        this.reset();
+    }
+
+    /**
+     * On mouse up, check if a point is close to the ray and deselect it
+     */
+    public onUp(): void {
+        if (this.#drawingToolsManager.closed) return;
+        this.#interactionManagerHelper.onUp();
+        this.reset();
+    }
+
+    public removePoint(index: number): void {
+        this.#interactionManagerHelper.removePoint(index);
+    }
+
+    public startInsertion(): void {
+        this.#restrictionManager.showRestrictionVisualization = true;
+
+        this.#midPointInteractionHandler.stopMidPointInsertion();
+
+        if (!this.#cameraFreezeFlag)
+            this.#cameraFreezeFlag = this.#viewport.addFlag(FLAG_TYPE.CAMERA_FREEZE);
+
+        this.#insertionInteractionHandler.startInsertion(this.#lastEvent!);
+    }
+
+    public stopInsertion(): void {
+        this.#restrictionManager.showRestrictionVisualization = false;
+        this.#insertionInteractionHandler.stopInsertion();
+        this.#viewport.removeFlag(this.#cameraFreezeFlag);
+        this.#cameraFreezeFlag = '';
+    }
+
+    // #endregion Public Methods (10)
+
+    // #region Private Methods (1)
+
+    private reset(): void {
+        if (this.#insertionInteractionHandler.insertionActive === false) {
+            this.#restrictionManager.showRestrictionVisualization = false;
+            this.#viewport.removeFlag(this.#cameraFreezeFlag);
+            this.#cameraFreezeFlag = '';
+        }
+        this.#interactionManagerHelper.reset();
+    }
+
+    // #endregion Private Methods (1)
+}

package/src/business/implementation/managers/interaction/RestrictionManager.ts

@@ -0,0 +1,135 @@
+import { AxisRestriction, AxisRestrictionProperties } from './restrictions/axis/AxisRestriction';
+import { DrawingToolsManager } from '../../DrawingToolsManager';
+import { GeometryRestriction, GeometryRestrictionProperties } from './restrictions/geometry/GeometryRestriction';
+import { IManager } from '../../../interfaces/IManager';
+import { IRay } from '@shapediver/viewer.features.interaction';
+import {
+    IRestriction,
+    RESTRICTION_TYPE,
+    RestrictionMetaData,
+    RestrictionProperties
+} from '../../../interfaces/IRestriction';
+import { PlaneRestriction, PlaneRestrictionProperties } from './restrictions/plane/PlaneRestriction';
+import { Settings } from '../../../interfaces/IDrawingToolsManager';
+import { UuidGenerator } from '@shapediver/viewer.shared.services';
+import { vec3 } from 'gl-matrix';
+
+export class RestrictionManager implements IManager {
+    // #region Properties (5)
+
+    readonly #drawingToolsManager: DrawingToolsManager;
+    readonly #restrictions: { [token: string]: IRestriction } = {};
+    readonly #settings: Settings;
+    readonly #uuidGenerator = UuidGenerator.instance;
+
+    #showRestrictionVisualization: boolean = false;
+
+    // #endregion Properties (5)
+
+    // #region Constructors (1)
+
+    constructor(drawingToolsManager: DrawingToolsManager) {
+        this.#drawingToolsManager = drawingToolsManager;
+        this.#settings = drawingToolsManager.settings;
+
+        for (const restrictionToken in this.#settings.restrictions) {
+            this.addRestriction(this.#settings.restrictions[restrictionToken], restrictionToken);
+        }
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Getters And Setters (3)
+
+    public get restrictions(): { [token: string]: IRestriction } {
+        return this.#restrictions;
+    }
+
+    public get showRestrictionVisualization(): boolean {
+        return this.#showRestrictionVisualization;
+    }
+
+    public set showRestrictionVisualization(value: boolean) {
+        this.#showRestrictionVisualization = value;
+        for (const restriction of Object.values(this.#restrictions)) {
+            restriction.showVisualization = value;
+            for (const snapRestriction of Object.values(restriction.snapRestrictions)) {
+                snapRestriction.showVisualization = value;
+            }
+        }
+    }
+
+    // #endregion Public Getters And Setters (3)
+
+    // #region Public Methods (4)
+
+    public addRestriction(properties: RestrictionProperties, token?: string): string | undefined {
+        token = token || this.#uuidGenerator.create();
+
+        let restriction: IRestriction | undefined;
+        if (properties.type === RESTRICTION_TYPE.PLANE) {
+            restriction = new PlaneRestriction(this.#drawingToolsManager, token, properties as PlaneRestrictionProperties);
+        } else if (properties.type === RESTRICTION_TYPE.GEOMETRY) {
+            restriction = new GeometryRestriction(this.#drawingToolsManager, token, properties as GeometryRestrictionProperties);
+        } else if (properties.type === RESTRICTION_TYPE.AXIS) {
+            restriction = new AxisRestriction(this.#drawingToolsManager, token, properties as AxisRestrictionProperties);
+        }
+
+        if (restriction) {
+            this.#restrictions[token] = restriction;
+            return token;
+        }
+        return;
+    }
+
+    public close(): void {
+        Object.keys(this.#restrictions).forEach(key => this.removeRestriction(key));
+    }
+
+    public rayTrace(ray: IRay, metaData?: RestrictionMetaData): vec3 | undefined {
+        let rayTracingResult: {
+            result: vec3 | undefined;
+            distance: number;
+            restriction: IRestriction;
+        } | undefined = undefined;
+
+        // create an array of arrays with the restrictions sorted by priority
+        const restrictionsSorted = Object.values(this.#restrictions).sort((a, b) => (b.priority || 0) - (a.priority || 0));
+
+        for (const restriction of restrictionsSorted) {
+            if (rayTracingResult && rayTracingResult.restriction.priority > restriction.priority) break;
+
+            const hit = restriction.rayTrace(ray, metaData);
+
+            if (!hit) continue;
+            const distance = vec3.squaredDistance(ray.origin, hit);
+            if (distance < (rayTracingResult ? rayTracingResult.distance : Infinity)) {
+                rayTracingResult = {
+                    result: hit,
+                    distance: distance,
+                    restriction: restriction
+                };
+            }
+        }
+
+        // deactivate the visualization of all restrictions that are not hit
+        for (const restriction of Object.values(this.#restrictions)) {
+            if (rayTracingResult && restriction !== rayTracingResult.restriction) {
+                for (const snapRestriction of Object.values(restriction.snapRestrictions)) {
+                    snapRestriction.active = false;
+                }
+            }
+        }
+        return rayTracingResult?.result;
+    }
+
+    public removeRestriction(token: string): void {
+        if (this.#restrictions[token]) {
+            Object.values(this.#restrictions[token].snapRestrictions).forEach(r => r.removeVisualization());
+            this.#restrictions[token].removeVisualization();
+            delete this.#restrictions[token];
+        }
+    }
+
+    // #endregion Public Methods (4)
+}

package/src/business/implementation/managers/interaction/handlers/DeletionInteractionHandler.ts

@@ -0,0 +1,48 @@
+import { DrawingToolsManager } from '../../../DrawingToolsManager';
+import { EventEngine, EVENTTYPE_DRAWING_TOOLS } from '@shapediver/viewer.shared.services';
+import { GeometryMathManager } from '../../geometry/GeometryMathManager';
+import { InteractionManager } from '../InteractionManager';
+import { IRay, IViewportApi } from '@shapediver/viewer.features.interaction';
+
+export class DeletionInteractionHandler {
+    // #region Properties (4)
+
+    readonly #drawingToolsManager: DrawingToolsManager;
+    readonly #eventEngine = EventEngine.instance;
+    readonly #geometryMathManager: GeometryMathManager;
+    readonly #viewport: IViewportApi;
+
+    // #endregion Properties (4)
+
+    // #region Constructors (1)
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(drawingToolsManager: DrawingToolsManager, interactionManager: InteractionManager) {
+        this.#drawingToolsManager = drawingToolsManager;
+        this.#viewport = drawingToolsManager.viewport;
+        this.#geometryMathManager = drawingToolsManager.geometryMathManager;
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Methods (2)
+
+    public deletePoint(ray: IRay): void {
+        // check if there is a point close to the ray
+        const distances = this.#geometryMathManager.checkPointDistances(ray);
+        if (distances) {
+            // add the id if it is not already in the array
+            // remove it if it is in the array
+            this.#drawingToolsManager.removePoint(distances[0].index);
+            this.#eventEngine.emitEvent(EVENTTYPE_DRAWING_TOOLS.REMOVED, { viewportId: this.#viewport.id, drawingToolsId: this.#drawingToolsManager.uuid });
+        }
+    }
+
+    public deleteSelection(indices: number[]): void {
+        if(indices.length === 0) return;
+        this.#drawingToolsManager.removePoints(indices);
+        this.#eventEngine.emitEvent(EVENTTYPE_DRAWING_TOOLS.REMOVED, { viewportId: this.#viewport.id, drawingToolsId: this.#drawingToolsManager.uuid });
+    }
+
+    // #endregion Public Methods (2)
+}

package/src/business/implementation/managers/interaction/handlers/InsertionInteractionHandler.ts

@@ -0,0 +1,149 @@
+import { DrawingToolsManager } from '../../../DrawingToolsManager';
+import { GeometryMathManager } from '../../geometry/GeometryMathManager';
+import { GeometryState } from '../../geometry/GeometryState';
+import { InteractionManager } from '../InteractionManager';
+import { IRay, IViewportApi } from '@shapediver/viewer.features.interaction';
+import { MATERIAL_INDEX, Settings } from '../../../../interfaces/IDrawingToolsManager';
+import { RestrictionManager } from '../RestrictionManager';
+
+export class InsertionInteractionHandler {
+    // #region Properties (11)
+
+    readonly #drawingToolsManager: DrawingToolsManager;
+    readonly #geometryMathManager: GeometryMathManager;
+    readonly #geometryState: GeometryState;
+    readonly #restrictionManager: RestrictionManager;
+    readonly #settings: Settings;
+    readonly #viewport: IViewportApi;
+
+    #alreadyInserted: boolean = false;
+    #insertionActive: boolean = false;
+    #insertionActiveIndex: number = -1;
+
+    // #endregion Properties (11)
+
+    // #region Constructors (1)
+
+    constructor(drawingToolsManager: DrawingToolsManager, interactionManager: InteractionManager) {
+        this.#drawingToolsManager = drawingToolsManager;
+
+        this.#settings = drawingToolsManager.settings;
+        this.#viewport = drawingToolsManager.viewport;
+        this.#geometryMathManager = drawingToolsManager.geometryMathManager;
+        this.#restrictionManager = interactionManager.restrictionManager;
+        this.#geometryState = drawingToolsManager.geometryState;
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Getters And Setters (2)
+
+    public get alreadyInserted(): boolean {
+        return this.#alreadyInserted;
+    }
+
+    public get insertionActive(): boolean {
+        return this.#insertionActive;
+    }
+
+    // #endregion Public Getters And Setters (2)
+
+    // #region Public Methods (4)
+
+    public finalizeInsertion(): boolean {
+        let result = false;
+
+        if (this.#insertionActive === true && this.#alreadyInserted === true) {
+            this.#geometryState.makePointPersistent(this.#insertionActiveIndex);
+            
+            const canBeClosed = this.#geometryState.getPointCount() > 3 && this.#geometryState.checkNumberOfPoints(this.#geometryState.getPointCount() - 1);
+            const shouldBeClosed = this.#settings.geometry.close === true && this.#geometryState.closeLoop === false && this.#settings.geometry.autoClose === false;
+
+            // if there are more than 2 points and the geometry can be closed, check if the last point is close to the first point
+            if (canBeClosed && shouldBeClosed) {
+                // if restricted point is close to the first point, remove the current insertion point and draw a line to the first point
+                const firstPoint = this.#geometryState.getPosition(0);
+                const lastPoint = this.#geometryState.getPosition(this.#insertionActiveIndex);
+
+                if (this.#geometryMathManager.screenSpaceDistanceCheck(firstPoint, lastPoint, this.#settings.visualization.points.size_0! * this.#settings.visualization.distanceMultiplicationFactor).check === true) {
+                    this.#geometryState.closeLoop = true;
+                    this.#drawingToolsManager.removePoint(this.#insertionActiveIndex);
+                    result = true;
+                } else {
+                    this.#drawingToolsManager.updateMaterialIndex(this.#insertionActiveIndex, MATERIAL_INDEX.DEFAULT);
+                }
+            } else {
+                this.#drawingToolsManager.updateMaterialIndex(this.#insertionActiveIndex, MATERIAL_INDEX.DEFAULT);
+            }
+        }
+
+        this.#insertionActive = false;
+        this.#alreadyInserted = false;
+        this.#insertionActiveIndex = -1;
+
+        return result;
+    }
+
+    public onMove(ray: IRay): void {
+        if (this.#insertionActive === false) return;
+
+        if (this.#geometryState.getPointCount() > 0 && this.#insertionActive === true) {
+            const restrictedPoint = this.#restrictionManager.rayTrace(ray, { index: this.#insertionActiveIndex });
+
+            if (restrictedPoint) {
+                const canBeClosed = this.#geometryState.getPointCount() > 3 && this.#geometryState.checkNumberOfPoints(this.#geometryState.getPointCount() - 1);
+                const shouldBeClosed = this.#settings.geometry.close === true && this.#geometryState.closeLoop === false && this.#settings.geometry.autoClose === false;
+
+                // if there are more than 2 points and the geometry can be closed, check if the last point is close to the first point
+                if (canBeClosed && shouldBeClosed) {
+                    // if restricted point is close to the first point, remove the current insertion point and draw a line to the first point
+                    const firstPoint = this.#geometryState.getPosition(0);
+                    const lastPoint = restrictedPoint;
+    
+                    if (lastPoint && this.#geometryMathManager.screenSpaceDistanceCheck(firstPoint, lastPoint, this.#settings.visualization.points.size_0! * this.#settings.visualization.distanceMultiplicationFactor).check === true) {
+                        // close the geometry
+                        this.#drawingToolsManager.updateMaterialIndex(this.#insertionActiveIndex, MATERIAL_INDEX.SELECTED_HOVERED);
+                        this.#drawingToolsManager.movePointTemporary(this.#insertionActiveIndex, firstPoint);
+                    } else {
+                        // not close enough to close the geometry
+                        this.#drawingToolsManager.updateMaterialIndex(this.#insertionActiveIndex, MATERIAL_INDEX.INSERTION_HOVERED);
+                        this.#drawingToolsManager.movePointTemporary(this.#insertionActiveIndex, restrictedPoint);
+                    }
+                } else {
+                    // not enough points to close the geometry or auto close is enabled
+                    this.#drawingToolsManager.updateMaterialIndex(this.#insertionActiveIndex, MATERIAL_INDEX.INSERTION_HOVERED);
+                    this.#drawingToolsManager.movePointTemporary(this.#insertionActiveIndex, restrictedPoint);
+                }
+            }
+        }
+    }
+
+    public startInsertion(event: PointerEvent): void {
+        if (this.#insertionActive === false) {
+            // get current ray
+            const ray = this.#viewport.pointerEventToRay(event);
+
+            // add a point at the ray intersection
+            const restrictedPoint = this.#restrictionManager.rayTrace(ray);
+            // add at last position
+            this.#insertionActiveIndex = this.#geometryState.getPointCount();
+            this.#drawingToolsManager.addPointTemporary(this.#insertionActiveIndex, restrictedPoint);
+            this.#drawingToolsManager.updateMaterialIndex(this.#insertionActiveIndex, MATERIAL_INDEX.INSERTION_HOVERED);
+
+            this.#insertionActive = true;
+            this.#alreadyInserted = true;
+        }
+    }
+
+    public stopInsertion(): void {
+        if (this.#insertionActive === true) {
+            // remove last added point
+            this.#drawingToolsManager.removePointTemporary(this.#insertionActiveIndex);
+            this.#insertionActive = false;
+            this.#alreadyInserted = false;
+            this.#insertionActiveIndex = -1;
+        }
+    }
+
+    // #endregion Public Methods (4)
+}