@aibee/owlly 1.0.25

package/src/owlly/geometries/ExtrudeGeometry2.ts

@@ -0,0 +1,255 @@
+/* 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';
+
+export interface ExtrudeGeometry2Options {
+  extrudePath: NS_THREE.Vector3[];
+  closed: boolean;
+}
+
+export interface UVGenerator2 {
+  generateTopUV(
+      geometry: ExtrudeGeometry2,
+      vertices: number[],
+      indexA: number,
+      indexB: number,
+      indexC: number,
+  ): THREE.Vector2[];
+  generateSideWallUV(
+      geometry: ExtrudeGeometry2,
+      vertices: number[],
+      indexA: number,
+      indexB: number,
+      indexC: number,
+      indexD: number,
+  ): THREE.Vector2[];
+}
+
+function toJSON(shapes: NS_THREE.Shape|NS_THREE.Shape[], options: ExtrudeGeometry2Options, data: any): any {
+  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 {
+  private parameters: {shapes: NS_THREE.Shape|NS_THREE.Shape[]; options: ExtrudeGeometry2Options};
+
+  constructor(shapes: NS_THREE.Shape|NS_THREE.Shape[], options: ExtrudeGeometry2Options) {
+    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 = [] as number[];
+    const vertices = [] as number[];
+    const uvs = [] as number[];
+    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 = [] as NS_THREE.Vector3[];
+    const pSubNormals = [] as NS_THREE.Vector3[];
+    const pZNormals = [] as NS_THREE.Vector3[];
+    // 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: THREE.Vector3;
+      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: THREE.Shape, pIndex: number, invert: boolean): void => {
+      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: THREE.Shape): void => {
+      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
+  public toJSON(): any {
+    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/src/owlly/index.ts

@@ -0,0 +1,19 @@
+// 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 };