@shapediver/viewer.features.drawing-tools 3.1.2 → 3.2.0

package/src/business/implementation/managers/interaction/restrictions/plane/PlaneRestriction.ts

@@ -1,8 +1,15 @@
 import { AbstractRestriction } from '../AbstractRestriction';
 import { AngularRestriction, AngularRestrictionProperties } from './snap/AngularRestriction';
+import { AxisRestriction, AxisRestrictionProperties } from './snap/AxisRestriction';
+import {
+    CAMERA_TYPE,
+    ICameraApi,
+    IOrthographicCameraApi,
+    ORTHOGRAPHIC_CAMERA_DIRECTION
+} from '@shapediver/viewer';
 import { DrawingToolsManager } from '../../../../DrawingToolsManager';
 import { GridRestriction, GridRestrictionProperties } from './snap/GridRestriction';
-import { IRay } from '@shapediver/viewer.features.interaction';
+import { IRay, IViewportApi } from '@shapediver/viewer.features.interaction';
 import { IRestriction, RestrictionMetaData, RestrictionProperties } from '../../../../../interfaces/IRestriction';
 import { ISnapRestriction } from '../../../../../interfaces/ISnapRestriction';
 import { mat4, vec3 } from 'gl-matrix';
@@ -39,6 +46,11 @@ export type PlaneRestrictionProperties = {
      * angular snap restriction
      */
     angularSnapRestriction?: AngularRestrictionProperties;
+
+    /**
+     * axis snap restriction
+     */
+    axisSnapRestriction?: AxisRestrictionProperties;
 } & RestrictionProperties;
 
 // #endregion Type aliases (1)
@@ -46,56 +58,61 @@ export type PlaneRestrictionProperties = {
 // #region Classes (1)
 
 export class PlaneRestriction extends AbstractRestriction implements IRestriction {
-    // #region Properties (10)
+    // #region Properties (14)
 
+    readonly #properties: PlaneRestrictionProperties;
     readonly #uuidGenerator = UuidGenerator.instance;
+    readonly #viewport: IViewportApi;
 
     #angularRestriction: AngularRestriction;
+    #axisRestriction: AxisRestriction;
+    #cameraId: string = '';
     #gridRestriction: GridRestriction;
-    #normal: vec3;
-    #origin: vec3;
+    #normal: vec3 = vec3.create();
+    #origin: vec3 = vec3.create();
     #snapRestrictions: { [key: string]: ISnapRestriction };
     #transformationFromXYPlaneMatrix: mat4 = mat4.create();
     #transformationToXYPlaneMatrix: mat4 = mat4.create();
-    #vectorU: vec3;
-    #vectorV: vec3;
+    #vectorU: vec3 = vec3.create();
+    #vectorV: vec3 = vec3.create();
 
-    // #endregion Properties (10)
+    // #endregion Properties (14)
 
     // #region Constructors (1)
 
     constructor(drawingToolsManager: DrawingToolsManager, id: string, properties: PlaneRestrictionProperties) {
         super(drawingToolsManager, id);
-        properties.vector_u = properties.vector_u ? vec3.normalize(vec3.create(), properties.vector_u) : vec3.fromValues(1, 0, 0);
-        properties.vector_v = properties.vector_v ? vec3.normalize(vec3.create(), properties.vector_v) : vec3.fromValues(0, 1, 0);
 
-        this.#normal = vec3.normalize(vec3.create(), vec3.cross(vec3.create(), properties.vector_u, properties.vector_v));
-        if (vec3.dot(properties.vector_u, properties.vector_v) !== 0)
-            properties.vector_v = vec3.normalize(vec3.create(), vec3.cross(vec3.create(), this.#normal, properties.vector_u));
+        this.#viewport = drawingToolsManager.viewport;
+        this.#cameraId = this.#viewport.camera!.id;
 
-        this.#vectorU = properties.vector_u;
-        this.#vectorV = properties.vector_v;
-        this.#origin = properties.origin || vec3.create();
+        this.#properties = properties;
 
-        this.createTransformationMatrices();
+        this.#gridRestriction = new GridRestriction(drawingToolsManager, this, this.#properties.gridSnapRestriction);
+        this.#angularRestriction = new AngularRestriction(drawingToolsManager, this, this.#properties.angularSnapRestriction);
+        this.#axisRestriction = new AxisRestriction(drawingToolsManager, this, this.#properties.axisSnapRestriction);
 
-        this.#gridRestriction = new GridRestriction(drawingToolsManager, this, properties.gridSnapRestriction);
-        this.#angularRestriction = new AngularRestriction(drawingToolsManager, this, properties.angularSnapRestriction);
+        this.updatePlaneDefinition();
 
         this.#snapRestrictions = {
             grid: this.#gridRestriction,
-            angular: this.#angularRestriction
+            angular: this.#angularRestriction,
+            axis: this.#axisRestriction
         };
     }
 
     // #endregion Constructors (1)
 
-    // #region Public Getters And Setters (13)
+    // #region Public Getters And Setters (14)
 
     public get angularRestriction(): AngularRestriction {
         return this.#angularRestriction;
     }
 
+    public get axisRestriction(): AxisRestriction {
+        return this.#axisRestriction;
+    }
+
     public get gridRestriction(): GridRestriction {
         return this.#gridRestriction;
     }
@@ -110,8 +127,7 @@ export class PlaneRestriction extends AbstractRestriction implements IRestrictio
 
     public set origin(value: vec3) {
         this.#origin = value;
-        this.#gridRestriction.updatePlaneDefinition(this.#origin, this.#vectorU, this.#vectorV, this.#normal);
-        this.createTransformationMatrices();
+        this.updatePlaneDefinition();
     }
 
     public get priority(): number {
@@ -135,15 +151,8 @@ export class PlaneRestriction extends AbstractRestriction implements IRestrictio
     }
 
     public set vectorU(value: vec3) {
-        this.#vectorU = value;
-        this.#normal = vec3.normalize(vec3.create(), vec3.cross(vec3.create(), this.#vectorU, this.#vectorV));
-
-        if (vec3.dot(this.#vectorU, this.#vectorV) !== 0)
-            this.#vectorV = vec3.normalize(vec3.create(), vec3.cross(vec3.create(), this.#normal, this.#vectorU));
-
-        this.createTransformationMatrices();
-        this.#gridRestriction.updatePlaneDefinition(this.#origin, this.#vectorU, this.#vectorV, this.#normal);
-        this.#angularRestriction.updatePlaneDefinition(this.#origin, this.#vectorU, this.#vectorV, this.#normal);
+        this.#properties.vector_u = value;
+        this.updatePlaneDefinition();
     }
 
     public get vectorV(): vec3 {
@@ -151,24 +160,19 @@ export class PlaneRestriction extends AbstractRestriction implements IRestrictio
     }
 
     public set vectorV(value: vec3) {
-        this.#vectorV = value;
-        this.#normal = vec3.normalize(vec3.create(), vec3.cross(vec3.create(), this.#vectorU, this.#vectorV));
-
-        if (vec3.dot(this.#vectorU, this.#vectorV) !== 0)
-            this.#vectorV = vec3.normalize(vec3.create(), vec3.cross(vec3.create(), this.#normal, this.#vectorU));
-
-        this.createTransformationMatrices();
-        this.#gridRestriction.updatePlaneDefinition(this.#origin, this.#vectorU, this.#vectorV, this.#normal);
-        this.#angularRestriction.updatePlaneDefinition(this.#origin, this.#vectorU, this.#vectorV, this.#normal);
+        this.#properties.vector_v = value;
+        this.updatePlaneDefinition();
     }
 
-    // #endregion Public Getters And Setters (13)
+    // #endregion Public Getters And Setters (14)
 
     // #region Public Methods (1)
 
     public rayTrace(ray: IRay, metaData?: RestrictionMetaData): vec3 | undefined {
         if (this.enabled === false) return vec3.create();
 
+        if (this.#cameraId !== this.#viewport.camera!.id) this.updatePlaneDefinition();
+
         let origin = this.#origin;
         if (metaData?.referencePoint)
             origin = vec3.sub(vec3.create(), this.#origin, vec3.scale(vec3.create(), this.#normal, vec3.dot(vec3.sub(vec3.create(), this.#origin, metaData.referencePoint), this.#normal)));
@@ -176,7 +180,7 @@ export class PlaneRestriction extends AbstractRestriction implements IRestrictio
         // find intersection of ray and plane
         const t = (vec3.dot(origin, this.#normal) - vec3.dot(ray.origin, this.#normal)) / vec3.dot(ray.direction, this.#normal);
         const intersection = vec3.add(vec3.create(), ray.origin, vec3.multiply(vec3.create(), ray.direction, vec3.fromValues(t, t, t)));
-        return this.snap(intersection, metaData);
+        return this.snap(ray, intersection, metaData);
     }
 
     // #endregion Public Methods (1)
@@ -187,7 +191,28 @@ export class PlaneRestriction extends AbstractRestriction implements IRestrictio
 
     // #endregion Protected Methods (1)
 
-    // #region Private Methods (2)
+    // #region Private Methods (4)
+
+    private createDefaultPlane(camera: ICameraApi): void {
+        if (camera.type === CAMERA_TYPE.PERSPECTIVE ||
+            (camera.type === CAMERA_TYPE.ORTHOGRAPHIC && (camera as IOrthographicCameraApi).direction === ORTHOGRAPHIC_CAMERA_DIRECTION.CUSTOM)) {
+            this.#vectorU = vec3.fromValues(1, 0, 0);
+            this.#vectorV = vec3.fromValues(0, 1, 0);
+            this.#normal = vec3.fromValues(0, 0, 1);
+            this.#origin = vec3.fromValues(0, 0, 0);
+        } else {
+            const orthographicCamera = camera as IOrthographicCameraApi;
+            const direction = vec3.normalize(vec3.create(), vec3.sub(vec3.create(), orthographicCamera.target, orthographicCamera.position));
+            const up =
+                orthographicCamera.direction === ORTHOGRAPHIC_CAMERA_DIRECTION.TOP || orthographicCamera.direction === ORTHOGRAPHIC_CAMERA_DIRECTION.BOTTOM ?
+                    vec3.fromValues(0, 1, 0) : vec3.fromValues(0, 0, 1);
+
+            this.#origin = vec3.fromValues(0, 0, 0);
+            this.#normal = vec3.negate(vec3.create(), direction);
+            this.#vectorU = vec3.clone(up);
+            this.#vectorV = vec3.normalize(vec3.create(), vec3.cross(vec3.create(), this.#normal, this.#vectorU));
+        }
+    }
 
     private createTransformationMatrices(): void {
         // Calculate the transformation matrix for the rotation
@@ -198,7 +223,10 @@ export class PlaneRestriction extends AbstractRestriction implements IRestrictio
             0, 0, 0, 1
         );
 
-        const rotationMatrixInverse = mat4.invert(mat4.create(), rotationMatrix);
+        let rotationMatrixInverse = mat4.invert(mat4.create(), rotationMatrix);
+        if (!rotationMatrixInverse)
+            rotationMatrixInverse = mat4.create();
+
         const pivotMatrix = mat4.fromTranslation(mat4.create(), vec3.fromValues(this.#origin[0], this.#origin[1], this.#origin[2]));
         const pivotMatrixInverse = mat4.fromTranslation(mat4.create(), vec3.fromValues(-this.#origin[0], -this.#origin[1], -this.#origin[2]));
 
@@ -209,9 +237,11 @@ export class PlaneRestriction extends AbstractRestriction implements IRestrictio
         mat4.multiply(this.#transformationFromXYPlaneMatrix, this.#transformationFromXYPlaneMatrix, pivotMatrixInverse);
     }
 
-    private snap(point: vec3, metaData?: RestrictionMetaData): vec3 | undefined {
+    private snap(ray: IRay, point: vec3, metaData?: RestrictionMetaData): vec3 | undefined {
         if (this.enabled === false) return;
 
+        if (this.#cameraId !== this.#viewport.camera!.id) this.updatePlaneDefinition();
+
         const sortedSnapRestrictions = Object.values(this.#snapRestrictions).sort((a, b) => b.priority - a.priority);
 
         // group snap restrictions by priority
@@ -225,7 +255,7 @@ export class PlaneRestriction extends AbstractRestriction implements IRestrictio
         for (const snapRestrictions of Object.values(groupedSnapRestrictions)) {
             const results = [];
             for (const snapRestriction of snapRestrictions) {
-                results.push(snapRestriction.snap(point, metaData));
+                results.push(snapRestriction.snap(ray, point, metaData));
             }
 
             const indexedResults = results.map((value, index) => ({ index, value }));
@@ -251,7 +281,57 @@ export class PlaneRestriction extends AbstractRestriction implements IRestrictio
         return point;
     }
 
-    // #endregion Private Methods (2)
+    private updatePlaneDefinition(): void {
+        const camera = this.#viewport.camera!;
+        this.#cameraId = camera!.id;
+
+        const origin = this.#properties.origin ? vec3.clone(this.#properties.origin) : undefined;
+        const vectorU = this.#properties.vector_u ? vec3.clone(this.#properties.vector_u) : undefined;
+        const vectorV = this.#properties.vector_v ? vec3.clone(this.#properties.vector_v) : undefined;
+
+        const planeDefined = origin && vectorU && vectorV;
+
+        let normal = vec3.fromValues(0, 0, 1);
+
+        if (planeDefined) {
+            vec3.normalize(vectorU, vectorU);
+            vec3.normalize(vectorV, vectorV);
+
+            normal = vec3.normalize(vec3.create(), vec3.cross(vec3.create(), vectorU, vectorV));
+            if (vec3.dot(vectorU, vectorV) !== 0)
+                vec3.normalize(vectorV, vec3.cross(vec3.create(), normal, vectorU));
+
+            if (camera.type === CAMERA_TYPE.ORTHOGRAPHIC) {
+                const cameraApi = camera as IOrthographicCameraApi;
+                const cameraDirection = vec3.normalize(vec3.create(), vec3.sub(vec3.create(), cameraApi.target, cameraApi.position));
+
+                // if the dot product of the camera direction and the normal tells us that they are parallel
+                // the plane is perpendicular to the camera direction
+                if (Math.abs(vec3.dot(cameraDirection, normal)) < 0.0001) {
+                    this.createDefaultPlane(camera);
+                } else {
+                    this.#vectorU = vectorU;
+                    this.#vectorV = vectorV;
+                    this.#normal = normal;
+                    this.#origin = origin;
+                }
+            } else {
+                this.#vectorU = vectorU;
+                this.#vectorV = vectorV;
+                this.#normal = normal;
+                this.#origin = origin;
+            }
+        } else {
+            this.createDefaultPlane(camera);
+        }
+
+        this.createTransformationMatrices();
+        this.#gridRestriction.updatePlaneDefinition();
+        this.#angularRestriction.updatePlaneDefinition();
+        this.#axisRestriction.updatePlaneDefinition();
+    }
+
+    // #endregion Private Methods (4)
 }
 
 // #endregion Classes (1)

package/src/business/implementation/managers/interaction/restrictions/plane/snap/AngularRestriction.ts

@@ -2,6 +2,7 @@ import { AbstractRestriction } from '../../AbstractRestriction';
 import { CSS2DObject } from '../../../../../../../three/CSS2DRenderer';
 import { DrawingToolsManager } from '../../../../../DrawingToolsManager';
 import { GeometryMathManager } from '../../../../geometry/GeometryMathManager';
+import { IRay } from '@shapediver/viewer.features.interaction';
 import { ISnapRestriction, SnapRestrictionProperties } from '../../../../../../interfaces/ISnapRestriction';
 import { numberCleaner } from '../../../../../utils/numberCleaner';
 import { PlaneRestriction } from '../PlaneRestriction';
@@ -30,7 +31,7 @@ export type AngularRestrictionProperties = {
 // #region Classes (1)
 
 export class AngularRestriction extends AbstractRestriction implements ISnapRestriction {
-    // #region Properties (16)
+    // #region Properties (13)
 
     readonly #activationKey: string;
     readonly #drawingToolsManager: DrawingToolsManager;
@@ -48,12 +49,9 @@ export class AngularRestriction extends AbstractRestriction implements ISnapRest
     #angles: number[] = [];
     #labelNext?: CSS2DObject;
     #labelPrevious?: CSS2DObject;
-    #normal: vec3;
     #priority: number = 0;
-    #vectorU: vec3;
-    #vectorV: vec3;
 
-    // #endregion Properties (16)
+    // #endregion Properties (13)
 
     // #region Constructors (1)
 
@@ -66,13 +64,6 @@ export class AngularRestriction extends AbstractRestriction implements ISnapRest
 
         this.#planeRestriction = planeRestriction;
 
-        // we store the properties of the plane restriction
-        // as we need them to calculate the transformation matrices
-        // and the offset of the grid size to the origin
-        this.#vectorU = planeRestriction.vectorU!;
-        this.#vectorV = planeRestriction.vectorV!;
-        this.#normal = planeRestriction.normal;
-
         this.#activationKey = properties?.activationKey || 'a';
         this.enabled = properties?.enabled ?? false;
         this._enabledEditable = properties?.enabledEditable ?? true;
@@ -135,7 +126,7 @@ export class AngularRestriction extends AbstractRestriction implements ISnapRest
 
     // #region Public Methods (2)
 
-    public snap(point: vec3, metaData?: RestrictionMetaData): vec3 | undefined {
+    public snap(ray: IRay, point: vec3, metaData?: RestrictionMetaData): vec3 | undefined {
         // if the restriction is not enabled OR the activation key is set and the key is not pressed, return
         if (this.enabled === false && this.#drawingToolsManager.keyPressed(this.#activationKey) === false) return;
 
@@ -184,10 +175,10 @@ export class AngularRestriction extends AbstractRestriction implements ISnapRest
         const previousPreviousPointFromData = vec3.fromValues(positionArray.at((previousPreviousIndex * 3))!, positionArray.at((previousPreviousIndex * 3) + 1)!, positionArray.at((previousPreviousIndex * 3) + 2)!);
 
         // project them onto the same plane as the point
-        const nextPointProjected = vec3.sub(vec3.create(), nextPointFromData, vec3.scale(vec3.create(), this.#normal, vec3.dot(vec3.sub(vec3.create(), nextPointFromData, point), this.#normal)));
-        const nextNextPointProjected = vec3.sub(vec3.create(), nextNextPointFromData, vec3.scale(vec3.create(), this.#normal, vec3.dot(vec3.sub(vec3.create(), nextNextPointFromData, point), this.#normal)));
-        const previousPointProjected = vec3.sub(vec3.create(), previousPointFromData, vec3.scale(vec3.create(), this.#normal, vec3.dot(vec3.sub(vec3.create(), previousPointFromData, point), this.#normal)));
-        const previousPreviousPointProjected = vec3.sub(vec3.create(), previousPreviousPointFromData, vec3.scale(vec3.create(), this.#normal, vec3.dot(vec3.sub(vec3.create(), previousPreviousPointFromData, point), this.#normal)));
+        const nextPointProjected = vec3.sub(vec3.create(), nextPointFromData, vec3.scale(vec3.create(), this.#planeRestriction.normal, vec3.dot(vec3.sub(vec3.create(), nextPointFromData, point), this.#planeRestriction.normal)));
+        const nextNextPointProjected = vec3.sub(vec3.create(), nextNextPointFromData, vec3.scale(vec3.create(), this.#planeRestriction.normal, vec3.dot(vec3.sub(vec3.create(), nextNextPointFromData, point), this.#planeRestriction.normal)));
+        const previousPointProjected = vec3.sub(vec3.create(), previousPointFromData, vec3.scale(vec3.create(), this.#planeRestriction.normal, vec3.dot(vec3.sub(vec3.create(), previousPointFromData, point), this.#planeRestriction.normal)));
+        const previousPreviousPointProjected = vec3.sub(vec3.create(), previousPreviousPointFromData, vec3.scale(vec3.create(), this.#planeRestriction.normal, vec3.dot(vec3.sub(vec3.create(), previousPreviousPointFromData, point), this.#planeRestriction.normal)));
 
         // project the point onto the XY-Plane
         const pointProjected = vec3.transformMat4(vec3.create(), point, this.#planeRestriction.transformationToXYPlaneMatrix);
@@ -262,11 +253,7 @@ export class AngularRestriction extends AbstractRestriction implements ISnapRest
         }
     }
 
-    public updatePlaneDefinition(origin: vec3, vectorU: vec3, vectorV: vec3, normal: vec3): void {
-        this.#vectorU = vectorU;
-        this.#vectorV = vectorV;
-        this.#normal = normal;
-    }
+    public updatePlaneDefinition(): void { }
 
     // #endregion Public Methods (2)
 
@@ -300,31 +287,54 @@ export class AngularRestriction extends AbstractRestriction implements ISnapRest
 
         const text = document.createElement('div');
         text.className = 'label';
+        label = new CSS2DObject(text);
 
+        // remove the old style, if there is one 
+        document.head.querySelectorAll('style').forEach(style => {
+            if (style.textContent?.includes(label!.uuid))
+                document.head.removeChild(style);
+        });
+
+        const parent = document.createElement('div');
+        parent.className = `angular-label-parent-${label!.uuid}`;
         const child = document.createElement('div');
-        child.className = 'angular-label';
+        child.className = `angular-label-${label!.uuid}`;
 
         const style = document.createElement('style');
         style.textContent = `
-            .angular-label {
+            .angular-label-${label!.uuid} {
                 display: flex;
                 justify-content: center;
                 align-items: center;
-                width: 40px;
-                height: 40px;
+                width: 32px;
+                height: 32px;
                 color: white;
                 background-color: ${this.#settings.visualization.points.color_1};
                 border-radius: 50%;
                 font-size: 16px;
                 text-align: center;
             }
+
+            .angular-label-parent-${label!.uuid} {
+                display: flex;
+                justify-content: center;
+                align-items: center;
+                width: 40px; /* 32px + 2 * 4px border width */
+                height: 40px; /* 32px + 2 * 4px border width */
+                border-radius: 50%;
+                background: conic-gradient(
+                    ${this.#settings.visualization.points.color_2} 0% ${(angle / Math.PI) * 100}%,
+                    ${this.#settings.visualization.points.color_1} ${(angle / Math.PI) * 100}% 100%
+                );
+            }
         `;
         document.head.appendChild(style);
 
+        parent.appendChild(child);
+
         child.textContent = `${numberCleaner((angle / Math.PI) * 180)}°`;
-        text.appendChild(child);
+        text.appendChild(parent);
 
-        label = new CSS2DObject(text);
         label.position.set(position[0], position[1], position[2]);
         label.visible = false;
         this._object3D.add(label);

package/src/business/implementation/managers/interaction/restrictions/plane/snap/AxisRestriction.ts

@@ -0,0 +1,116 @@
+import { AbstractRestriction } from '../../AbstractRestriction';
+import { DrawingToolsManager } from '../../../../../DrawingToolsManager';
+import { GeometryMathManager } from '../../../../geometry/GeometryMathManager';
+import { IRay } from '@shapediver/viewer.features.interaction';
+import { ISnapRestriction, SnapRestrictionProperties } from '../../../../../../interfaces/ISnapRestriction';
+import { PlaneRestriction } from '../PlaneRestriction';
+import { RestrictionMetaData } from '../../../../../../interfaces/IRestriction';
+import { vec3 } from 'gl-matrix';
+
+// #region Type aliases (1)
+
+export type AxisRestrictionProperties = {
+    activationKeyX?: string;
+    activationKeyY?: string;
+    activationKeyZ?: string;
+    activationKeyPlane?: string;
+} & SnapRestrictionProperties;
+
+// #endregion Type aliases (1)
+
+// #region Classes (1)
+
+export class AxisRestriction extends AbstractRestriction implements ISnapRestriction {
+    // #region Properties (8)
+
+    readonly #activationKeyX: string;
+    readonly #activationKeyY: string;
+    readonly #activationKeyZ: string;
+    readonly #activationKeyPlane: string;
+    readonly #drawingToolsManager: DrawingToolsManager;
+    readonly #planeRestriction: PlaneRestriction;
+
+    #active: boolean = false;
+    #geometryMathManager: GeometryMathManager;
+    #priority: number = 0;
+
+    // #endregion Properties (8)
+
+    // #region Constructors (1)
+
+    constructor(drawingToolsManager: DrawingToolsManager, planeRestriction: PlaneRestriction, properties?: AxisRestrictionProperties) {
+        super(drawingToolsManager, 'axis');
+        this.#drawingToolsManager = drawingToolsManager;
+        this.#planeRestriction = planeRestriction;
+        this.#geometryMathManager = drawingToolsManager.geometryMathManager;
+
+        this.#activationKeyX = properties?.activationKeyX || 'x';
+        this.#activationKeyY = properties?.activationKeyY || 'y';
+        this.#activationKeyZ = properties?.activationKeyZ || 'z';
+        this.#activationKeyPlane = properties?.activationKeyPlane || 'p';
+
+        this.#priority = properties?.priority || 1;
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Getters And Setters (5)
+
+    public get active(): boolean {
+        return this.#active;
+    }
+
+    public set active(value: boolean) {
+        this.#active = value;
+
+        // if (this.#gridHelper) this.#gridHelper.visible = value;
+    }
+
+    public get enabledEditable(): boolean {
+        return this._enabledEditable;
+    }
+
+    public get priority(): number {
+        return this.#priority;
+    }
+
+    public set priority(value: number) {
+        this.#priority = value;
+    }
+
+    // #endregion Public Getters And Setters (5)
+
+    // #region Public Methods (2)
+
+    public snap(ray: IRay, point: vec3, metaData?: RestrictionMetaData): vec3 | undefined {
+        if (this.enabled === false) return;
+        if (!metaData || !metaData.referencePoint) return;
+
+        const xPressed = this.#drawingToolsManager.keyPressed(this.#activationKeyX);
+        const yPressed = this.#drawingToolsManager.keyPressed(this.#activationKeyY);
+        const zPressed = this.#drawingToolsManager.keyPressed(this.#activationKeyZ);
+        const pPressed = this.#drawingToolsManager.keyPressed('p');
+
+        if (xPressed) {
+            return this.#geometryMathManager.closestPoint({ origin: metaData.referencePoint, direction: this.#planeRestriction.vectorU }, point);
+        } else if (yPressed) {
+            return this.#geometryMathManager.closestPoint({ origin: metaData.referencePoint, direction: this.#planeRestriction.vectorV }, point);
+        } else if (zPressed) {
+            return this.#geometryMathManager.closestPointsRayRay({ origin: metaData.referencePoint, direction: this.#planeRestriction.normal }, ray).closestPointOnRay1;
+        } else if (pPressed) {
+            return this.#geometryMathManager.closestPointOnPlane(this.#planeRestriction.origin, this.#planeRestriction.normal, point);
+        }
+    }
+
+    public updatePlaneDefinition(): void {}
+
+    // #endregion Public Methods (2)
+
+    // #region Protected Methods (1)
+
+    protected visibilityChanged(): void { }
+
+    // #endregion Protected Methods (1)
+}
+
+// #endregion Classes (1)