@realsee/dnalogel 3.38.0 → 3.40.0-alpha.0

package/libs/GuideLinePlugin/GuideLineModeItem.d.ts

@@ -29,7 +29,9 @@ declare class GuideLineModeItem {
     geometryStyle: PluginType.GuideLineGeometryStyle;
     materialStyle: PluginType.GuideLineMaterialStyle;
     meshStyle: PluginType.GuideLineMeshStyle;
-    readonly mesh: THREE.Mesh<THREE.BufferGeometry, THREE.ShaderMaterial>;
+    readonly group: THREE.Group;
+    readonly meshWithDepthTest: THREE.Mesh<THREE.BufferGeometry, THREE.ShaderMaterial>;
+    readonly meshWithoutDepthTest: THREE.Mesh<THREE.BufferGeometry, THREE.ShaderMaterial>;
     private five;
     private mode;
     private _curvePath;
@@ -61,6 +63,8 @@ declare class GuideLineModeItem {
     private cacheLengths;
     /** 为了让多条路线在高度上错开，每个路线都需要有个额外的 offset */
     private heightOffset;
+    private panoMap;
+    private autoDepthTestEffectDistance?;
     constructor(five: Five, options: {
         mode: PluginType.GuideLineModeItemMode;
         plugin: GuideLinePlugin;
@@ -78,9 +82,14 @@ declare class GuideLineModeItem {
     /** 通过点位设置线条形状 */
     setGeometryByPanoGroup(_panoGroup: number[], options?: CatmullRomCurve3RestParams & PluginType.GuideLineGeometryStyle & {
         skipPanoGroup?: boolean;
+        useAutoDepthTest?: boolean;
+        autoDepthTestEffectDistance?: number;
     }): void;
     /** 通过路径设置线条形状 */
-    setGeometryByPath(path: PluginType.PathItem[], options?: PluginType.GuideLineGeometryStyle): void;
+    setGeometryByPath(path: PluginType.PathItem[], options?: PluginType.GuideLineGeometryStyle & {
+        useAutoDepthTest?: boolean;
+        autoDepthTestEffectDistance?: number;
+    }): void;
     /** 设置线条材质 */
     setMartial(options?: PluginType.GuideLineMaterialStyle): void;
     /** 设置模型状态 */
@@ -128,6 +137,8 @@ declare class GuideLineModeItem {
     private onWalkAnimationEnd;
     /** 模型状态变更 */
     private onFiveModeChange;
+    /** 走点 */
+    private onFivePanoArrived;
     private onFiveModelShownFloorChange;
     /** 更新可见性 */
     private updateVisible;

package/libs/GuideLinePlugin/GuideLineModeItem.js

@@ -14,7 +14,7 @@ import "../PanoTagPlugin/controller/index.js";
 import "./Components/Tag.js";
 import "./utils/index.js";
 import "../vendor/object-assign-deep/objectAssignDeep.js";
-import { GuideLineModeItem as $i } from "./GuideLineModeItem/index.js";
+import { GuideLineModeItem as om } from "./GuideLineModeItem/index.js";
 import "../vendor/polyline-normals/index.js";
 import "../vendor/polyline-miter-util/index.js";
 import "../vendor/gl-vec2/add.js";
@@ -22,6 +22,7 @@ import "../vendor/gl-vec2/set.js";
 import "../vendor/gl-vec2/normalize.js";
 import "../vendor/gl-vec2/subtract.js";
 import "../vendor/gl-vec2/dot.js";
+import "../shared-utils/math/intersecting.js";
 import "../shared-utils/positionToVector3.js";
 import "../CSS3DRenderPlugin/utils/three/CSS3DRenderer.js";
 import "three/examples/jsm/renderers/CSS3DRenderer";
@@ -158,5 +159,5 @@ import "../shared-utils/three/blink.js";
 import "../PanoTagPlugin/utils/DebugUtil.js";
 import "../CruisePlugin/utils/sleep.js";
 export {
-  $i as GuideLineModeItem
+  om as GuideLineModeItem
 };

package/libs/GuideLinePlugin/index.js

@@ -1,6 +1,6 @@
 import t from "./Controller.js";
-import { GuideLineItem$1 as wt } from "./GuideLineItem/index.js";
-import { GuideLineModeItem$1 as bt } from "./GuideLineModeItem/index.js";
+import { GuideLineItem$1 as Ct } from "./GuideLineItem/index.js";
+import { GuideLineModeItem$1 as ht } from "./GuideLineModeItem/index.js";
 import "../base/BasePluginWithData.js";
 import "../base/BasePlugin.js";
 import "../shared-utils/Subscribe.js";
@@ -52,6 +52,7 @@ import "../vendor/gl-vec2/set.js";
 import "../vendor/gl-vec2/normalize.js";
 import "../vendor/gl-vec2/subtract.js";
 import "../vendor/gl-vec2/dot.js";
+import "../shared-utils/math/intersecting.js";
 import "../shared-utils/five/mode.js";
 import "../shared-utils/animationFrame/BetterTween.js";
 import "../shared-utils/animationFrame/index.js";
@@ -177,10 +178,10 @@ import "../shared-utils/five/changeMode.js";
 import "../shared-utils/nearlyEqual.js";
 import "../CruisePlugin/Move.js";
 import "../CruisePlugin/utils/getFiveStateOnCurve.js";
-const r = (i, o) => new t(i, o), gt = r;
+const r = (i, o) => new t(i, o), Mt = r;
 export {
-  wt as GuideLineItem,
-  bt as GuideLineModeItem,
+  Ct as GuideLineItem,
+  ht as GuideLineModeItem,
   r as GuideLinePlugin,
-  gt as default
+  Mt as default
 };

package/libs/GuideLinePlugin/typing.d.ts

@@ -4,7 +4,6 @@ import type * as BasePluginWithData from '../base/BasePluginWithData';
 import type { Tag } from '../PanoTagPlugin';
 export interface RouteConfig {
     arrowTextureUrl?: string;
-    skipPanoIndexMesh?: boolean;
     unitWidth?: number;
     unitHeight?: number;
 }
@@ -88,8 +87,21 @@ export type GuideLineItem = RequireAtLeastOne<{
 export interface PanoramaGuideLineStyle extends GuideLineStyle {
     start_tag?: Tag;
     end_tag?: Tag;
-    /** 是否跳过点位 */
+    /**
+     * @description 是否跳过点位
+     * @default false
+     */
     skip_group?: boolean;
+    /**
+     * @description 是否自动关闭点位附近路线的深度测试
+     * @default false
+     */
+    use_auto_depthtest?: boolean;
+    /**
+     * @description use_auto_depthtest 开启时，自动关闭深度测试的距离
+     * @default 1~3 之间
+     */
+    auto_depth_test_effect_distance?: number;
 }
 /** 模型路径样式 */
 export interface ModelGuideLineStyle extends GuideLineStyle {
@@ -165,4 +177,6 @@ export interface CatmullRomCurve3 {
     closed?: boolean;
     curve_type?: string;
     tension?: number;
+    panoIndexList?: number[];
+    panoIndexMap?: Record<number, number>;
 }

package/libs/GuideLinePlugin/utils/createLineGeometry.d.ts

@@ -9,6 +9,7 @@ interface LineGeometryOption {
     /** 每一段的长度，默认是 0.5 */
     unitLength: number;
     skipPositions?: THREE.Vector3[] | null;
+    useAutoDepthTest?: boolean;
 }
 /** 创建路线的几何体
  * @param curvePoints 三维点位
@@ -18,8 +19,22 @@ interface LineGeometryOption {
  */
 export declare function createLineGeometry(options: LineGeometryOption): {
     geometry: THREE.BufferGeometry;
-    maxU: number;
+    maxV: number;
+    curvePath: any;
+    curvePoints: any;
+    animationWillError?: undefined;
+    panoMap?: undefined;
+    totalLength?: undefined;
+} | {
+    geometry: THREE.BufferGeometry;
+    maxV: number;
+    animationWillError: {
+        start: number;
+        end: number;
+    }[];
     curvePath: THREE.CurvePath<THREE.Vector3>;
     curvePoints: THREE.Vector3[];
+    panoMap: Record<number, number>;
+    totalLength: number;
 };
 export {};

package/libs/GuideLinePlugin/utils/createLineGeometry.js

@@ -1,51 +1,144 @@
-import * as n from "three";
-import { Vector3 as x } from "three";
-import { polylineNormals as G } from "../../vendor/polyline-normals/index.js";
+import * as l from "three";
+import { Vector3 as nt } from "three";
+import { polylineNormals as ht } from "../../vendor/polyline-normals/index.js";
+import { lineIsIntersecting as mt, findIntersectingOfLines as pt } from "../../shared-utils/math/intersecting.js";
 import "../../vendor/polyline-miter-util/index.js";
 import "../../vendor/gl-vec2/add.js";
 import "../../vendor/gl-vec2/set.js";
 import "../../vendor/gl-vec2/normalize.js";
 import "../../vendor/gl-vec2/subtract.js";
 import "../../vendor/gl-vec2/dot.js";
-const z = 2, M = 3, X = 3, k = 2;
-function Q(e) {
-  const i = e.width, g = e.unitLength / i, c = i / 2, E = e.path;
-  if (E.length === 0)
-    return { geometry: new n.BufferGeometry(), maxU: 0, curvePath: null, curvePoints: null };
-  const u = new n.CurvePath();
-  E.forEach((t) => {
-    const l = I(t);
-    l && u.add(l);
+const dt = 2, xt = 3, gt = 3, vt = 2;
+function kt(i) {
+  const G = i.width, L = i.unitLength, V = G / 2, B = i.path;
+  if (B.length === 0)
+    return { geometry: new l.BufferGeometry(), maxV: 0, curvePath: null, curvePoints: null };
+  const I = new l.CurvePath();
+  B.forEach((t) => {
+    const e = yt(t);
+    e && I.add(e);
   });
-  const w = Math.ceil(u.getLength() * 100);
-  u.arcLengthDivisions = w;
-  const o = u.getPoints(w), y = o.length, L = G(o.map((t) => [t.x, t.z])), B = (y - 1) * z * M, d = 2 * y, C = d * X, U = d * k, r = new Uint32Array(B), s = new Float32Array(C), a = new Float32Array(U);
-  let N = 0, P = 0;
-  for (let t = 0; t < o.length; t++) {
-    const [l, R] = L[t][0], T = o[t], { x: A, y: _, z: b } = T, v = new x(A + l * c, _ + 0.05, b + R * c);
-    s[t * 6 + 0] = v.x, s[t * 6 + 1] = v.y, s[t * 6 + 2] = v.z;
-    const f = new x(A - l * c, _ + 0.05, b - R * c);
-    s[t * 6 + 3] = f.x, s[t * 6 + 4] = f.y, s[t * 6 + 5] = f.z, N += t > 0 ? o[t - 1].clone().sub(o[t]).length() : 0;
-    const h = N / i / g;
-    if (P = h, a[t * 4 + 0] = 0, a[t * 4 + 1] = h, a[t * 4 + 2] = 1, a[t * 4 + 3] = h, e.skipPositions) {
-      const V = new n.Vector3().lerpVectors(v, f, 0.5);
-      if (e.skipPositions.some((F) => F.distanceTo(V) < 0.26))
-        continue;
+  const W = Math.ceil(I.getLength() * 100);
+  I.arcLengthDivisions = W;
+  const P = I.getPoints(W), x = P.length, et = ht(P.map((t) => [t.x, t.z])), ot = (x - 1) * dt * xt, X = 2 * x, st = X * gt, ct = X * vt, E = new Uint32Array(ot), n = new Float32Array(st), N = new Float32Array(ct), H = I.getLength();
+  let R = 0, Z = 0, $ = {};
+  const b = i.path[0].points.map((t) => new l.Vector3().fromArray(t)), j = i.path[0].panoIndexList ? [...i.path[0].panoIndexList] : void 0, q = (() => {
+    const t = [];
+    for (let s = 0; s < b.length; s++) {
+      const u = b[s];
+      if (s === 0)
+        t.push(0);
+      else {
+        const f = b[s - 1];
+        t.push(u.distanceTo(f) + t[s - 1]);
+      }
     }
-    t !== o.length - 1 && (r[t * 6 + 0] = t * 2 + 0, r[t * 6 + 1] = t * 2 + 2, r[t * 6 + 2] = t * 2 + 1, r[t * 6 + 3] = t * 2 + 2, r[t * 6 + 4] = t * 2 + 3, r[t * 6 + 5] = t * 2 + 1);
+    const e = t.at(-1), p = [];
+    for (let s = 0; s < t.length; s++) {
+      const u = t[s], f = s === 0 ? 0 : t[s - 1], w = s === t.length - 1 ? e : t[s + 1], r = u - Math.min(0.3, (u - f) / 2), a = u + Math.min(0.3, (w - u) / 2);
+      p.push([H * (r / e), H * (a / e)]);
+    }
+    return p;
+  })();
+  let D = [];
+  for (let t = 0; t < x; t++) {
+    const [e, p] = et[t][0], s = P[t], { x: u, y: f, z: w } = s, r = new nt(u + e * V, f + 0.05, w + p * V);
+    n[t * 6 + 0] = r.x, n[t * 6 + 1] = r.y, n[t * 6 + 2] = r.z;
+    const a = new nt(u - e * V, f + 0.05, w - p * V);
+    n[t * 6 + 3] = a.x, n[t * 6 + 4] = a.y, n[t * 6 + 5] = a.z, R += t > 0 ? P[t - 1].clone().sub(P[t]).length() : 0;
+    const g = R / L;
+    Z = g, N[t * 4 + 0] = 0, N[t * 4 + 1] = g, N[t * 4 + 2] = 1, N[t * 4 + 3] = g;
+    const A = new l.Vector3().lerpVectors(r, a, 0.5);
+    if (i.skipPositions && i.skipPositions.some((_) => _.distanceTo(A) < 0.26))
+      continue;
+    const h = b[0];
+    if (i.useAutoDepthTest && h && j) {
+      const T = j[0], [_, v] = q[0];
+      if (R > _ && R < v && D.push({
+        distance: h.distanceTo(A),
+        index: t
+      }), R >= v || t === x - 1) {
+        const Y = Math.min(...D.map((M) => M.distance)), c = D.find((M) => M.distance === Y);
+        if (D = [], b.shift(), j.shift(), q.shift(), c)
+          $[T] = c.index;
+        else {
+          console.error(`can not find the min distance ${T}`);
+          continue;
+        }
+      }
+    }
+    t !== x - 1 && (E[t * 6 + 0] = t * 2 + 0, E[t * 6 + 1] = t * 2 + 2, E[t * 6 + 2] = t * 2 + 1, E[t * 6 + 3] = t * 2 + 2, E[t * 6 + 4] = t * 2 + 3, E[t * 6 + 5] = t * 2 + 1);
   }
-  const m = new n.BufferGeometry();
-  return m.setAttribute("position", new n.BufferAttribute(s, 3)), m.setAttribute("uv", new n.BufferAttribute(a, 2)), m.setIndex(new n.BufferAttribute(r, 1)), { geometry: m, maxU: P, curvePath: u, curvePoints: o };
+  const m = [], z = [];
+  for (let t = 0; t < x - 1; t++) {
+    const e = t + 1, p = {
+      x: n[t * 6 + 0],
+      y: n[t * 6 + 2]
+    }, s = {
+      x: n[t * 6 + 3],
+      y: n[t * 6 + 5]
+    }, u = {
+      x: n[e * 6 + 0],
+      y: n[e * 6 + 2]
+    }, f = {
+      x: n[e * 6 + 3],
+      y: n[e * 6 + 5]
+    }, w = mt([p, s], [u, f]);
+    if (w && m.push(t), !w && m.length) {
+      m.push(e);
+      const r = new l.Vector2(p.x, p.y).distanceTo(new l.Vector2(u.x, u.y)), a = new l.Vector2(s.x, s.y).distanceTo(new l.Vector2(f.x, f.y)), g = [], A = [], h = Math.max(0, m[0] - L * 100), T = m[0];
+      for (let c = h; c < T; c++)
+        r < a ? g.push({ x: n[c * 6 + 0], y: n[c * 6 + 2] }) : g.push({ x: n[c * 6 + 3], y: n[c * 6 + 5] });
+      const _ = m.at(-1), v = Math.min(x - 1, m.at(-1) + L * 100);
+      for (let c = _; c < v; c++)
+        r < a ? A.push({ x: n[c * 6 + 0], y: n[c * 6 + 2] }) : A.push({ x: n[c * 6 + 3], y: n[c * 6 + 5] });
+      const Y = pt(g, A);
+      if (console.log(Y, r < a, m, g, A), Y) {
+        const {
+          line1RelativeIndex: c,
+          line2RelativeIndex: M,
+          x: J,
+          y: K
+        } = Y, y = h + c, d = _ + M + 2;
+        console.log(y, d, r < a);
+        for (let o = y; o < d; o++)
+          r < a ? (n[o * 6 + 0] = J, n[o * 6 + 2] = K) : (n[o * 6 + 3] = J, n[o * 6 + 5] = K);
+        const Q = n[h * 6 + 1], tt = n[h * 6 + 4], it = n[y * 6 + 1], rt = n[y * 6 + 4], at = n[d * 6 + 1], lt = n[d * 6 + 4], ut = n[(v - 1) * 6 + 1], ft = n[(v - 1) * 6 + 4], F = (it + at) / 2, U = (rt + lt) / 2;
+        for (let o = h; o < y; o++) {
+          const O = y - h, C = (o - h) / O;
+          r < a ? n[o * 6 + 1] = Q + (F - Q) * C : n[o * 6 + 4] = tt + (U - tt) * C;
+        }
+        for (let o = y; o < d; o++)
+          r < a ? n[o * 6 + 1] = F : n[o * 6 + 4] = U;
+        for (let o = d; o < v; o++) {
+          const O = v - d, C = (o - d + 1) / O;
+          r < a ? n[o * 6 + 1] = F + (ut - F) * C : n[o * 6 + 4] = U + (ft - U) * C;
+        }
+        z.push({
+          start: y,
+          end: d
+        });
+      }
+      m.length = 0;
+    }
+  }
+  const k = new Float32Array(X);
+  z.forEach((t) => {
+    for (let e = 0; e < x - 1; e++)
+      e >= t.start && e <= t.end ? (k[e * 2 + 0] = 1, k[e * 2 + 1] = 1) : k[e] !== 1 && (k[e * 2 + 0] = 0, k[e * 2 + 1] = 0);
+  });
+  const S = new l.BufferGeometry();
+  return S.setAttribute("position", new l.BufferAttribute(n, 3)), S.setAttribute("uv", new l.BufferAttribute(N, 2)), S.setIndex(new l.BufferAttribute(E, 1)), { geometry: S, maxV: Z, animationWillError: z, curvePath: I, curvePoints: P, panoMap: $, totalLength: R };
 }
-function I(e) {
-  if (O(e)) {
-    const i = [e.closed, e.curve_type, e.tension], p = e.points.map((c) => new n.Vector3().fromArray(c));
-    return new n.CatmullRomCurve3(p, ...i);
+function yt(i) {
+  if (Et(i)) {
+    const G = [i.closed, i.curve_type, i.tension], L = i.points.map((B) => new l.Vector3().fromArray(B));
+    return new l.CatmullRomCurve3(L, ...G);
   }
 }
-function O(e) {
-  return e.type === "CatmullRomCurve3";
+function Et(i) {
+  return i.type === "CatmullRomCurve3";
 }
 export {
-  Q as createLineGeometry
+  kt as createLineGeometry
 };

package/libs/base/BasePlugin.js

@@ -15,7 +15,7 @@ let x = class {
     /**
      * @realsee/dnalogel 版本号
      */
-    o(this, "VERSION", "3.38.0");
+    o(this, "VERSION", "3.40.0-alpha.0");
     o(this, "NAME");
     o(this, "five");
     o(this, "workUtil");