@itwin/editor-frontend 4.0.0-dev.8 → 4.0.0-dev.81

package/lib/esm/ElementGeometryTool.js

@@ -1,702 +1,697 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Editing
- */
-import { Id64 } from "@itwin/core-bentley";
-import { FeatureAppearance, FeatureAppearanceProvider, RgbColor } from "@itwin/core-common";
-import { AccuDrawHintBuilder, BeModifierKeys, CoordSource, CoreTools, ElementSetTool, EventHandled, GraphicBranch, GraphicType, IModelApp, InputSource, readElementGraphics, ToolAssistance, ToolAssistanceImage, ToolAssistanceInputMethod, } from "@itwin/core-frontend";
-import { Point3d, Range3d, Transform } from "@itwin/core-geometry";
-import { BRepEntityType, editorBuiltInCmdIds, SubEntityType, } from "@itwin/editor-common";
-import { computeChordToleranceFromPoint } from "./CreateElementTool";
-import { EditTools } from "./EditTool";
-import { solidModelingIpc } from "./EditToolIpc";
-/** @alpha */
-export class ElementGeometryGraphicsProvider {
-    constructor(iModel) {
-        this.iModel = iModel;
-    }
-    /** Call to request a RenderGraphic for the supplied graphic data.
-     * @see [[cleanupGraphic]] Must be called when the tool exits.
-     */
-    async createGraphic(graphicData) {
-        try {
-            const graphic = await readElementGraphics(graphicData, this.iModel, Id64.invalid, true, { noFlash: true, noHilite: true });
-            const graphicOwner = graphic ? IModelApp.renderSystem.createGraphicOwner(graphic) : undefined;
-            this.cleanupGraphic();
-            return (undefined !== (this.graphic = graphicOwner));
-        }
-        catch {
-            return false;
-        }
-    }
-    /** Call to dispose of [[RenderGraphic]] held by [[RenderGraphicOwner]].
-     * @note Must be called when the tool exits to avoid leaks of graphics memory or other webgl resources.
-     */
-    cleanupGraphic() {
-        if (undefined === this.graphic)
-            return;
-        this.graphic.disposeGraphic();
-        this.graphic = undefined;
-    }
-    addGraphic(context, transform, opts) {
-        if (undefined === this.graphic)
-            return;
-        if (undefined === transform && undefined === opts) {
-            context.addGraphic(this.graphic);
-            return;
-        }
-        const branch = new GraphicBranch(false);
-        branch.add(this.graphic);
-        const branchGraphic = context.createGraphicBranch(branch, transform ? transform : Transform.createIdentity(), opts);
-        context.addGraphic(branchGraphic);
-    }
-    addDecoration(context, type, transform, opts) {
-        if (undefined === this.graphic)
-            return;
-        const branch = new GraphicBranch(false);
-        branch.add(this.graphic);
-        const branchGraphic = context.createGraphicBranch(branch, transform ? transform : Transform.createIdentity(), opts);
-        context.addDecoration(type, branchGraphic);
-    }
-}
-/** @alpha */
-export function isSameSubEntity(a, b) {
-    if (a.type !== b.type)
-        return false;
-    if (a.id !== b.id)
-        return false;
-    if ((undefined !== a.index ? a.index : 0) !== (undefined !== b.index ? b.index : 0))
-        return false;
-    return true;
-}
-/** @alpha */
-export class SubEntityData {
-    constructor(props) { this._props = props; }
-    get props() { return this._props; }
-    set props(value) {
-        this.cleanupGraphic();
-        this._props = value;
-    }
-    get geometry() { return this._geometry; }
-    set geometry(value) { this._geometry = value; }
-    isSame(other) { return isSameSubEntity(this._props, other); }
-    getAppearance(vp, accepted) {
-        var _a, _b, _c, _d;
-        const color = vp.hilite.color;
-        const rgb = RgbColor.fromColorDef(accepted ? color.inverse() : color);
-        const transparency = 0.25;
-        const emphasized = true; // Necessary for obscured sub-entities w/SceneGraphic...
-        let weight;
-        switch (this.props.type) {
-            case SubEntityType.Face:
-                break;
-            case SubEntityType.Edge:
-                const edgeWeight = accepted ? 1 : 3;
-                weight = ((_b = (_a = this._geometry) === null || _a === void 0 ? void 0 : _a.appearance) === null || _b === void 0 ? void 0 : _b.weight) ? Math.min(this._geometry.appearance.weight + edgeWeight, 31) : edgeWeight;
-                break;
-            case SubEntityType.Vertex:
-                const vertexWeight = accepted ? 8 : 10;
-                weight = ((_d = (_c = this._geometry) === null || _c === void 0 ? void 0 : _c.appearance) === null || _d === void 0 ? void 0 : _d.weight) ? Math.min(this._geometry.appearance.weight + vertexWeight, 31) : vertexWeight;
-                break;
-        }
-        return FeatureAppearance.fromJSON({ rgb, transparency, weight, emphasized, nonLocatable: true });
-    }
-    async createGraphic(iModel) {
-        var _a;
-        if (undefined === ((_a = this._geometry) === null || _a === void 0 ? void 0 : _a.graphic))
-            return false;
-        if (undefined === this._graphicsProvider)
-            this._graphicsProvider = new ElementGeometryGraphicsProvider(iModel);
-        return this._graphicsProvider.createGraphic(this._geometry.graphic);
-    }
-    cleanupGraphic() {
-        if (undefined === this._graphicsProvider)
-            return;
-        this._graphicsProvider.cleanupGraphic();
-        this._graphicsProvider = undefined;
-    }
-    get hasGraphic() {
-        var _a;
-        return (undefined !== ((_a = this._graphicsProvider) === null || _a === void 0 ? void 0 : _a.graphic));
-    }
-    display(context, accepted) {
-        var _a, _b;
-        if (undefined === ((_a = this._graphicsProvider) === null || _a === void 0 ? void 0 : _a.graphic))
-            return;
-        const range = (((_b = this._geometry) === null || _b === void 0 ? void 0 : _b.range) ? Range3d.fromJSON(this._geometry.range) : undefined);
-        const pixelSize = context.viewport.getPixelSizeAtPoint(range ? range.center : undefined);
-        const offsetDir = context.viewport.view.getZVector();
-        offsetDir.scaleToLength(3 * pixelSize, offsetDir);
-        const offsetTrans = Transform.createTranslation(offsetDir);
-        const appearanceProvider = FeatureAppearanceProvider.supplement((app) => {
-            return app.extendAppearance(this.getAppearance(context.viewport, accepted));
-        });
-        this._graphicsProvider.addDecoration(context, GraphicType.Scene, offsetTrans, { appearanceProvider });
-    }
-}
-/** @alpha Base class for tools that want to use the backend geometry cache. */
-export class ElementGeometryCacheTool extends ElementSetTool {
-    constructor() {
-        super(...arguments);
-        this._checkedIds = new Map();
-        this._firstResult = true;
-    }
-    allowView(vp) { return vp.view.is3d(); }
-    isCompatibleViewport(vp, isSelectedViewChange) { return (super.isCompatibleViewport(vp, isSelectedViewChange) && undefined !== vp && this.allowView(vp)); }
-    async startCommand() {
-        if (undefined !== this._startedCmd)
-            return this._startedCmd;
-        return EditTools.startCommand({ commandId: editorBuiltInCmdIds.cmdSolidModeling, iModelKey: this.iModel.key });
-    }
-    agendaAppearance(isDynamics) {
-        if (isDynamics) {
-            if (undefined === this._agendaAppearanceDynamic)
-                this._agendaAppearanceDynamic = FeatureAppearance.fromTransparency(0.0);
-            return this._agendaAppearanceDynamic;
-        }
-        if (undefined === this._agendaAppearanceDefault)
-            this._agendaAppearanceDefault = FeatureAppearance.fromTransparency(0.9);
-        return this._agendaAppearanceDefault;
-    }
-    get wantAgendaAppearanceOverride() { return false; }
-    addFeatureOverrides(overrides, _vp) {
-        if (this.agenda.isEmpty)
-            return;
-        const appearance = this.agendaAppearance(false);
-        this.agenda.elements.forEach((elementId) => overrides.override({ elementId, appearance }));
-    }
-    updateAgendaAppearanceProvider(drop) {
-        if (!this.wantAgendaAppearanceOverride)
-            return;
-        for (const vp of IModelApp.viewManager) {
-            if (!this.allowView(vp))
-                continue;
-            if (drop || this.agenda.isEmpty)
-                vp.dropFeatureOverrideProvider(this);
-            else if (!vp.addFeatureOverrideProvider(this))
-                vp.setFeatureOverrideProviderChanged();
-        }
-    }
-    get geometryCacheFilter() { return undefined; }
-    onGeometryCacheFilterChanged() { this._checkedIds.clear(); }
-    async createElementGeometryCache(id) {
-        // NOTE: Creates cache if it doesn't already exist then test new or existing cache against filter...
-        try {
-            this._startedCmd = await this.startCommand();
-            return await solidModelingIpc.createElementGeometryCache(id, this.geometryCacheFilter);
-        }
-        catch (err) {
-            return false;
-        }
-    }
-    async acceptElementForOperation(id) {
-        if (Id64.isInvalid(id) || Id64.isTransient(id))
-            return false;
-        let accept = this._checkedIds.get(id);
-        if (undefined === accept) {
-            if (this.agenda.isEmpty && this._checkedIds.size > 1000)
-                this._checkedIds.clear(); // Limit auto-locate cache size to something reasonable...
-            accept = await this.createElementGeometryCache(id);
-            this._checkedIds.set(id, accept);
-        }
-        return accept;
-    }
-    async isElementValidForOperation(hit, out) {
-        if (!await super.isElementValidForOperation(hit, out))
-            return false;
-        return this.acceptElementForOperation(hit.sourceId);
-    }
-    async postFilterIds(arg) {
-        const ids = [];
-        for (const id of Id64.iterable(arg)) {
-            if (await this.acceptElementForOperation(id))
-                ids.push(id);
-        }
-        return ids;
-    }
-    async getGroupIds(id) {
-        return this.postFilterIds(await super.getGroupIds(id));
-    }
-    async getSelectionSetCandidates(ss) {
-        return this.postFilterIds(await super.getSelectionSetCandidates(ss));
-    }
-    async getDragSelectCandidates(vp, origin, corner, method, overlap) {
-        return this.postFilterIds(await super.getDragSelectCandidates(vp, origin, corner, method, overlap));
-    }
-    onDynamicFrame(_ev, context) {
-        if (undefined === this._graphicsProvider)
-            return;
-        if (!this.wantAgendaAppearanceOverride)
-            return this._graphicsProvider.addGraphic(context);
-        const appearanceProvider = FeatureAppearanceProvider.supplement((app) => {
-            return app.extendAppearance(this.agendaAppearance(true));
-        });
-        this._graphicsProvider.addGraphic(context, undefined, { appearanceProvider });
-    }
-    async onMouseMotion(ev) {
-        return this.updateGraphic(ev, IModelApp.viewManager.inDynamicsMode);
-    }
-    async getGraphicData(_ev) { return undefined; }
-    async updateGraphic(ev, isDynamics) {
-        if (!isDynamics || this._graphicsPending)
-            return; // Continue displaying previous graphic if new graphic is still pending...
-        this._graphicsPending = true;
-        const graphicData = await this.getGraphicData(ev);
-        this._graphicsPending = undefined;
-        if (undefined !== graphicData) {
-            if (this._firstResult) {
-                this.updateAgendaAppearanceProvider();
-                this._firstResult = false;
-            }
-            return this.createGraphic(graphicData);
-        }
-        if (undefined !== this._graphicsProvider)
-            this._graphicsProvider.cleanupGraphic();
-    }
-    async createGraphic(graphicData) {
-        if (undefined === this._graphicsProvider)
-            this._graphicsProvider = new ElementGeometryGraphicsProvider(this.iModel);
-        await this._graphicsProvider.createGraphic(graphicData);
-    }
-    clearGraphic() {
-        if (undefined === this._graphicsProvider)
-            return;
-        this._graphicsProvider.cleanupGraphic();
-        this._graphicsProvider = undefined;
-    }
-    async clearElementGeometryCache() {
-        try {
-            this._startedCmd = await this.startCommand();
-            await solidModelingIpc.clearElementGeometryCache();
-        }
-        catch (err) { }
-    }
-    async onUnsuspend() {
-        if (!this._firstResult)
-            this.updateAgendaAppearanceProvider();
-        return super.onUnsuspend();
-    }
-    async onSuspend() {
-        if (!this._firstResult)
-            this.updateAgendaAppearanceProvider(true);
-        return super.onSuspend();
-    }
-    async onPostInstall() {
-        await super.onPostInstall();
-        if (this.wantAgendaAppearanceOverride)
-            this.agenda.manageHiliteState = false;
-    }
-    async onCleanup() {
-        await super.onCleanup();
-        await this.clearElementGeometryCache();
-        this.updateAgendaAppearanceProvider(true);
-        this.clearGraphic();
-    }
-}
-/** @alpha Base class for tools that need to locate faces, edges, and vertices. */
-export class LocateSubEntityTool extends ElementGeometryCacheTool {
-    constructor() {
-        super(...arguments);
-        this._acceptedSubEntities = [];
-        this._summaryIds = new Map();
-    }
-    provideToolAssistance(mainInstrText, additionalInstr) {
-        if (this.wantAdditionalSubEntities) {
-            const faceKey = this.wantSubEntityType(SubEntityType.Face) ? "Face" : "";
-            const edgeKey = this.wantSubEntityType(SubEntityType.Edge) ? "Edge" : "";
-            const vertexKey = this.wantSubEntityType(SubEntityType.Vertex) ? "Vertex" : "";
-            const subEntityKey = `${faceKey}${edgeKey}${vertexKey}`;
-            if (0 === subEntityKey.length) {
-                super.provideToolAssistance(mainInstrText, additionalInstr);
-                return;
-            }
-            if (undefined === mainInstrText)
-                mainInstrText = EditTools.translate(`LocateSubEntities.Identify.${subEntityKey}`);
-            const leftMsg = EditTools.translate(`LocateSubEntities.Accept.${subEntityKey}`);
-            const rightMsg = this.haveAcceptedSubEntities && this.allowSubEntitySelectNext ? EditTools.translate(`LocateSubEntities.AcceptNext.${subEntityKey}`) : CoreTools.translate("ElementSet.Inputs.Cancel");
-            const mouseInstructions = [];
-            const touchInstructions = [];
-            if (!ToolAssistance.createTouchCursorInstructions(touchInstructions))
-                touchInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.OneTouchTap, leftMsg, false, ToolAssistanceInputMethod.Touch));
-            mouseInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.LeftClick, leftMsg, false, ToolAssistanceInputMethod.Mouse));
-            touchInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.TwoTouchTap, rightMsg, false, ToolAssistanceInputMethod.Touch));
-            mouseInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.RightClick, rightMsg, false, ToolAssistanceInputMethod.Mouse));
-            if (this.allowSubEntityControlSelect)
-                mouseInstructions.push(ToolAssistance.createModifierKeyInstruction(ToolAssistance.ctrlKey, ToolAssistanceImage.LeftClickDrag, EditTools.translate(`LocateSubEntities.IdentifyAdditional.${subEntityKey}`), false, ToolAssistanceInputMethod.Mouse));
-            if (undefined !== additionalInstr) {
-                for (const instr of additionalInstr) {
-                    if (ToolAssistanceInputMethod.Touch === instr.inputMethod)
-                        touchInstructions.push(instr);
-                    else
-                        mouseInstructions.push(instr);
-                }
-            }
-            const sections = [];
-            sections.push(ToolAssistance.createSection(mouseInstructions, ToolAssistance.inputsLabel));
-            sections.push(ToolAssistance.createSection(touchInstructions, ToolAssistance.inputsLabel));
-            const mainInstruction = ToolAssistance.createInstruction(this.iconSpec, mainInstrText);
-            const instructions = ToolAssistance.createInstructions(mainInstruction, sections);
-            IModelApp.notifications.setToolAssistance(instructions);
-            return;
-        }
-        super.provideToolAssistance(mainInstrText, additionalInstr);
-    }
-    get wantAgendaAppearanceOverride() { return true; }
-    get wantGeometrySummary() { return false; }
-    get wantSubEntitySnap() { return false; }
-    wantSubEntityType(type) { return SubEntityType.Face === type; }
-    getMaximumSubEntityHits(type) { return this.wantSubEntityType(type) ? 25 : 0; }
-    get requiredSubEntityCount() { return 1; }
-    get haveAcceptedSubEntities() { return (0 !== this._acceptedSubEntities.length); }
-    get inhibitSubEntityDisplay() { return this.isDynamicsStarted; }
-    get allowSubEntityControlSelect() { return true; }
-    get allowSubEntityControlDeselect() { return this.allowSubEntityControlSelect; }
-    get allowSubEntitySelectNext() { return !this.isDynamicsStarted; }
-    getBRepEntityTypeForSubEntity(id, subEntity) {
-        const summary = this._summaryIds.get(id);
-        if (undefined === summary)
-            return BRepEntityType.Invalid;
-        const index = (undefined !== subEntity.index ? subEntity.index : 0);
-        if (index >= summary.length)
-            return BRepEntityType.Invalid;
-        return summary[index];
-    }
-    async createElementGeometrySummary(id) {
-        let summary = this._summaryIds.get(id);
-        if (undefined === summary) {
-            if (this.agenda.isEmpty && this._summaryIds.size > 1000)
-                this._summaryIds.clear(); // Limit auto-locate cache size to something reasonable...
-            try {
-                this._startedCmd = await this.startCommand();
-                if (undefined === (summary = await solidModelingIpc.summarizeElementGeometryCache(id)))
-                    return false;
-            }
-            catch (err) {
-                return false;
-            }
-            this._summaryIds.set(id, summary);
-        }
-        return true;
-    }
-    async createElementGeometryCache(id) {
-        const accept = await super.createElementGeometryCache(id);
-        return (accept && this.wantGeometrySummary ? this.createElementGeometrySummary(id) : accept);
-    }
-    getAcceptedSubEntityData(index = -1) {
-        if (-1 === index)
-            index = this._acceptedSubEntities.length - 1;
-        if (index < 0 || index > this._acceptedSubEntities.length - 1)
-            return undefined;
-        return this._acceptedSubEntities[index];
-    }
-    getAcceptedSubEntities() {
-        const accepted = [];
-        this._acceptedSubEntities.forEach((entry) => accepted.push(entry.props));
-        return accepted;
-    }
-    drawSubEntity(context, subEntity, accepted) {
-        subEntity.display(context, accepted);
-    }
-    drawAcceptedSubEntities(context) {
-        this._acceptedSubEntities.forEach((entry) => this.drawSubEntity(context, entry, true));
-    }
-    decorate(context) {
-        if (this.inhibitSubEntityDisplay || !this.allowView(context.viewport))
-            return;
-        if (this.haveAcceptedSubEntities)
-            this.drawAcceptedSubEntities(context);
-        if (undefined !== this._currentSubEntity)
-            this.drawSubEntity(context, this._currentSubEntity, false);
-    }
-    decorateSuspended(context) {
-        if (this.inhibitSubEntityDisplay || !this.allowView(context.viewport))
-            return;
-        if (this.haveAcceptedSubEntities)
-            this.drawAcceptedSubEntities(context);
-    }
-    getLocateAperture(ev) {
-        if (undefined === ev.viewport)
-            return 0.0;
-        return ev.viewport.pixelsFromInches(InputSource.Touch === ev.inputSource ? IModelApp.locateManager.touchApertureInches : IModelApp.locateManager.apertureInches);
-    }
-    getMaxRayDistance(ev, aperture) {
-        if (undefined === ev.viewport)
-            return 0.0;
-        // NOTE: Compute a world coordinate radius for ray test, try getting aperture size at point on element...
-        const hit = IModelApp.accuSnap.currHit;
-        const vec = [];
-        vec[0] = ev.viewport.worldToView(hit ? hit.hitPoint : ev.point);
-        vec[1] = vec[0].clone();
-        vec[1].x += 1;
-        ev.viewport.viewToWorldArray(vec);
-        // The edge and vertex hits get post-filtered on xy distance, so this is fine for perspective views...
-        return (aperture * vec[0].distance(vec[1]));
-    }
-    getRayOrigin(ev) {
-        const spacePoint = ev.point.clone();
-        const vp = ev.viewport;
-        if (undefined === vp)
-            return spacePoint;
-        vp.worldToNpc(spacePoint, spacePoint);
-        spacePoint.z = 1.0;
-        vp.npcToWorld(spacePoint, spacePoint);
-        return spacePoint;
-    }
-    wantHiddenEdges(vp) {
-        return vp.viewFlags.hiddenEdgesVisible();
-    }
-    getSubEntityFilter() { return undefined; }
-    async pickSubEntities(id, boresite, maxFace, maxEdge, maxVertex, maxDistance, hiddenEdgesVisible, filter) {
-        try {
-            this._startedCmd = await this.startCommand();
-            const opts = {
-                maxFace,
-                maxEdge,
-                maxVertex,
-                maxDistance,
-                hiddenEdgesVisible,
-                filter,
-            };
-            return await solidModelingIpc.locateSubEntities(id, boresite.origin, boresite.direction, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async doPickSubEntities(id, ev) {
-        const vp = ev.viewport;
-        if (undefined === vp)
-            return undefined;
-        const maxFace = this.getMaximumSubEntityHits(SubEntityType.Face);
-        const maxEdge = this.getMaximumSubEntityHits(SubEntityType.Edge);
-        const maxVertex = this.getMaximumSubEntityHits(SubEntityType.Vertex);
-        if (0 === maxFace && 0 === maxEdge && 0 === maxVertex)
-            return undefined;
-        const aperture = this.getLocateAperture(ev);
-        const maxDistance = this.getMaxRayDistance(ev, aperture);
-        const spacePoint = this.getRayOrigin(ev);
-        const boresite = AccuDrawHintBuilder.getBoresite(spacePoint, vp);
-        const hiddenEdgesVisible = this.wantHiddenEdges(vp);
-        const filter = this.getSubEntityFilter();
-        let hits = await this.pickSubEntities(id, boresite, maxFace, maxEdge, maxVertex, maxDistance, hiddenEdgesVisible, filter);
-        // NOTE: Remove erroneous edge/vertex hits in perspective views by checking real xy distance to hit point...
-        if (undefined === hits || !vp.isCameraOn)
-            return hits;
-        if (maxEdge > 0 && hits.length > 1) {
-            const edgeApertureSquared = (aperture * aperture);
-            const vertexApertureSquared = ((aperture * 2.0) * (aperture * 2.0));
-            const e2 = Math.pow(aperture, 2);
-            const v2 = Math.pow(aperture * 2.0, 2);
-            if (e2 !== edgeApertureSquared || v2 !== vertexApertureSquared)
-                return hits;
-            const rayOrigin = vp.worldToView(boresite.origin);
-            hits = hits.filter((hit) => {
-                if (SubEntityType.Face === hit.subEntity.type)
-                    return true;
-                const hitPoint = vp.worldToView(Point3d.fromJSON(hit.point));
-                const distance = hitPoint.distanceSquaredXY(rayOrigin);
-                return (distance <= (SubEntityType.Edge === hit.subEntity.type ? edgeApertureSquared : vertexApertureSquared));
-            });
-        }
-        return hits;
-    }
-    async createSubEntityData(id, hit) {
-        const data = new SubEntityData(hit.subEntity);
-        const chordTolerance = (this.targetView ? computeChordToleranceFromPoint(this.targetView, Point3d.fromJSON(hit.point)) : undefined);
-        await this.createSubEntityGraphic(id, data, chordTolerance);
-        return data;
-    }
-    /** Append specified sub-entity to accepted array. */
-    async addSubEntity(id, props) {
-        this._acceptedSubEntities.push(await this.createSubEntityData(id, props));
-    }
-    /** Remove specified sub-entity from accepted array, or pop last sub-entity if undefined. */
-    async removeSubEntity(_id, props) {
-        if (undefined !== props)
-            this._acceptedSubEntities = this._acceptedSubEntities.filter((entry) => !isSameSubEntity(entry.props, props.subEntity));
-        else
-            this._acceptedSubEntities.pop();
-    }
-    /** Locate sub-entities for the most recently added (last) agenda entry. Tool sub-classes that wish to identity
-     * sub-entities from multiple elements are responsible for maintaining the sub-entities per-element.
-     */
-    async doLocateSubEntity(ev, newSearch) {
-        var _a;
-        if (this.agenda.isEmpty || undefined === ev.viewport)
-            return false;
-        const id = this.agenda.elements[this.agenda.length - 1];
-        if (newSearch) {
-            this._locatedSubEntities = await this.doPickSubEntities(id, ev);
-            if (undefined === this._locatedSubEntities || 0 === this._locatedSubEntities.length)
-                return false;
-            /** NOTE: Set last button location to point on sub-entity when not snapping.
-              * If dynamics are enabled on this event, onDynamicFrame is called with this location.
-              */
-            if (CoordSource.ElemSnap !== ev.coordsFrom) {
-                ev.point.setFrom(Point3d.fromJSON(this._locatedSubEntities[0].point));
-                IModelApp.toolAdmin.setAdjustedDataPoint(ev);
-            }
-        }
-        else {
-            await this.removeSubEntity(id);
-        }
-        const hit = (_a = this._locatedSubEntities) === null || _a === void 0 ? void 0 : _a.shift();
-        if (undefined !== hit) {
-            if (undefined === this._acceptedSubEntities.find((entry) => isSameSubEntity(entry.props, hit.subEntity)))
-                await this.addSubEntity(id, hit);
-            else if (this.allowSubEntityControlDeselect)
-                await this.removeSubEntity(id, hit);
-        }
-        IModelApp.viewManager.invalidateDecorationsAllViews();
-        return true;
-    }
-    async chooseNextHit(ev) {
-        if (!this.haveAcceptedSubEntities)
-            return super.chooseNextHit(ev);
-        if (!this.allowSubEntitySelectNext) {
-            await this.onReinitialize(); // Don't cycle through hits after starting dynamics...
-        }
-        else {
-            await this.doLocateSubEntity(ev, false);
-            if (!this.haveAcceptedSubEntities)
-                await this.onReinitialize();
-        }
-        return EventHandled.No;
-    }
-    get wantAdditionalSubEntities() {
-        return (this._acceptedSubEntities.length < this.requiredSubEntityCount || (this.allowSubEntityControlSelect && this.isControlDown));
-    }
-    async gatherInput(ev) {
-        if (this.wantAdditionalSubEntities) {
-            await this.doLocateSubEntity(ev, true);
-            if (this.wantAdditionalSubEntities) {
-                this.setupAndPromptForNextAction();
-                return EventHandled.No;
-            }
-            this.clearCurrentSubEntity();
-        }
-        return super.gatherInput(ev);
-    }
-    getCurrentElement() {
-        if (!this.agenda.isEmpty)
-            return this.agenda.elements[this.agenda.length - 1];
-        const hit = IModelApp.accuSnap.currHit;
-        return (undefined !== hit && hit.isElementHit ? hit.sourceId : undefined);
-    }
-    clearCurrentSubEntity() {
-        if (undefined === this._currentSubEntity)
-            return;
-        this._currentSubEntity.cleanupGraphic();
-        this._currentSubEntity = undefined;
-    }
-    async setCurrentSubEntity(id, hit, chordTolerance) {
-        if (undefined === this._currentSubEntity)
-            this._currentSubEntity = new SubEntityData(hit.subEntity);
-        else
-            this._currentSubEntity.props = hit.subEntity;
-        return this.createSubEntityGraphic(id, this._currentSubEntity, chordTolerance);
-    }
-    async changeCurrentSubEntity(id, current, chordTolerance) {
-        if (undefined === id || undefined === current) {
-            if (undefined === this._currentSubEntity || !this._currentSubEntity.hasGraphic)
-                return false;
-            this._currentSubEntity.cleanupGraphic();
-            return true;
-        }
-        if (undefined !== this._currentSubEntity && this._currentSubEntity.hasGraphic && this._currentSubEntity.isSame(current.subEntity))
-            return false;
-        return this.setCurrentSubEntity(id, current, chordTolerance);
-    }
-    async updateCurrentSubEntity(ev) {
-        if (undefined === ev.viewport)
-            return false;
-        const id = this.wantAdditionalSubEntities ? this.getCurrentElement() : undefined;
-        if (undefined === id)
-            return this.changeCurrentSubEntity();
-        if (this._subEntityGraphicPending)
-            return false;
-        this._subEntityGraphicPending = true;
-        const current = await this.doPickSubEntities(id, ev);
-        const chordTolerance = current ? computeChordToleranceFromPoint(ev.viewport, Point3d.fromJSON(current[0].point)) : 0.0;
-        const status = await this.changeCurrentSubEntity(id, current ? current[0] : undefined, chordTolerance);
-        this._subEntityGraphicPending = undefined;
-        if (status)
-            IModelApp.viewManager.invalidateDecorationsAllViews();
-        return status;
-    }
-    async createSubEntityGraphic(id, data, chordTolerance) {
-        try {
-            const opts = {
-                wantGraphic: true,
-                wantRange: true,
-                wantAppearance: true,
-                chordTolerance,
-            };
-            data.chordTolerance = chordTolerance;
-            data.geometry = await solidModelingIpc.getSubEntityGeometry(id, data.props, opts);
-            return await data.createGraphic(this.iModel);
-        }
-        catch (err) {
-            return false;
-        }
-    }
-    async updateGraphic(ev, isDynamics) {
-        if (isDynamics)
-            return super.updateGraphic(ev, isDynamics);
-        await this.updateCurrentSubEntity(ev);
-    }
-    async getGraphicData(ev) {
-        const result = await this.applyAgendaOperation(ev, false);
-        return result === null || result === void 0 ? void 0 : result.graphic;
-    }
-    async applyAgendaOperation(_ev, _isAccept) { return undefined; }
-    async processAgenda(ev) {
-        const result = await this.applyAgendaOperation(ev, true);
-        if (result === null || result === void 0 ? void 0 : result.elementId)
-            await this.saveChanges();
-    }
-    async onModifierKeyTransition(wentDown, modifier, event) {
-        if (EventHandled.Yes === await super.onModifierKeyTransition(wentDown, modifier, event))
-            return EventHandled.Yes;
-        if (BeModifierKeys.Control !== modifier)
-            return EventHandled.No;
-        if (IModelApp.toolAdmin.isLocateCircleOn === this.wantAdditionalSubEntities)
-            return EventHandled.No;
-        this.setupAndPromptForNextAction();
-        return EventHandled.Yes;
-    }
-    changeLocateState(enableLocate, enableSnap, cursor, coordLockOvr) {
-        super.changeLocateState(enableLocate, enableSnap, cursor, coordLockOvr);
-        // Keep showing locate circle when identifying sub-entities even if done locating elements...
-        if (!IModelApp.toolAdmin.isLocateCircleOn && this.wantAdditionalSubEntities)
-            IModelApp.toolAdmin.setLocateCircleOn(true);
-    }
-    get shouldEnableSnap() {
-        if (this.isSelectByPoints || !this.wantAccuSnap)
-            return false;
-        if (this.isDynamicsStarted)
-            return true;
-        const isCtrlSelect = (this.isControlDown && (this.controlKeyContinuesSelection || this.allowSubEntityControlSelect));
-        if (isCtrlSelect || this.wantAdditionalElements || this.wantAdditionalSubEntities)
-            return this.wantSubEntitySnap;
-        return !this.wantSubEntitySnap;
-    }
-    setupAccuDraw() { }
-    setupAndPromptForNextAction() {
-        this.setupAccuDraw();
-        super.setupAndPromptForNextAction();
-    }
-    clearSubEntityGraphics() {
-        if (undefined !== this._currentSubEntity)
-            this._currentSubEntity.cleanupGraphic();
-        this._acceptedSubEntities.forEach((entry) => entry.cleanupGraphic());
-    }
-    async onCleanup() {
-        this.clearSubEntityGraphics();
-        return super.onCleanup();
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Editing
+ */
+import { Id64 } from "@itwin/core-bentley";
+import { FeatureAppearance, FeatureAppearanceProvider, RgbColor } from "@itwin/core-common";
+import { AccuDrawHintBuilder, BeModifierKeys, CoordSource, CoreTools, ElementSetTool, EventHandled, GraphicBranch, GraphicType, IModelApp, InputSource, readElementGraphics, ToolAssistance, ToolAssistanceImage, ToolAssistanceInputMethod, } from "@itwin/core-frontend";
+import { Point3d, Range3d, Transform } from "@itwin/core-geometry";
+import { BRepEntityType, editorBuiltInCmdIds, SubEntityType, } from "@itwin/editor-common";
+import { computeChordToleranceFromPoint } from "./CreateElementTool";
+import { EditTools } from "./EditTool";
+import { solidModelingIpc } from "./EditToolIpc";
+/** @alpha */
+export class ElementGeometryGraphicsProvider {
+    constructor(iModel) {
+        this.iModel = iModel;
+    }
+    /** Call to request a RenderGraphic for the supplied graphic data.
+     * @see [[cleanupGraphic]] Must be called when the tool exits.
+     */
+    async createGraphic(graphicData) {
+        try {
+            const graphic = await readElementGraphics(graphicData, this.iModel, Id64.invalid, true, { noFlash: true, noHilite: true });
+            const graphicOwner = graphic ? IModelApp.renderSystem.createGraphicOwner(graphic) : undefined;
+            this.cleanupGraphic();
+            return (undefined !== (this.graphic = graphicOwner));
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Call to dispose of [[RenderGraphic]] held by [[RenderGraphicOwner]].
+     * @note Must be called when the tool exits to avoid leaks of graphics memory or other webgl resources.
+     */
+    cleanupGraphic() {
+        if (undefined === this.graphic)
+            return;
+        this.graphic.disposeGraphic();
+        this.graphic = undefined;
+    }
+    addGraphic(context, transform, opts) {
+        if (undefined === this.graphic)
+            return;
+        if (undefined === transform && undefined === opts) {
+            context.addGraphic(this.graphic);
+            return;
+        }
+        const branch = new GraphicBranch(false);
+        branch.add(this.graphic);
+        const branchGraphic = context.createGraphicBranch(branch, transform ? transform : Transform.createIdentity(), opts);
+        context.addGraphic(branchGraphic);
+    }
+    addDecoration(context, type, transform, opts) {
+        if (undefined === this.graphic)
+            return;
+        const branch = new GraphicBranch(false);
+        branch.add(this.graphic);
+        const branchGraphic = context.createGraphicBranch(branch, transform ? transform : Transform.createIdentity(), opts);
+        context.addDecoration(type, branchGraphic);
+    }
+}
+/** @alpha */
+export function isSameSubEntity(a, b) {
+    if (a.type !== b.type)
+        return false;
+    if (a.id !== b.id)
+        return false;
+    if ((undefined !== a.index ? a.index : 0) !== (undefined !== b.index ? b.index : 0))
+        return false;
+    return true;
+}
+/** @alpha */
+export class SubEntityData {
+    constructor(props) { this._props = props; }
+    get props() { return this._props; }
+    set props(value) {
+        this.cleanupGraphic();
+        this._props = value;
+    }
+    get geometry() { return this._geometry; }
+    set geometry(value) { this._geometry = value; }
+    isSame(other) { return isSameSubEntity(this._props, other); }
+    getAppearance(vp, accepted) {
+        const color = vp.hilite.color;
+        const rgb = RgbColor.fromColorDef(accepted ? color.inverse() : color);
+        const transparency = 0.25;
+        const emphasized = true; // Necessary for obscured sub-entities w/SceneGraphic...
+        let weight;
+        switch (this.props.type) {
+            case SubEntityType.Face:
+                break;
+            case SubEntityType.Edge:
+                const edgeWeight = accepted ? 1 : 3;
+                weight = this._geometry?.appearance?.weight ? Math.min(this._geometry.appearance.weight + edgeWeight, 31) : edgeWeight;
+                break;
+            case SubEntityType.Vertex:
+                const vertexWeight = accepted ? 8 : 10;
+                weight = this._geometry?.appearance?.weight ? Math.min(this._geometry.appearance.weight + vertexWeight, 31) : vertexWeight;
+                break;
+        }
+        return FeatureAppearance.fromJSON({ rgb, transparency, weight, emphasized, nonLocatable: true });
+    }
+    async createGraphic(iModel) {
+        if (undefined === this._geometry?.graphic)
+            return false;
+        if (undefined === this._graphicsProvider)
+            this._graphicsProvider = new ElementGeometryGraphicsProvider(iModel);
+        return this._graphicsProvider.createGraphic(this._geometry.graphic);
+    }
+    cleanupGraphic() {
+        if (undefined === this._graphicsProvider)
+            return;
+        this._graphicsProvider.cleanupGraphic();
+        this._graphicsProvider = undefined;
+    }
+    get hasGraphic() {
+        return (undefined !== this._graphicsProvider?.graphic);
+    }
+    display(context, accepted) {
+        if (undefined === this._graphicsProvider?.graphic)
+            return;
+        const range = (this._geometry?.range ? Range3d.fromJSON(this._geometry.range) : undefined);
+        const pixelSize = context.viewport.getPixelSizeAtPoint(range ? range.center : undefined);
+        const offsetDir = context.viewport.view.getZVector();
+        offsetDir.scaleToLength(3 * pixelSize, offsetDir);
+        const offsetTrans = Transform.createTranslation(offsetDir);
+        const appearanceProvider = FeatureAppearanceProvider.supplement((app) => {
+            return app.extendAppearance(this.getAppearance(context.viewport, accepted));
+        });
+        this._graphicsProvider.addDecoration(context, GraphicType.Scene, offsetTrans, { appearanceProvider });
+    }
+}
+/** @alpha Base class for tools that want to use the backend geometry cache. */
+export class ElementGeometryCacheTool extends ElementSetTool {
+    constructor() {
+        super(...arguments);
+        this._checkedIds = new Map();
+        this._firstResult = true;
+    }
+    allowView(vp) { return vp.view.is3d(); }
+    isCompatibleViewport(vp, isSelectedViewChange) { return (super.isCompatibleViewport(vp, isSelectedViewChange) && undefined !== vp && this.allowView(vp)); }
+    async startCommand() {
+        if (undefined !== this._startedCmd)
+            return this._startedCmd;
+        return EditTools.startCommand({ commandId: editorBuiltInCmdIds.cmdSolidModeling, iModelKey: this.iModel.key });
+    }
+    agendaAppearance(isDynamics) {
+        if (isDynamics) {
+            if (undefined === this._agendaAppearanceDynamic)
+                this._agendaAppearanceDynamic = FeatureAppearance.fromTransparency(0.0);
+            return this._agendaAppearanceDynamic;
+        }
+        if (undefined === this._agendaAppearanceDefault)
+            this._agendaAppearanceDefault = FeatureAppearance.fromTransparency(0.9);
+        return this._agendaAppearanceDefault;
+    }
+    get wantAgendaAppearanceOverride() { return false; }
+    addFeatureOverrides(overrides, _vp) {
+        if (this.agenda.isEmpty)
+            return;
+        const appearance = this.agendaAppearance(false);
+        this.agenda.elements.forEach((elementId) => overrides.override({ elementId, appearance }));
+    }
+    updateAgendaAppearanceProvider(drop) {
+        if (!this.wantAgendaAppearanceOverride)
+            return;
+        for (const vp of IModelApp.viewManager) {
+            if (!this.allowView(vp))
+                continue;
+            if (drop || this.agenda.isEmpty)
+                vp.dropFeatureOverrideProvider(this);
+            else if (!vp.addFeatureOverrideProvider(this))
+                vp.setFeatureOverrideProviderChanged();
+        }
+    }
+    get geometryCacheFilter() { return undefined; }
+    onGeometryCacheFilterChanged() { this._checkedIds.clear(); }
+    async createElementGeometryCache(id) {
+        // NOTE: Creates cache if it doesn't already exist then test new or existing cache against filter...
+        try {
+            this._startedCmd = await this.startCommand();
+            return await solidModelingIpc.createElementGeometryCache(id, this.geometryCacheFilter);
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async acceptElementForOperation(id) {
+        if (Id64.isInvalid(id) || Id64.isTransient(id))
+            return false;
+        let accept = this._checkedIds.get(id);
+        if (undefined === accept) {
+            if (this.agenda.isEmpty && this._checkedIds.size > 1000)
+                this._checkedIds.clear(); // Limit auto-locate cache size to something reasonable...
+            accept = await this.createElementGeometryCache(id);
+            this._checkedIds.set(id, accept);
+        }
+        return accept;
+    }
+    async isElementValidForOperation(hit, out) {
+        if (!await super.isElementValidForOperation(hit, out))
+            return false;
+        return this.acceptElementForOperation(hit.sourceId);
+    }
+    async postFilterIds(arg) {
+        const ids = [];
+        for (const id of Id64.iterable(arg)) {
+            if (await this.acceptElementForOperation(id))
+                ids.push(id);
+        }
+        return ids;
+    }
+    async getGroupIds(id) {
+        return this.postFilterIds(await super.getGroupIds(id));
+    }
+    async getSelectionSetCandidates(ss) {
+        return this.postFilterIds(await super.getSelectionSetCandidates(ss));
+    }
+    async getDragSelectCandidates(vp, origin, corner, method, overlap) {
+        return this.postFilterIds(await super.getDragSelectCandidates(vp, origin, corner, method, overlap));
+    }
+    onDynamicFrame(_ev, context) {
+        if (undefined === this._graphicsProvider)
+            return;
+        if (!this.wantAgendaAppearanceOverride)
+            return this._graphicsProvider.addGraphic(context);
+        const appearanceProvider = FeatureAppearanceProvider.supplement((app) => {
+            return app.extendAppearance(this.agendaAppearance(true));
+        });
+        this._graphicsProvider.addGraphic(context, undefined, { appearanceProvider });
+    }
+    async onMouseMotion(ev) {
+        return this.updateGraphic(ev, IModelApp.viewManager.inDynamicsMode);
+    }
+    async getGraphicData(_ev) { return undefined; }
+    async updateGraphic(ev, isDynamics) {
+        if (!isDynamics || this._graphicsPending)
+            return; // Continue displaying previous graphic if new graphic is still pending...
+        this._graphicsPending = true;
+        const graphicData = await this.getGraphicData(ev);
+        this._graphicsPending = undefined;
+        if (undefined !== graphicData) {
+            if (this._firstResult) {
+                this.updateAgendaAppearanceProvider();
+                this._firstResult = false;
+            }
+            return this.createGraphic(graphicData);
+        }
+        if (undefined !== this._graphicsProvider)
+            this._graphicsProvider.cleanupGraphic();
+    }
+    async createGraphic(graphicData) {
+        if (undefined === this._graphicsProvider)
+            this._graphicsProvider = new ElementGeometryGraphicsProvider(this.iModel);
+        await this._graphicsProvider.createGraphic(graphicData);
+    }
+    clearGraphic() {
+        if (undefined === this._graphicsProvider)
+            return;
+        this._graphicsProvider.cleanupGraphic();
+        this._graphicsProvider = undefined;
+    }
+    async clearElementGeometryCache() {
+        try {
+            this._startedCmd = await this.startCommand();
+            await solidModelingIpc.clearElementGeometryCache();
+        }
+        catch (err) { }
+    }
+    async onUnsuspend() {
+        if (!this._firstResult)
+            this.updateAgendaAppearanceProvider();
+        return super.onUnsuspend();
+    }
+    async onSuspend() {
+        if (!this._firstResult)
+            this.updateAgendaAppearanceProvider(true);
+        return super.onSuspend();
+    }
+    async onPostInstall() {
+        await super.onPostInstall();
+        if (this.wantAgendaAppearanceOverride)
+            this.agenda.manageHiliteState = false;
+    }
+    async onCleanup() {
+        await super.onCleanup();
+        await this.clearElementGeometryCache();
+        this.updateAgendaAppearanceProvider(true);
+        this.clearGraphic();
+    }
+}
+/** @alpha Base class for tools that need to locate faces, edges, and vertices. */
+export class LocateSubEntityTool extends ElementGeometryCacheTool {
+    constructor() {
+        super(...arguments);
+        this._acceptedSubEntities = [];
+        this._summaryIds = new Map();
+    }
+    provideToolAssistance(mainInstrText, additionalInstr) {
+        if (this.wantAdditionalSubEntities) {
+            const faceKey = this.wantSubEntityType(SubEntityType.Face) ? "Face" : "";
+            const edgeKey = this.wantSubEntityType(SubEntityType.Edge) ? "Edge" : "";
+            const vertexKey = this.wantSubEntityType(SubEntityType.Vertex) ? "Vertex" : "";
+            const subEntityKey = `${faceKey}${edgeKey}${vertexKey}`;
+            if (0 === subEntityKey.length) {
+                super.provideToolAssistance(mainInstrText, additionalInstr);
+                return;
+            }
+            if (undefined === mainInstrText)
+                mainInstrText = EditTools.translate(`LocateSubEntities.Identify.${subEntityKey}`);
+            const leftMsg = EditTools.translate(`LocateSubEntities.Accept.${subEntityKey}`);
+            const rightMsg = this.haveAcceptedSubEntities && this.allowSubEntitySelectNext ? EditTools.translate(`LocateSubEntities.AcceptNext.${subEntityKey}`) : CoreTools.translate("ElementSet.Inputs.Cancel");
+            const mouseInstructions = [];
+            const touchInstructions = [];
+            if (!ToolAssistance.createTouchCursorInstructions(touchInstructions))
+                touchInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.OneTouchTap, leftMsg, false, ToolAssistanceInputMethod.Touch));
+            mouseInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.LeftClick, leftMsg, false, ToolAssistanceInputMethod.Mouse));
+            touchInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.TwoTouchTap, rightMsg, false, ToolAssistanceInputMethod.Touch));
+            mouseInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.RightClick, rightMsg, false, ToolAssistanceInputMethod.Mouse));
+            if (this.allowSubEntityControlSelect)
+                mouseInstructions.push(ToolAssistance.createModifierKeyInstruction(ToolAssistance.ctrlKey, ToolAssistanceImage.LeftClickDrag, EditTools.translate(`LocateSubEntities.IdentifyAdditional.${subEntityKey}`), false, ToolAssistanceInputMethod.Mouse));
+            if (undefined !== additionalInstr) {
+                for (const instr of additionalInstr) {
+                    if (ToolAssistanceInputMethod.Touch === instr.inputMethod)
+                        touchInstructions.push(instr);
+                    else
+                        mouseInstructions.push(instr);
+                }
+            }
+            const sections = [];
+            sections.push(ToolAssistance.createSection(mouseInstructions, ToolAssistance.inputsLabel));
+            sections.push(ToolAssistance.createSection(touchInstructions, ToolAssistance.inputsLabel));
+            const mainInstruction = ToolAssistance.createInstruction(this.iconSpec, mainInstrText);
+            const instructions = ToolAssistance.createInstructions(mainInstruction, sections);
+            IModelApp.notifications.setToolAssistance(instructions);
+            return;
+        }
+        super.provideToolAssistance(mainInstrText, additionalInstr);
+    }
+    get wantAgendaAppearanceOverride() { return true; }
+    get wantGeometrySummary() { return false; }
+    get wantSubEntitySnap() { return false; }
+    wantSubEntityType(type) { return SubEntityType.Face === type; }
+    getMaximumSubEntityHits(type) { return this.wantSubEntityType(type) ? 25 : 0; }
+    get requiredSubEntityCount() { return 1; }
+    get haveAcceptedSubEntities() { return (0 !== this._acceptedSubEntities.length); }
+    get inhibitSubEntityDisplay() { return this.isDynamicsStarted; }
+    get allowSubEntityControlSelect() { return true; }
+    get allowSubEntityControlDeselect() { return this.allowSubEntityControlSelect; }
+    get allowSubEntitySelectNext() { return !this.isDynamicsStarted; }
+    getBRepEntityTypeForSubEntity(id, subEntity) {
+        const summary = this._summaryIds.get(id);
+        if (undefined === summary)
+            return BRepEntityType.Invalid;
+        const index = (undefined !== subEntity.index ? subEntity.index : 0);
+        if (index >= summary.length)
+            return BRepEntityType.Invalid;
+        return summary[index];
+    }
+    async createElementGeometrySummary(id) {
+        let summary = this._summaryIds.get(id);
+        if (undefined === summary) {
+            if (this.agenda.isEmpty && this._summaryIds.size > 1000)
+                this._summaryIds.clear(); // Limit auto-locate cache size to something reasonable...
+            try {
+                this._startedCmd = await this.startCommand();
+                if (undefined === (summary = await solidModelingIpc.summarizeElementGeometryCache(id)))
+                    return false;
+            }
+            catch (err) {
+                return false;
+            }
+            this._summaryIds.set(id, summary);
+        }
+        return true;
+    }
+    async createElementGeometryCache(id) {
+        const accept = await super.createElementGeometryCache(id);
+        return (accept && this.wantGeometrySummary ? this.createElementGeometrySummary(id) : accept);
+    }
+    getAcceptedSubEntityData(index = -1) {
+        if (-1 === index)
+            index = this._acceptedSubEntities.length - 1;
+        if (index < 0 || index > this._acceptedSubEntities.length - 1)
+            return undefined;
+        return this._acceptedSubEntities[index];
+    }
+    getAcceptedSubEntities() {
+        const accepted = [];
+        this._acceptedSubEntities.forEach((entry) => accepted.push(entry.props));
+        return accepted;
+    }
+    drawSubEntity(context, subEntity, accepted) {
+        subEntity.display(context, accepted);
+    }
+    drawAcceptedSubEntities(context) {
+        this._acceptedSubEntities.forEach((entry) => this.drawSubEntity(context, entry, true));
+    }
+    decorate(context) {
+        if (this.inhibitSubEntityDisplay || !this.allowView(context.viewport))
+            return;
+        if (this.haveAcceptedSubEntities)
+            this.drawAcceptedSubEntities(context);
+        if (undefined !== this._currentSubEntity)
+            this.drawSubEntity(context, this._currentSubEntity, false);
+    }
+    decorateSuspended(context) {
+        if (this.inhibitSubEntityDisplay || !this.allowView(context.viewport))
+            return;
+        if (this.haveAcceptedSubEntities)
+            this.drawAcceptedSubEntities(context);
+    }
+    getLocateAperture(ev) {
+        if (undefined === ev.viewport)
+            return 0.0;
+        return ev.viewport.pixelsFromInches(InputSource.Touch === ev.inputSource ? IModelApp.locateManager.touchApertureInches : IModelApp.locateManager.apertureInches);
+    }
+    getMaxRayDistance(ev, aperture) {
+        if (undefined === ev.viewport)
+            return 0.0;
+        // NOTE: Compute a world coordinate radius for ray test, try getting aperture size at point on element...
+        const hit = IModelApp.accuSnap.currHit;
+        const vec = [];
+        vec[0] = ev.viewport.worldToView(hit ? hit.hitPoint : ev.point);
+        vec[1] = vec[0].clone();
+        vec[1].x += 1;
+        ev.viewport.viewToWorldArray(vec);
+        // The edge and vertex hits get post-filtered on xy distance, so this is fine for perspective views...
+        return (aperture * vec[0].distance(vec[1]));
+    }
+    getRayOrigin(ev) {
+        const spacePoint = ev.point.clone();
+        const vp = ev.viewport;
+        if (undefined === vp)
+            return spacePoint;
+        vp.worldToNpc(spacePoint, spacePoint);
+        spacePoint.z = 1.0;
+        vp.npcToWorld(spacePoint, spacePoint);
+        return spacePoint;
+    }
+    wantHiddenEdges(vp) {
+        return vp.viewFlags.hiddenEdgesVisible();
+    }
+    getSubEntityFilter() { return undefined; }
+    async pickSubEntities(id, boresite, maxFace, maxEdge, maxVertex, maxDistance, hiddenEdgesVisible, filter) {
+        try {
+            this._startedCmd = await this.startCommand();
+            const opts = {
+                maxFace,
+                maxEdge,
+                maxVertex,
+                maxDistance,
+                hiddenEdgesVisible,
+                filter,
+            };
+            return await solidModelingIpc.locateSubEntities(id, boresite.origin, boresite.direction, opts);
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    async doPickSubEntities(id, ev) {
+        const vp = ev.viewport;
+        if (undefined === vp)
+            return undefined;
+        const maxFace = this.getMaximumSubEntityHits(SubEntityType.Face);
+        const maxEdge = this.getMaximumSubEntityHits(SubEntityType.Edge);
+        const maxVertex = this.getMaximumSubEntityHits(SubEntityType.Vertex);
+        if (0 === maxFace && 0 === maxEdge && 0 === maxVertex)
+            return undefined;
+        const aperture = this.getLocateAperture(ev);
+        const maxDistance = this.getMaxRayDistance(ev, aperture);
+        const spacePoint = this.getRayOrigin(ev);
+        const boresite = AccuDrawHintBuilder.getBoresite(spacePoint, vp);
+        const hiddenEdgesVisible = this.wantHiddenEdges(vp);
+        const filter = this.getSubEntityFilter();
+        let hits = await this.pickSubEntities(id, boresite, maxFace, maxEdge, maxVertex, maxDistance, hiddenEdgesVisible, filter);
+        // NOTE: Remove erroneous edge/vertex hits in perspective views by checking real xy distance to hit point...
+        if (undefined === hits || !vp.isCameraOn)
+            return hits;
+        if (maxEdge > 0 && hits.length > 1) {
+            const edgeApertureSquared = (aperture * aperture);
+            const vertexApertureSquared = ((aperture * 2.0) * (aperture * 2.0));
+            const e2 = Math.pow(aperture, 2);
+            const v2 = Math.pow(aperture * 2.0, 2);
+            if (e2 !== edgeApertureSquared || v2 !== vertexApertureSquared)
+                return hits;
+            const rayOrigin = vp.worldToView(boresite.origin);
+            hits = hits.filter((hit) => {
+                if (SubEntityType.Face === hit.subEntity.type)
+                    return true;
+                const hitPoint = vp.worldToView(Point3d.fromJSON(hit.point));
+                const distance = hitPoint.distanceSquaredXY(rayOrigin);
+                return (distance <= (SubEntityType.Edge === hit.subEntity.type ? edgeApertureSquared : vertexApertureSquared));
+            });
+        }
+        return hits;
+    }
+    async createSubEntityData(id, hit) {
+        const data = new SubEntityData(hit.subEntity);
+        const chordTolerance = (this.targetView ? computeChordToleranceFromPoint(this.targetView, Point3d.fromJSON(hit.point)) : undefined);
+        await this.createSubEntityGraphic(id, data, chordTolerance);
+        return data;
+    }
+    /** Append specified sub-entity to accepted array. */
+    async addSubEntity(id, props) {
+        this._acceptedSubEntities.push(await this.createSubEntityData(id, props));
+    }
+    /** Remove specified sub-entity from accepted array, or pop last sub-entity if undefined. */
+    async removeSubEntity(_id, props) {
+        if (undefined !== props)
+            this._acceptedSubEntities = this._acceptedSubEntities.filter((entry) => !isSameSubEntity(entry.props, props.subEntity));
+        else
+            this._acceptedSubEntities.pop();
+    }
+    /** Locate sub-entities for the most recently added (last) agenda entry. Tool sub-classes that wish to identity
+     * sub-entities from multiple elements are responsible for maintaining the sub-entities per-element.
+     */
+    async doLocateSubEntity(ev, newSearch) {
+        if (this.agenda.isEmpty || undefined === ev.viewport)
+            return false;
+        const id = this.agenda.elements[this.agenda.length - 1];
+        if (newSearch) {
+            this._locatedSubEntities = await this.doPickSubEntities(id, ev);
+            if (undefined === this._locatedSubEntities || 0 === this._locatedSubEntities.length)
+                return false;
+            /** NOTE: Set last button location to point on sub-entity when not snapping.
+              * If dynamics are enabled on this event, onDynamicFrame is called with this location.
+              */
+            if (CoordSource.ElemSnap !== ev.coordsFrom) {
+                ev.point.setFrom(Point3d.fromJSON(this._locatedSubEntities[0].point));
+                IModelApp.toolAdmin.setAdjustedDataPoint(ev);
+            }
+        }
+        else {
+            await this.removeSubEntity(id);
+        }
+        const hit = this._locatedSubEntities?.shift();
+        if (undefined !== hit) {
+            if (undefined === this._acceptedSubEntities.find((entry) => isSameSubEntity(entry.props, hit.subEntity)))
+                await this.addSubEntity(id, hit);
+            else if (this.allowSubEntityControlDeselect)
+                await this.removeSubEntity(id, hit);
+        }
+        IModelApp.viewManager.invalidateDecorationsAllViews();
+        return true;
+    }
+    async chooseNextHit(ev) {
+        if (!this.haveAcceptedSubEntities)
+            return super.chooseNextHit(ev);
+        if (!this.allowSubEntitySelectNext) {
+            await this.onReinitialize(); // Don't cycle through hits after starting dynamics...
+        }
+        else {
+            await this.doLocateSubEntity(ev, false);
+            if (!this.haveAcceptedSubEntities)
+                await this.onReinitialize();
+        }
+        return EventHandled.No;
+    }
+    get wantAdditionalSubEntities() {
+        return (this._acceptedSubEntities.length < this.requiredSubEntityCount || (this.allowSubEntityControlSelect && this.isControlDown));
+    }
+    async gatherInput(ev) {
+        if (this.wantAdditionalSubEntities) {
+            await this.doLocateSubEntity(ev, true);
+            if (this.wantAdditionalSubEntities) {
+                this.setupAndPromptForNextAction();
+                return EventHandled.No;
+            }
+            this.clearCurrentSubEntity();
+        }
+        return super.gatherInput(ev);
+    }
+    getCurrentElement() {
+        if (!this.agenda.isEmpty)
+            return this.agenda.elements[this.agenda.length - 1];
+        const hit = IModelApp.accuSnap.currHit;
+        return (undefined !== hit && hit.isElementHit ? hit.sourceId : undefined);
+    }
+    clearCurrentSubEntity() {
+        if (undefined === this._currentSubEntity)
+            return;
+        this._currentSubEntity.cleanupGraphic();
+        this._currentSubEntity = undefined;
+    }
+    async setCurrentSubEntity(id, hit, chordTolerance) {
+        if (undefined === this._currentSubEntity)
+            this._currentSubEntity = new SubEntityData(hit.subEntity);
+        else
+            this._currentSubEntity.props = hit.subEntity;
+        return this.createSubEntityGraphic(id, this._currentSubEntity, chordTolerance);
+    }
+    async changeCurrentSubEntity(id, current, chordTolerance) {
+        if (undefined === id || undefined === current) {
+            if (undefined === this._currentSubEntity || !this._currentSubEntity.hasGraphic)
+                return false;
+            this._currentSubEntity.cleanupGraphic();
+            return true;
+        }
+        if (undefined !== this._currentSubEntity && this._currentSubEntity.hasGraphic && this._currentSubEntity.isSame(current.subEntity))
+            return false;
+        return this.setCurrentSubEntity(id, current, chordTolerance);
+    }
+    async updateCurrentSubEntity(ev) {
+        if (undefined === ev.viewport)
+            return false;
+        const id = this.wantAdditionalSubEntities ? this.getCurrentElement() : undefined;
+        if (undefined === id)
+            return this.changeCurrentSubEntity();
+        if (this._subEntityGraphicPending)
+            return false;
+        this._subEntityGraphicPending = true;
+        const current = await this.doPickSubEntities(id, ev);
+        const chordTolerance = current ? computeChordToleranceFromPoint(ev.viewport, Point3d.fromJSON(current[0].point)) : 0.0;
+        const status = await this.changeCurrentSubEntity(id, current ? current[0] : undefined, chordTolerance);
+        this._subEntityGraphicPending = undefined;
+        if (status)
+            IModelApp.viewManager.invalidateDecorationsAllViews();
+        return status;
+    }
+    async createSubEntityGraphic(id, data, chordTolerance) {
+        try {
+            const opts = {
+                wantGraphic: true,
+                wantRange: true,
+                wantAppearance: true,
+                chordTolerance,
+            };
+            data.chordTolerance = chordTolerance;
+            data.geometry = await solidModelingIpc.getSubEntityGeometry(id, data.props, opts);
+            return await data.createGraphic(this.iModel);
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async updateGraphic(ev, isDynamics) {
+        if (isDynamics)
+            return super.updateGraphic(ev, isDynamics);
+        await this.updateCurrentSubEntity(ev);
+    }
+    async getGraphicData(ev) {
+        const result = await this.applyAgendaOperation(ev, false);
+        return result?.graphic;
+    }
+    async applyAgendaOperation(_ev, _isAccept) { return undefined; }
+    async processAgenda(ev) {
+        const result = await this.applyAgendaOperation(ev, true);
+        if (result?.elementId)
+            await this.saveChanges();
+    }
+    async onModifierKeyTransition(wentDown, modifier, event) {
+        if (EventHandled.Yes === await super.onModifierKeyTransition(wentDown, modifier, event))
+            return EventHandled.Yes;
+        if (BeModifierKeys.Control !== modifier)
+            return EventHandled.No;
+        if (IModelApp.toolAdmin.isLocateCircleOn === this.wantAdditionalSubEntities)
+            return EventHandled.No;
+        this.setupAndPromptForNextAction();
+        return EventHandled.Yes;
+    }
+    changeLocateState(enableLocate, enableSnap, cursor, coordLockOvr) {
+        super.changeLocateState(enableLocate, enableSnap, cursor, coordLockOvr);
+        // Keep showing locate circle when identifying sub-entities even if done locating elements...
+        if (!IModelApp.toolAdmin.isLocateCircleOn && this.wantAdditionalSubEntities)
+            IModelApp.toolAdmin.setLocateCircleOn(true);
+    }
+    get shouldEnableSnap() {
+        if (this.isSelectByPoints || !this.wantAccuSnap)
+            return false;
+        if (this.isDynamicsStarted)
+            return true;
+        const isCtrlSelect = (this.isControlDown && (this.controlKeyContinuesSelection || this.allowSubEntityControlSelect));
+        if (isCtrlSelect || this.wantAdditionalElements || this.wantAdditionalSubEntities)
+            return this.wantSubEntitySnap;
+        return !this.wantSubEntitySnap;
+    }
+    setupAccuDraw() { }
+    setupAndPromptForNextAction() {
+        this.setupAccuDraw();
+        super.setupAndPromptForNextAction();
+    }
+    clearSubEntityGraphics() {
+        if (undefined !== this._currentSubEntity)
+            this._currentSubEntity.cleanupGraphic();
+        this._acceptedSubEntities.forEach((entry) => entry.cleanupGraphic());
+    }
+    async onCleanup() {
+        this.clearSubEntityGraphics();
+        return super.onCleanup();
+    }
+}
 //# sourceMappingURL=ElementGeometryTool.js.map