@shapediver/viewer.features.drawing-tools 3.1.0

package/src/business/implementation/managers/interaction/restrictions/axis/AxisRestriction.ts

@@ -0,0 +1,107 @@
+import { AbstractRestriction } from '../AbstractRestriction';
+import { DrawingToolsManager } from '../../../../DrawingToolsManager';
+import { GeometryMathManager } from '../../../geometry/GeometryMathManager';
+import { IRay } from '@shapediver/viewer.features.interaction';
+import { IRestriction, RestrictionMetaData, RestrictionProperties } from '../../../../../interfaces/IRestriction';
+import { ISnapRestriction } from '../../../../../interfaces/ISnapRestriction';
+import { vec3 } from 'gl-matrix';
+
+// #region Type aliases (1)
+
+export type AxisRestrictionProperties = {
+    activationKeyX?: string;
+    activationKeyY?: string;
+    activationKeyZ?: string;
+} & RestrictionProperties;
+
+// #endregion Type aliases (1)
+
+// #region Classes (1)
+
+export class AxisRestriction extends AbstractRestriction implements IRestriction {
+    // #region Properties (7)
+
+    readonly #activationKeyX: string;
+    readonly #activationKeyY: string;
+    readonly #activationKeyZ: string;
+    readonly #drawingToolsManager: DrawingToolsManager;
+
+    #geometryMathManager: GeometryMathManager;
+    #snapRestrictions: { [key: string]: ISnapRestriction; } = {};
+
+    // #endregion Properties (7)
+
+    // #region Constructors (1)
+
+    constructor(drawingToolsManager: DrawingToolsManager, id: string, properties: AxisRestrictionProperties) {
+        super(drawingToolsManager, id);
+        this.#drawingToolsManager = drawingToolsManager;
+        this.#geometryMathManager = drawingToolsManager.geometryMathManager;
+
+        this.#activationKeyX = properties.activationKeyX || 'x';
+        this.#activationKeyY = properties.activationKeyY || 'y';
+        this.#activationKeyZ = properties.activationKeyZ || 'z';
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Getters And Setters (2)
+
+    public get priority(): number {
+        return 1;
+    }
+
+    public get snapRestrictions(): { [key: string]: ISnapRestriction; } {
+        return this.#snapRestrictions;
+    }
+
+    // #endregion Public Getters And Setters (2)
+
+    // #region Public Methods (1)
+
+    public rayTrace(ray: IRay, 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 xyPressed = this.#drawingToolsManager.keyPressed(`${this.#activationKeyX}+${this.#activationKeyY}`);
+        const xzPressed = this.#drawingToolsManager.keyPressed(`${this.#activationKeyX}+${this.#activationKeyZ}`);
+        const yzPressed = this.#drawingToolsManager.keyPressed(`${this.#activationKeyY}+${this.#activationKeyZ}`);
+        const xyzPressed = this.#drawingToolsManager.keyPressed(`${this.#activationKeyX}+${this.#activationKeyY}+${this.#activationKeyZ}`);
+
+        if (xPressed) {
+            const { closestPointOnRay2 } = this.#geometryMathManager.closestPointsRayRay(ray, { origin: metaData.referencePoint, direction: vec3.fromValues(1, 0, 0) });
+            return closestPointOnRay2;
+        } else if (yPressed) {
+            const { closestPointOnRay2 } = this.#geometryMathManager.closestPointsRayRay(ray, { origin: metaData.referencePoint, direction: vec3.fromValues(0, 1, 0) });
+            return closestPointOnRay2;
+        } else if (zPressed) {
+            const { closestPointOnRay2 } = this.#geometryMathManager.closestPointsRayRay(ray, { origin: metaData.referencePoint, direction: vec3.fromValues(0, 0, 1) });
+            return closestPointOnRay2;
+        } else if (xyPressed) {
+            const { closestPointOnRay2 } = this.#geometryMathManager.closestPointsRayRay(ray, { origin: metaData.referencePoint, direction: vec3.fromValues(1, 1, 0) });
+            return closestPointOnRay2;
+        } else if (xzPressed) {
+            const { closestPointOnRay2 } = this.#geometryMathManager.closestPointsRayRay(ray, { origin: metaData.referencePoint, direction: vec3.fromValues(1, 0, 1) });
+            return closestPointOnRay2;
+        } else if (yzPressed) {
+            const { closestPointOnRay2 } = this.#geometryMathManager.closestPointsRayRay(ray, { origin: metaData.referencePoint, direction: vec3.fromValues(0, 1, 1) });
+            return closestPointOnRay2;
+        } else if (xyzPressed) {
+            const { closestPointOnRay2 } = this.#geometryMathManager.closestPointsRayRay(ray, { origin: metaData.referencePoint, direction: vec3.fromValues(1, 1, 1) });
+            return closestPointOnRay2;
+        }
+    }
+
+    // #endregion Public Methods (1)
+
+    // #region Protected Methods (1)
+
+    protected visibilityChanged(): void { }
+
+    // #endregion Protected Methods (1)
+}
+
+// #endregion Classes (1)

package/src/business/implementation/managers/interaction/restrictions/geometry/GeometryRestriction.ts

@@ -0,0 +1,237 @@
+import * as THREE from 'three';
+import { AbstractRestriction } from '../AbstractRestriction';
+import { DrawingToolsManager } from '../../../../DrawingToolsManager';
+import { GeometryMathManager } from '../../../geometry/GeometryMathManager';
+import { IRay, IViewportApi } from '@shapediver/viewer.features.interaction';
+import { IRestriction, RestrictionMetaData, RestrictionProperties } from '../../../../../interfaces/IRestriction';
+import { ISnapRestriction } from '../../../../../interfaces/ISnapRestriction';
+import { ITreeNode } from '@shapediver/viewer.shared.node-tree';
+import { Settings } from '../../../../../interfaces/IDrawingToolsManager';
+import { vec3 } from 'gl-matrix';
+
+// #region Type aliases (1)
+
+export type GeometryRestrictionProperties = {
+    /**
+     * The nodes to restrict the interaction to.
+     */
+    nodes: ITreeNode[];
+    /**
+     * If the geometry should be displayed as wireframe.
+     */
+    wireframe?: boolean;
+    /**
+     * The color of the wireframe.
+     */
+    wireframeColor?: string;
+} & RestrictionProperties;
+
+// #endregion Type aliases (1)
+
+// #region Classes (1)
+
+export class GeometryRestriction extends AbstractRestriction implements IRestriction {
+    // #region Properties (10)
+
+    readonly #raycaster = new THREE.Raycaster();
+    readonly #viewport: IViewportApi;
+
+    #geometryMathManager: GeometryMathManager;
+    #nodes: ITreeNode[] = [];
+    #settings: Settings;
+    #snapRestrictions: { [key: string]: ISnapRestriction; } = {};
+    #snapToEdges: boolean = true;
+    #snapToFaces: boolean = true;
+    #snapToVertices: boolean = true;
+    #visualizationObject: THREE.Object3D = new THREE.Object3D();
+    #wireframe: boolean;
+    #wireframeColor: string;
+
+    // #endregion Properties (10)
+
+    // #region Constructors (1)
+
+    constructor(drawingToolsManager: DrawingToolsManager, id: string, properties: GeometryRestrictionProperties) {
+        super(drawingToolsManager, id);
+        this.#viewport = drawingToolsManager.viewport;
+        this.#settings = drawingToolsManager.settings;
+        this.#geometryMathManager = drawingToolsManager.geometryMathManager;
+        this.#wireframe = properties.wireframe ?? true;
+        this.#wireframeColor = properties.wireframeColor ?? this.#settings.visualization.points.color_1 as string;
+
+        this.updateNodes(properties.nodes);
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Getters And Setters (8)
+
+    public get priority(): number {
+        return 0;
+    }
+
+    public get snapRestrictions(): { [key: string]: ISnapRestriction; } {
+        return this.#snapRestrictions;
+    }
+
+    public get snapToEdges(): boolean {
+        return this.#snapToEdges;
+    }
+
+    public set snapToEdges(value: boolean) {
+        this.#snapToEdges = value;
+    }
+
+    public get snapToFaces(): boolean {
+        return this.#snapToFaces;
+    }
+
+    public set snapToFaces(value: boolean) {
+        this.#snapToFaces = value;
+    }
+
+    public get snapToVertices(): boolean {
+        return this.#snapToVertices;
+    }
+
+    public set snapToVertices(value: boolean) {
+        this.#snapToVertices = value;
+    }
+
+    // #endregion Public Getters And Setters (8)
+
+    // #region Public Methods (2)
+
+    public rayTrace(ray: IRay, metaData?: RestrictionMetaData): vec3 | undefined {
+        if (this.enabled === false) return;
+        if (this.#snapToVertices === false && this.#snapToEdges === false && this.#snapToFaces === false) return;
+
+        this.#raycaster.ray.direction.set(ray.direction[0], ray.direction[1], ray.direction[2]);
+        this.#raycaster.ray.origin.set(ray.origin[0], ray.origin[1], ray.origin[2]);
+
+        // intersect all nodes
+        let intersections: THREE.Intersection[] = [];
+        this.#nodes.forEach(node => {
+            const threeJsObject = node.convertedObject[this.#viewport.id] as THREE.Object3D;
+            if (threeJsObject) {
+                const currentIntersections = this.#raycaster.intersectObject(threeJsObject);
+                intersections = intersections.concat(currentIntersections);
+            }
+        });
+
+        // sort
+        intersections.sort((a, b) => a.distance - b.distance);
+
+        // return first intersection
+        if (intersections.length > 0) {
+            const object = intersections[0].object as THREE.Mesh;
+            const geometry = object.geometry;
+            const positionAttribute = geometry.getAttribute('position');
+            const intersectionPoint = intersections[0].point;
+            const intersectionPointVec3 = vec3.fromValues(intersectionPoint.x, intersectionPoint.y, intersectionPoint.z);
+
+            if (!intersections[0].face) return vec3.fromValues(intersectionPoint.x, intersectionPoint.y, intersectionPoint.z);
+
+            if (this.#snapToVertices === true || this.#snapToEdges === true) {
+                const vertexA = new THREE.Vector3();
+                vertexA.fromBufferAttribute(positionAttribute, intersections[0].face!.a);
+                object.localToWorld(vertexA);
+                const vertexAVec3 = vec3.fromValues(vertexA.x, vertexA.y, vertexA.z);
+
+                const vertexB = new THREE.Vector3();
+                vertexB.fromBufferAttribute(positionAttribute, intersections[0].face!.b);
+                object.localToWorld(vertexB);
+                const vertexBVec3 = vec3.fromValues(vertexB.x, vertexB.y, vertexB.z);
+
+                const vertexC = new THREE.Vector3();
+                vertexC.fromBufferAttribute(positionAttribute, intersections[0].face!.c);
+                object.localToWorld(vertexC);
+                const vertexCVec3 = vec3.fromValues(vertexC.x, vertexC.y, vertexC.z);
+
+                if (this.#snapToVertices === true) {
+                    const distanceA = this.#geometryMathManager.screenSpaceDistanceCheck(intersectionPointVec3, vertexAVec3, this.#settings.visualization.points.size_0! * this.#settings.visualization.distanceMultiplicationFactor);
+                    const distanceB = this.#geometryMathManager.screenSpaceDistanceCheck(intersectionPointVec3, vertexBVec3, this.#settings.visualization.points.size_0! * this.#settings.visualization.distanceMultiplicationFactor);
+                    const distanceC = this.#geometryMathManager.screenSpaceDistanceCheck(intersectionPointVec3, vertexCVec3, this.#settings.visualization.points.size_0! * this.#settings.visualization.distanceMultiplicationFactor);
+
+                    // part 1 - check if the intersection point is close to a vertex
+                    if (distanceA.check && distanceA.distanceSquared < distanceB.distanceSquared && distanceA.distanceSquared < distanceC.distanceSquared) {
+                        return vec3.fromValues(vertexA.x, vertexA.y, vertexA.z);
+                    } else if (distanceB.check && distanceB.distanceSquared < distanceA.distanceSquared && distanceB.distanceSquared < distanceC.distanceSquared) {
+                        return vec3.fromValues(vertexB.x, vertexB.y, vertexB.z);
+                    } else if (distanceC.check && distanceC.distanceSquared < distanceA.distanceSquared && distanceC.distanceSquared < distanceB.distanceSquared) {
+                        return vec3.fromValues(vertexC.x, vertexC.y, vertexC.z);
+                    }
+                }
+
+                if (this.#snapToEdges === true) {
+                    // part 2 - check if the intersection point is close to an edge
+
+                    // create the closest points on the edges
+                    const closestPointOnEdgeAB = this.#geometryMathManager.closestPointOnLine(vertexAVec3, vertexBVec3, intersectionPointVec3);
+                    const closestPointOnEdgeBC = this.#geometryMathManager.closestPointOnLine(vertexBVec3, vertexCVec3, intersectionPointVec3);
+                    const closestPointOnEdgeCA = this.#geometryMathManager.closestPointOnLine(vertexCVec3, vertexAVec3, intersectionPointVec3);
+
+                    // create the distances
+                    const distanceAB = this.#geometryMathManager.screenSpaceDistanceCheck(intersectionPointVec3, closestPointOnEdgeAB, this.#settings.visualization.points.size_0! * this.#settings.visualization.distanceMultiplicationFactor);
+                    const distanceBC = this.#geometryMathManager.screenSpaceDistanceCheck(intersectionPointVec3, closestPointOnEdgeBC, this.#settings.visualization.points.size_0! * this.#settings.visualization.distanceMultiplicationFactor);
+                    const distanceCA = this.#geometryMathManager.screenSpaceDistanceCheck(intersectionPointVec3, closestPointOnEdgeCA, this.#settings.visualization.points.size_0! * this.#settings.visualization.distanceMultiplicationFactor);
+
+                    // check if the intersection point is close to an edge
+                    if (distanceAB.check && distanceAB.distanceSquared < distanceBC.distanceSquared && distanceAB.distanceSquared < distanceCA.distanceSquared) {
+                        return closestPointOnEdgeAB;
+                    } else if (distanceBC.check && distanceBC.distanceSquared < distanceAB.distanceSquared && distanceBC.distanceSquared < distanceCA.distanceSquared) {
+                        return closestPointOnEdgeBC;
+                    } else if (distanceCA.check && distanceCA.distanceSquared < distanceAB.distanceSquared && distanceCA.distanceSquared < distanceBC.distanceSquared) {
+                        return closestPointOnEdgeCA;
+                    }
+                }
+            }
+
+            if (this.#snapToFaces === true) {
+                // part 3 - face intersection
+                return vec3.fromValues(intersectionPoint.x, intersectionPoint.y, intersectionPoint.z);
+            }
+        }
+
+        return;
+    }
+
+    public updateNodes(nodes: ITreeNode[]) {
+        this.#nodes = nodes;
+
+        if (this.#wireframe) {
+            this.#visualizationObject.traverse((object) => {
+                if (object instanceof THREE.LineSegments) {
+                    object.geometry.dispose();
+                    object.material.dispose();
+                }
+            });
+            this._object3D.remove(this.#visualizationObject);
+
+            this.#visualizationObject = new THREE.Object3D();
+            this.#nodes.forEach(node => {
+                const threeJsObject = node.convertedObject[this.#viewport.id] as THREE.Object3D;
+                if (threeJsObject) {
+                    threeJsObject.traverse((object) => {
+                        if (object instanceof THREE.Mesh) {
+                            const wireframe = new THREE.WireframeGeometry(object.geometry);
+                            const line = new THREE.LineSegments(wireframe, new THREE.LineBasicMaterial({ color: new THREE.Color(this.#wireframeColor) }));
+                            this.#visualizationObject.add(line);
+                        }
+                    });
+                }
+            });
+            this._object3D.add(this.#visualizationObject);
+        }
+    }
+
+    // #endregion Public Methods (2)
+
+    // #region Protected Methods (1)
+
+    protected visibilityChanged(): void { }
+
+    // #endregion Protected Methods (1)
+}
+
+// #endregion Classes (1)

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

@@ -0,0 +1,257 @@
+import { AbstractRestriction } from '../AbstractRestriction';
+import { AngularRestriction, AngularRestrictionProperties } from './snap/AngularRestriction';
+import { DrawingToolsManager } from '../../../../DrawingToolsManager';
+import { GridRestriction, GridRestrictionProperties } from './snap/GridRestriction';
+import { IRay } from '@shapediver/viewer.features.interaction';
+import { IRestriction, RestrictionMetaData, RestrictionProperties } from '../../../../../interfaces/IRestriction';
+import { ISnapRestriction } from '../../../../../interfaces/ISnapRestriction';
+import { mat4, vec3 } from 'gl-matrix';
+import { UuidGenerator } from '@shapediver/viewer.shared.services';
+
+// #region Type aliases (1)
+
+export type PlaneRestrictionProperties = {
+    /**
+     * The origin of the plane.
+     * 
+     * @default vec3.fromValues(0, 0, 0)
+     */
+    origin?: vec3
+
+    /**
+     * Vector U of the plane
+     * with the cross product of vector_u and vector_v the normal of the plane can be calculated
+     */
+    vector_u?: vec3;
+
+    /**
+     * Vector V of the plane
+     * with the cross product of vector_u and vector_v the normal of the plane can be calculated
+     */
+    vector_v?: vec3;
+
+    /**
+     * grid snap restriction
+     */
+    gridSnapRestriction?: GridRestrictionProperties;
+
+    /**
+     * angular snap restriction
+     */
+    angularSnapRestriction?: AngularRestrictionProperties;
+} & RestrictionProperties;
+
+// #endregion Type aliases (1)
+
+// #region Classes (1)
+
+export class PlaneRestriction extends AbstractRestriction implements IRestriction {
+    // #region Properties (10)
+
+    readonly #uuidGenerator = UuidGenerator.instance;
+
+    #angularRestriction: AngularRestriction;
+    #gridRestriction: GridRestriction;
+    #normal: vec3;
+    #origin: vec3;
+    #snapRestrictions: { [key: string]: ISnapRestriction };
+    #transformationFromXYPlaneMatrix: mat4 = mat4.create();
+    #transformationToXYPlaneMatrix: mat4 = mat4.create();
+    #vectorU: vec3;
+    #vectorV: vec3;
+
+    // #endregion Properties (10)
+
+    // #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.#vectorU = properties.vector_u;
+        this.#vectorV = properties.vector_v;
+        this.#origin = properties.origin || vec3.create();
+
+        this.createTransformationMatrices();
+
+        this.#gridRestriction = new GridRestriction(drawingToolsManager, this, properties.gridSnapRestriction);
+        this.#angularRestriction = new AngularRestriction(drawingToolsManager, this, properties.angularSnapRestriction);
+
+        this.#snapRestrictions = {
+            grid: this.#gridRestriction,
+            angular: this.#angularRestriction
+        };
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Getters And Setters (13)
+
+    public get angularRestriction(): AngularRestriction {
+        return this.#angularRestriction;
+    }
+
+    public get gridRestriction(): GridRestriction {
+        return this.#gridRestriction;
+    }
+
+    public get normal(): vec3 {
+        return this.#normal;
+    }
+
+    public get origin(): vec3 {
+        return this.#origin;
+    }
+
+    public set origin(value: vec3) {
+        this.#origin = value;
+        this.#gridRestriction.updatePlaneDefinition(this.#origin, this.#vectorU, this.#vectorV, this.#normal);
+        this.createTransformationMatrices();
+    }
+
+    public get priority(): number {
+        return -1;
+    }
+
+    public get snapRestrictions(): { [key: string]: ISnapRestriction; } {
+        return this.#snapRestrictions;
+    }
+
+    public get transformationFromXYPlaneMatrix(): mat4 {
+        return this.#transformationFromXYPlaneMatrix;
+    }
+
+    public get transformationToXYPlaneMatrix(): mat4 {
+        return this.#transformationToXYPlaneMatrix;
+    }
+
+    public get vectorU(): vec3 {
+        return this.#vectorU;
+    }
+
+    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);
+    }
+
+    public get vectorV(): vec3 {
+        return this.#vectorV;
+    }
+
+    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);
+    }
+
+    // #endregion Public Getters And Setters (13)
+
+    // #region Public Methods (1)
+
+    public rayTrace(ray: IRay, metaData?: RestrictionMetaData): vec3 | undefined {
+        if (this.enabled === false) return vec3.create();
+
+        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)));
+
+        // 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);
+    }
+
+    // #endregion Public Methods (1)
+
+    // #region Protected Methods (1)
+
+    protected visibilityChanged(): void { }
+
+    // #endregion Protected Methods (1)
+
+    // #region Private Methods (2)
+
+    private createTransformationMatrices(): void {
+        // Calculate the transformation matrix for the rotation
+        const rotationMatrix = mat4.fromValues(
+            this.#vectorU[0], this.#vectorV[0], this.#normal[0], 0,
+            this.#vectorU[1], this.#vectorV[1], this.#normal[1], 0,
+            this.#vectorU[2], this.#vectorV[2], this.#normal[2], 0,
+            0, 0, 0, 1
+        );
+
+        const rotationMatrixInverse = mat4.invert(mat4.create(), rotationMatrix);
+        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]));
+
+        mat4.multiply(this.#transformationToXYPlaneMatrix, pivotMatrix, rotationMatrix);
+        mat4.multiply(this.#transformationToXYPlaneMatrix, this.#transformationToXYPlaneMatrix, pivotMatrixInverse);
+
+        mat4.multiply(this.#transformationFromXYPlaneMatrix, pivotMatrix, rotationMatrixInverse);
+        mat4.multiply(this.#transformationFromXYPlaneMatrix, this.#transformationFromXYPlaneMatrix, pivotMatrixInverse);
+    }
+
+    private snap(point: vec3, metaData?: RestrictionMetaData): vec3 | undefined {
+        if (this.enabled === false) return;
+
+        const sortedSnapRestrictions = Object.values(this.#snapRestrictions).sort((a, b) => b.priority - a.priority);
+
+        // group snap restrictions by priority
+        const groupedSnapRestrictions: { [key: number]: ISnapRestriction[] } = {};
+        for (const snapRestriction of sortedSnapRestrictions) {
+            if (!groupedSnapRestrictions[snapRestriction.priority]) groupedSnapRestrictions[snapRestriction.priority] = [];
+            groupedSnapRestrictions[snapRestriction.priority].push(snapRestriction);
+        }
+
+        // call snap method for each group
+        for (const snapRestrictions of Object.values(groupedSnapRestrictions)) {
+            const results = [];
+            for (const snapRestriction of snapRestrictions) {
+                results.push(snapRestriction.snap(point, metaData));
+            }
+
+            const indexedResults = results.map((value, index) => ({ index, value }));
+
+            // find the result that is closest to the point and set the snap restriction to active
+            indexedResults.sort((a, b) => {
+                if (!a.value) return 1;
+                if (!b.value) return -1;
+                return vec3.squaredDistance(point, a.value) - vec3.squaredDistance(point, b.value);
+            });
+
+            for (const snapRestriction of snapRestrictions) {
+                snapRestriction.active = false;
+            }
+
+            // if a snap restriction returned a result, return it
+            if (indexedResults[0].value !== undefined) {
+                snapRestrictions[indexedResults[0].index].active = true;
+                return indexedResults[0].value;
+            }
+        }
+
+        return point;
+    }
+
+    // #endregion Private Methods (2)
+}
+
+// #endregion Classes (1)