@realsee/dnalogel 2.1.2-alpha.2 → 2.1.2-alpha.4

package/esm/shared-utils/Object3DHelper/Helper/MoveHelper.js

@@ -0,0 +1,30 @@
+var w = Object.defineProperty;
+var A = (i, o, r) => o in i ? w(i, o, { enumerable: !0, configurable: !0, writable: !0, value: r }) : i[o] = r;
+var s = (i, o, r) => (A(i, typeof o != "symbol" ? o + "" : o, r), r);
+import { M as h } from "../Base/BaseHelper.js";
+import { A as e } from "./Objects/ArrowGroup.js";
+import { A as t } from "../Constants/color.js";
+import "three";
+import "three/examples/jsm/renderers/CSS3DRenderer";
+import "./OutlineHelper.js";
+class u extends h {
+  constructor(r) {
+    super(r);
+    s(this, "xArrow", new e({ direction: "x", color: t.X }));
+    s(this, "yArrow", new e({ direction: "y", color: t.Y }));
+    s(this, "zArrow", new e({ direction: "z", color: t.Z }));
+    this.add(this.xArrow), this.add(this.yArrow), this.add(this.zArrow);
+  }
+  show() {
+    super.show(), this.xArrow.visible = !0, this.yArrow.visible = !0, this.zArrow.visible = !0;
+  }
+  showDraggingHelper(r) {
+    this.xArrow.visible = r.includes("x"), this.yArrow.visible = r.includes("y"), this.zArrow.visible = r.includes("z");
+  }
+  dispose() {
+    this.remove(this.xArrow, this.yArrow, this.zArrow);
+  }
+}
+export {
+  u as M
+};

package/esm/shared-utils/Object3DHelper/Helper/Objects/ArrowGroup.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+import type { Direction } from '../../typings';
+import { DirectionGroup, DirectionMesh } from '../../utils';
+interface InstanceParameter {
+    direction: Direction;
+    color?: THREE.Color | string | number;
+}
+export declare class ArrowGroup extends DirectionGroup {
+    line: DirectionMesh<THREE.Geometry, THREE.MeshBasicMaterial>;
+    arrow: DirectionMesh<THREE.ConeGeometry, THREE.MeshBasicMaterial>;
+    private lineHeight;
+    private arrowHeight;
+    constructor(param: InstanceParameter);
+    private formatArrow;
+    private formatLine;
+}
+export {};

package/esm/shared-utils/Object3DHelper/Helper/Objects/ArrowGroup.js

@@ -0,0 +1,35 @@
+var y = Object.defineProperty;
+var g = (r, t, e) => t in r ? y(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var i = (r, t, e) => (g(r, typeof t != "symbol" ? t + "" : t, e), e);
+import * as o from "three";
+import { D as f, a as l } from "../../utils/direction.js";
+class G extends f {
+  constructor(e) {
+    var c;
+    super(e.direction);
+    i(this, "line");
+    i(this, "arrow");
+    i(this, "lineHeight", 0.4);
+    i(this, "arrowHeight", 0.1);
+    this.name = "ArrowGroup";
+    const w = new o.Color((c = e.color) != null ? c : 16214315), n = new o.MeshBasicMaterial({
+      color: w,
+      depthTest: !1,
+      opacity: 1,
+      transparent: !0,
+      side: o.DoubleSide
+    }), d = new o.ConeGeometry(0.04, 0.1, 32), s = new l(d, n.clone(), e.direction);
+    s.name = `arrow-${e.direction}`, this.arrow = s;
+    const a = 4e-3, m = new o.CylinderGeometry(a, a, 0.4, 32), h = new l(m, n.clone(), e.direction);
+    h.name = `line-${e.direction}`, this.line = h, this.formatArrow(), this.formatLine(), this.add(this.arrow, this.line);
+  }
+  formatArrow() {
+    this.arrow.geometry.translate(0, this.lineHeight + this.arrowHeight / 2, 0), this.direction === "x" ? (this.arrow.geometry.rotateX(Math.PI / 2), this.arrow.geometry.rotateY(Math.PI / 2)) : this.direction === "z" && this.arrow.geometry.rotateX(Math.PI / 2);
+  }
+  formatLine() {
+    this.line.geometry.translate(0, this.lineHeight / 2, 0), this.direction === "x" ? (this.line.geometry.rotateX(Math.PI / 2), this.line.geometry.rotateY(Math.PI / 2)) : this.direction === "z" && this.line.geometry.rotateX(Math.PI / 2);
+  }
+}
+export {
+  G as A
+};

package/esm/shared-utils/Object3DHelper/Helper/OutlineHelper.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+export declare class OutlineHelper extends THREE.Group {
+    box: THREE.Mesh<THREE.BufferGeometry, THREE.MeshBasicMaterial>;
+    outline: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial>;
+    private originObject;
+    private positionAttribute;
+    constructor(obj: THREE.Object3D);
+    private update;
+    private createOutline;
+    private createBox;
+}

package/esm/shared-utils/Object3DHelper/Helper/OutlineHelper.js

@@ -0,0 +1,2 @@
+import * as o from "three";
+new o.Vector3();

package/esm/shared-utils/Object3DHelper/Helper/RectangleScaleHelper.d.ts

@@ -0,0 +1,40 @@
+import * as THREE from 'three';
+import { RectangleScaleHelperAbstract } from '.';
+import type { Create3DElementReturnType } from '../../../CSS3DRenderPlugin';
+import type { Vector3 } from 'three';
+import { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
+import type { CSS3DObjectPlus } from '../../../CSS3DRenderPlugin/utils/CSS3DObjectPlus';
+declare type NonVoid<T> = T extends void ? never : T;
+declare type OriginObjectType = CSS3DObject | THREE.Object3D;
+export declare class RectangleScaleHelper<T extends OriginObjectType = OriginObjectType> extends RectangleScaleHelperAbstract<T, HTMLElement> {
+    points: RectangleScaleHelperAbstract<THREE.Object3D, HTMLElement>['points'];
+    cornerPositions: Vector3[];
+    css3DInstance?: NonVoid<Create3DElementReturnType>;
+    get helperObject(): CSS3DObjectPlus<HTMLElement>;
+    plane?: THREE.Mesh<THREE.PlaneGeometry, THREE.MeshBasicMaterial>;
+    private css3DRenderer;
+    private camera;
+    private scene;
+    private container;
+    private enabled;
+    constructor(originObject3D: T, container: Element, camera: THREE.Camera, scene: THREE.Scene);
+    updatePosition(): void;
+    updateQuaternion(): void;
+    applyMatrix4(matrix: THREE.Matrix4): void;
+    showDraggingHelper(): void;
+    applyHelperScaleMatrix4(matrix: THREE.Matrix4, params?: {
+        origin?: Vector3;
+        helperOrigin?: Vector3;
+    }): void;
+    updatePoints(): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    dispose(): void;
+    private initRectangleScaleHelper;
+    private getCornerPositions;
+    private calculatePointPosition;
+}
+export {};

package/esm/shared-utils/Object3DHelper/Helper/RectangleScaleHelper.js

@@ -0,0 +1,137 @@
+var b = Object.defineProperty;
+var f = (o, n, e) => n in o ? b(o, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[n] = e;
+var i = (o, n, e) => (f(o, typeof n != "symbol" ? n + "" : n, e), e);
+import { C as y } from "../../../CSS3DRenderPlugin/CSS3DRender.js";
+import * as c from "three";
+import { R as m } from "../Base/BaseHelper.js";
+import { CSS3DObject as S } from "three/examples/jsm/renderers/CSS3DRenderer";
+import { r as j } from "./HTML/rectangleScaleDom.js";
+import "./OutlineHelper.js";
+class M extends m {
+  constructor(e, t, s, l) {
+    super(e);
+    i(this, "points", []);
+    i(this, "cornerPositions", []);
+    i(this, "css3DInstance");
+    i(this, "plane");
+    i(this, "css3DRenderer", new y());
+    i(this, "camera");
+    i(this, "scene");
+    i(this, "container");
+    i(this, "enabled", !1);
+    this.camera = s, this.scene = l, this.container = t, this.initRectangleScaleHelper();
+  }
+  get helperObject() {
+    var e;
+    if (!((e = this.css3DInstance) != null && e.css3DObject))
+      throw new Error("css3DInstance is not initialized");
+    return this.css3DInstance.css3DObject;
+  }
+  updatePosition() {
+    var e;
+    this.helperObject.position.copy(this.originObject3D.position), (e = this.plane) == null || e.position.copy(this.originObject3D.position);
+  }
+  updateQuaternion() {
+    var e;
+    (e = this.plane) == null || e.quaternion.copy(this.originObject3D.quaternion);
+  }
+  applyMatrix4(e) {
+    var t;
+    super.applyMatrix4(e), this.helperObject.applyMatrix4(e), (t = this.plane) == null || t.applyMatrix4(e), this.cornerPositions.forEach((s) => s.applyMatrix4(e));
+  }
+  showDraggingHelper() {
+  }
+  applyHelperScaleMatrix4(e, t) {
+    var s;
+    (s = this.plane) == null || s.scale.applyMatrix4(e), this.helperObject.applyScaleMatrix4(e);
+  }
+  updatePoints() {
+    const e = this.calculatePointPosition(this.cornerPositions);
+    this.points.forEach((t, s) => {
+      t.position.copy(e[s]);
+    });
+  }
+  applyHelperQuaternion(e, t) {
+    var l;
+    const s = (l = this.css3DInstance) == null ? void 0 : l.css3DObject;
+    if (s) {
+      const a = new c.Vector3().subVectors(s.position, t).applyQuaternion(e).add(t);
+      s.position.copy(a), s.applyQuaternion(e);
+    }
+    if (this.plane) {
+      const a = new c.Vector3().subVectors(this.plane.position, t).applyQuaternion(e).add(t);
+      this.plane.position.copy(a), this.plane.applyQuaternion(e);
+    }
+    this.cornerPositions.forEach((a) => {
+      const r = new c.Vector3().subVectors(a, t).applyQuaternion(e).add(t);
+      a.copy(r);
+    });
+  }
+  enable() {
+    var e;
+    this.enabled || (this.enabled = !0, (e = this.css3DInstance) == null || e.enable(), this.plane && this.scene.add(this.plane));
+  }
+  disable() {
+    var e;
+    !this.enabled || (this.enabled = !1, (e = this.css3DInstance) == null || e.disable(), this.plane && this.scene.remove(this.plane));
+  }
+  show() {
+    var e;
+    (e = this.css3DInstance) == null || e.show(), this.plane && (this.plane.visible = !0);
+  }
+  hide() {
+    var e;
+    (e = this.css3DInstance) == null || e.hide(), this.plane && (this.plane.visible = !1);
+  }
+  dispose() {
+    this.disable(), this.css3DRenderer.dispose();
+  }
+  initRectangleScaleHelper() {
+    var p;
+    const e = this.getCornerPositions();
+    if (!e)
+      return;
+    this.cornerPositions = e;
+    const t = this.css3DRenderer.create3DElement(this.camera, e, { ratio: 3e-3 });
+    if (!t)
+      return;
+    this.css3DInstance = t, t.appendToElement(this.container);
+    const s = t.css3DObject.container, { container: l, squares: a } = j();
+    this.points = a.map((h, D) => ({
+      direction: h.direction,
+      point: h.element,
+      position: this.calculatePointPosition(e)[D]
+    })), s.insertBefore(l, (p = s.children[0]) != null ? p : null);
+    const r = new c.PlaneGeometry(t.css3DObject.width, t.css3DObject.height), d = new c.MeshBasicMaterial({
+      color: 0,
+      opacity: 0.15,
+      transparent: !0,
+      side: c.DoubleSide
+    }), u = new c.Mesh(r, d);
+    this.scene.add(u), this.updatePosition();
+  }
+  getCornerPositions() {
+    const { originObject3D: e } = this;
+    if (e instanceof S) {
+      if (e.isCSS3DObjectPlus)
+        return e.cornerPoints;
+      console.error("\u6682\u65F6\u53EA\u652F\u6301 CSS3DRenderPlugin \u751F\u6210\u7684\u7269\u4F53");
+    } else
+      console.error("\u5F53\u524D\u7269\u4F53\u6682\u65F6\u4E0D\u652F\u6301 ScaleHelper");
+  }
+  calculatePointPosition(e) {
+    return [
+      e[0].clone(),
+      e[0].clone().add(e[1]).divideScalar(2),
+      e[1].clone(),
+      e[1].clone().add(e[2]).divideScalar(2),
+      e[2].clone(),
+      e[2].clone().add(e[3]).divideScalar(2),
+      e[3].clone(),
+      e[3].clone().add(e[0]).divideScalar(2)
+    ];
+  }
+}
+export {
+  M as R
+};

package/esm/shared-utils/Object3DHelper/Helper/RotateHelper.d.ts

@@ -0,0 +1,55 @@
+import * as THREE from 'three';
+import type { Object3D } from 'three';
+import { RotateHelperAbstract } from '../Base/BaseHelper';
+import type { Color, Direction } from '../typings';
+import { tipsDom } from './HTML/tipsDom';
+export declare class RotateHelper extends RotateHelperAbstract {
+    yzCircle: Circle;
+    xzCircle: Circle;
+    xyCircle: Circle;
+    xRingHelper: AxesDashedRing;
+    yRingHelper: AxesDashedRing;
+    zRingHelper: AxesDashedRing;
+    xAngleHelper: Sector;
+    yAngleHelper: Sector;
+    zAngleHelper: Sector;
+    angleTips?: ReturnType<typeof tipsDom>;
+    private container?;
+    constructor(originObject3D: Object3D, angleTipsParams?: {
+        container: HTMLElement;
+    });
+    updateAngleHelperQuaternion(): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;
+    hide(): void;
+    show(): void;
+    showDraggingHelper(directions: Direction[]): void;
+    dispose(): void;
+    private filterRingHelper;
+    private filterAngleHelper;
+}
+declare class Circle extends THREE.Mesh {
+    direction: Direction;
+    material: THREE.MeshBasicMaterial;
+    gapAngle: number;
+    geometry: THREE.RingGeometry;
+    constructor(options: {
+        direction: Direction;
+        color?: Color;
+    });
+}
+declare class AxesDashedRing extends THREE.Group {
+    direction: Readonly<Direction>;
+    constructor(options: {
+        direction: Direction;
+    });
+}
+declare class Sector extends THREE.Mesh {
+    direction: Direction;
+    material: THREE.MeshBasicMaterial;
+    baseAxes: THREE.Vector3;
+    constructor(options: {
+        direction: Direction;
+        color?: Color;
+    });
+}
+export {};

package/esm/shared-utils/Object3DHelper/Helper/RotateHelper.js

@@ -0,0 +1,136 @@
+var H = Object.defineProperty;
+var x = (n, s, e) => s in n ? H(n, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[s] = e;
+var t = (n, s, e) => (x(n, typeof s != "symbol" ? s + "" : s, e), e);
+import * as r from "three";
+import { a as A } from "../Base/BaseHelper.js";
+import { A as o } from "../Constants/color.js";
+import { t as u } from "./HTML/tipsDom.js";
+class f extends A {
+  constructor(e, i) {
+    var l;
+    super(e);
+    t(this, "yzCircle", new h({ direction: "x", color: o.X }));
+    t(this, "xzCircle", new h({ direction: "y", color: o.Y }));
+    t(this, "xyCircle", new h({ direction: "z", color: o.Z }));
+    t(this, "xRingHelper", new c({ direction: "x" }));
+    t(this, "yRingHelper", new c({ direction: "y" }));
+    t(this, "zRingHelper", new c({ direction: "z" }));
+    t(this, "xAngleHelper", new a({ direction: "x", color: o.X }));
+    t(this, "yAngleHelper", new a({ direction: "y", color: o.Y }));
+    t(this, "zAngleHelper", new a({ direction: "z", color: o.Z }));
+    t(this, "angleTips");
+    t(this, "container");
+    i && (this.container = i == null ? void 0 : i.container, this.angleTips = u({ display: "none" }), (l = this.container) == null || l.appendChild(this.angleTips.element)), this.show();
+  }
+  updateAngleHelperQuaternion() {
+    this.xAngleHelper.quaternion.copy(this.yzCircle.quaternion), this.yAngleHelper.quaternion.copy(this.xzCircle.quaternion), this.zAngleHelper.quaternion.copy(this.xyCircle.quaternion), this.xRingHelper.quaternion.copy(this.yzCircle.quaternion), this.yRingHelper.quaternion.copy(this.xzCircle.quaternion), this.zRingHelper.quaternion.copy(this.xyCircle.quaternion);
+  }
+  applyHelperQuaternion(e, i) {
+    this.yzCircle.applyQuaternion(e), this.xzCircle.applyQuaternion(e), this.xyCircle.applyQuaternion(e), this.xAngleHelper.baseAxes.applyQuaternion(e), this.yAngleHelper.baseAxes.applyQuaternion(e), this.zAngleHelper.baseAxes.applyQuaternion(e);
+  }
+  hide() {
+    this.remove(
+      this.yzCircle,
+      this.xzCircle,
+      this.xyCircle,
+      this.xRingHelper,
+      this.yRingHelper,
+      this.zRingHelper,
+      this.xAngleHelper,
+      this.yAngleHelper,
+      this.zAngleHelper
+    );
+  }
+  show() {
+    var e;
+    this.add(this.xyCircle, this.xzCircle, this.yzCircle), this.remove(this.xRingHelper, this.yRingHelper, this.zRingHelper, this.xAngleHelper, this.yAngleHelper, this.zAngleHelper), (e = this.angleTips) == null || e.hide();
+  }
+  showDraggingHelper(e) {
+    var i;
+    this.hide(), this.add(...this.filterRingHelper(e)), this.add(...this.filterAngleHelper(e)), (i = this.angleTips) == null || i.show();
+  }
+  dispose() {
+    var e, i;
+    this.remove(
+      this.yzCircle,
+      this.xzCircle,
+      this.xyCircle,
+      this.xRingHelper,
+      this.yRingHelper,
+      this.zRingHelper,
+      this.xAngleHelper,
+      this.yAngleHelper,
+      this.zAngleHelper
+    ), (e = this.angleTips) != null && e.element && ((i = this.container) == null || i.removeChild(this.angleTips.element));
+  }
+  filterRingHelper(e) {
+    return [this.xRingHelper, this.yRingHelper, this.zRingHelper].filter((i) => e.includes(i.direction));
+  }
+  filterAngleHelper(e) {
+    return [this.xAngleHelper, this.yAngleHelper, this.zAngleHelper].filter((i) => e.includes(i.direction));
+  }
+}
+class h extends r.Mesh {
+  constructor(e) {
+    var i;
+    super();
+    t(this, "direction");
+    t(this, "gapAngle", 0.02);
+    t(this, "geometry", new r.RingGeometry(0.25, 0.3, 20, 8, this.gapAngle, Math.PI / 2 - this.gapAngle * 2));
+    this.material = new r.MeshBasicMaterial({
+      opacity: 0.6,
+      color: (i = e.color) != null ? i : 16777215,
+      transparent: !0,
+      side: r.DoubleSide,
+      depthTest: !1
+    }), this.direction = e.direction, this.geometry.name = `RotateHelperCircleGeometry-${this.direction}`, this.direction === "y" ? this.rotateX(Math.PI / 2) : this.direction === "x" && this.rotateY(-Math.PI / 2);
+  }
+}
+class c extends r.Group {
+  constructor(e) {
+    super();
+    t(this, "direction");
+    this.direction = e.direction;
+    const i = 0.015, l = new Array(8).fill(null).map((z, p) => {
+      const d = new r.RingGeometry(0.25, 0.3, 20, 8, Math.PI / 4 * p + i, Math.PI / 4 - i * 2), y = new r.MeshBasicMaterial({
+        opacity: 1,
+        color: 16777215,
+        depthTest: !1,
+        transparent: !0,
+        side: r.DoubleSide
+      }), g = new r.Mesh(d, y);
+      return g.name = `AxesDashedRing-${this.direction}-${p}`, g;
+    });
+    this.add(...l), this.direction === "y" ? this.rotateX(Math.PI / 2) : this.direction === "x" && this.rotateY(-Math.PI / 2);
+  }
+}
+class a extends r.Mesh {
+  constructor(e) {
+    var l;
+    super();
+    t(this, "direction");
+    t(this, "baseAxes");
+    switch (e.direction) {
+      case "x":
+        this.baseAxes = new r.Vector3(0, 0, 1);
+        break;
+      case "y":
+        this.baseAxes = new r.Vector3(1, 0, 0);
+        break;
+      case "z":
+        this.baseAxes = new r.Vector3(1, 0, 0);
+        break;
+    }
+    const i = 0.3 + 5e-4;
+    this.geometry = new r.CircleGeometry(i, 48, 0, 1e-4), this.material = new r.MeshBasicMaterial({
+      opacity: 0.4,
+      color: (l = e.color) != null ? l : 16777215,
+      depthTest: !1,
+      transparent: !0,
+      side: r.DoubleSide
+    }), this.direction = e.direction, this.direction === "y" ? this.rotateX(Math.PI / 2) : this.direction === "x" && this.rotateY(-Math.PI / 2);
+  }
+}
+export {
+  f as R
+};

package/esm/shared-utils/Object3DHelper/Helper/index.d.ts

@@ -0,0 +1,5 @@
+export * from '../Base/BaseHelper';
+export * from './MoveHelper';
+export * from './RotateHelper';
+export * from './RectangleScaleHelper';
+export * from './OutlineHelper';

package/esm/shared-utils/Object3DHelper/Helper/index.js

@@ -0,0 +1,3 @@
+import "three";
+import "three/examples/jsm/renderers/CSS3DRenderer";
+import "./OutlineHelper.js";

package/esm/shared-utils/Object3DHelper/index.d.ts

@@ -0,0 +1,71 @@
+import type { OutlineHelper } from './Helper';
+import type { Object3DHelperEventMap, Object3DHelperState } from './typings';
+import type { MoveController } from './Controller/MoveController';
+import type { RotateController } from './Controller/RotateController';
+import type { BaseController } from './Base/BaseController';
+import { Subscribe } from '../Subscribe';
+interface Controllers {
+    moveController?: MoveController;
+    rotateController?: RotateController;
+    scaleController?: BaseController;
+}
+interface Helpers {
+    outlineHelper?: OutlineHelper;
+}
+export declare class Object3DHelper {
+    controllers: Controllers;
+    state: Object3DHelperState;
+    hooks: Subscribe<Object3DHelperEventMap>;
+    private helpers;
+    private eventListener;
+    constructor(controllers?: Controllers, helpers?: Helpers);
+    /**
+     * @description Show guide line
+     */
+    show(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    /**
+     * @description Hide guide line
+     */
+    hide(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    /**
+     * @description Enable
+     */
+    enable(options?: {
+        userAction?: boolean;
+    }): void;
+    /**
+     * @description Disable
+     */
+    disable(options?: {
+        userAction?: boolean;
+    }): void;
+    /**
+     * @description Dispose
+     */
+    dispose(): void;
+    setState(state: Partial<Object3DHelperState>, options?: {
+        userAction?: boolean;
+    } & Record<string, any>): void;
+    addControllers(controllers: Controllers): void;
+    addHelpers(helpers: Partial<{
+        [K in keyof Helpers]: Helpers[K];
+    }>): void;
+    getCurrentState(): Object3DHelperState;
+    private addEventListener;
+    private handleEnd;
+    private handleStart;
+    private setOtherHelpersVisible;
+    private handlePositionUpdate;
+    private handleScaleUpdate;
+    private handleRotateUpdate;
+    private handleEnable;
+    private handleVisible;
+    private everyControllerDo;
+    private handleDispose;
+    private actionIfStateIsEnabled;
+}
+export {};