@shapediver/viewer.features.drawing-tools 3.3.4 → 3.3.7

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

@@ -1,237 +0,0 @@
-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

@@ -1,337 +0,0 @@
-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, IViewportApi } 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;
-
-    /**
-     * axis snap restriction
-     */
-    axisSnapRestriction?: AxisRestrictionProperties;
-} & RestrictionProperties;
-
-// #endregion Type aliases (1)
-
-// #region Classes (1)
-
-export class PlaneRestriction extends AbstractRestriction implements IRestriction {
-    // #region Properties (14)
-
-    readonly #properties: PlaneRestrictionProperties;
-    readonly #uuidGenerator = UuidGenerator.instance;
-    readonly #viewport: IViewportApi;
-
-    #angularRestriction: AngularRestriction;
-    #axisRestriction: AxisRestriction;
-    #cameraId: string = '';
-    #gridRestriction: GridRestriction;
-    #normal: vec3 = vec3.create();
-    #origin: vec3 = vec3.create();
-    #snapRestrictions: { [key: string]: ISnapRestriction };
-    #transformationFromXYPlaneMatrix: mat4 = mat4.create();
-    #transformationToXYPlaneMatrix: mat4 = mat4.create();
-    #vectorU: vec3 = vec3.create();
-    #vectorV: vec3 = vec3.create();
-
-    // #endregion Properties (14)
-
-    // #region Constructors (1)
-
-    constructor(drawingToolsManager: DrawingToolsManager, id: string, properties: PlaneRestrictionProperties) {
-        super(drawingToolsManager, id);
-
-        this.#viewport = drawingToolsManager.viewport;
-        this.#cameraId = this.#viewport.camera!.id;
-
-        this.#properties = properties;
-
-        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.updatePlaneDefinition();
-
-        this.#snapRestrictions = {
-            grid: this.#gridRestriction,
-            angular: this.#angularRestriction,
-            axis: this.#axisRestriction
-        };
-    }
-
-    // #endregion Constructors (1)
-
-    // #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;
-    }
-
-    public get normal(): vec3 {
-        return this.#normal;
-    }
-
-    public get origin(): vec3 {
-        return this.#origin;
-    }
-
-    public set origin(value: vec3) {
-        this.#origin = value;
-        this.updatePlaneDefinition();
-    }
-
-    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.#properties.vector_u = value;
-        this.updatePlaneDefinition();
-    }
-
-    public get vectorV(): vec3 {
-        return this.#vectorV;
-    }
-
-    public set vectorV(value: vec3) {
-        this.#properties.vector_v = value;
-        this.updatePlaneDefinition();
-    }
-
-    // #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)));
-
-        // 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(ray, intersection, metaData);
-    }
-
-    // #endregion Public Methods (1)
-
-    // #region Protected Methods (1)
-
-    protected visibilityChanged(): void { }
-
-    // #endregion Protected Methods (1)
-
-    // #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
-        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
-        );
-
-        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]));
-
-        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(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
-        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(ray, 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;
-    }
-
-    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)