@realsee/dnalogel 3.20.6 → 3.21.0

package/libs/Sculpt/Meshes/RectangleWithEdge.js

@@ -0,0 +1,49 @@
+var r = Object.defineProperty;
+var o = Object.getOwnPropertySymbols;
+var u = Object.prototype.hasOwnProperty, c = Object.prototype.propertyIsEnumerable;
+var d = (e, s, t) => s in e ? r(e, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[s] = t;
+var g = (e, s) => {
+  var t = {};
+  for (var i in e)
+    u.call(e, i) && s.indexOf(i) < 0 && (t[i] = e[i]);
+  if (e != null && o)
+    for (var i of o(e))
+      s.indexOf(i) < 0 && c.call(e, i) && (t[i] = e[i]);
+  return t;
+};
+var h = (e, s, t) => (d(e, typeof s != "symbol" ? s + "" : s, t), t);
+import { RectangleMesh as p } from "./Rectangle.js";
+import { PolylineMesh as f } from "./Polyline.js";
+class S extends p {
+  constructor(t) {
+    const l = t != null ? t : {}, { points: i } = l, n = g(l, ["points"]);
+    super();
+    h(this, "name", "RectangleWithEdgeMesh");
+    h(this, "line", new f());
+    i && this.setPoints(i), n && this.setStyle(n);
+  }
+  get lineWidth() {
+    return this.line.lineWidth;
+  }
+  get lineColor() {
+    return this.line.lineColor;
+  }
+  setPoints(t) {
+    if (super.setPoints(t), this.points) {
+      const i = this.points;
+      this.line.setPoints([i[0], i[2], i[1], i[3], i[0]]), this.addIfNotExists(this.line);
+    }
+  }
+  setStyle(t) {
+    super.setStyle(t), this.line.setStyle(t);
+  }
+  highlight() {
+    super.highlight(), this.line.highlight();
+  }
+  unhighlight() {
+    super.unhighlight(), this.line.unhighlight();
+  }
+}
+export {
+  S as RectangleWithEdgeMesh
+};

package/libs/Sculpt/Modules/Cursor.d.ts

@@ -0,0 +1,13 @@
+type CursorType = 'auto' | 'pen' | 'pen-forbidden' | 'pen-crosshair' | 'pne-polygon' | 'pen-circle' | 'crosshair-rectangle' | 'crosshair-circle';
+export declare class Cursor {
+    private container;
+    constructor(container: HTMLElement);
+    /**
+     * @param type - The type of the cursor.
+     */
+    setType(type: CursorType): void;
+    tip(tip: string): () => void;
+    closeTip(): void;
+    reset(): void;
+}
+export {};

package/libs/Sculpt/Modules/Cursor.js

@@ -0,0 +1,37 @@
+var t = Object.defineProperty;
+var c = (s, r, e) => r in s ? t(s, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[r] = e;
+var o = (s, r, e) => (c(s, typeof r != "symbol" ? r + "" : r, e), e);
+const n = {
+  auto: "",
+  pen: "",
+  "pen-forbidden": "",
+  "pen-crosshair": "",
+  "pne-polygon": "",
+  "pen-circle": "",
+  "crosshair-rectangle": "",
+  "crosshair-circle": ""
+};
+class a {
+  constructor(r) {
+    o(this, "container");
+    this.container = r;
+  }
+  /**
+   * @param type - The type of the cursor.
+   */
+  setType(r) {
+    const e = n[r];
+    e ? this.container.style.cursor = `url(${e}), auto` : this.container.style.cursor = r;
+  }
+  tip(r) {
+    return () => this.closeTip();
+  }
+  closeTip() {
+  }
+  reset() {
+    this.container.style.cursor = "auto";
+  }
+}
+export {
+  a as Cursor
+};

package/libs/Sculpt/Modules/Global.d.ts

@@ -0,0 +1,20 @@
+import type { Five } from '@realsee/five';
+import { Cursor } from './Cursor';
+import { PointSelector } from '../../shared-utils/three/PointSelector';
+import { FiveDomEvents } from '../../shared-utils/five/FiveDomEvents';
+import { Object3DHelperController } from '../../Object3DHelperPlugin';
+declare class GlobalModules {
+    five: Five;
+    _cursor: Cursor;
+    _pointSelector: PointSelector;
+    _fiveDomEvents: FiveDomEvents;
+    _object3DHelper: Object3DHelperController;
+    inited: boolean;
+    get cursor(): Cursor;
+    get pointSelector(): PointSelector;
+    get fiveDomEvents(): FiveDomEvents;
+    get object3DHelper(): Object3DHelperController;
+    init: (five: Five) => void;
+}
+declare const globalModules: GlobalModules;
+export { globalModules };

package/libs/Sculpt/Modules/Global.js

@@ -0,0 +1,45 @@
+var o = Object.defineProperty;
+var n = (i, e, r) => e in i ? o(i, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : i[e] = r;
+var t = (i, e, r) => (n(i, typeof e != "symbol" ? e + "" : e, r), r);
+import { Cursor as s } from "./Cursor.js";
+import { PointSelector as l } from "../../shared-utils/three/PointSelector.js";
+import { FiveDomEvents as h } from "../../shared-utils/five/FiveDomEvents.js";
+import { Object3DHelperController as f } from "../../Object3DHelperPlugin/Controller.js";
+class c {
+  constructor() {
+    t(this, "five");
+    t(this, "_cursor");
+    t(this, "_pointSelector");
+    t(this, "_fiveDomEvents");
+    t(this, "_object3DHelper");
+    t(this, "inited", !1);
+    t(this, "init", (e) => {
+      this.inited = !0, this.five = e;
+    });
+  }
+  get cursor() {
+    if (!this.inited)
+      throw new Error("Global not inited");
+    return this._cursor ? this._cursor : (this._cursor = new s(this.five.getElement()), this._cursor);
+  }
+  get pointSelector() {
+    if (!this.inited)
+      throw new Error("Global not inited");
+    return this._pointSelector ? this._pointSelector : (this._pointSelector = new l(this.five), this._pointSelector);
+  }
+  get fiveDomEvents() {
+    if (!this.inited)
+      throw new Error("Global not inited");
+    return this._fiveDomEvents ? this._fiveDomEvents : (this._fiveDomEvents = new h(this.five), this._fiveDomEvents);
+  }
+  get object3DHelper() {
+    if (!this.inited)
+      throw new Error("Global not inited");
+    return this._object3DHelper ? this._object3DHelper : (this._object3DHelper = new f(this.five), this._object3DHelper);
+  }
+}
+const v = new c();
+window.globalModules = v;
+export {
+  v as globalModules
+};

package/libs/Sculpt/Objects/Base/Editor.d.ts

@@ -0,0 +1,21 @@
+import type * as THREE from 'three';
+import { IObject3D } from '../../../shared-utils/three/IObject3D';
+import type { AddObject3DHelperConfig } from '../../../Object3DHelperPlugin';
+export declare class BaseEditor<OriginObject extends THREE.Object3D = THREE.Object3D> extends IObject3D {
+    protected originObject: OriginObject;
+    constructor(originObject: OriginObject);
+    /**
+     * @description: 开启编辑器
+     */
+    enable(): void;
+    /**
+     * @description: 禁用编辑器
+     */
+    disable(): void;
+}
+export declare class BaseEditorWithObjectHelper<OriginObject extends THREE.Object3D = THREE.Object3D> extends BaseEditor<OriginObject> {
+    private objectHelperConfig;
+    constructor(originObject: OriginObject, objectHelperConfig?: AddObject3DHelperConfig | (() => AddObject3DHelperConfig));
+    enable(): void;
+    disable(): void;
+}

package/libs/Sculpt/Objects/Base/Editor.js

@@ -0,0 +1,52 @@
+var l = Object.defineProperty;
+var s = Object.getOwnPropertySymbols;
+var p = Object.prototype.hasOwnProperty, j = Object.prototype.propertyIsEnumerable;
+var i = (o, t, e) => t in o ? l(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e, c = (o, t) => {
+  for (var e in t || (t = {}))
+    p.call(t, e) && i(o, e, t[e]);
+  if (s)
+    for (var e of s(t))
+      j.call(t, e) && i(o, e, t[e]);
+  return o;
+};
+var r = (o, t, e) => (i(o, typeof t != "symbol" ? t + "" : t, e), e);
+import { Sculpt as b } from "../../index.js";
+import { IObject3D as d } from "../../../shared-utils/three/IObject3D.js";
+class g extends d {
+  constructor(e) {
+    super();
+    r(this, "originObject");
+    this.originObject = e;
+  }
+  /**
+   * @description: 开启编辑器
+   */
+  enable() {
+    this.originObject.add(this);
+  }
+  /**
+   * @description: 禁用编辑器
+   */
+  disable() {
+    this.originObject.remove(this);
+  }
+}
+class H extends g {
+  constructor(e, n) {
+    super(e);
+    r(this, "objectHelperConfig");
+    this.objectHelperConfig = n;
+  }
+  enable() {
+    super.enable();
+    const e = typeof this.objectHelperConfig == "function" ? this.objectHelperConfig() : this.objectHelperConfig;
+    b.modules.object3DHelper.addObject3DHelper(this.originObject, c({ positionFrom: "boundingBox" }, e));
+  }
+  disable() {
+    super.disable(), b.modules.object3DHelper.removeObject3DHelper(this.originObject);
+  }
+}
+export {
+  g as BaseEditor,
+  H as BaseEditorWithObjectHelper
+};

package/libs/Sculpt/Objects/Base/index.d.ts

@@ -0,0 +1,60 @@
+import type { FiveDomEventMap } from '../../../shared-utils/five/FiveDomEvents';
+import { IObject3D } from '../../../shared-utils/three/IObject3D';
+import type { BaseEditor } from './Editor';
+import type { RequiredDeep } from 'type-fest';
+import type * as THREE from 'three';
+export interface BaseImportData {
+    id?: string;
+    type: string;
+}
+export interface BaseExportData extends RequiredDeep<BaseImportData> {
+}
+export interface BaseObjectConfig {
+    /**
+     * @description: 是否可以编辑
+     * @default true
+     */
+    canEdit: boolean;
+    /**
+     * @description: 是否以一种半透明的方式显示遮挡的部分
+     * @default true
+     */
+    occlusionVisibility: boolean;
+}
+/**
+ * @description: 基础对象
+ */
+export declare abstract class BaseObject<ImportData extends BaseImportData = BaseImportData, ExportData extends BaseExportData = any, Config extends BaseObjectConfig = BaseObjectConfig> extends IObject3D {
+    name: string;
+    readonly isSculptObject = true;
+    draggable: boolean;
+    /**
+     * @description: 是否被选中
+     */
+    selected: boolean;
+    /**
+     * @description: 配置
+     */
+    config: Config;
+    protected editor: BaseEditor;
+    abstract type: string;
+    /**
+     * @description: 物体导出数据
+     */
+    abstract get data(): ExportData;
+    protected get baseData(): {
+        id: string;
+        type: string;
+    };
+    protected get pointSelector(): import("../../../shared-utils/three/PointSelector").PointSelector;
+    constructor(data?: Partial<ImportData>, config?: Partial<Config>);
+    on: <T extends keyof FiveDomEventMap>(event: T, callback: FiveDomEventMap[T]) => void;
+    off: (event: keyof FiveDomEventMap, callback: (e: import("../../../shared-utils/five/FiveDomEvents").FiveDomEvent) => any, ...args: any[]) => void;
+    stopCreating(): void;
+    delete(): void;
+    highlight(): void;
+    unhighlight(): void;
+    protected applyObjectMatrixWorld<P extends THREE.Vector3 | THREE.Vector3[]>(point: P): P;
+    protected applyObjectQuaternion<P extends THREE.Vector3 | THREE.Vector3[]>(point: P): P;
+    abstract create(...args: any): any;
+}

package/libs/Sculpt/Objects/Base/index.js

@@ -0,0 +1,77 @@
+var f = Object.defineProperty;
+var u = Object.getOwnPropertySymbols;
+var b = Object.prototype.hasOwnProperty, g = Object.prototype.propertyIsEnumerable;
+var n = (s, t, e) => t in s ? f(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e, d = (s, t) => {
+  for (var e in t || (t = {}))
+    b.call(t, e) && n(s, e, t[e]);
+  if (u)
+    for (var e of u(t))
+      g.call(t, e) && n(s, e, t[e]);
+  return s;
+};
+var r = (s, t, e) => (n(s, typeof t != "symbol" ? t + "" : t, e), e);
+import { hotkeys as p } from "../../../vendor/hotkeys-js/dist/hotkeys.esm.js";
+import { Sculpt as o } from "../../index.js";
+import { IObject3D as m } from "../../../shared-utils/three/IObject3D.js";
+const a = /* @__PURE__ */ new Map();
+class x extends m {
+  constructor(e, l) {
+    super();
+    r(this, "name", "Sculpt");
+    r(this, "isSculptObject", !0);
+    r(this, "draggable");
+    /**
+     * @description: 是否被选中
+     */
+    r(this, "selected");
+    /**
+     * @description: 配置
+     */
+    r(this, "config");
+    r(this, "editor");
+    r(this, "on", (e, l, ...i) => o.modules.fiveDomEvents.addEventListener(this, e, l, ...i));
+    r(this, "off", (...e) => o.modules.fiveDomEvents.addEventListener(this, ...e));
+    e != null && e.id && (this.uuid = e.id), this.config = d({ canEdit: !0, occlusionVisibility: !0 }, l), e != null && e.style && (e.style.occlusionVisibility = this.config.occlusionVisibility), this.config.canEdit && (p("backspace, delete", () => {
+      this.selected && this.delete();
+    }), this.on("click", () => {
+      var c, h;
+      if (this.pointSelector.enabled)
+        return;
+      let i = a.get(this.parent.uuid);
+      i && (i.selected = !1, i.unhighlight(), (c = i.editor) == null || c.disable()), a.set(this.parent.uuid, this), this.selected = !0, this.highlight(), (h = this.editor) == null || h.enable();
+    }), p("esc", () => {
+      var i;
+      this.selected = !1, this.unhighlight(), !this.pointSelector.enabled && ((i = this.editor) == null || i.disable());
+    }));
+  }
+  get baseData() {
+    return {
+      id: this.uuid,
+      type: this.type
+    };
+  }
+  get pointSelector() {
+    return o.modules.pointSelector;
+  }
+  stopCreating() {
+    o.modules.pointSelector.disable();
+  }
+  delete() {
+    var e;
+    this.removeFromParent(), (e = this.editor) == null || e.disable();
+  }
+  highlight() {
+  }
+  unhighlight() {
+  }
+  applyObjectMatrixWorld(e) {
+    return Array.isArray(e) ? e.map((l) => l.clone().applyMatrix4(this.matrixWorld)) : e.clone().applyMatrix4(this.matrixWorld);
+  }
+  applyObjectQuaternion(e) {
+    const l = this.quaternion.clone();
+    return Array.isArray(e) ? e.map((i) => i.clone().applyQuaternion(l)) : e.clone().applyQuaternion(l);
+  }
+}
+export {
+  x as BaseObject
+};

package/libs/Sculpt/Objects/Box/Editor.d.ts

@@ -0,0 +1,5 @@
+import type { Box } from '.';
+import { BaseEditorWithObjectHelper } from '../Base/Editor';
+export declare class BoxEditor extends BaseEditorWithObjectHelper<Box> {
+    constructor(originObject: Box);
+}

package/libs/Sculpt/Objects/Box/Editor.js

@@ -0,0 +1,44 @@
+import { BaseEditorWithObjectHelper as a } from "../Base/Editor.js";
+import * as c from "three";
+class m extends a {
+  constructor(e) {
+    super(e, () => {
+      const i = () => {
+        var s, t;
+        const o = (s = e.boxMesh.topPlane.getGeometryInfo()) == null ? void 0 : s.center, n = (t = e.boxMesh.bottomPlane.getGeometryInfo()) == null ? void 0 : t.center, r = new c.Vector3().lerpVectors(o, n, 0.5);
+        return { topCenter: o, bottomCenter: n, boxCenter: r };
+      };
+      return {
+        positionFrom: "boundingBox",
+        yAxis: e.boxMesh.bottomPlane.up,
+        scaleHelper: {
+          enable: !0,
+          positions: () => {
+            const o = i();
+            return [
+              {
+                id: "top",
+                handlePosition: o.topCenter,
+                basePosition: o.bottomCenter
+              },
+              {
+                id: "bottom",
+                handlePosition: o.bottomCenter,
+                basePosition: o.topCenter
+              }
+            ];
+          },
+          scaleCallback: (o) => {
+            const { intersectPoint: n, scalePosition: r } = o, { id: s } = r, { boxMesh: t } = e;
+            s === "top" ? t.setTopHeightPoint(n) : s === "bottom" && t.setPoints({
+              points: t.topPlane.points.map((p) => p.clone().add(n.clone().sub(r.basePosition)))
+            });
+          }
+        }
+      };
+    });
+  }
+}
+export {
+  m as BoxEditor
+};

package/libs/Sculpt/Objects/Box/index.d.ts

@@ -0,0 +1,28 @@
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import { BoxMesh, type BoxData, type BoxStyle } from '../../Meshes/Box';
+import type { LiteralString } from '../../typings/utils.type';
+export interface BoxImportData extends BaseImportData, BoxData {
+    type: LiteralString<'Box'>;
+    style?: Partial<BoxStyle>;
+}
+export declare class Box extends BaseObject<BoxImportData> {
+    readonly type = "Box";
+    boxMesh: BoxMesh;
+    get data(): {
+        points: [number, number, number][];
+        heightPoint: [number, number, number];
+        style: {
+            color: number;
+            lineWidth: number;
+            lineColor: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: BoxImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<BoxStyle>): Promise<void>;
+}
+export declare function createBox(boxMesh: BoxMesh, pointSelector: PointSelector): Promise<void>;

package/libs/Sculpt/Objects/Box/index.js

@@ -0,0 +1,107 @@
+var B = Object.defineProperty, E = Object.defineProperties;
+var C = Object.getOwnPropertyDescriptors;
+var P = Object.getOwnPropertySymbols;
+var H = Object.prototype.hasOwnProperty, O = Object.prototype.propertyIsEnumerable;
+var p = (o, e, t) => e in o ? B(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t, c = (o, e) => {
+  for (var t in e || (e = {}))
+    H.call(e, t) && p(o, t, e[t]);
+  if (P)
+    for (var t of P(e))
+      O.call(e, t) && p(o, t, e[t]);
+  return o;
+}, M = (o, e) => E(o, C(e));
+var d = (o, e, t) => (p(o, typeof e != "symbol" ? e + "" : e, t), t);
+var b = (o, e, t) => new Promise((r, i) => {
+  var a = (s) => {
+    try {
+      n(t.next(s));
+    } catch (h) {
+      i(h);
+    }
+  }, m = (s) => {
+    try {
+      n(t.throw(s));
+    } catch (h) {
+      i(h);
+    }
+  }, n = (s) => s.done ? r(s.value) : Promise.resolve(s.value).then(a, m);
+  n((t = t.apply(o, e)).next());
+});
+import { hotkeys as L } from "../../../vendor/hotkeys-js/dist/hotkeys.esm.js";
+import { BaseObject as W } from "../Base/index.js";
+import * as j from "three";
+import { BoxEditor as N } from "./Editor.js";
+import { BoxMesh as w } from "../../Meshes/Box.js";
+import { createRectangle as R } from "../Rectangle/index.js";
+import { LineMesh as T } from "../../Meshes/Line.js";
+import { getNormal as U } from "../../../shared-utils/three/getNormal.js";
+import { rayOnLine as k } from "../../utils/three/rayOnLine.js";
+import { Sculpt as z } from "../../index.js";
+import { vector3ToArray as v } from "../../../shared-utils/three/vector3ToArray.js";
+class Z extends W {
+  constructor(t, r) {
+    super(t, r);
+    d(this, "type", "Box");
+    d(this, "boxMesh");
+    this.editor = new N(this), t && (this.boxMesh = new w(c(c({}, t.style), t)), this.add(this.boxMesh)), L("esc", () => {
+      this.stopCreating();
+    });
+  }
+  get data() {
+    return M(c({}, this.baseData), {
+      points: v(this.applyObjectMatrixWorld(this.boxMesh.bottomPlane.points)),
+      heightPoint: v(this.applyObjectMatrixWorld(this.boxMesh.heightPoint)),
+      style: {
+        color: this.boxMesh.color.getHex(),
+        lineWidth: this.boxMesh.lineWidth,
+        lineColor: this.boxMesh.lineColor.getHex()
+      }
+    });
+  }
+  highlight() {
+    var t;
+    (t = this.boxMesh) == null || t.highlight();
+  }
+  unhighlight() {
+    var t;
+    (t = this.boxMesh) == null || t.unhighlight();
+  }
+  create(t) {
+    return b(this, null, function* () {
+      this.removeChildren(), this.boxMesh = new w(t), this.add(this.boxMesh), yield A(this.boxMesh, this.pointSelector), this.editor.enable();
+    });
+  }
+}
+function A(o, e) {
+  return b(this, null, function* () {
+    return yield R(o.bottomPlane, e), new Promise((t, r) => {
+      const i = o.parent;
+      if (!i) {
+        r(new Error("No container"));
+        return;
+      }
+      const a = new T(), m = U(o.bottomPlane.points).normalize(), n = o.bottomPlane.builtPoints.at(-1), s = n.clone().add(m.clone().multiplyScalar(10)), h = n.clone().sub(m.clone().multiplyScalar(10));
+      a.setPoints([s, h]), i.add(a), e.enable();
+      const f = (l) => {
+        g(), t();
+      }, x = (l) => {
+        if (!(l != null && l.raycaster))
+          return;
+        const y = k(
+          z.modules.five.camera.position,
+          l.raycaster.ray,
+          new j.Line3(s, h)
+        );
+        y && o.setPoints({ heightPoint: y });
+      }, g = () => {
+        e.off("select", f), e.off("intersectionUpdate", x), e.off("disable", u), e.disable(), i == null || i.remove(a);
+      }, u = () => {
+        g(), i == null || i.remove(o), r(new Error("Cancelled"));
+      };
+      e.on("select", f), e.on("intersectionUpdate", x), e.on("disable", u);
+    });
+  });
+}
+export {
+  Z as Box
+};

package/libs/Sculpt/Objects/Circle/Editor.d.ts

@@ -0,0 +1,5 @@
+import { BaseEditorWithObjectHelper } from '../Base/Editor';
+import type { Circle } from '.';
+export declare class CircleEditor extends BaseEditorWithObjectHelper<Circle> {
+    constructor(originObject: Circle);
+}

package/libs/Sculpt/Objects/Circle/Editor.js

@@ -0,0 +1,9 @@
+import { BaseEditorWithObjectHelper as e } from "../Base/Editor.js";
+class o extends e {
+  constructor(r) {
+    super(r, () => ({ yAxis: r.circleMesh.normal }));
+  }
+}
+export {
+  o as CircleEditor
+};

package/libs/Sculpt/Objects/Circle/index.d.ts

@@ -0,0 +1,28 @@
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { CircleData, CircleMesh } from '../../Meshes/Circle';
+import { CircleWithEdgeMesh, type CircleWithEdgeMeshStyle } from '../../Meshes/CircleWithEdge';
+import type { LiteralString } from '../../typings/utils.type';
+export interface CircleImportData extends BaseImportData, CircleData {
+    type: LiteralString<'Circle'>;
+    style?: Partial<CircleWithEdgeMeshStyle>;
+}
+export declare class Circle extends BaseObject<CircleImportData> {
+    readonly type = "Circle";
+    circleMesh: CircleWithEdgeMesh;
+    get data(): {
+        center: [number, number, number];
+        normal: [number, number, number];
+        radius: number;
+        style: {
+            color: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: CircleImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<CircleWithEdgeMeshStyle>): Promise<void>;
+}
+export declare function createCircle(circleMesh: CircleMesh, pointSelector: PointSelector): Promise<void>;