@itwin/editor-frontend 3.0.0-dev.130 → 3.0.0-dev.131

package/lib/esm/SolidModelingTools.js

@@ -7,7 +7,7 @@
  */
 import { BooleanMode, ChamferMode, CutDepthMode, CutDirectionMode, EmbossDirectionMode, ProfileClosure, SubEntityType } from "@itwin/editor-common";
 import { ColorDef, ElementGeometry } from "@itwin/core-common";
-import { Geometry, LineString3d, Point3d, Vector3d } from "@itwin/core-geometry";
+import { Angle, Geometry, LineString3d, Point3d, Vector3d } from "@itwin/core-geometry";
 import { AccuDrawHintBuilder, EventHandled, GraphicType } from "@itwin/core-frontend";
 import { computeChordToleranceFromPoint } from "./CreateElementTool";
 import { ElementGeometryCacheTool, isSameSubEntity, LocateSubEntityTool, SubEntityData } from "./ElementGeometryTool";
@@ -353,6 +353,13 @@ export class FaceLocationData {
 }
 /** @alpha Identify faces of solids and surfaces to offset. */
 export class OffsetFacesTool extends LocateSubEntityTool {
+    constructor() {
+        super(...arguments);
+        // TODO: Tool settings for offset distance...
+        this.useOffset = false;
+        this.offset = 0.1;
+        this.addSmoothFaces = false;
+    }
     get wantDynamics() { return true; }
     get wantAccuSnap() { return this.isDynamicsStarted; }
     get geometryCacheFilter() {
@@ -376,6 +383,15 @@ export class OffsetFacesTool extends LocateSubEntityTool {
         builder.addPointString([faceData.point]);
         context.addDecorationFromBuilder(builder);
     }
+    async getSmoothFaces(id, face) {
+        try {
+            // NOTE: For offset, include all smoothly connected faces, not just adjacent...
+            return await ElementGeometryCacheTool.callCommand("getConnectedSubEntities", id, face, SubEntityType.Face, { smoothFaces: true });
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
     async applyAgendaOperation(ev, isAccept) {
         var _a;
         if (undefined === ev.viewport || this.agenda.isEmpty || !this.haveAcceptedSubEntities)
@@ -387,6 +403,8 @@ export class OffsetFacesTool extends LocateSubEntityTool {
         if (undefined === projPt)
             return undefined;
         const offsetDir = Vector3d.createStartEnd(faceData.point, projPt);
+        if (this.useOffset && undefined === offsetDir.scaleToLength(this.offset, offsetDir))
+            return undefined;
         let offset = offsetDir.magnitude();
         if (offset < Geometry.smallMetricDistance)
             return undefined;
@@ -394,14 +412,28 @@ export class OffsetFacesTool extends LocateSubEntityTool {
             offset = -offset;
         try {
             this._startedCmd = await this.startCommand();
-            const params = { faces: this.getAcceptedSubEntities(), distances: offset };
+            const id = this.agenda.elements[0];
+            const faces = this.getAcceptedSubEntities();
+            if (this.addSmoothFaces) {
+                const allSmoothFaces = [];
+                for (const face of faces) {
+                    const smoothFaces = await this.getSmoothFaces(id, face);
+                    if (undefined !== smoothFaces)
+                        allSmoothFaces.push(...smoothFaces);
+                }
+                for (const smooth of allSmoothFaces) {
+                    if (undefined === faces.find((selected) => isSameSubEntity(selected, smooth)))
+                        faces.unshift(smooth); // Preserve last selected entry as reference face...
+                }
+            }
+            const params = { faces, distances: offset };
             const opts = {
                 wantGraphic: isAccept ? undefined : true,
                 chordTolerance: computeChordToleranceFromPoint(ev.viewport, ev.point),
-                requestId: `${this.toolId}:${this.agenda.elements[0]}`,
+                requestId: `${this.toolId}:${id}`,
                 writeChanges: isAccept ? true : undefined,
             };
-            return await ElementGeometryCacheTool.callCommand("offsetFaces", this.agenda.elements[0], params, opts);
+            return await ElementGeometryCacheTool.callCommand("offsetFaces", id, params, opts);
         }
         catch (err) {
             return undefined;
@@ -468,6 +500,72 @@ export class HollowFacesTool extends LocateSubEntityTool {
 }
 HollowFacesTool.toolId = "HollowFaces";
 HollowFacesTool.iconSpec = "icon-move"; // TODO: Need better icon...
+/** @alpha Identify faces or edges for removal by growing surrounding faces. */
+export class DeleteSubEntitiesTool extends LocateSubEntityTool {
+    wantSubEntityType(type) {
+        switch (type) {
+            case SubEntityType.Face:
+            case SubEntityType.Edge:
+                // Choose all faces or all edges...
+                return (0 === this._acceptedSubEntities.length || this._acceptedSubEntities[0].props.type === type);
+            default:
+                return false;
+        }
+    }
+    getMaximumSubEntityHits(type) {
+        if (!this.wantSubEntityType(type))
+            return 0;
+        // Only return single closest edge, avoids having to test for redundant edges on reset...
+        return (SubEntityType.Edge === type ? 1 : 25);
+    }
+    get geometryCacheFilter() {
+        return { parts: true, curves: false, surfaces: true, solids: true, other: false };
+    }
+    async doPickSubEntities(id, ev) {
+        const hits = await super.doPickSubEntities(id, ev);
+        if (undefined === hits)
+            return hits;
+        // Don't allow reset to select a back edge...
+        if (SubEntityType.Face === hits[0].subEntity.type)
+            return hits.filter((hit) => { return SubEntityType.Face === hit.subEntity.type; });
+        try {
+            const accept = await ElementGeometryCacheTool.callCommand("isRedundantEdge", id, hits[0].subEntity);
+            if (accept)
+                return hits;
+            if (hits.length > 1 && SubEntityType.Face === hits[1].subEntity.type)
+                return hits.slice(1); // Accept face of rejected edge...
+            return undefined;
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    async applyAgendaOperation(ev, isAccept) {
+        if (undefined === ev.viewport || this.agenda.isEmpty || !this.haveAcceptedSubEntities)
+            return undefined;
+        try {
+            this._startedCmd = await this.startCommand();
+            const params = { subEntities: this.getAcceptedSubEntities() };
+            const opts = {
+                wantGraphic: isAccept ? undefined : true,
+                chordTolerance: computeChordToleranceFromPoint(ev.viewport, ev.point),
+                requestId: `${this.toolId}:${this.agenda.elements[0]}`,
+                writeChanges: isAccept ? true : undefined,
+            };
+            return await ElementGeometryCacheTool.callCommand("deleteSubEntities", this.agenda.elements[0], params, opts);
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    async onRestartTool() {
+        const tool = new DeleteSubEntitiesTool();
+        if (!await tool.run())
+            return this.exitTool();
+    }
+}
+DeleteSubEntitiesTool.toolId = "DeleteSubEntities";
+DeleteSubEntitiesTool.iconSpec = "icon-move"; // TODO: Need better icon...
 /** @alpha */
 export var ImprintSolidMethod;
 (function (ImprintSolidMethod) {
@@ -764,4 +862,205 @@ export class ChamferEdgesTool extends BlendEdgesTool {
 }
 ChamferEdgesTool.toolId = "ChamferEdges";
 ChamferEdgesTool.iconSpec = "icon-move"; // TODO: Need better icon...
+/** @alpha Identify faces of solids and surfaces to translate. */
+export class SweepFacesTool extends LocateSubEntityTool {
+    constructor() {
+        super(...arguments);
+        // TODO: Tool settings for sweep distance...
+        this.useDistance = false;
+        this.distance = 0.1;
+        this.addSmoothFaces = false;
+    }
+    get wantDynamics() { return true; }
+    get wantAccuSnap() { return this.isDynamicsStarted; }
+    // TODO: Sweep open path to surface, sweep surface to solid...
+    get geometryCacheFilter() {
+        return { parts: true, curves: false, surfaces: true, solids: true, other: false };
+    }
+    async createSubEntityData(id, hit) {
+        const data = await super.createSubEntityData(id, hit);
+        if (undefined !== hit.point && undefined !== hit.normal)
+            data.toolData = FaceLocationData.create(hit.point, hit.normal);
+        return data;
+    }
+    drawAcceptedSubEntities(context) {
+        var _a;
+        super.drawAcceptedSubEntities(context);
+        // Show pick point on last identified face, offset direction/distance will be computed from this location...
+        const faceData = (_a = this.getAcceptedSubEntityData()) === null || _a === void 0 ? void 0 : _a.toolData;
+        if (undefined === faceData)
+            return;
+        const builder = context.createGraphic({ type: GraphicType.WorldOverlay });
+        builder.setSymbology(context.viewport.getContrastToBackgroundColor(), ColorDef.black, 10);
+        builder.addPointString([faceData.point]);
+        context.addDecorationFromBuilder(builder);
+    }
+    async getSmoothFaces(id, face) {
+        try {
+            // NOTE: For sweep/translation, it makes sense to limit smooth to immediately adjacent...
+            return await ElementGeometryCacheTool.callCommand("getConnectedSubEntities", id, face, SubEntityType.Face, { smoothFaces: true, adjacentFaces: true });
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    async applyAgendaOperation(ev, isAccept) {
+        var _a;
+        if (undefined === ev.viewport || this.agenda.isEmpty || !this.haveAcceptedSubEntities)
+            return undefined;
+        const faceData = (_a = this.getAcceptedSubEntityData()) === null || _a === void 0 ? void 0 : _a.toolData;
+        if (undefined === faceData)
+            return undefined;
+        const path = Vector3d.createStartEnd(faceData.point, ev.point);
+        if (this.useDistance && undefined === path.scaleToLength(this.distance, path))
+            return undefined;
+        if (path.magnitude() < Geometry.smallMetricDistance)
+            return undefined;
+        try {
+            this._startedCmd = await this.startCommand();
+            const id = this.agenda.elements[0];
+            const opts = {
+                wantGraphic: isAccept ? undefined : true,
+                chordTolerance: computeChordToleranceFromPoint(ev.viewport, ev.point),
+                requestId: `${this.toolId}:${id}`,
+                writeChanges: isAccept ? true : undefined,
+            };
+            const faces = this.getAcceptedSubEntities();
+            if (this.addSmoothFaces) {
+                const allSmoothFaces = [];
+                for (const face of faces) {
+                    const smoothFaces = await this.getSmoothFaces(id, face);
+                    if (undefined !== smoothFaces)
+                        allSmoothFaces.push(...smoothFaces);
+                }
+                for (const smooth of allSmoothFaces) {
+                    if (undefined === faces.find((selected) => isSameSubEntity(selected, smooth)))
+                        faces.unshift(smooth); // Preserve last selected entry as reference face...
+                }
+            }
+            const params = { faces, path };
+            return await ElementGeometryCacheTool.callCommand("sweepFaces", id, params, opts);
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    setupAccuDraw() {
+        var _a;
+        if (!this.haveAcceptedSubEntities)
+            return;
+        const faceData = (_a = this.getAcceptedSubEntityData()) === null || _a === void 0 ? void 0 : _a.toolData;
+        if (undefined === faceData)
+            return;
+        const hints = new AccuDrawHintBuilder();
+        hints.setOriginFixed = true;
+        hints.setLockY = true;
+        hints.setLockZ = true;
+        hints.setModeRectangular();
+        hints.setOrigin(faceData.point);
+        hints.setXAxis2(faceData.normal);
+        hints.sendHints(false);
+    }
+    async onRestartTool() {
+        const tool = new SweepFacesTool();
+        if (!await tool.run())
+            return this.exitTool();
+    }
+}
+SweepFacesTool.toolId = "SweepFaces";
+SweepFacesTool.iconSpec = "icon-move"; // TODO: Need better icon...
+/** @alpha Identify faces of solids and surfaces to revolve. */
+export class SpinFacesTool extends LocateSubEntityTool {
+    constructor() {
+        super(...arguments);
+        this.points = [];
+        // TODO: Tool settings for sweep angle...
+        this.sweep = Angle.piOver2Radians;
+    }
+    get wantDynamics() { return true; }
+    get wantAccuSnap() { return this.isDynamicsStarted || (this.haveAcceptedSubEntities && !this.isControlDown); }
+    // TODO: Spin open path to surface, spin surface to solid...
+    get geometryCacheFilter() {
+        return { parts: true, curves: false, surfaces: true, solids: true, other: false };
+    }
+    getSubEntityFilter() {
+        return { nonPlanarFaces: true };
+    }
+    async createSubEntityData(id, hit) {
+        const data = await super.createSubEntityData(id, hit);
+        if (undefined !== hit.point && undefined !== hit.normal)
+            data.toolData = FaceLocationData.create(hit.point, hit.normal);
+        return data;
+    }
+    async applyAgendaOperation(ev, isAccept) {
+        if (undefined === ev.viewport || this.agenda.isEmpty || !this.haveAcceptedSubEntities || this.points.length < (isAccept ? 2 : 1))
+            return undefined;
+        const direction = Vector3d.createStartEnd(this.points[0], isAccept ? this.points[1] : ev.point);
+        if (direction.magnitude() < Geometry.smallMetricDistance)
+            return undefined;
+        const origin = this.points[0];
+        const angle = Angle.createRadians(this.sweep);
+        try {
+            this._startedCmd = await this.startCommand();
+            const id = this.agenda.elements[0];
+            const opts = {
+                wantGraphic: isAccept ? undefined : true,
+                chordTolerance: computeChordToleranceFromPoint(ev.viewport, ev.point),
+                requestId: `${this.toolId}:${id}`,
+                writeChanges: isAccept ? true : undefined,
+            };
+            const faces = this.getAcceptedSubEntities();
+            const params = { faces, origin, direction, angle };
+            let result = await ElementGeometryCacheTool.callCommand("spinFaces", id, params, opts);
+            // Spun face can be used to create a pocket...retry with negative sweep...
+            if (undefined === result) {
+                angle.setRadians(-angle.radians);
+                result = await ElementGeometryCacheTool.callCommand("spinFaces", id, params, opts);
+            }
+            return result;
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    onDynamicFrame(ev, context) {
+        if (0 === this.points.length)
+            return;
+        const pts = this.points.slice();
+        pts.push(ev.point.clone());
+        const builder = context.createGraphic({ type: GraphicType.WorldOverlay });
+        builder.setSymbology(context.viewport.getContrastToBackgroundColor(), ColorDef.black, 3);
+        builder.addLineString(pts);
+        context.addGraphic(builder.finish());
+        super.onDynamicFrame(ev, context);
+    }
+    async gatherInput(ev) {
+        if (this.haveAcceptedSubEntities)
+            this.points.push(ev.point.clone());
+        return super.gatherInput(ev);
+    }
+    get wantAdditionalInput() {
+        return super.wantAdditionalInput || this.points.length < 2;
+    }
+    setupAccuDraw() {
+        var _a;
+        if (!this.haveAcceptedSubEntities || 0 !== this.points.length)
+            return;
+        const faceData = (_a = this.getAcceptedSubEntityData()) === null || _a === void 0 ? void 0 : _a.toolData;
+        if (undefined === faceData)
+            return;
+        const hints = new AccuDrawHintBuilder();
+        hints.setModeRectangular();
+        hints.setOrigin(faceData.point);
+        hints.setNormal(faceData.normal);
+        hints.sendHints(false);
+    }
+    async onRestartTool() {
+        const tool = new SpinFacesTool();
+        if (!await tool.run())
+            return this.exitTool();
+    }
+}
+SpinFacesTool.toolId = "SpinFaces";
+SpinFacesTool.iconSpec = "icon-move"; // TODO: Need better icon...
 //# sourceMappingURL=SolidModelingTools.js.map