@loaders.gl/math 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/esm/geometry/primitives/modes.js

@@ -0,0 +1,48 @@
+import { GL } from '../constants';
+export function getPrimitiveModeType(mode) {
+  switch (mode) {
+    case GL.POINTS:
+      return GL.POINTS;
+    case GL.LINES:
+    case GL.LINE_STRIP:
+    case GL.LINE_LOOP:
+      return GL.LINES;
+    case GL.TRIANGLES:
+    case GL.TRIANGLE_STRIP:
+    case GL.TRIANGLE_FAN:
+      return GL.TRIANGLES;
+    default:
+      throw new Error('Unknown primitive mode');
+  }
+}
+export function isPrimitiveModeExpandable(mode) {
+  switch (mode) {
+    case GL.LINE_STRIP:
+    case GL.LINE_LOOP:
+    case GL.TRIANGLE_STRIP:
+    case GL.TRIANGLE_FAN:
+      return true;
+    default:
+      return false;
+  }
+}
+export function getPrimitiveModeExpandedLength(mode, length) {
+  switch (mode) {
+    case GL.POINTS:
+      return length;
+    case GL.LINES:
+      return length;
+    case GL.LINE_STRIP:
+      return length;
+    case GL.LINE_LOOP:
+      return length + 1;
+    case GL.TRIANGLES:
+      return length;
+    case GL.TRIANGLE_STRIP:
+    case GL.TRIANGLE_FAN:
+      return (length - 2) * 3;
+    default:
+      throw new Error('Unknown length');
+  }
+}
+//# sourceMappingURL=modes.js.map

package/dist/esm/geometry/primitives/modes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modes.js","names":["GL","getPrimitiveModeType","mode","POINTS","LINES","LINE_STRIP","LINE_LOOP","TRIANGLES","TRIANGLE_STRIP","TRIANGLE_FAN","Error","isPrimitiveModeExpandable","getPrimitiveModeExpandedLength","length"],"sources":["../../../../src/geometry/primitives/modes.ts"],"sourcesContent":["import {GL} from '../constants';\n\n/**\n * Different methods of working with geometries depending on glType\n /**\n\n/**\n * @param mode\n * @returns draw points | lines | triangles\n */\nexport function getPrimitiveModeType(mode?: number): number {\n  switch (mode) {\n    case GL.POINTS: // draw single points.\n      return GL.POINTS;\n    case GL.LINES: // draw lines. Each set of two vertices is treated as a separate line segment.\n    case GL.LINE_STRIP: // draw lines. Each vertex connects to the one after it.\n    case GL.LINE_LOOP: // draw a connected group of line segments from the first vertex to the last\n      return GL.LINES;\n    case GL.TRIANGLES:\n    case GL.TRIANGLE_STRIP:\n    case GL.TRIANGLE_FAN: // draw a connected group of triangles.\n      return GL.TRIANGLES;\n    default:\n      throw new Error('Unknown primitive mode');\n  }\n}\n/**\n * @param mode\n * @returns true | false\n */\nexport function isPrimitiveModeExpandable(mode: number): boolean {\n  switch (mode) {\n    case GL.LINE_STRIP: // draw lines. Each vertex connects to the one after it.\n    case GL.LINE_LOOP: // draw a connected group of line segments from the first vertex to the last\n    case GL.TRIANGLE_STRIP: // draw a connected group of triangles.\n    case GL.TRIANGLE_FAN: // draw a connected group of triangles.\n      return true;\n    default:\n      return false;\n  }\n}\n/**\n * Returns new length depends on glType\n * @param mode\n * @param length\n * @returns new length\n */\nexport function getPrimitiveModeExpandedLength(mode: number, length: number): number {\n  switch (mode) {\n    case GL.POINTS: // draw single points.\n      return length;\n    case GL.LINES: // draw lines. Each set of two vertices is treated as a separate line segment.\n      return length;\n    case GL.LINE_STRIP: // draw lines. Each vertex connects to the one after it.\n      return length;\n    case GL.LINE_LOOP: // draw a connected group of line segments from the first vertex to the last\n      return length + 1;\n    case GL.TRIANGLES: // draw triangles. Each set of three vertices creates a separate triangle.\n      return length;\n    case GL.TRIANGLE_STRIP: // draw a connected group of triangles.\n    case GL.TRIANGLE_FAN: // draw a connected group of triangles.\n      return (length - 2) * 3;\n    default:\n      throw new Error('Unknown length');\n  }\n}\n"],"mappings":"AAAA,SAAQA,EAAE,QAAO,cAAc;AAU/B,OAAO,SAASC,oBAAoBA,CAACC,IAAa,EAAU;EAC1D,QAAQA,IAAI;IACV,KAAKF,EAAE,CAACG,MAAM;MACZ,OAAOH,EAAE,CAACG,MAAM;IAClB,KAAKH,EAAE,CAACI,KAAK;IACb,KAAKJ,EAAE,CAACK,UAAU;IAClB,KAAKL,EAAE,CAACM,SAAS;MACf,OAAON,EAAE,CAACI,KAAK;IACjB,KAAKJ,EAAE,CAACO,SAAS;IACjB,KAAKP,EAAE,CAACQ,cAAc;IACtB,KAAKR,EAAE,CAACS,YAAY;MAClB,OAAOT,EAAE,CAACO,SAAS;IACrB;MACE,MAAM,IAAIG,KAAK,CAAC,wBAAwB,CAAC;EAC7C;AACF;AAKA,OAAO,SAASC,yBAAyBA,CAACT,IAAY,EAAW;EAC/D,QAAQA,IAAI;IACV,KAAKF,EAAE,CAACK,UAAU;IAClB,KAAKL,EAAE,CAACM,SAAS;IACjB,KAAKN,EAAE,CAACQ,cAAc;IACtB,KAAKR,EAAE,CAACS,YAAY;MAClB,OAAO,IAAI;IACb;MACE,OAAO,KAAK;EAChB;AACF;AAOA,OAAO,SAASG,8BAA8BA,CAACV,IAAY,EAAEW,MAAc,EAAU;EACnF,QAAQX,IAAI;IACV,KAAKF,EAAE,CAACG,MAAM;MACZ,OAAOU,MAAM;IACf,KAAKb,EAAE,CAACI,KAAK;MACX,OAAOS,MAAM;IACf,KAAKb,EAAE,CAACK,UAAU;MAChB,OAAOQ,MAAM;IACf,KAAKb,EAAE,CAACM,SAAS;MACf,OAAOO,MAAM,GAAG,CAAC;IACnB,KAAKb,EAAE,CAACO,SAAS;MACf,OAAOM,MAAM;IACf,KAAKb,EAAE,CAACQ,cAAc;IACtB,KAAKR,EAAE,CAACS,YAAY;MAClB,OAAO,CAACI,MAAM,GAAG,CAAC,IAAI,CAAC;IACzB;MACE,MAAM,IAAIH,KAAK,CAAC,gBAAgB,CAAC;EACrC;AACF"}

package/dist/esm/geometry/typed-arrays/typed-array-utils.js

@@ -0,0 +1,18 @@
+export function concatTypedArrays() {
+  let arrays = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let byteLength = 0;
+  for (let i = 0; i < arrays.length; ++i) {
+    byteLength += arrays[i].byteLength;
+  }
+  const buffer = new Uint8Array(byteLength);
+  let byteOffset = 0;
+  for (let i = 0; i < arrays.length; ++i) {
+    const data = new Uint8Array(arrays[i].buffer);
+    byteLength = data.length;
+    for (let j = 0; j < byteLength; ++j) {
+      buffer[byteOffset++] = data[j];
+    }
+  }
+  return buffer;
+}
+//# sourceMappingURL=typed-array-utils.js.map

package/dist/esm/geometry/typed-arrays/typed-array-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-array-utils.js","names":["concatTypedArrays","arrays","arguments","length","undefined","byteLength","i","buffer","Uint8Array","byteOffset","data","j"],"sources":["../../../../src/geometry/typed-arrays/typed-array-utils.ts"],"sourcesContent":["/**\n * Concats typed arrays\n * @param arrays\n * @returns new Uint8Array\n */\nexport function concatTypedArrays(arrays: any = []): Uint8Array {\n  let byteLength = 0;\n  for (let i = 0; i < arrays.length; ++i) {\n    byteLength += arrays[i].byteLength;\n  }\n  const buffer = new Uint8Array(byteLength);\n\n  let byteOffset = 0;\n  for (let i = 0; i < arrays.length; ++i) {\n    const data = new Uint8Array(arrays[i].buffer);\n    byteLength = data.length;\n    for (let j = 0; j < byteLength; ++j) {\n      buffer[byteOffset++] = data[j];\n    }\n  }\n  return buffer;\n}\n"],"mappings":"AAKA,OAAO,SAASA,iBAAiBA,CAAA,EAA+B;EAAA,IAA9BC,MAAW,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,EAAE;EAChD,IAAIG,UAAU,GAAG,CAAC;EAClB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGL,MAAM,CAACE,MAAM,EAAE,EAAEG,CAAC,EAAE;IACtCD,UAAU,IAAIJ,MAAM,CAACK,CAAC,CAAC,CAACD,UAAU;EACpC;EACA,MAAME,MAAM,GAAG,IAAIC,UAAU,CAACH,UAAU,CAAC;EAEzC,IAAII,UAAU,GAAG,CAAC;EAClB,KAAK,IAAIH,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGL,MAAM,CAACE,MAAM,EAAE,EAAEG,CAAC,EAAE;IACtC,MAAMI,IAAI,GAAG,IAAIF,UAAU,CAACP,MAAM,CAACK,CAAC,CAAC,CAACC,MAAM,CAAC;IAC7CF,UAAU,GAAGK,IAAI,CAACP,MAAM;IACxB,KAAK,IAAIQ,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGN,UAAU,EAAE,EAAEM,CAAC,EAAE;MACnCJ,MAAM,CAACE,UAAU,EAAE,CAAC,GAAGC,IAAI,CAACC,CAAC,CAAC;IAChC;EACF;EACA,OAAOJ,MAAM;AACf"}

package/dist/esm/geometry/utils/assert.js

@@ -0,0 +1,6 @@
+export function assert(condition, message) {
+  if (!condition) {
+    throw new Error("math.gl assertion failed. ".concat(message));
+  }
+}
+//# sourceMappingURL=assert.js.map

package/dist/esm/geometry/utils/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.js","names":["assert","condition","message","Error","concat"],"sources":["../../../../src/geometry/utils/assert.ts"],"sourcesContent":["/**\n * Throws error message\n * @param condition checks if an attribute equal to condition\n * @param message error message\n */\nexport function assert(condition: any, message?: any): void {\n  if (!condition) {\n    throw new Error(`math.gl assertion failed. ${message}`);\n  }\n}\n"],"mappings":"AAKA,OAAO,SAASA,MAAMA,CAACC,SAAc,EAAEC,OAAa,EAAQ;EAC1D,IAAI,CAACD,SAAS,EAAE;IACd,MAAM,IAAIE,KAAK,8BAAAC,MAAA,CAA8BF,OAAO,CAAE,CAAC;EACzD;AACF"}

package/dist/esm/index.js

@@ -0,0 +1,11 @@
+export { GL } from './geometry/constants';
+export { GL_TYPE } from './geometry/constants';
+export { default as GLType } from './geometry/gl/gl-type';
+export { default as isGeometry } from './geometry/is-geometry';
+export { makeAttributeIterator } from './geometry/iterators/attribute-iterator';
+export { makePrimitiveIterator } from './geometry/iterators/primitive-iterator';
+export { computeVertexNormals } from './geometry/attributes/compute-vertex-normals';
+export { encodeRGB565, decodeRGB565 } from './geometry/colors/rgb565';
+export { concatTypedArrays } from './geometry/typed-arrays/typed-array-utils';
+export { octEncodeInRange, octEncode, octEncodeToVector4, octDecodeInRange, octDecode, octDecodeFromVector4, octPackFloat, octEncodeFloat, octDecodeFloat, octPack, octUnpack, compressTextureCoordinates, decompressTextureCoordinates, zigZagDeltaDecode } from './geometry/compression/attribute-compression';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["GL","GL_TYPE","default","GLType","isGeometry","makeAttributeIterator","makePrimitiveIterator","computeVertexNormals","encodeRGB565","decodeRGB565","concatTypedArrays","octEncodeInRange","octEncode","octEncodeToVector4","octDecodeInRange","octDecode","octDecodeFromVector4","octPackFloat","octEncodeFloat","octDecodeFloat","octPack","octUnpack","compressTextureCoordinates","decompressTextureCoordinates","zigZagDeltaDecode"],"sources":["../../src/index.ts"],"sourcesContent":["export type TypedArrayConstructor =\n  | Int8ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int16ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Float32ArrayConstructor\n  | Float64ArrayConstructor;\n\nexport {GL} from './geometry/constants';\n\n// GL support\nexport {GL_TYPE} from './geometry/constants';\nexport {default as GLType} from './geometry/gl/gl-type';\n\n// Geometry\nexport {default as isGeometry} from './geometry/is-geometry';\n\n// Iterators\nexport {makeAttributeIterator} from './geometry/iterators/attribute-iterator';\nexport {makePrimitiveIterator} from './geometry/iterators/primitive-iterator';\n\n// Helper methods\nexport {computeVertexNormals} from './geometry/attributes/compute-vertex-normals';\n\nexport {encodeRGB565, decodeRGB565} from './geometry/colors/rgb565';\n\n// Typed array utils\nexport {concatTypedArrays} from './geometry/typed-arrays/typed-array-utils';\n\n// Compression\nexport {\n  octEncodeInRange,\n  octEncode,\n  octEncodeToVector4,\n  octDecodeInRange,\n  octDecode,\n  octDecodeFromVector4,\n  octPackFloat,\n  octEncodeFloat,\n  octDecodeFloat,\n  octPack,\n  octUnpack,\n  compressTextureCoordinates,\n  decompressTextureCoordinates,\n  zigZagDeltaDecode\n} from './geometry/compression/attribute-compression';\n"],"mappings":"AAYA,SAAQA,EAAE,QAAO,sBAAsB;AAGvC,SAAQC,OAAO,QAAO,sBAAsB;AAC5C,SAAQC,OAAO,IAAIC,MAAM,QAAO,uBAAuB;AAGvD,SAAQD,OAAO,IAAIE,UAAU,QAAO,wBAAwB;AAG5D,SAAQC,qBAAqB,QAAO,yCAAyC;AAC7E,SAAQC,qBAAqB,QAAO,yCAAyC;AAG7E,SAAQC,oBAAoB,QAAO,8CAA8C;AAEjF,SAAQC,YAAY,EAAEC,YAAY,QAAO,0BAA0B;AAGnE,SAAQC,iBAAiB,QAAO,2CAA2C;AAG3E,SACEC,gBAAgB,EAChBC,SAAS,EACTC,kBAAkB,EAClBC,gBAAgB,EAChBC,SAAS,EACTC,oBAAoB,EACpBC,YAAY,EACZC,cAAc,EACdC,cAAc,EACdC,OAAO,EACPC,SAAS,EACTC,0BAA0B,EAC1BC,4BAA4B,EAC5BC,iBAAiB,QACZ,8CAA8C"}

package/dist/esm/utils/assert.js

@@ -0,0 +1,6 @@
+export function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || '3d-tile loader: assertion failed.');
+  }
+}
+//# sourceMappingURL=assert.js.map

package/dist/esm/utils/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.js","names":["assert","condition","message","Error"],"sources":["../../../src/utils/assert.ts"],"sourcesContent":["// Replacement for the external assert method to reduce bundle size\n// Note: We don't use the second \"message\" argument in calling code,\n// so no need to support it here\nexport function assert(condition: Boolean, message?: string): void {\n  if (!condition) {\n    throw new Error(message || '3d-tile loader: assertion failed.');\n  }\n}\n"],"mappings":"AAGA,OAAO,SAASA,MAAMA,CAACC,SAAkB,EAAEC,OAAgB,EAAQ;EACjE,IAAI,CAACD,SAAS,EAAE;IACd,MAAM,IAAIE,KAAK,CAACD,OAAO,IAAI,mCAAmC,CAAC;EACjE;AACF"}

package/dist/geometry/attributes/compute-bounding-box.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Getting bounding box geometry according to positions parameters
+ * @param positions
+ * @returns Bounding Box
+ */
+export declare function computeBoundingBox(positions?: any): {
+    min: number[];
+    max: number[];
+};
+//# sourceMappingURL=compute-bounding-box.d.ts.map

package/dist/geometry/attributes/compute-bounding-box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-bounding-box.d.ts","sourceRoot":"","sources":["../../../src/geometry/attributes/compute-bounding-box.ts"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,GAAE,GAAQ;;;EAqBrD"}

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

@@ -1,30 +1,44 @@
-import { makeAttributeIterator } from '../iterators/attribute-iterator';
-import { assert } from '../utils/assert';
-export function computeBoundingBox(positions = []) {
-  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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeBoundingBox = void 0;
+const attribute_iterator_1 = require("../iterators/attribute-iterator");
+const assert_1 = require("../utils/assert");
+/**
+ * Getting bounding box geometry according to positions parameters
+ * @param positions
+ * @returns Bounding Box
+ */
+function computeBoundingBox(positions = []) {
+    const min = [Number(Infinity), Number(Infinity), Number(Infinity)];
+    const max = [-Infinity, -Infinity, -Infinity];
+    // @ts-ignore
+    for (const position of (0, attribute_iterator_1.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;
 }
-
+exports.computeBoundingBox = computeBoundingBox;
 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]));
+    (0, assert_1.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.d.ts

@@ -0,0 +1,29 @@
+/**
+import {getPositions} from './get-attribute-from-geometry';
+
+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};
+}
+*/
+//# sourceMappingURL=compute-bounding-sphere.d.ts.map

package/dist/geometry/attributes/compute-bounding-sphere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-bounding-sphere.d.ts","sourceRoot":"","sources":["../../../src/geometry/attributes/compute-bounding-sphere.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BE"}

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.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=compute-tangents.d.ts.map

package/dist/geometry/attributes/compute-tangents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-tangents.d.ts","sourceRoot":"","sources":["../../../src/geometry/attributes/compute-tangents.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,17 @@
+import type { TypedArray } from '@math.gl/core';
+type Geometry = {
+    mode: any;
+    indices?: {
+        size: number;
+        values: TypedArray;
+    };
+    attributes?: {};
+};
+/**
+ * Computes vertex normals for a geometry
+ * @param param0
+ * @returns
+ */
+export declare function computeVertexNormals(geometry: Geometry): Float32Array;
+export {};
+//# sourceMappingURL=compute-vertex-normals.d.ts.map

package/dist/geometry/attributes/compute-vertex-normals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-vertex-normals.d.ts","sourceRoot":"","sources":["../../../src/geometry/attributes/compute-vertex-normals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAQ9C,KAAK,QAAQ,GAAG;IACd,IAAI,EAAE,GAAG,CAAC;IACV,OAAO,CAAC,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,CAAA;KAAC,CAAC;IAC7C,UAAU,CAAC,EAAE,EAAE,CAAC;CACjB,CAAC;AACF;;;;GAIG;AAEH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,YAAY,CAyCrE"}

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

@@ -1,43 +1,48 @@
-import { Vector3 } from '@math.gl/core';
-import { GL } from '../constants';
-import { assert } from '../utils/assert';
-import { makePrimitiveIterator } from '../iterators/primitive-iterator';
-import { getPrimitiveModeType } from '../primitives/modes';
-import { getPositions } from './get-attribute-from-geometry';
-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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeVertexNormals = void 0;
+const core_1 = require("@math.gl/core");
+const constants_1 = require("../constants");
+const assert_1 = require("../utils/assert");
+const primitive_iterator_1 = require("../iterators/primitive-iterator");
+const modes_1 = require("../primitives/modes");
+const get_attribute_from_geometry_1 = require("./get-attribute-from-geometry");
+/**
+ * Computes vertex normals for a geometry
+ * @param param0
+ * @returns
+ */
+// eslint-disable-next-line max-statements
+function computeVertexNormals(geometry) {
+    // Only support GL.TRIANGLES, GL.TRIANGLE_STRIP, GL.TRIANGLE_FAN
+    (0, assert_1.assert)((0, modes_1.getPrimitiveModeType)(geometry.mode) === constants_1.GL.TRIANGLES, 'TRIANGLES required');
+    const { values: positions } = (0, get_attribute_from_geometry_1.getPositions)(geometry);
+    const normals = new Float32Array(positions.length);
+    const vectorA = new core_1.Vector3();
+    const vectorB = new core_1.Vector3();
+    const vectorC = new core_1.Vector3();
+    const vectorCB = new core_1.Vector3();
+    const vectorAB = new core_1.Vector3();
+    for (const primitive of (0, primitive_iterator_1.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
+exports.computeVertexNormals = computeVertexNormals;

package/dist/geometry/attributes/convert-to-non-indexed.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Converts indices of geometry.
+ *
+ * @param param0
+ * @returns no indexed geometry
+ */
+export declare function convertBuffersToNonIndexed({ indices, attributes }: {
+    indices: any;
+    attributes: any;
+}): any;
+//# sourceMappingURL=convert-to-non-indexed.d.ts.map

package/dist/geometry/attributes/convert-to-non-indexed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-to-non-indexed.d.ts","sourceRoot":"","sources":["../../../src/geometry/attributes/convert-to-non-indexed.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,EAAC,OAAO,EAAE,UAAU,EAAC;;;CAAA,GAAG,GAAG,CA2BrE"}

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

@@ -1,32 +1,33 @@
-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++];
-      }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertBuffersToNonIndexed = void 0;
+/* eslint-disable */
+// @ts-nocheck
+/**
+ * Converts indices of geometry.
+ *
+ * @param param0
+ * @returns no indexed geometry
+ */
+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
+exports.convertBuffersToNonIndexed = convertBuffersToNonIndexed;

package/dist/geometry/attributes/get-attribute-from-geometry.d.ts

@@ -0,0 +1,8 @@
+/**
+ * analyze positions of geometry
+ *
+ * @param geometry
+ * @returns Position| New geometry |assert
+ */
+export declare function getPositions(geometry: any): any;
+//# sourceMappingURL=get-attribute-from-geometry.d.ts.map