@loaders.gl/math 4.2.0-alpha.3 → 4.2.0-alpha.5

package/dist/geometry/attributes/compute-bounding-box.js

@@ -1,28 +1,40 @@
 import { makeAttributeIterator } from "../iterators/attribute-iterator.js";
 import { assert } from "../utils/assert.js";
-export function computeBoundingBox() {
-  let positions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  const min = [Number(Infinity), Number(Infinity), Number(Infinity)];
-  const max = [-Infinity, -Infinity, -Infinity];
-  for (const position of makeAttributeIterator(positions)) {
-    const x = position[0];
-    const y = position[1];
-    const z = position[2];
-    if (x < min[0]) min[0] = x;
-    if (y < min[1]) min[1] = y;
-    if (z < min[2]) min[2] = z;
-    if (x > max[0]) max[0] = x;
-    if (y > max[1]) max[1] = y;
-    if (z > max[2]) max[2] = z;
-  }
-  const boundingBox = {
-    min,
-    max
-  };
-  validateBoundingBox(boundingBox);
-  return boundingBox;
+/**
+ * Getting bounding box geometry according to positions parameters
+ * @param positions
+ * @returns Bounding Box
+ */
+export function computeBoundingBox(positions = []) {
+    const min = [Number(Infinity), Number(Infinity), Number(Infinity)];
+    const max = [-Infinity, -Infinity, -Infinity];
+    // @ts-ignore
+    for (const position of makeAttributeIterator(positions)) {
+        const x = position[0];
+        const y = position[1];
+        const z = position[2];
+        if (x < min[0])
+            min[0] = x;
+        if (y < min[1])
+            min[1] = y;
+        if (z < min[2])
+            min[2] = z;
+        if (x > max[0])
+            max[0] = x;
+        if (y > max[1])
+            max[1] = y;
+        if (z > max[2])
+            max[2] = z;
+    }
+    const boundingBox = { min, max };
+    validateBoundingBox(boundingBox);
+    return boundingBox;
 }
 function validateBoundingBox(boundingBox) {
-  assert(Number.isFinite(boundingBox.min[0]) && Number.isFinite(boundingBox.min[1]) && Number.isFinite(boundingBox.min[2]) && Number.isFinite(boundingBox.max[0]) && Number.isFinite(boundingBox.max[1]) && Number.isFinite(boundingBox.max[2]));
+    assert(Number.isFinite(boundingBox.min[0]) &&
+        Number.isFinite(boundingBox.min[1]) &&
+        Number.isFinite(boundingBox.min[2]) &&
+        Number.isFinite(boundingBox.max[0]) &&
+        Number.isFinite(boundingBox.max[1]) &&
+        Number.isFinite(boundingBox.max[2]));
 }
-//# sourceMappingURL=compute-bounding-box.js.map

package/dist/geometry/attributes/compute-bounding-sphere.js

@@ -1,2 +1,30 @@
+"use strict";
+/* eslint-disable */
+/**
+import {getPositions} from './get-attribute-from-geometry';
 
-//# sourceMappingURL=compute-bounding-sphere.js.map
+export function computeBoundingSphere(geometry: any, boundingBox: object, vector: Vector3 ) {
+  const positions = getPositions(geometry);
+
+  const center = getBoundingBox(center);
+  box.setFromBufferAttribute(position);
+  box.getCenter(center);
+
+  // hoping to find a boundingSphere with a radius smaller than the
+  // boundingSphere of the boundingBox: sqrt(3) smaller in the best case
+
+  var maxRadiusSq = 0;
+
+  for (const position of makeAttributeIterator(positions)) {
+    vector.x = position[0];
+    vector.y = position[1];
+    vector.z = position[2];
+    maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(vector));
+  }
+
+  const radius = Math.sqrt(maxRadiusSq);
+  assert(Number.isFinite(radius));
+
+  return {center, radius};
+}
+*/

package/dist/geometry/attributes/compute-tangents.js

@@ -1,2 +1,146 @@
+"use strict";
+/*
+export function computeTangents({indices, positions, normals, uvs}) {
+  var index = geometry.index;
+  var attributes = geometry.attributes;
 
-//# sourceMappingURL=compute-tangents.js.map
+  // based on http://www.terathon.com/code/tangent.html
+  // (per vertex tangents)
+
+  if (
+    index === null ||
+    attributes.position === undefined ||
+    attributes.normal === undefined ||
+    attributes.uv === undefined
+  ) {
+    console.warn(
+      'THREE.BufferGeometry: Missing required attributes (index, position, normal or uv) in BufferGeometry.computeTangents()'
+    );
+    return;
+  }
+
+  var nVertices = positions.length / 3;
+
+  var tangents = new Float32Array(4 * nVertices); // size: 4
+
+  var tan1 = [],
+    tan2 = [];
+
+  for (var k = 0; k < nVertices; k++) {
+    tan1[k] = new THREE.Vector3();
+    tan2[k] = new THREE.Vector3();
+  }
+
+  var vA = new THREE.Vector3(),
+    vB = new THREE.Vector3(),
+    vC = new THREE.Vector3(),
+    uvA = new THREE.Vector2(),
+    uvB = new THREE.Vector2(),
+    uvC = new THREE.Vector2(),
+    sdir = new THREE.Vector3(),
+    tdir = new THREE.Vector3();
+
+  function handleTriangle(a, b, c) {
+    vA.fromArray(positions, a * 3);
+    vB.fromArray(positions, b * 3);
+    vC.fromArray(positions, c * 3);
+
+    uvA.fromArray(uvs, a * 2);
+    uvB.fromArray(uvs, b * 2);
+    uvC.fromArray(uvs, c * 2);
+
+    var x1 = vB.x - vA.x;
+    var x2 = vC.x - vA.x;
+
+    var y1 = vB.y - vA.y;
+    var y2 = vC.y - vA.y;
+
+    var z1 = vB.z - vA.z;
+    var z2 = vC.z - vA.z;
+
+    var s1 = uvB.x - uvA.x;
+    var s2 = uvC.x - uvA.x;
+
+    var t1 = uvB.y - uvA.y;
+    var t2 = uvC.y - uvA.y;
+
+    var r = 1.0 / (s1 * t2 - s2 * t1);
+
+    sdir.set((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r, (t2 * z1 - t1 * z2) * r);
+
+    tdir.set((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r, (s1 * z2 - s2 * z1) * r);
+
+    tan1[a].add(sdir);
+    tan1[b].add(sdir);
+    tan1[c].add(sdir);
+
+    tan2[a].add(tdir);
+    tan2[b].add(tdir);
+    tan2[c].add(tdir);
+  }
+
+  var groups = geometry.groups;
+
+  if (groups.length === 0) {
+    groups = [
+      {
+        start: 0,
+        count: indices.length
+      }
+    ];
+  }
+
+  for (var j = 0, jl = groups.length; j < jl; ++j) {
+    var group = groups[j];
+
+    var start = group.start;
+    var count = group.count;
+
+    for (var i = start, il = start + count; i < il; i += 3) {
+      handleTriangle(indices[i + 0], indices[i + 1], indices[i + 2]);
+    }
+  }
+
+  var tmp = new THREE.Vector3(),
+    tmp2 = new THREE.Vector3();
+  var n = new THREE.Vector3(),
+    n2 = new THREE.Vector3();
+  var w, t, test;
+
+  function handleVertex(v) {
+    n.fromArray(normals, v * 3);
+    n2.copy(n);
+
+    t = tan1[v];
+
+    // Gram-Schmidt orthogonalize
+
+    tmp.copy(t);
+    tmp.sub(n.multiplyScalar(n.dot(t))).normalize();
+
+    // Calculate handedness
+
+    tmp2.crossVectors(n2, t);
+    test = tmp2.dot(tan2[v]);
+    w = test < 0.0 ? -1.0 : 1.0;
+
+    tangents[v * 4] = tmp.x;
+    tangents[v * 4 + 1] = tmp.y;
+    tangents[v * 4 + 2] = tmp.z;
+    tangents[v * 4 + 3] = w;
+  }
+
+  for (var j = 0, jl = groups.length; j < jl; ++j) {
+    var group = groups[j];
+
+    var start = group.start;
+    var count = group.count;
+
+    for (var i = start, il = start + count; i < il; i += 3) {
+      handleVertex(indices[i + 0]);
+      handleVertex(indices[i + 1]);
+      handleVertex(indices[i + 2]);
+    }
+  }
+}
+*/

package/dist/geometry/attributes/compute-vertex-normals.js

@@ -4,38 +4,41 @@ import { assert } from "../utils/assert.js";
 import { makePrimitiveIterator } from "../iterators/primitive-iterator.js";
 import { getPrimitiveModeType } from "../primitives/modes.js";
 import { getPositions } from "./get-attribute-from-geometry.js";
+/**
+ * Computes vertex normals for a geometry
+ * @param param0
+ * @returns
+ */
+// eslint-disable-next-line max-statements
 export function computeVertexNormals(geometry) {
-  assert(getPrimitiveModeType(geometry.mode) === GL.TRIANGLES, 'TRIANGLES required');
-  const {
-    values: positions
-  } = getPositions(geometry);
-  const normals = new Float32Array(positions.length);
-  const vectorA = new Vector3();
-  const vectorB = new Vector3();
-  const vectorC = new Vector3();
-  const vectorCB = new Vector3();
-  const vectorAB = new Vector3();
-  for (const primitive of makePrimitiveIterator(geometry)) {
-    vectorA.fromArray(positions, primitive.i1 * 3);
-    vectorB.fromArray(positions, primitive.i2 * 3 + 3);
-    vectorC.fromArray(positions, primitive.i3 * 3 + 6);
-    vectorCB.subVectors(vectorC, vectorB);
-    vectorAB.subVectors(vectorA, vectorB);
-    const normal = vectorCB.cross(vectorAB);
-    normal.normalize();
-    const {
-      primitiveIndex
-    } = primitive;
-    normals[primitiveIndex * 9 + 0] = normal.x;
-    normals[primitiveIndex * 9 + 1] = normal.y;
-    normals[primitiveIndex * 9 + 2] = normal.z;
-    normals[primitiveIndex * 9 + 3] = normal.x;
-    normals[primitiveIndex * 9 + 4] = normal.y;
-    normals[primitiveIndex * 9 + 5] = normal.z;
-    normals[primitiveIndex * 9 + 6] = normal.x;
-    normals[primitiveIndex * 9 + 7] = normal.y;
-    normals[primitiveIndex * 9 + 8] = normal.z;
-  }
-  return normals;
+    // Only support GL.TRIANGLES, GL.TRIANGLE_STRIP, GL.TRIANGLE_FAN
+    assert(getPrimitiveModeType(geometry.mode) === GL.TRIANGLES, 'TRIANGLES required');
+    const { values: positions } = getPositions(geometry);
+    const normals = new Float32Array(positions.length);
+    const vectorA = new Vector3();
+    const vectorB = new Vector3();
+    const vectorC = new Vector3();
+    const vectorCB = new Vector3();
+    const vectorAB = new Vector3();
+    for (const primitive of makePrimitiveIterator(geometry)) {
+        vectorA.fromArray(positions, primitive.i1 * 3);
+        vectorB.fromArray(positions, primitive.i2 * 3 + 3);
+        vectorC.fromArray(positions, primitive.i3 * 3 + 6);
+        vectorCB.subVectors(vectorC, vectorB);
+        vectorAB.subVectors(vectorA, vectorB);
+        const normal = vectorCB.cross(vectorAB);
+        normal.normalize();
+        // @ts-ignore
+        const { primitiveIndex } = primitive;
+        normals[primitiveIndex * 9 + 0] = normal.x;
+        normals[primitiveIndex * 9 + 1] = normal.y;
+        normals[primitiveIndex * 9 + 2] = normal.z;
+        normals[primitiveIndex * 9 + 3] = normal.x;
+        normals[primitiveIndex * 9 + 4] = normal.y;
+        normals[primitiveIndex * 9 + 5] = normal.z;
+        normals[primitiveIndex * 9 + 6] = normal.x;
+        normals[primitiveIndex * 9 + 7] = normal.y;
+        normals[primitiveIndex * 9 + 8] = normal.z;
+    }
+    return normals;
 }
-//# sourceMappingURL=compute-vertex-normals.js.map

package/dist/geometry/attributes/convert-to-non-indexed.js

@@ -1,27 +1,29 @@
-export function convertBuffersToNonIndexed(_ref) {
-  let {
-    indices,
-    attributes
-  } = _ref;
-  const geometry2 = new BufferGeometry();
-  for (const name in attributes) {
-    const attribute = attributes[name];
-    const array = attribute.array;
-    const itemSize = attribute.itemSize;
-    const array2 = new array.constructor(indices.length * itemSize);
-    let index = 0,
-      index2 = 0;
-    for (var i = 0, l = indices.length; i < l; i++) {
-      index = indices[i] * itemSize;
-      for (var j = 0; j < itemSize; j++) {
-        array2[index2++] = array[index++];
-      }
+/* eslint-disable */
+// @ts-nocheck
+/**
+ * Converts indices of geometry.
+ *
+ * @param param0
+ * @returns no indexed geometry
+ */
+export function convertBuffersToNonIndexed({ indices, attributes }) {
+    const geometry2 = new BufferGeometry();
+    for (const name in attributes) {
+        const attribute = attributes[name];
+        const array = attribute.array;
+        const itemSize = attribute.itemSize;
+        const array2 = new array.constructor(indices.length * itemSize);
+        let index = 0, index2 = 0;
+        for (var i = 0, l = indices.length; i < l; i++) {
+            index = indices[i] * itemSize;
+            for (var j = 0; j < itemSize; j++) {
+                array2[index2++] = array[index++];
+            }
+        }
+        geometry2.addAttribute(name, new BufferAttribute(array2, itemSize));
     }
-    geometry2.addAttribute(name, new BufferAttribute(array2, itemSize));
-  }
-  for (const group of this.groups) {
-    geometry2.addGroup(group.start, group.count, group.materialIndex);
-  }
-  return geometry2;
+    for (const group of this.groups) {
+        geometry2.addGroup(group.start, group.count, group.materialIndex);
+    }
+    return geometry2;
 }
-//# sourceMappingURL=convert-to-non-indexed.js.map

package/dist/geometry/attributes/get-attribute-from-geometry.js

@@ -1,24 +1,27 @@
 import isGeometry from "../is-geometry.js";
 import { assert } from "../utils/assert.js";
+/**
+ * analyze positions of geometry
+ *
+ * @param geometry
+ * @returns Position| New geometry |assert
+ */
 export function getPositions(geometry) {
-  if (isGeometry(geometry)) {
-    const {
-      attributes
-    } = geometry;
-    const position = attributes.POSITION || attributes.positions;
-    assert(position);
-    return position;
-  }
-  if (ArrayBuffer.isView(geometry)) {
-    return {
-      values: geometry,
-      size: 3
-    };
-  }
-  if (geometry) {
-    assert(geometry.values);
-    return geometry;
-  }
-  return assert(false);
+    // If geometry, extract positions
+    if (isGeometry(geometry)) {
+        const { attributes } = geometry;
+        const position = attributes.POSITION || attributes.positions;
+        assert(position);
+        return position;
+    }
+    // If arraybuffer, assume 3 components
+    if (ArrayBuffer.isView(geometry)) {
+        return { values: geometry, size: 3 };
+    }
+    // Else assume accessor object
+    if (geometry) {
+        assert(geometry.values);
+        return geometry;
+    }
+    return assert(false);
 }
-//# sourceMappingURL=get-attribute-from-geometry.js.map

package/dist/geometry/attributes/normalize.js

@@ -1,13 +1,16 @@
-export function normalize() {
-  let normals = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  let vector = arguments.length > 1 ? arguments[1] : undefined;
-  normals = this.attributes.normal;
-  for (let i = 0, il = normals.count; i < il; i++) {
-    vector.x = normals.getX(i);
-    vector.y = normals.getY(i);
-    vector.z = normals.getZ(i);
-    vector.normalize();
-    normals.setXYZ(i, vector.x, vector.y, vector.z);
-  }
+/**
+ * Setting X, Y, Z for Vector
+ * @param normals
+ * @param vector
+ */
+export function normalize(normals = {}, vector) {
+    //@ts-ignore
+    normals = this.attributes.normal;
+    for (let i = 0, il = normals.count; i < il; i++) {
+        vector.x = normals.getX(i);
+        vector.y = normals.getY(i);
+        vector.z = normals.getZ(i);
+        vector.normalize();
+        normals.setXYZ(i, vector.x, vector.y, vector.z);
+    }
 }
-//# sourceMappingURL=normalize.js.map

package/dist/geometry/colors/rgb565.js

@@ -1,17 +1,26 @@
-export function decodeRGB565(rgb565) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0];
-  const r5 = rgb565 >> 11 & 31;
-  const g6 = rgb565 >> 5 & 63;
-  const b5 = rgb565 & 31;
-  target[0] = r5 << 3;
-  target[1] = g6 << 2;
-  target[2] = b5 << 3;
-  return target;
+/**
+ * Decode color values
+ * @param rgb565
+ * @param target
+ * @returns target
+ */
+export function decodeRGB565(rgb565, target = [0, 0, 0]) {
+    const r5 = (rgb565 >> 11) & 31;
+    const g6 = (rgb565 >> 5) & 63;
+    const b5 = rgb565 & 31;
+    target[0] = r5 << 3;
+    target[1] = g6 << 2;
+    target[2] = b5 << 3;
+    return target;
 }
+/**
+ * Encode color values
+ * @param rgb
+ * @returns color
+ */
 export function encodeRGB565(rgb) {
-  const r5 = Math.floor(rgb[0] / 8) + 4;
-  const g6 = Math.floor(rgb[1] / 4) + 2;
-  const b5 = Math.floor(rgb[2] / 8) + 4;
-  return r5 + (g6 << 5) + (b5 << 11);
+    const r5 = Math.floor(rgb[0] / 8) + 4;
+    const g6 = Math.floor(rgb[1] / 4) + 2;
+    const b5 = Math.floor(rgb[2] / 8) + 4;
+    return r5 + (g6 << 5) + (b5 << 11);
 }
-//# sourceMappingURL=rgb565.js.map