@aibee/owlly 1.0.26 → 1.0.29

package/lib/owlly/geometries/ExtrudeGeometry2.js

@@ -0,0 +1,210 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/camelcase */
+import { Matrix4, Vector3 } from 'three';
+import { PathUtils } from '../utils/path-utils';
+import { Externals, NS_THREE } from '../stage/externals';
+function toJSON(shapes, options, data) {
+    data.shapes = [];
+    if (Array.isArray(shapes)) {
+        for (let i = 0, l = shapes.length; i < l; i++) {
+            const shape = shapes[i];
+            data.shapes.push(shape.uuid);
+        }
+    }
+    else {
+        data.shapes.push(shapes.uuid);
+    }
+    if (options.extrudePath !== undefined)
+        data.options.extrudePath = options.extrudePath;
+    return data;
+}
+class ExtrudeGeometry2 extends NS_THREE.BufferGeometry {
+    constructor(shapes, options) {
+        super();
+        this.type = 'ExtrudeGeometry';
+        this.parameters = {
+            shapes,
+            options,
+        };
+        const { THREE } = Externals.getInstance();
+        // eslint-disable-next-line no-param-reassign
+        shapes = Array.isArray(shapes) ? shapes : [shapes];
+        const indices = [];
+        const vertices = [];
+        const uvs = [];
+        const m = new Matrix4();
+        const tm = new Matrix4();
+        const extrudePath = Array.from(options.extrudePath);
+        PathUtils.mergeSamePoint3(extrudePath);
+        PathUtils.mergePathSameVectorPoint3(extrudePath);
+        let closed = options.closed;
+        if (PathUtils.nearlyEqualsV3(extrudePath[0], extrudePath[extrudePath.length - 1])) {
+            closed = true;
+            extrudePath.splice(extrudePath.length - 1, 1);
+        }
+        // extrudePath.splice(3, 1);
+        const extrudePathLength = extrudePath.length;
+        const pNormals = [];
+        const pSubNormals = [];
+        const pZNormals = [];
+        // if(extrudePathLength === 2){
+        //   const v1 = extrudePath[1].clone().sub(extrudePath[0]).normalize();
+        //   pNormals[0] = pNormals[1] = v1;
+        //   pSubNormals[0] = pSubNormals[1] =  new THREE.Vector3(0,0,1);
+        // }
+        const tv = new THREE.Vector3();
+        const sv = new THREE.Vector3();
+        const tq = new THREE.Quaternion();
+        for (let i = 0; i < extrudePathLength; i++) {
+            let v1;
+            if (i === 0) {
+                if (closed) {
+                    v1 = extrudePath[i].clone().sub(extrudePath[extrudePathLength - 1]).normalize();
+                    sv.copy(extrudePath[i + 1]).sub(extrudePath[i]).normalize();
+                    v1.add(sv).normalize();
+                    tv.copy(v1).cross(sv);
+                }
+                else {
+                    v1 = extrudePath[i + 1].clone().sub(extrudePath[i]).normalize();
+                    const vt = new Vector3(1, 0, 0);
+                    const v2 = vt.clone().cross(v1);
+                    const angle = vt.angleTo(v1);
+                    m.makeRotationFromQuaternion(tq.setFromAxisAngle(v2, angle));
+                    tv.copy(new Vector3(0, 0, -1).applyMatrix4(m));
+                }
+            }
+            else if (i === (extrudePathLength - 1)) {
+                if (closed) {
+                    v1 = extrudePath[i].clone().sub(extrudePath[i - 1]).normalize();
+                    sv.copy(extrudePath[0]).sub(extrudePath[i]).normalize();
+                    v1.add(sv).normalize();
+                    tv.copy(v1).cross(sv);
+                }
+                else {
+                    v1 = extrudePath[i].clone().sub(extrudePath[i - 1]).normalize();
+                    const vt = new Vector3(1, 0, 0);
+                    const v2 = vt.clone().cross(v1);
+                    const angle = vt.angleTo(v1);
+                    m.makeRotationFromQuaternion(tq.setFromAxisAngle(v2, angle));
+                    tv.copy(new Vector3(0, 0, -1).applyMatrix4(m));
+                }
+            }
+            else {
+                v1 = extrudePath[i].clone().sub(extrudePath[i - 1]).normalize();
+                sv.copy(extrudePath[i + 1]).sub(extrudePath[i]).normalize();
+                v1.add(sv).normalize();
+                tv.copy(v1).cross(sv);
+            }
+            tv.normalize();
+            if (tv.z > 0) {
+                tv.multiplyScalar(-1);
+            }
+            pZNormals[i] = v1;
+            const v = v1.clone().cross(tv).normalize();
+            if (v.equals(new THREE.Vector3(0, 0, 0))) {
+                // console.log('zero', i, v);
+            }
+            pNormals[i] = v;
+            pSubNormals[i] = tv.clone();
+            // m.makeRotationFromQuaternion(tq.setFromAxisAngle(tv, -Math.PI / 2));
+        }
+        const addSideShape = (shape, pIndex, invert) => {
+            const indexOffset = vertices.length / 3;
+            const points = shape.getPoints();
+            const tPoints = points.map((p) => new THREE.Vector3(p.x, p.y, 0));
+            // check direction of vertices
+            const faces = THREE.ShapeUtils.triangulateShape(points, []);
+            const ep = extrudePath[pIndex];
+            const pSubNormal = pSubNormals[pIndex];
+            const pNormal = pNormals[pIndex];
+            const pZNormal = pZNormals[pIndex];
+            // vertices, normals, uvs
+            for (let i = 0, l = points.length; i < l; i++) {
+                const vertex = points[i];
+                // vertices.push(vertex.x, vertex.y, 0);
+                m.makeBasis(pSubNormal, pNormal, pZNormal);
+                // console.log(new THREE.Vector3(0, 0, 1).applyMatrix4(m), pZNormal, pNormal);
+                m.premultiply(tm.makeTranslation(ep.x, ep.y, ep.z));
+                const tp = tPoints[i];
+                tp.applyMatrix4(m);
+                vertices.push(tp.x, tp.y, tp.z);
+                uvs.push(vertex.x, vertex.y); // world uvs
+            }
+            // incides
+            for (let i = 0, l = faces.length; i < l; i++) {
+                const face = faces[i];
+                const a = (invert ? face[2] : face[0]) + indexOffset;
+                const b = face[1] + indexOffset;
+                const c = (invert ? face[0] : face[2]) + indexOffset;
+                indices.push(a, b, c);
+            }
+        };
+        const addShape = (shape) => {
+            const points = shape.getPoints().map((p) => new THREE.Vector3(p.x, p.y, 0));
+            const pLength = points.length;
+            for (let i = 0; i < extrudePathLength; i++) {
+                const ep = extrudePath[i];
+                const pSubNormal = pSubNormals[i];
+                const pNormal = pNormals[i];
+                const pZNormal = pZNormals[i];
+                m.makeBasis(pSubNormal, pNormal, pZNormal);
+                // console.log(new THREE.Vector3(0, 0, 1).applyMatrix4(m), pZNormal, pNormal);
+                m.premultiply(tm.makeTranslation(ep.x, ep.y, ep.z));
+                for (let j = 0; j < pLength; j++) {
+                    const p = points[j].clone().applyMatrix4(m);
+                    // console.log(p);
+                    vertices.push(p.x, p.y, p.z);
+                    uvs.push(i / (extrudePathLength - 1), j / (pLength - 1));
+                }
+            }
+            for (let i = 0; i < (extrudePathLength - 1); i++) {
+                for (let j = 0; j < (pLength - 1); j++) {
+                    const base = j + i * pLength;
+                    const a = base;
+                    const b = base + pLength;
+                    const c = base + pLength + 1;
+                    const d = base + 1;
+                    // faces
+                    indices.push(a, b, d);
+                    indices.push(b, c, d);
+                }
+            }
+            if (closed) {
+                const i = extrudePathLength - 1;
+                for (let j = 0; j < (pLength - 1); j++) {
+                    const base = j + i * pLength;
+                    const a = base;
+                    const b = j;
+                    const c = j + 1;
+                    const d = base + 1;
+                    // faces
+                    indices.push(a, b, d);
+                    indices.push(b, c, d);
+                }
+            }
+            if (!closed) {
+                addSideShape(shape, 0, true);
+                addSideShape(shape, extrudePathLength - 1, false);
+            }
+        };
+        for (let i = 0, l = shapes.length; i < l; i++) {
+            const shape1 = shapes[i];
+            addShape(shape1);
+        }
+        // build geometry
+        this.setIndex(indices);
+        this.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));
+        this.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+        this.computeVertexNormals();
+        // functions
+    }
+    // eslint-disable-next-line
+    toJSON() {
+        const { THREE } = Externals.getInstance();
+        const data = THREE.BufferGeometry.prototype.toJSON.call(this);
+        const shapes = this.parameters.shapes;
+        const options = this.parameters.options;
+        return toJSON(shapes, options, data);
+    }
+}
+export { ExtrudeGeometry2, ExtrudeGeometry2 as ExtrudeBufferGeometry2 };

package/lib/owlly/index.d.ts

@@ -0,0 +1,13 @@
+import TWEEN from '@tweenjs/tween.js';
+export * from './stage';
+export * from './screen';
+export * from './view';
+export * from './overlay';
+export * from './element';
+export * from './controller';
+export * from './utils';
+export * from '../external/loaders/gltf-loader';
+export * from '../external/lines/line-geometry';
+export * from '../external/lines/line-material';
+export * from '../external/lines/line-segments-2';
+export { TWEEN };

package/lib/owlly/index.js

@@ -0,0 +1,16 @@
+// Owlly 的主入口, 会将所有外部需要的内容暴露出来
+// TODO: TWEEN 后期应尽量收回到 SDK 内部使用, 不去使用 TWEEN 默认的动画组
+import TWEEN from '@tweenjs/tween.js';
+export * from './stage';
+export * from './screen';
+export * from './view';
+export * from './overlay';
+export * from './element';
+export * from './controller';
+export * from './utils';
+export * from '../external/loaders/gltf-loader';
+export * from '../external/lines/line-geometry';
+export * from '../external/lines/line-material';
+export * from '../external/lines/line-segments-2';
+// TODO: 在讲 TWEEN 所管理的动画转换到内部使用时, 可将该行去掉
+export { TWEEN };

package/lib/owlly/overlay/canvas-overlay.d.ts

@@ -0,0 +1,96 @@
+import { NS_THREE, NS_KONVA } from '../stage/externals';
+import { Overlay } from './overlay';
+import { Shape } from '../element/map-kit/shape';
+import { View } from '../view/view';
+declare class ShapeGroup {
+    shape: NS_KONVA.Shape;
+    rawShape: Shape;
+    baseZoom: {
+        x: number;
+        y: number;
+    };
+    zIndices: number[];
+    points: NS_KONVA.Shape[];
+    vertexOptions: NS_KONVA.CircleConfig;
+    lineJointsStyle: 'none' | 'endpoints' | 'joints';
+    constructor(shape: NS_KONVA.Shape, rawShape: Shape, baseZoom: {
+        x: number;
+        y: number;
+    }, zIndices?: number[]);
+}
+/**
+ * POI覆盖层, 可以展示POI图标与文字, 存在图标时以图标中心为中心, 否则为文字中心
+ * @example
+ * ```typescript
+ * const poiOverlay = new PoiOverlay();
+ * // 任意View
+ * view.addOverlay(poiOverlay);
+ * ```
+ */
+declare class CanvasOverlay extends Overlay {
+    private owlly2D;
+    private container;
+    private parent;
+    private layer;
+    private renderThisFrame;
+    private shapes;
+    private mouseState;
+    private mousePositionBuffer;
+    private eventTarget;
+    private enabled;
+    private listeners;
+    init(parent: View, container?: HTMLElement): void;
+    /**
+     * 打开交互
+     */
+    openInteraction(): void;
+    /**
+     * 关闭交互
+     */
+    closeInteraction(): void;
+    update(): boolean;
+    render(): void;
+    setRenderOrder(order: number): void;
+    dispose(): void;
+    private onPointerDown;
+    private onPointerUp;
+    private onTouchStart;
+    private onTouchEnd;
+    private onNodePointerDown;
+    private onNodePointerUp;
+    /**
+     * 清空画布
+     */
+    clearShapes(): void;
+    /**
+     * 删除Shape
+     * @param shape Shape
+     */
+    removeShape(shape: Shape | NS_KONVA.Shape): void;
+    /**
+     * 更新Shape
+     * @param shape Shape
+     */
+    updateShape(shape: Shape | NS_KONVA.Shape, zIndices?: number[]): NS_KONVA.Shape | null;
+    setVertexConfig(shape: Shape | NS_KONVA.Shape, config: NS_KONVA.CircleConfig): NS_KONVA.Shape | null;
+    /**
+     * 将shapeData转换为Konva.Path对象
+     * @param shapeData ShapeData
+     */
+    private transformShapeDataToKonvaShape;
+    private updateShapeDataToKonvaShape;
+    addShape(shapes: Shape | Shape[], baseZoom?: {
+        x: number;
+        y: number;
+    }, zIndices?: number[] | number[][]): NS_KONVA.Shape | NS_KONVA.Shape[] | null;
+    getShapeGroup(shape: Shape | NS_KONVA.Shape): ShapeGroup | undefined;
+    forceRender(): void;
+    /**
+     * 计算路径距离中点
+     * @param shape 目标图形
+     */
+    getMiddlePoint(shape: Shape | NS_KONVA.Shape): NS_THREE.Vector3 | null;
+    setEnabled(value: boolean): void;
+    resize(containerWidth: number, containerHeight: number): void;
+}
+export { CanvasOverlay, ShapeGroup };