@aibee/owlly 1.0.25

package/src/external/lines/line-segments-geometry.ts

@@ -0,0 +1,197 @@
+/* eslint-disable max-len, no-continue, @typescript-eslint/no-explicit-any, no-underscore-dangle, func-names, @typescript-eslint/no-this-alias, no-console, consistent-return */
+import { Externals, NS_THREE } from '../../owlly/stage/externals';
+
+class LineSegmentsGeometry extends NS_THREE.InstancedBufferGeometry {
+  isLineSegmentsGeometry: true;
+
+  constructor() {
+    super();
+
+    const { THREE } = Externals.getInstance();
+
+    this.type = 'LineSegmentsGeometry';
+
+    const positions = [-1, 2, 0, 1, 2, 0, -1, 1, 0, 1, 1, 0, -1, 0, 0, 1, 0, 0, -1, -1, 0, 1, -1, 0];
+    const uvs = [-1, 2, 1, 2, -1, 1, 1, 1, -1, -1, 1, -1, -1, -2, 1, -2];
+    const index = [0, 2, 1, 2, 3, 1, 2, 4, 3, 4, 5, 3, 4, 6, 5, 6, 7, 5];
+
+    this.setIndex(index);
+    this.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+    this.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+
+    const that = this;
+    this.computeBoundingBox = (function (): any {
+      const box = new THREE.Box3();
+
+      return function (): any {
+        if (that.boundingBox === null) {
+          that.boundingBox = new THREE.Box3();
+        }
+
+        const start = that.attributes.instanceStart;
+        const end = that.attributes.instanceEnd;
+
+        if (start !== undefined && end !== undefined) {
+          that.boundingBox.setFromBufferAttribute(start as NS_THREE.BufferAttribute);
+
+          box.setFromBufferAttribute(end as NS_THREE.BufferAttribute);
+
+          that.boundingBox.union(box);
+        }
+      };
+    }());
+
+    this.computeBoundingSphere = (function (): any {
+      const vector = new THREE.Vector3();
+
+      return function (): any {
+        if (that.boundingSphere === null) {
+          that.boundingSphere = new THREE.Sphere();
+        }
+
+        if (that.boundingBox === null) {
+          that.computeBoundingBox();
+        }
+
+        const start = that.attributes.instanceStart;
+        const end = that.attributes.instanceEnd;
+
+        if (start !== undefined && end !== undefined) {
+          const { center } = that.boundingSphere;
+
+          that.boundingBox!.getCenter(center);
+
+          let maxRadiusSq = 0;
+
+          for (let i = 0, il = start.count; i < il; i++) {
+            vector.fromBufferAttribute(start as NS_THREE.BufferAttribute, i);
+            maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(vector));
+
+            vector.fromBufferAttribute(end as NS_THREE.BufferAttribute, i);
+            maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(vector));
+          }
+
+          that.boundingSphere.radius = Math.sqrt(maxRadiusSq);
+
+          if (Number.isNaN(that.boundingSphere.radius)) {
+            console.error('THREE.LineSegmentsGeometry.computeBoundingSphere(): Computed radius is NaN. The instanced position data is likely to have NaN values.', that);
+          }
+        }
+      };
+    }());
+  }
+
+  applyMatrix4(matrix: any): this {
+    const start = this.attributes.instanceStart;
+    const end = this.attributes.instanceEnd;
+
+    if (start !== undefined) {
+      start.applyMatrix4(matrix);
+
+      end.applyMatrix4(matrix);
+
+      start.needsUpdate = true;
+    }
+
+    if (this.boundingBox !== null) {
+      this.computeBoundingBox();
+    }
+
+    if (this.boundingSphere !== null) {
+      this.computeBoundingSphere();
+    }
+
+    return this;
+  }
+
+  setPositions(array: any): this {
+    let lineSegments;
+
+    if (array instanceof Float32Array) {
+      lineSegments = array;
+    } else if (Array.isArray(array)) {
+      lineSegments = new Float32Array(array);
+    }
+
+    const { THREE } = Externals.getInstance();
+    const instanceBuffer = new THREE.InstancedInterleavedBuffer(lineSegments as Float32Array, 6, 1); // xyz, xyz
+
+    this.setAttribute('instanceStart', new THREE.InterleavedBufferAttribute(instanceBuffer, 3, 0)); // xyz
+    this.setAttribute('instanceEnd', new THREE.InterleavedBufferAttribute(instanceBuffer, 3, 3)); // xyz
+
+    //
+
+    this.computeBoundingBox();
+    this.computeBoundingSphere();
+
+    return this;
+  }
+
+  setColors(array: any): this {
+    let colors;
+
+    if (array instanceof Float32Array) {
+      colors = array;
+    } else if (Array.isArray(array)) {
+      colors = new Float32Array(array);
+    }
+
+    const { THREE } = Externals.getInstance();
+    const instanceColorBuffer = new THREE.InstancedInterleavedBuffer(colors as Float32Array, 6, 1); // rgb, rgb
+
+    this.setAttribute('instanceColorStart', new THREE.InterleavedBufferAttribute(instanceColorBuffer, 3, 0)); // rgb
+    this.setAttribute('instanceColorEnd', new THREE.InterleavedBufferAttribute(instanceColorBuffer, 3, 3)); // rgb
+
+    return this;
+  }
+
+  fromWireframeGeometry(geometry: any): this {
+    this.setPositions(geometry.attributes.position.array);
+
+    return this;
+  }
+
+  fromEdgesGeometry(geometry: any): this {
+    this.setPositions(geometry.attributes.position.array);
+
+    return this;
+  }
+
+  fromMesh(mesh: any): this {
+    const { THREE } = Externals.getInstance();
+    this.fromWireframeGeometry(new THREE.WireframeGeometry(mesh.geometry));
+
+    // set colors, maybe
+
+    return this;
+  }
+
+  fromLineSegments(lineSegments: any): any {
+    const { geometry } = lineSegments;
+
+    if (geometry.isGeometry) {
+      console.error('THREE.LineSegmentsGeometry no longer supports Geometry. Use THREE.BufferGeometry instead.');
+      return;
+    } if (geometry.isBufferGeometry) {
+      this.setPositions(geometry.attributes.position.array); // assumes non-indexed
+    }
+
+    // set colors, maybe
+
+    return this;
+  }
+
+  toJSON(): any {
+
+    // todo
+
+  }
+
+  applyMatrix(matrix: any): any {
+    console.warn('THREE.LineSegmentsGeometry: applyMatrix() has been renamed to applyMatrix4().');
+
+    return this.applyMatrix4(matrix);
+  }
+}
+
+export { LineSegmentsGeometry };