@realsee/dnalogel 3.20.6 → 3.21.0

package/libs/PanoTagPlugin/utils/model/mediaPlane.js

@@ -21,8 +21,8 @@ import * as I from "three";
 import { Vector3 as w } from "three";
 import { centerPoint as b } from "../../../shared-utils/three/centerPoint.js";
 import { loadPicture as x } from "../../../shared-utils/three/loadTexture.js";
-import { QuadrangleGeometry as V, QuadrangleMesh as P } from "../../../shared-utils/three/Quadrangle.js";
-import { getVideoTexture as H } from "../../../shared-utils/three/loadVideoTexture.js";
+import { QuadrangleGeometry as H, QuadrangleMesh as P } from "../../../shared-utils/three/Quadrangle.js";
+import { getVideoTexture as V } from "../../../shared-utils/three/loadVideoTexture.js";
 import { Image_Play_Icon_With_Text as L, Image_Play_Icon as T } from "../../Assets/Icon.js";
 import { getPositionsByObjectFit as g } from "../../../shared-utils/three/getPositionsByObjectFit.js";
 import { FragmentTransparencyMaterial as R } from "../../../shared-utils/three/FragmentTransparencyMaterial.js";
@@ -68,7 +68,7 @@ class $ extends C {
         (p = t == null ? void 0 : t.objectFit) != null ? p : "contain",
         a,
         s.image.width / s.image.height
-      ), l = b(...d), m = d.map((y) => y.clone().sub(l)), f = new V(m);
+      ), l = b(...d), m = d.map((y) => y.clone().sub(l)), f = new H(m);
       this.position.copy(l), this.geometry = f, this.material = M;
     }).catch((s) => {
       console.error(`Imageplane error ${s == null ? void 0 : s.message}`);
@@ -175,9 +175,14 @@ class q extends C {
       }))();
       if (!e)
         return;
-      this.domEvents.addAutoBindEventListener(e, "click", () => {
-        !this.videoInstance.paused && this.videoInstance.muted ? this.videoInstance.muted = !1 : this.pause();
-      });
+      this.domEvents.addAutoBindEventListener(
+        e,
+        "click",
+        () => {
+          !this.videoInstance.paused && this.videoInstance.muted ? this.videoInstance.muted = !1 : this.pause();
+        },
+        { noEmitWhenHide: !0 }
+      );
       const i = e.material.map.image;
       return i.addEventListener("playing", () => {
         this.coverMesh || this.remove(this.buttonMesh), this.render();
@@ -195,9 +200,14 @@ class q extends C {
         if (this.buttonMesh)
           return this.buttonMesh;
         const i = (f = (m = this.videoMesh) == null ? void 0 : m.geometry.points[0].distanceTo(this.videoMesh.geometry.points[3])) != null ? f : 1 / 0, t = (y = (p = this.coverMesh) == null ? void 0 : p.geometry.points[0].distanceTo(this.coverMesh.geometry.points[3])) != null ? y : 1 / 0, n = this.cornerPoints[0].distanceTo(this.cornerPoints[3]), o = Math.min(i, t, n) / n * 0.3, { texture: s, transparent: u } = yield this.getImageTexture(this.buttonSrc), M = g("contain", this.cornerPoints, s.image.width / s.image.height), d = new P(M, new R(s));
-        d.position.copy(new w(0, 0, 0)), d.name = "buttonMesh", d.scale.set(o, o, o), this.domEvents.addAutoBindEventListener(d, "click", () => {
-          this.play();
-        });
+        d.position.copy(new w(0, 0, 0)), d.name = "buttonMesh", d.scale.set(o, o, o), this.domEvents.addAutoBindEventListener(
+          d,
+          "click",
+          () => {
+            this.play();
+          },
+          { noEmitWhenHide: !0 }
+        );
         const l = E(M, 5e-4);
         return d.position.add(l), d;
       }))();
@@ -217,7 +227,7 @@ class q extends C {
     var t, n;
     if ((t = this.videoTextureMap) != null && t.has(e))
       return this.videoTextureMap.get(e);
-    const i = H(e);
+    const i = V(e);
     return (n = this.videoTextureMap) == null || n.set(e, i), i;
   }
 }

package/libs/Sculpt/Meshes/Area.d.ts

@@ -0,0 +1,30 @@
+import type { LineStyle } from '../utils/color';
+import { type AnyPositions } from '../../shared-utils/positionToVector3';
+import { PolylineWithDotsMesh } from './Polyline';
+import * as THREE from 'three';
+import PolygonMesh from './Polygon';
+import type { PointsData } from '../utils/data';
+import type { ColoredMeshStyle } from '../utils/three/ColoredMesh';
+export type AreaStyle = ColoredMeshStyle & LineStyle;
+export type AreaData = PointsData;
+export declare class AreaMesh extends PolylineWithDotsMesh {
+    name: string;
+    polygon: PolygonMesh;
+    get color(): THREE.Color;
+    get opacity(): number;
+    /** 多边形前三个点组成的平面，用来使得后面加的点也落在这个平面上 */
+    private planeHelper;
+    private planeHelperNeedUpdate;
+    constructor(params?: Partial<AreaStyle & AreaData>);
+    setStyle(params: Partial<AreaStyle>): void;
+    setPoints(points: AnyPositions, autoClosed?: boolean): void;
+    getGeometryInfo(): {
+        center: THREE.Vector3;
+        area: number;
+    };
+    /**
+     * @description: 获取一个点投影在当前平面上的点
+     */
+    projectPoint(point: THREE.Vector3): THREE.Vector3;
+    private updatePlaneHelper;
+}

package/libs/Sculpt/Meshes/Area.js

@@ -0,0 +1,56 @@
+var y = Object.defineProperty;
+var r = Object.getOwnPropertySymbols;
+var u = Object.prototype.hasOwnProperty, c = Object.prototype.propertyIsEnumerable;
+var i = (o, t, e) => t in o ? y(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e, p = (o, t) => {
+  for (var e in t || (t = {}))
+    u.call(t, e) && i(o, e, t[e]);
+  if (r)
+    for (var e of r(t))
+      c.call(t, e) && i(o, e, t[e]);
+  return o;
+};
+var l = (o, t, e) => (i(o, typeof t != "symbol" ? t + "" : t, e), e);
+import { anyPositionToVector3 as g } from "../../shared-utils/positionToVector3.js";
+import { PolylineWithDotsMesh as a } from "./Polyline.js";
+import * as h from "three";
+import { PolygonMesh as d } from "./Polygon.js";
+class N extends a {
+  constructor(e) {
+    super();
+    l(this, "name", "AreaMesh");
+    l(this, "polygon");
+    /** 多边形前三个点组成的平面，用来使得后面加的点也落在这个平面上 */
+    l(this, "planeHelper");
+    l(this, "planeHelperNeedUpdate", !0);
+    this.add(this.polygon = new d(e)), e != null && e.points && this.setPoints(e.points), e && this.setStyle(e);
+  }
+  get color() {
+    return this.polygon.color;
+  }
+  get opacity() {
+    return this.polygon.opacity;
+  }
+  setStyle(e) {
+    var s;
+    super.setStyle(p({ color: e.lineColor }, e)), (s = this.polygon) == null || s.setStyle(e);
+  }
+  setPoints(e, s = !0) {
+    const n = e.map(g);
+    s && n.length >= 3 && !n[0].equals(n.at(-1)) && n.push(n[0]), super.setPoints(n), this.polygon.setPoints(n), this.planeHelperNeedUpdate = !0;
+  }
+  getGeometryInfo() {
+    return this.polygon.getGeometryInfo();
+  }
+  /**
+   * @description: 获取一个点投影在当前平面上的点
+   */
+  projectPoint(e) {
+    return e && (this.planeHelperNeedUpdate && this.updatePlaneHelper(), this.planeHelper ? this.planeHelper.projectPoint(e, new h.Vector3()) : e);
+  }
+  updatePlaneHelper() {
+    this.points.length >= 3 ? this.planeHelper = new h.Plane().setFromCoplanarPoints(this.points[0], this.points[1], this.points[2]) : this.planeHelper = null, this.planeHelperNeedUpdate = !1;
+  }
+}
+export {
+  N as AreaMesh
+};

package/libs/Sculpt/Meshes/Box.d.ts

@@ -0,0 +1,35 @@
+import { IObject3D } from '../../shared-utils/three/IObject3D';
+import { type AnyPositions, type AnyPosition } from '../../shared-utils/positionToVector3';
+import type * as THREE from 'three';
+import type { LineStyle } from '../utils/color';
+import { RectangleWithEdgeMesh } from './RectangleWithEdge';
+import { RectangleMesh } from './Rectangle';
+import type { PointsData } from '../utils/data';
+import type { ColoredMeshStyle } from '../utils/three/ColoredMesh';
+export type BoxStyle = ColoredMeshStyle & LineStyle;
+export type BoxData = PointsData & {
+    heightPoint: AnyPosition;
+};
+/**
+ * @description: Box
+ */
+export declare class BoxMesh extends IObject3D {
+    name: string;
+    get planes(): RectangleMesh[];
+    bottomPlane: RectangleWithEdgeMesh;
+    topPlane: RectangleWithEdgeMesh;
+    heightPoint: THREE.Vector3;
+    protected edgePlanes: RectangleWithEdgeMesh[];
+    get color(): THREE.Color;
+    get lineColor(): THREE.Color;
+    get lineWidth(): number;
+    get occlusionVisibility(): boolean;
+    constructor(params?: Partial<BoxStyle & BoxData>);
+    setPoints(params: Partial<BoxData>): void;
+    setBottomPoints(points: AnyPositions): void;
+    setTopHeightPoint(point: AnyPosition): void;
+    setEdgePlanes(): void;
+    setStyle(style: Partial<BoxStyle>): void;
+    highlight(): void;
+    unhighlight(): void;
+}

package/libs/Sculpt/Meshes/Box.js

@@ -0,0 +1,88 @@
+var p = Object.defineProperty;
+var a = (e, o, t) => o in e ? p(e, o, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[o] = t;
+var n = (e, o, t) => (a(e, typeof o != "symbol" ? o + "" : o, t), t);
+import { IObject3D as d } from "../../shared-utils/three/IObject3D.js";
+import { anyPositionToVector3 as c } from "../../shared-utils/positionToVector3.js";
+import "hammerjs";
+import "three";
+import "@realsee/five";
+import "../../vendor/@tweenjs/tween/dist/tween.esm.js.js";
+import "../../CSS3DRenderPlugin/utils/three/CSS3DRender.js";
+import "../../CSS3DRenderPlugin/utils/generateBehindFiveElement.js";
+import { notNil as r } from "../../shared-utils/isNil.js";
+import { RectangleWithEdgeMesh as P } from "./RectangleWithEdge.js";
+import { RectangleMesh as m } from "./Rectangle.js";
+class T extends d {
+  constructor(t) {
+    super();
+    n(this, "name", "BoxMesh");
+    n(this, "bottomPlane");
+    n(this, "topPlane");
+    n(this, "heightPoint");
+    n(this, "edgePlanes", []);
+    this.bottomPlane = new P(t), this.topPlane = new P(t), this.add(this.bottomPlane), t != null && t.points && this.setPoints(t);
+  }
+  get planes() {
+    return this.children.filter((t) => t instanceof m);
+  }
+  get color() {
+    var t;
+    return (t = this.bottomPlane) == null ? void 0 : t.color;
+  }
+  get lineColor() {
+    var t;
+    return (t = this.bottomPlane) == null ? void 0 : t.lineColor;
+  }
+  get lineWidth() {
+    var t;
+    return (t = this.bottomPlane) == null ? void 0 : t.lineWidth;
+  }
+  get occlusionVisibility() {
+    var t;
+    return (t = this.bottomPlane) == null ? void 0 : t.occlusionVisibility;
+  }
+  setPoints(t) {
+    r(t.heightPoint) && this.setTopHeightPoint(t.heightPoint), r(t.points) && this.setBottomPoints(t.points);
+  }
+  setBottomPoints(t) {
+    const i = t.map(c).filter(r);
+    if (i.length < 3) {
+      console.error("Invalid position");
+      return;
+    }
+    this.bottomPlane.setPoints(i), this.heightPoint && this.setTopHeightPoint(this.heightPoint);
+  }
+  setTopHeightPoint(t) {
+    if (!this.bottomPlane.points.length)
+      return;
+    const i = c(t);
+    this.heightPoint = i, this.addIfNotExists(this.topPlane);
+    const h = this.bottomPlane.projectPoint(i), s = i.clone().sub(h), l = this.bottomPlane.points.map((g) => g.clone().add(s));
+    this.topPlane.setPoints(l), this.up.copy(s.clone().normalize()), this.setEdgePlanes();
+  }
+  setEdgePlanes() {
+    for (let t = 0; t < 4; t++) {
+      let i = this.edgePlanes[t];
+      i || (this.edgePlanes[t] = new P({
+        color: this.color,
+        lineColor: this.lineColor,
+        lineWidth: this.lineWidth,
+        occlusionVisibility: this.occlusionVisibility
+      }), i = this.edgePlanes[t]);
+      const h = this.topPlane.sortedPoint, s = this.bottomPlane.sortedPoint, l = t === 3 ? 0 : t + 1;
+      i.setPoints([h[t], s[l], s[t]]), this.addIfNotExists(i);
+    }
+  }
+  setStyle(t) {
+    this.planes.forEach((i) => i.setStyle(t));
+  }
+  highlight() {
+    this.planes.forEach((t) => t.highlight());
+  }
+  unhighlight() {
+    this.planes.forEach((t) => t.unhighlight());
+  }
+}
+export {
+  T as BoxMesh
+};

package/libs/Sculpt/Meshes/Circle.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from 'three';
+import { type OcclusionStyle } from '../utils/color';
+import ColoredMesh, { type ColoredMeshStyle } from '../utils/three/ColoredMesh';
+import { type AnyPosition } from '../../shared-utils/positionToVector3';
+export type CircleStyle = ColoredMeshStyle & OcclusionStyle;
+export type CircleData = {
+    center: AnyPosition;
+    normal: AnyPosition;
+    radius: number;
+};
+type Params = Partial<CircleStyle & CircleData>;
+export declare class CircleMesh extends ColoredMesh {
+    get center(): THREE.Vector3;
+    get normal(): THREE.Vector3;
+    private set normal(value);
+    get radius(): number;
+    meshFont: THREE.Mesh<THREE.CircleGeometry, THREE.MeshBasicMaterial>;
+    private _normal;
+    private opacityBeforeHighlight;
+    private highlighted;
+    constructor(params?: Params);
+    setPoints(params: CircleData): void;
+    highlight(): void;
+    unhighlight(): void;
+}
+export {};

package/libs/Sculpt/Meshes/Circle.js

@@ -0,0 +1,42 @@
+var g = Object.defineProperty;
+var c = (i, e, t) => e in i ? g(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var o = (i, e, t) => (c(i, typeof e != "symbol" ? e + "" : e, t), t);
+import * as d from "three";
+import { DEFAULT_HIGHLIGHT_OPACITY as u } from "../utils/color.js";
+import { radiusToSegments as y } from "../utils/radiusToSegments.js";
+import { ColoredMesh as f } from "../utils/three/ColoredMesh.js";
+import { anyPositionToVector3 as s } from "../../shared-utils/positionToVector3.js";
+class P extends f {
+  constructor(t) {
+    super(t);
+    o(this, "_normal");
+    o(this, "opacityBeforeHighlight");
+    o(this, "highlighted", !1);
+    t != null && t.center && (t != null && t.normal) && (t != null && t.radius) && this.setPoints(t);
+  }
+  get center() {
+    return this.position.clone();
+  }
+  get normal() {
+    return this._normal;
+  }
+  set normal(t) {
+    this._normal = t;
+  }
+  get radius() {
+    return this.meshFont.geometry.parameters.radius;
+  }
+  setPoints(t) {
+    const h = s(t.center), n = s(t.normal), r = t.radius, l = y(r);
+    this.geometry = new d.CircleGeometry(r, l), this.position.copy(h), this.lookAt(n.clone().add(h)), this.normal = n.clone().normalize(), this.needsRender = !0;
+  }
+  highlight() {
+    this.highlighted || (this.highlighted = !0, this.opacityBeforeHighlight = this.opacity, this.setStyle({ opacity: this.opacity * u }), this.needsRender = !0);
+  }
+  unhighlight() {
+    this.highlighted && (this.highlighted = !1, this.setStyle({ opacity: this.opacityBeforeHighlight }), this.needsRender = !0);
+  }
+}
+export {
+  P as CircleMesh
+};

package/libs/Sculpt/Meshes/CircleWithEdge.d.ts

@@ -0,0 +1,11 @@
+import type { LineStyle } from '../utils/color';
+import { CircleMesh, type CircleData, type CircleStyle } from './Circle';
+export type CircleWithEdgeMeshStyle = CircleStyle & LineStyle;
+export declare class CircleWithEdgeMesh extends CircleMesh {
+    private edgeLine;
+    constructor(params?: Partial<CircleWithEdgeMeshStyle & CircleData>);
+    setPoints(...params: Parameters<InstanceType<typeof CircleMesh>['setPoints']>): void;
+    setStyle(style: Partial<CircleWithEdgeMeshStyle>): void;
+    highlight(): void;
+    unhighlight(): void;
+}

package/libs/Sculpt/Meshes/CircleWithEdge.js

@@ -0,0 +1,41 @@
+var c = Object.defineProperty;
+var r = Object.getOwnPropertySymbols;
+var u = Object.prototype.hasOwnProperty, L = Object.prototype.propertyIsEnumerable;
+var P = (i, s, e) => s in i ? c(i, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[s] = e;
+var l = (i, s) => {
+  var e = {};
+  for (var t in i)
+    u.call(i, t) && s.indexOf(t) < 0 && (e[t] = i[t]);
+  if (i != null && r)
+    for (var t of r(i))
+      s.indexOf(t) < 0 && L.call(i, t) && (e[t] = i[t]);
+  return e;
+};
+var d = (i, s, e) => (P(i, typeof s != "symbol" ? s + "" : s, e), e);
+import { CircleMesh as p } from "./Circle.js";
+import { LineMesh as y } from "./Line.js";
+class S extends p {
+  constructor(e) {
+    const o = e != null ? e : {}, { normal: t, radius: h, center: n } = o, g = l(o, ["normal", "radius", "center"]);
+    super(g);
+    d(this, "edgeLine");
+    this.edgeLine = new y(g), this.add(this.edgeLine), t && h && n && this.setPoints({ normal: t, radius: h, center: n });
+  }
+  setPoints(...e) {
+    super.setPoints(...e);
+    const t = this.meshFont.geometry.vertices.slice(1);
+    this.edgeLine.setPoints(t.concat(t[0]));
+  }
+  setStyle(e) {
+    super.setStyle(e), this.edgeLine.setStyle(e);
+  }
+  highlight() {
+    super.highlight(), this.edgeLine.highlight();
+  }
+  unhighlight() {
+    super.unhighlight(), this.edgeLine.unhighlight();
+  }
+}
+export {
+  S as CircleWithEdgeMesh
+};

package/libs/Sculpt/Meshes/Cylinder.d.ts

@@ -0,0 +1,34 @@
+import { IObject3D } from '../../shared-utils/three/IObject3D';
+import * as THREE from 'three';
+import { CircleWithEdgeMesh, type CircleWithEdgeMeshStyle } from './CircleWithEdge';
+import ColoredMesh from '../utils/three/ColoredMesh';
+import { type AnyPosition } from '../../shared-utils/positionToVector3';
+export type CylinderStyle = CircleWithEdgeMeshStyle;
+export interface CylinderData {
+    bottomCenter: AnyPosition;
+    topCenter: AnyPosition;
+    radius: number;
+}
+type Params = Partial<CylinderStyle & CylinderData>;
+export declare class CylinderMesh extends IObject3D {
+    get bottomCenter(): THREE.Vector3;
+    get topCenter(): THREE.Vector3;
+    get normal(): THREE.Vector3;
+    get radius(): number;
+    get color(): THREE.Color;
+    bottomCircle: CircleWithEdgeMesh;
+    topCircle: CircleWithEdgeMesh;
+    protected edgeMesh: ColoredMesh;
+    private opacityBeforeHighlight;
+    private highlighted;
+    private params;
+    constructor(params?: Params);
+    setPoints(params: CylinderData): void;
+    setTopCenter(center: THREE.Vector3): void;
+    setBottomCenter(center: THREE.Vector3): void;
+    setStyle(style: CylinderStyle): void;
+    highlight(): void;
+    unhighlight(): void;
+    private setEdgeMesh;
+}
+export {};

package/libs/Sculpt/Meshes/Cylinder.js

@@ -0,0 +1,88 @@
+var u = Object.defineProperty;
+var c = Object.getOwnPropertySymbols;
+var p = Object.prototype.hasOwnProperty, b = Object.prototype.propertyIsEnumerable;
+var n = (i, e, t) => e in i ? u(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, l = (i, e) => {
+  for (var t in e || (e = {}))
+    p.call(e, t) && n(i, t, e[t]);
+  if (c)
+    for (var t of c(e))
+      b.call(e, t) && n(i, t, e[t]);
+  return i;
+};
+var o = (i, e, t) => (n(i, typeof e != "symbol" ? e + "" : e, t), t);
+import { IObject3D as f } from "../../shared-utils/three/IObject3D.js";
+import * as h from "three";
+import "hammerjs";
+import "@realsee/five";
+import "../../vendor/@tweenjs/tween/dist/tween.esm.js.js";
+import "../../CSS3DRenderPlugin/utils/three/CSS3DRender.js";
+import "../../CSS3DRenderPlugin/utils/generateBehindFiveElement.js";
+import { notNil as d } from "../../shared-utils/isNil.js";
+import { CircleWithEdgeMesh as g } from "./CircleWithEdge.js";
+import { radiusToSegments as M } from "../utils/radiusToSegments.js";
+import { ColoredMesh as y } from "../utils/three/ColoredMesh.js";
+import { anyPositionToVector3 as C } from "../../shared-utils/positionToVector3.js";
+import { DEFAULT_HIGHLIGHT_OPACITY as a } from "../utils/color.js";
+class q extends f {
+  constructor(t) {
+    super();
+    o(this, "bottomCircle");
+    o(this, "topCircle");
+    o(this, "edgeMesh");
+    o(this, "opacityBeforeHighlight");
+    o(this, "highlighted", !1);
+    o(this, "params");
+    this.params = t, this.bottomCircle = new g(t), this.bottomCircle.name = "bottomCircle", this.topCircle = new g(t), this.topCircle.name = "topCircle", this.edgeMesh = new y(t), t != null && t.bottomCenter && (t != null && t.topCenter) && (t != null && t.radius) && this.setPoints(t), this.addIfNotExists(this.bottomCircle);
+  }
+  get bottomCenter() {
+    return this.bottomCircle.center;
+  }
+  get topCenter() {
+    return this.topCircle.center;
+  }
+  get normal() {
+    return this.bottomCircle.normal;
+  }
+  get radius() {
+    return this.bottomCircle.radius;
+  }
+  get color() {
+    return this.bottomCircle.color;
+  }
+  setPoints(t) {
+    const r = C(t.topCenter), s = C(t.bottomCenter), m = r.clone().sub(s).normalize();
+    this.bottomCircle.setPoints({ center: s, normal: m, radius: t.radius }), this.setTopCenter(r), this.needsRender = !0;
+  }
+  setTopCenter(t) {
+    this.addIfNotExists(this.topCircle), this.topCircle.setPoints({ center: t, normal: this.normal, radius: this.radius }), this.setEdgeMesh();
+  }
+  setBottomCenter(t) {
+    this.addIfNotExists(this.bottomCircle), this.bottomCircle.setPoints({ center: t, normal: this.normal, radius: this.radius }), this.setEdgeMesh();
+  }
+  setStyle(t) {
+    this.params = l(l({}, this.params), t), d(t.color) && this.bottomCircle.setStyle({ color: t.color }), d(t.color) && this.topCircle.setStyle({ color: t.color });
+  }
+  highlight() {
+    this.highlighted || (this.highlighted = !0, this.opacityBeforeHighlight = this.edgeMesh.opacity, this.edgeMesh.setStyle({ opacity: this.edgeMesh.opacity * a }), this.bottomCircle.highlight(), this.topCircle.highlight(), this.needsRender = !0);
+  }
+  unhighlight() {
+    this.highlighted && (this.highlighted = !1, this.edgeMesh.setStyle({ opacity: this.opacityBeforeHighlight }), this.bottomCircle.unhighlight(), this.topCircle.unhighlight(), this.needsRender = !0);
+  }
+  setEdgeMesh() {
+    this.addIfNotExists(this.edgeMesh);
+    const t = this.topCircle.center, r = this.bottomCircle.center;
+    this.edgeMesh.geometry.dispose(), this.edgeMesh.geometry = new h.CylinderGeometry(
+      this.radius,
+      this.radius,
+      t.distanceTo(r),
+      M(this.radius),
+      1,
+      !0
+    );
+    const s = new h.Quaternion().setFromUnitVectors(new h.Vector3(0, 1, 0), this.normal.clone().normalize());
+    this.edgeMesh.position.copy(new h.Vector3().lerpVectors(r, t, 0.5)), this.edgeMesh.quaternion.copy(s);
+  }
+}
+export {
+  q as CylinderMesh
+};

package/libs/Sculpt/Meshes/Line.d.ts

@@ -0,0 +1,27 @@
+import * as THREE from 'three';
+import { type OcclusionStyle, type LineStyle } from '../utils/color';
+import { type AnyPositions } from '../../shared-utils/positionToVector3';
+import { IObject3D } from '../../shared-utils/three/IObject3D';
+import type { PointsData } from '../utils/data';
+export type LineMeshStyle = LineStyle & {
+    dashed?: boolean;
+} & OcclusionStyle;
+export type LineData = PointsData;
+export declare class LineMesh extends IObject3D {
+    name: string;
+    points: THREE.Vector3[];
+    get lineWidth(): number;
+    get color(): THREE.Color;
+    get dashed(): boolean;
+    get occlusionVisibility(): boolean;
+    protected highlighted: boolean;
+    private line;
+    private backLine;
+    private opacityBeforeHighlight;
+    constructor(params?: Partial<LineMeshStyle & LineData>);
+    setPoints(points: AnyPositions): void;
+    setResolution(width: number, height: number): void;
+    setStyle(params: Partial<LineMeshStyle>): void;
+    highlight(): void;
+    unhighlight(): void;
+}

package/libs/Sculpt/Meshes/Line.js

@@ -0,0 +1,108 @@
+var k = Object.defineProperty;
+var E = (h, o, e) => o in h ? k(h, o, { enumerable: !0, configurable: !0, writable: !0, value: e }) : h[o] = e;
+var l = (h, o, e) => (E(h, typeof o != "symbol" ? o + "" : o, e), e);
+import * as r from "three";
+import { DEFAULT_LINE_COLOR as g, DEFAULT_LINE_WIDTH as w, DEFAULT_HIGHLIGHT_OPACITY as L } from "../utils/color.js";
+import { LineGeometry as y, LineMaterial as a, THREE_Line2 as H } from "@realsee/five/line";
+import { anyPositionToVector3 as C } from "../../shared-utils/positionToVector3.js";
+import { IObject3D as D } from "../../shared-utils/three/IObject3D.js";
+import "hammerjs";
+import "@realsee/five";
+import "../../vendor/@tweenjs/tween/dist/tween.esm.js.js";
+import "../../CSS3DRenderPlugin/utils/three/CSS3DRender.js";
+import "../../CSS3DRenderPlugin/utils/generateBehindFiveElement.js";
+import { notNil as s } from "../../shared-utils/isNil.js";
+class b extends a {
+  constructor(e) {
+    var t, i;
+    super(e);
+    l(this, "_three_color");
+    s(e == null ? void 0 : e.color) && (this.three_color = (t = e == null ? void 0 : e.color) != null ? t : 16777215), Object.keys(e).forEach((n) => {
+      ["color", "dashed", "dashScale", "dashSize", "gapSize", "resolution"].includes(n) || n in this && (this[n] = e[n]);
+    }), this.setDashed((i = e == null ? void 0 : e.dashed) != null ? i : !1);
+  }
+  get three_color() {
+    return this._three_color;
+  }
+  set three_color(e) {
+    this._three_color = e, this.color = e;
+  }
+  setDashed(e) {
+    e ? this.defines.USE_DASH = "" : delete this.defines.USE_DASH, this.needsUpdate = !0;
+  }
+}
+class _ extends H {
+  constructor(e, t) {
+    super(e, t);
+    l(this, "name", "Line3");
+  }
+}
+class P extends D {
+  constructor(e) {
+    var c, d, f, u;
+    super();
+    l(this, "name", "LineMesh");
+    l(this, "points");
+    l(this, "highlighted", !1);
+    l(this, "line");
+    l(this, "backLine");
+    l(this, "opacityBeforeHighlight");
+    const t = new y(), i = new b({
+      color: new r.Color((c = e == null ? void 0 : e.lineColor) != null ? c : g),
+      linewidth: (d = e == null ? void 0 : e.lineWidth) != null ? d : w,
+      dashScale: 40,
+      opacity: 1,
+      transparent: !0,
+      dashed: (f = e == null ? void 0 : e.dashed) != null ? f : !1
+    }), n = new b({
+      color: new r.Color((u = e == null ? void 0 : e.lineColor) != null ? u : g),
+      linewidth: i == null ? void 0 : i.linewidth,
+      dashScale: i.dashScale,
+      depthTest: !1,
+      depthWrite: !1,
+      transparent: !0,
+      opacity: 0.2,
+      dashed: i.dashed,
+      resolution: i.resolution
+    });
+    this.line = new _(t, i), this.backLine = new _(t, n), this.line.renderOrder = 1, this.backLine.renderOrder = 0, this.line.name = "lineFrontMaterial", this.backLine.name = "lineBackMaterial", e && this.setStyle(e), e != null && e.points && this.setPoints(e.points);
+  }
+  get lineWidth() {
+    return this.line.material.linewidth;
+  }
+  get color() {
+    return new r.Color(this.line.material.three_color);
+  }
+  get dashed() {
+    return this.line.material.dashed;
+  }
+  get occlusionVisibility() {
+    return this.backLine.visible;
+  }
+  setPoints(e) {
+    const t = e.map(C).filter(s);
+    if (this.points = t, t.length < 2)
+      return;
+    this.addIfNotExists(this.line, this.backLine);
+    const i = t.flatMap((n) => [n.x, n.y, n.z]);
+    i.length > 2 && (this.line.geometry.dispose(), this.line.geometry = new y(), this.backLine.geometry = this.line.geometry), this.line.geometry.setPositions(i), this.line.computeLineDistances(), this.needsRender = !0;
+  }
+  setResolution(e, t) {
+    const i = this.line.material.resolution;
+    (i.x !== e || i.y !== t) && (i.set(e, t), this.needsRender = !0);
+    const n = this.backLine.material.resolution;
+    (n.x !== e || n.y !== t) && (n.set(e, t), this.needsRender = !0);
+  }
+  setStyle(e) {
+    s(e.lineColor) && (this.line.material.three_color = new r.Color(e.lineColor), this.backLine.material.three_color = new r.Color(e.lineColor)), s(e.lineWidth) && (this.line.material.linewidth = e.lineWidth, this.backLine.material.linewidth = e.lineWidth), s(e.dashed) && (this.line.material.setDashed(e.dashed), this.backLine.material.setDashed(e.dashed)), s(e.occlusionVisibility) && (this.backLine.visible = e.occlusionVisibility), this.needsRender = !0;
+  }
+  highlight() {
+    this.highlighted || (this.highlighted = !0, this.opacityBeforeHighlight = this.line.material.opacity, this.line.material.opacity = this.opacityBeforeHighlight * L, this.backLine.material.opacity = this.backLine.material.opacity * L, this.needsRender = !0);
+  }
+  unhighlight() {
+    this.highlighted && (this.highlighted = !1, this.line.material.opacity = this.opacityBeforeHighlight, this.backLine.material.opacity = 0.2, this.needsRender = !0);
+  }
+}
+export {
+  P as LineMesh
+};