@aibee/owlly 1.0.25

package/src/owlly/utils/helper.ts

@@ -0,0 +1,33 @@
+import {
+  Vector3,
+  BufferGeometry,
+  DoubleSide,
+  LineBasicMaterial,
+  Line,
+  AxesHelper,
+} from 'three';
+
+class Helper {
+  static createLine(points: [number, number, number][], color = '0000ff', order = 10): Line {
+    const vecs = points.map((pt: [number, number, number]) => new Vector3(...pt));
+    const geometry = new BufferGeometry().setFromPoints(vecs);
+    const lineMaterial = new LineBasicMaterial({
+      color,
+      side: DoubleSide,
+      depthTest: false,
+    });
+    const line = new Line(geometry, lineMaterial);
+    lineMaterial.needsUpdate = true;
+    line.renderOrder = order;
+    return line;
+  }
+
+  static createAxes(position: [number, number, number], size = 10, order = 10): AxesHelper {
+    const axesHelper = new AxesHelper(size);
+    axesHelper.visible = true;
+    axesHelper.position.set(...position);
+    axesHelper.renderOrder = order;
+    return axesHelper;
+  }
+}
+export { Helper };

package/src/owlly/utils/index.ts

@@ -0,0 +1,17 @@
+// #if WEB_ONLY
+export * from './svgutils';
+// #endif
+export * from './map-utils';
+export * from './event-hub';
+export * from './events';
+export * from './bvh-tree';
+export * from './alignment-utils';
+export * from './geometry-utils';
+export * from './device-utils';
+export * from './environment-utils';
+// edited by kxiao
+export * from './basic-tools';
+export * from './path-utils';
+export * from './basic-calc';
+export * from './helper';
+export * from './tile-util';

package/src/owlly/utils/lru-cache.ts

@@ -0,0 +1,126 @@
+// <script src="https://gist.github.com/dherges/86012049be7b1263b2e594134ff5816a.js"></script>
+class LruCache<T> {
+    private values: Map<string, T> = new Map<string, T>();
+
+    private capacity: number;
+
+    private totalCost: number;
+
+    private costCallback?: (value: T) => number;
+
+    constructor(capacity: number, costCallback?: (value: T) => number) {
+      this.capacity = capacity;
+      this.totalCost = 0;
+      this.costCallback = costCallback;
+    }
+
+    public get(key: string, missedCallback?: {(key: string): T|undefined}): T | undefined {
+      const hasKey = this.values.has(key);
+      let entry: T | undefined;
+      if (hasKey) {
+        // peek the entry, re-insert for LRU strategy
+        // console.log(`#LruCache# Hit cache with key: '${key}'`);
+        entry = this.values.get(key);
+        if (entry) {
+          this.values.delete(key);
+          this.values.set(key, entry);
+        }
+      } else if (missedCallback) {
+        // console.log(`#LruCache# Miss key: '${key}', will create one`);
+        entry = missedCallback(key);
+        if (entry) {
+          this.put(key, entry);
+        }
+      }
+      return entry;
+    }
+
+    /**
+     *
+     * @param key
+     * @param value
+     * @param evictCallback
+     * @param abortIfFull
+     * @returns If some other item is evicted
+     */
+    public put(key: string, value: T,
+      evictCallback?: {(key: string, value: T): void},
+      abortIfFull: boolean|undefined = false): boolean {
+      let ret = false;
+      // console.log(`#LruCache# abortIfFull=${abortIfFull}`);
+      if (this.totalCost >= this.capacity) {
+        if (abortIfFull) {
+          // console.log(`#LruCache# abortIfFull, return. this.totalCost=${this.totalCost}, this.capacity=${this.capacity}`);
+          return ret;
+        }
+        // least-recently used cache eviction strategy
+        const keyToDelete = this.values.keys().next().value;
+        const recycled = this.values.get(keyToDelete);
+        if (recycled) {
+          const recycledIncome = this.costCallback === undefined ? 1 : this.costCallback(recycled);
+          this.totalCost -= recycledIncome;
+          // console.log(`#LruCache# Cost exceeds capacity, evict entry with key'${keyToDelete}', totalCost=${this.totalCost}`);
+          if (evictCallback) {
+            // console.log('#LruCache# Will call evictCallback');
+            evictCallback(keyToDelete, recycled);
+          }
+          this.values.delete(keyToDelete);
+        }
+
+        ret = true;
+      }
+
+      if (this.values.has(key)) {
+        let cost0 = 1;
+        const oldValue = this.values.get(key);
+        if (oldValue && this.costCallback) {
+          cost0 = this.costCallback(oldValue);
+        }
+        const cost1 = this.costCallback === undefined ? 1 : this.costCallback(value);
+        this.values.set(key, value);
+        this.totalCost += (cost1 - cost0);
+        // console.log(`#LruCache# Replace entry with key'${key}', totalCost=${this.totalCost}`);
+      } else {
+        this.values.set(key, value);
+        const cost = this.costCallback === undefined ? 1 : this.costCallback(value);
+        this.totalCost += cost;
+        // console.log(`#LruCache# Add new entry with key'${key}', totalCost=${this.totalCost}`);
+      }
+
+      return ret;
+    }
+
+    public recycle(key: string, disposeCallback?: (key: string, value: T) => void): boolean {
+      let ret = false;
+      const recycled = this.values.get(key);
+      if (recycled) {
+        ret = true;
+        const recycledIncome = this.costCallback === undefined ? 1 : this.costCallback(recycled);
+        this.totalCost -= recycledIncome;
+        // console.log(`#LruCache# Recycle entry with key'${key}', totalCost=${this.totalCost}`);
+        if (disposeCallback) {
+          // console.log('#LruCache# Will call disposeCallback');
+          disposeCallback(key, recycled);
+        }
+        this.values.delete(key);
+      }
+      return ret;
+    }
+
+    public clear(disposeCallback: (key: string, value: T) => void): void {
+      this.values.forEach((recycled: T, key: string) => {
+        if (recycled) {
+          // console.log('#LruCache# Will call disposeCallback');
+          disposeCallback(key, recycled);
+        }
+      });
+      this.totalCost = 0;
+      this.values.clear();
+    }
+
+    public getCapacity(): number { return this.capacity; }
+
+    public getTotalCost(): number { return this.totalCost; }
+}
+
+export { LruCache };

package/src/owlly/utils/map-utils.ts

@@ -0,0 +1,55 @@
+import { Externals, NS_THREE } from '../stage/externals';
+
+import { PathStep, PathCommand } from '../element/map-kit/shape';
+
+/** Block 专用类, 仅用于通过 Shape 生成 THREE 可用的路径格式 @ignore */
+class MapUtils {
+  static GenerateShapeFromSteps(steps: PathStep[]): NS_THREE.Shape {
+    const { THREE } = Externals.getInstance();
+
+    const holes: NS_THREE.Path[] = [];
+    let hole: NS_THREE.Path | null = null;
+    let shapeCount = 0;
+    const result = new THREE.Shape();
+
+    steps.forEach(({ coords, command }) => {
+      switch (command) {
+        case PathCommand.MOVE:
+          if (coords.length !== 1) throw new Error(`Parse path command error. Command: ${command}`);
+          shapeCount += 1;
+          if (shapeCount > 1) {
+            hole = new THREE.Path();
+            holes.push(hole);
+            hole.moveTo(coords[0][0], coords[0][1]);
+          } else {
+            result.moveTo(coords[0][0], coords[0][1]);
+          }
+          break;
+        case PathCommand.LINE:
+          if (coords.length !== 1) throw new Error(`Parse path command error. Command: ${command}`);
+          if (hole && shapeCount > 1) hole.lineTo(coords[0][0], coords[0][1]);
+          else result.lineTo(coords[0][0], coords[0][1]);
+          break;
+        case PathCommand.CURVE:
+          if (coords.length !== 3) throw new Error(`Parse path command error. Command: ${command}`);
+          if (hole && shapeCount > 1) {
+            hole.bezierCurveTo(
+              coords[0][0], coords[0][1], coords[1][0], coords[1][1], coords[2][0], coords[2][1],
+            );
+          } else {
+            result.bezierCurveTo(
+              coords[0][0], coords[0][1], coords[1][0], coords[1][1], coords[2][0], coords[2][1],
+            );
+          }
+          break;
+        default:
+          break;
+      }
+    });
+
+    result.holes = holes;
+    return result;
+  }
+}
+
+export { MapUtils };

package/src/owlly/utils/number-utils.ts

@@ -0,0 +1,75 @@
+class NumberUtils {
+  static mergeRange(ranges: [number, number][], tolerance = 0.0001): [number, number][] {
+    const t = [] as [number, number][];
+    const s = Array.from(ranges);
+    s.sort((a, b) => b[0] - a[0]);
+    let cur = s.pop();
+    while (cur) {
+      const next = s.pop();
+      if (next) {
+        if (
+          (next[0] >= cur[0] && next[0] <= cur[1])
+          || NumberUtils.nearlyEquals(next[0], cur[0], tolerance)
+          || NumberUtils.nearlyEquals(next[0], cur[1], tolerance)
+        ) {
+          cur[1] = Math.max(cur[1], next[1]);
+        } else {
+          t.push(cur);
+          cur = next;
+        }
+      } else {
+        t.push(cur);
+        cur = next;
+      }
+    }
+    return t;
+  }
+
+  static rangeSub(range: [number, number], subRanges: [number, number][], tolerance = 0.0001): [number, number][] {
+    const [start, end] = range;
+    const trs = [] as number[][];
+    let tr = [] as number[];
+    trs.push(tr);
+    tr.push(start);
+    // eslint-disable-next-line no-param-reassign
+    subRanges = NumberUtils.mergeRange(subRanges, tolerance);
+    for (let i = 0; i < subRanges.length; i++) {
+      const subRange = subRanges[i];
+      const [subStart, subEnd] = subRange;
+      if (subStart <= end) {
+        tr.push(subStart);
+        tr = [];
+        trs.push(tr);
+      } else {
+        break;
+      }
+      if (subEnd <= end) {
+        tr.push(subEnd);
+      } else {
+        break;
+      }
+    }
+    if (tr.length === 1 && tr[0] < end) {
+      tr.push(end);
+    }
+    // const trsResult = [] as number[][];
+    const trsResult = trs.filter(([v1, v2]) => v2 !== undefined && !NumberUtils.nearlyEquals(v1, v2));
+    return trsResult as [number, number][];
+  }
+
+  static nearlyEquals(a: number, b: number, tolerance = 0.0001): boolean {
+    return Math.abs(a - b) < tolerance;
+  }
+
+  static nearlyLess(a: number, b: number, include: boolean, tolerance = 0.0001): boolean {
+    const equals = NumberUtils.nearlyEquals(a, b, tolerance);
+    return (include ? equals : false) || a < b;
+  }
+
+  static nearlyThan(a: number, b: number, include: boolean, tolerance = 0.0001): boolean {
+    const equals = NumberUtils.nearlyEquals(a, b, tolerance);
+    return (include ? equals : false) || a > b;
+  }
+}
+
+export { NumberUtils };

package/src/owlly/utils/panorama-model-util.ts

@@ -0,0 +1,255 @@
+import { Externals, NS_THREE } from '../stage/externals';
+
+/* eslint-disable max-len */
+class PanoramaModelUtil {
+  /**
+   * 获取模型的顶点着色器
+   * @ignore
+   */
+  public static getModelVS(): string {
+    const vertexShader = `
+      uniform vec3 pano0Position;
+      uniform mat4 pano0Matrix;
+      uniform vec3 pano1Position;
+      uniform mat4 pano1Matrix;
+
+      varying vec3 vWorldPosition0;
+      varying vec3 vWorldPosition1;
+
+      void main() {
+
+      vec4 worldPosition = modelMatrix * vec4(position, 1.0);
+
+      vec3 positionLocalToPanoCenter0 = worldPosition.xyz - pano0Position;
+      vWorldPosition0 = (vec4(positionLocalToPanoCenter0, 1.0) * pano0Matrix).xyz;
+      vWorldPosition0.y *= -1.0;
+
+      vec3 positionLocalToPanoCenter1 = worldPosition.xyz - pano1Position;
+      vWorldPosition1 = (vec4(positionLocalToPanoCenter1, 1.0) * pano1Matrix).xyz;
+      vWorldPosition1.y *= -1.0;
+
+      gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+      }`;
+    return vertexShader;
+  }
+
+  /**
+   * 获取穿梭的定点着色器
+   * @ignore
+   */
+  public static getInstantTranslationVS(): string {
+    const vertexShader = `
+      uniform mat4 matrixT;
+
+      uniform vec3 pano0Position;
+      uniform mat4 pano0Matrix;
+      uniform vec3 pano1Position;
+      uniform mat4 pano1Matrix;
+
+      varying vec3 vWorldPosition0;
+      varying vec3 vWorldPosition1;
+
+      void main() {
+
+      vec4 worldPosition = modelMatrix * vec4(position, 1.0);
+      vec4 worldPosition0 = matrixT * worldPosition;
+
+      vec3 positionLocalToPanoCenter1 = worldPosition.xyz - pano1Position;
+      vWorldPosition1 = (vec4(positionLocalToPanoCenter1, 1.0) * pano1Matrix).xyz;
+      vWorldPosition1.y *= -1.0;
+
+      vec3 positionLocalToPanoCenter0 = worldPosition0.xyz - pano0Position;
+      vWorldPosition0 = (vec4(positionLocalToPanoCenter0, 1.0) * pano0Matrix).xyz;
+      vWorldPosition0.y *= -1.0;
+
+      gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+      }`;
+    return vertexShader;
+  }
+
+  /**
+   * 获得模型片源着色器
+   * @ignore
+   * @returns {string} 片源着色器代码
+   */
+  public static getModelFS(): string {
+    const fragmentShader = `
+      uniform float weight0;
+      uniform float weight1;
+
+      uniform samplerCube pano0Map;
+
+      uniform samplerCube pano1Map;
+
+      varying vec3 vWorldPosition0;
+      varying vec3 vWorldPosition1;
+
+      void main() {
+      vec3 cp0 = vWorldPosition0.xyz;
+      vec3 cp1 = vWorldPosition1.xyz;
+      vec4 colorFromPano0 = textureCube( pano0Map, cp0);
+      vec4 colorFromPano1 = textureCube( pano1Map, cp1);
+
+      vec4 colorFromPanos;
+      // 'colorFromPanos = mix(colorFromPano0, colorFromPano1, progress);
+      colorFromPanos = colorFromPano0 * weight0 + colorFromPano1 * weight1;
+      gl_FragColor = vec4(colorFromPanos.rgb, 1.0);
+      }`;
+    return fragmentShader;
+  }
+
+  /**
+   * debug模型顶点着色器
+   * @ignore
+   */
+  public static debugModelVS(): string {
+    const vertexShader = `
+      uniform vec2 xRange;
+      uniform vec2 yRange;
+      uniform vec2 zRange;
+      varying vec4 vColor;
+
+      void main() {
+      float x = (position.x - xRange.x) / xRange.y;
+      float y = (position.y - yRange.x) / yRange.y;
+      float z = (position.z - zRange.x) / zRange.y;
+      vColor = vec4(x, y, z, 1.0);
+      gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+      }`;
+    return vertexShader;
+  }
+
+  /**
+   * debug模型片源着色器
+   * @ignore
+   */
+  public static debugModelFS(): string {
+    const fragmentShader = `
+      varying vec4 vColor;
+
+      void main() {
+      gl_FragColor = vColor;
+      }`;
+    return fragmentShader;
+  }
+
+  public static createModelUniforms(): { [uniform: string]: NS_THREE.IUniform } {
+    const { THREE } = Externals.getInstance();
+    const modelUniforms = {
+      weight0: {
+        type: 'f',
+        value: 0,
+      },
+      weight1: {
+        type: 'f',
+        value: 0,
+      },
+      // 源全景图立方体贴图
+      pano0Map: {
+        type: 't',
+        value: null,
+      },
+      // 源全景图位置
+      pano0Position: {
+        type: 'v3',
+        value: new THREE.Vector3(),
+      },
+      // 源全景图世界变换矩阵
+      pano0Matrix: {
+        type: 'm4',
+        value: new THREE.Matrix4(),
+      },
+      // 目标全景图立方体贴图
+      pano1Map: {
+        type: 't',
+        value: null,
+      },
+      // 目标全景图位置
+      pano1Position: {
+        type: 'v3',
+        value: new THREE.Vector3(),
+      },
+      // 目标全景图世界变换矩阵
+      pano1Matrix: {
+        type: 'm4',
+        value: new THREE.Matrix4(),
+      },
+    };
+    return modelUniforms;
+  }
+
+  /**
+   * @ignore
+   */
+  public static createInstantTranslationUniforms(): { [uniform: string]: NS_THREE.IUniform } {
+    const { THREE } = Externals.getInstance();
+    const modelUniforms = {
+      weight0: {
+        type: 'f',
+        value: 0,
+      },
+      weight1: {
+        type: 'f',
+        value: 0,
+      },
+      // 源全景图立方体贴图
+      pano0Map: {
+        type: 't',
+        value: null,
+      },
+      pano0Position: {
+        type: 'v3',
+        value: new THREE.Vector3(),
+      },
+      // 源全景图世界变换矩阵
+      pano0Matrix: {
+        type: 'm4',
+        value: new THREE.Matrix4(),
+      },
+      // 目标全景图立方体贴图
+      pano1Map: {
+        type: 't',
+        value: null,
+      },
+      // 目标全景图位置
+      pano1Position: {
+        type: 'v3',
+        value: new THREE.Vector3(),
+      },
+      // 目标全景图世界变换矩阵
+      pano1Matrix: {
+        type: 'm4',
+        value: new THREE.Matrix4(),
+      },
+      matrixT: {
+        type: 'm4',
+        value: new THREE.Matrix4(),
+      },
+    };
+    return modelUniforms;
+  }
+
+  /**
+   * 获取模型网格
+   * @ignore
+   * @param e 3d对象
+   * @returns
+   */
+  public static getModelMeshInElement(e: NS_THREE.Object3D): NS_THREE.Mesh | undefined {
+    let ret;
+    const { THREE } = Externals.getInstance();
+    if (e instanceof THREE.Mesh) return e;
+    if (e) {
+      e.traverse((obj) => {
+        if (obj instanceof THREE.Mesh) {
+          ret = obj as NS_THREE.Mesh;
+        }
+      });
+    }
+    return ret;
+  }
+}
+
+export {
+  PanoramaModelUtil,
+};