@loaders.gl/math 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/es5/geometry/gl/gl-type.js

@@ -0,0 +1,92 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _constants = require("../constants");
+var _GL_TYPE_TO_ARRAY_TYP;
+var GL_TYPE_TO_ARRAY_TYPE = (_GL_TYPE_TO_ARRAY_TYP = {}, (0, _defineProperty2.default)(_GL_TYPE_TO_ARRAY_TYP, _constants.GL_TYPE.DOUBLE, Float64Array), (0, _defineProperty2.default)(_GL_TYPE_TO_ARRAY_TYP, _constants.GL_TYPE.FLOAT, Float32Array), (0, _defineProperty2.default)(_GL_TYPE_TO_ARRAY_TYP, _constants.GL_TYPE.UNSIGNED_SHORT, Uint16Array), (0, _defineProperty2.default)(_GL_TYPE_TO_ARRAY_TYP, _constants.GL_TYPE.UNSIGNED_INT, Uint32Array), (0, _defineProperty2.default)(_GL_TYPE_TO_ARRAY_TYP, _constants.GL_TYPE.UNSIGNED_BYTE, Uint8Array), (0, _defineProperty2.default)(_GL_TYPE_TO_ARRAY_TYP, _constants.GL_TYPE.BYTE, Int8Array), (0, _defineProperty2.default)(_GL_TYPE_TO_ARRAY_TYP, _constants.GL_TYPE.SHORT, Int16Array), (0, _defineProperty2.default)(_GL_TYPE_TO_ARRAY_TYP, _constants.GL_TYPE.INT, Int32Array), _GL_TYPE_TO_ARRAY_TYP);
+var NAME_TO_GL_TYPE = {
+  DOUBLE: _constants.GL_TYPE.DOUBLE,
+  FLOAT: _constants.GL_TYPE.FLOAT,
+  UNSIGNED_SHORT: _constants.GL_TYPE.UNSIGNED_SHORT,
+  UNSIGNED_INT: _constants.GL_TYPE.UNSIGNED_INT,
+  UNSIGNED_BYTE: _constants.GL_TYPE.UNSIGNED_BYTE,
+  BYTE: _constants.GL_TYPE.BYTE,
+  SHORT: _constants.GL_TYPE.SHORT,
+  INT: _constants.GL_TYPE.INT
+};
+var ERR_TYPE_CONVERSION = 'Failed to convert GL type';
+var GLType = function () {
+  function GLType() {
+    (0, _classCallCheck2.default)(this, GLType);
+  }
+  (0, _createClass2.default)(GLType, null, [{
+    key: "fromTypedArray",
+    value: function fromTypedArray(arrayOrType) {
+      arrayOrType = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
+      for (var glType in GL_TYPE_TO_ARRAY_TYPE) {
+        var ArrayType = GL_TYPE_TO_ARRAY_TYPE[glType];
+        if (ArrayType === arrayOrType) {
+          return glType;
+        }
+      }
+      throw new Error(ERR_TYPE_CONVERSION);
+    }
+  }, {
+    key: "fromName",
+    value: function fromName(name) {
+      var glType = NAME_TO_GL_TYPE[name];
+      if (!glType) {
+        throw new Error(ERR_TYPE_CONVERSION);
+      }
+      return glType;
+    }
+  }, {
+    key: "getArrayType",
+    value: function getArrayType(glType) {
+      switch (glType) {
+        case _constants.GL_TYPE.UNSIGNED_SHORT_5_6_5:
+        case _constants.GL_TYPE.UNSIGNED_SHORT_4_4_4_4:
+        case _constants.GL_TYPE.UNSIGNED_SHORT_5_5_5_1:
+          return Uint16Array;
+        default:
+          var ArrayType = GL_TYPE_TO_ARRAY_TYPE[glType];
+          if (!ArrayType) {
+            throw new Error(ERR_TYPE_CONVERSION);
+          }
+          return ArrayType;
+      }
+    }
+  }, {
+    key: "getByteSize",
+    value: function getByteSize(glType) {
+      var ArrayType = GLType.getArrayType(glType);
+      return ArrayType.BYTES_PER_ELEMENT;
+    }
+  }, {
+    key: "validate",
+    value: function validate(glType) {
+      return Boolean(GLType.getArrayType(glType));
+    }
+  }, {
+    key: "createTypedArray",
+    value: function createTypedArray(glType, buffer) {
+      var byteOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+      var length = arguments.length > 3 ? arguments[3] : undefined;
+      if (length === undefined) {
+        length = (buffer.byteLength - byteOffset) / GLType.getByteSize(glType);
+      }
+      var ArrayType = GLType.getArrayType(glType);
+      return new ArrayType(buffer, byteOffset, length);
+    }
+  }]);
+  return GLType;
+}();
+exports.default = GLType;
+//# sourceMappingURL=gl-type.js.map

package/dist/es5/geometry/gl/gl-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gl-type.js","names":["_constants","require","_GL_TYPE_TO_ARRAY_TYP","GL_TYPE_TO_ARRAY_TYPE","_defineProperty2","default","GL","DOUBLE","Float64Array","FLOAT","Float32Array","UNSIGNED_SHORT","Uint16Array","UNSIGNED_INT","Uint32Array","UNSIGNED_BYTE","Uint8Array","BYTE","Int8Array","SHORT","Int16Array","INT","Int32Array","NAME_TO_GL_TYPE","ERR_TYPE_CONVERSION","GLType","_classCallCheck2","_createClass2","key","value","fromTypedArray","arrayOrType","ArrayBuffer","isView","constructor","glType","ArrayType","Error","fromName","name","getArrayType","UNSIGNED_SHORT_5_6_5","UNSIGNED_SHORT_4_4_4_4","UNSIGNED_SHORT_5_5_5_1","getByteSize","BYTES_PER_ELEMENT","validate","Boolean","createTypedArray","buffer","byteOffset","arguments","length","undefined","byteLength","exports"],"sources":["../../../../src/geometry/gl/gl-type.ts"],"sourcesContent":["import type {TypedArray} from '@math.gl/core';\nimport {GL_TYPE as GL} from '../constants';\n\nconst GL_TYPE_TO_ARRAY_TYPE = {\n  [GL.DOUBLE]: Float64Array,\n  [GL.FLOAT]: Float32Array,\n  [GL.UNSIGNED_SHORT]: Uint16Array,\n  [GL.UNSIGNED_INT]: Uint32Array,\n  [GL.UNSIGNED_BYTE]: Uint8Array,\n  [GL.BYTE]: Int8Array,\n  [GL.SHORT]: Int16Array,\n  [GL.INT]: Int32Array\n};\ntype GlTypeMap = {\n  [index: string]: number;\n};\nconst NAME_TO_GL_TYPE: GlTypeMap = {\n  DOUBLE: GL.DOUBLE,\n  FLOAT: GL.FLOAT,\n  UNSIGNED_SHORT: GL.UNSIGNED_SHORT,\n  UNSIGNED_INT: GL.UNSIGNED_INT,\n  UNSIGNED_BYTE: GL.UNSIGNED_BYTE,\n  BYTE: GL.BYTE,\n  SHORT: GL.SHORT,\n  INT: GL.INT\n};\nconst ERR_TYPE_CONVERSION = 'Failed to convert GL type';\n// Converts TYPED ARRAYS to corresponding GL constant\n// Used to auto deduce gl parameter types\nexport default class GLType {\n  // Signature: fromTypedArray(new Uint8Array())\n  // Signature: fromTypedArray(Uint8Array)\n  /**\n   * Returns the size, in bytes, of the corresponding datatype\n   * @param arrayOrType\n   * @returns glType a a string\n   */\n  static fromTypedArray(arrayOrType: TypedArray | Function): string {\n    // If typed array, look up constructor\n    arrayOrType = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;\n    for (const glType in GL_TYPE_TO_ARRAY_TYPE) {\n      const ArrayType = GL_TYPE_TO_ARRAY_TYPE[glType];\n      if (ArrayType === arrayOrType) {\n        return glType;\n      }\n    }\n    throw new Error(ERR_TYPE_CONVERSION);\n  }\n  /**\n   * Extracts name for glType from array NAME_TO_GL_TYPE\n   * @param name\n   * @returns glType as a number\n   */\n  static fromName(name: string): number {\n    const glType = NAME_TO_GL_TYPE[name];\n    if (!glType) {\n      throw new Error(ERR_TYPE_CONVERSION);\n    }\n    return glType;\n  }\n  // Converts GL constant to corresponding typed array type\n  // eslint-disable-next-line complexity\n  static getArrayType(glType: number) {\n    switch (glType) {\n      /*eslint-disable*/\n      // @ts-ignore\n      case GL.UNSIGNED_SHORT_5_6_5:\n      // @ts-ignore\n      case GL.UNSIGNED_SHORT_4_4_4_4:\n      // @ts-ignore\n      case GL.UNSIGNED_SHORT_5_5_5_1:\n        /* eslint-enable*/\n        return Uint16Array;\n      default:\n        const ArrayType = GL_TYPE_TO_ARRAY_TYPE[glType];\n        if (!ArrayType) {\n          throw new Error(ERR_TYPE_CONVERSION);\n        }\n        return ArrayType;\n    }\n  }\n  /**\n   * Returns the size in bytes of one element of the provided WebGL type\n   * @param glType\n   * @returns size of glType\n   */\n  static getByteSize(glType: number): number {\n    const ArrayType = GLType.getArrayType(glType);\n    return ArrayType.BYTES_PER_ELEMENT;\n  }\n  /**\n   * Returns `true` if `glType` is a valid WebGL data type.\n   * @param glType\n   * @returns boolean\n   */\n  static validate(glType: number): boolean {\n    return Boolean(GLType.getArrayType(glType));\n  }\n  /**\n   * Creates a typed view of an array of bytes\n   * @param glType The type of typed array (ArrayBuffer view) to create\n   * @param buffer The buffer storage to use for the view.\n   * @param byteOffset The offset, in bytes, to the first element in the view\n   * @param length The number of elements in the view. Defaults to buffer length\n   * @returns A typed array view of the buffer\n   */\n  static createTypedArray(\n    glType: number,\n    buffer: TypedArray,\n    byteOffset: number = 0,\n    length?: number\n  ): TypedArray {\n    if (length === undefined) {\n      length = (buffer.byteLength - byteOffset) / GLType.getByteSize(glType);\n    }\n    const ArrayType = GLType.getArrayType(glType);\n    return new ArrayType(buffer, byteOffset, length);\n  }\n}\n"],"mappings":"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"}

package/dist/es5/geometry/is-geometry.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isGeometry;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+function isGeometry(geometry) {
+  return geometry && (0, _typeof2.default)(geometry) === 'object' && geometry.mode && geometry.attributes && (0, _typeof2.default)(geometry.attributes) === 'object';
+}
+//# sourceMappingURL=is-geometry.js.map

package/dist/es5/geometry/is-geometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-geometry.js","names":["isGeometry","geometry","_typeof2","default","mode","attributes"],"sources":["../../../src/geometry/is-geometry.ts"],"sourcesContent":["/**\n * Checking if it is geometry\n * @param geometry\n */\nexport default function isGeometry(geometry: any): boolean {\n  return (\n    geometry &&\n    typeof geometry === 'object' &&\n    geometry.mode &&\n    geometry.attributes &&\n    typeof geometry.attributes === 'object'\n  );\n}\n"],"mappings":";;;;;;;;AAIe,SAASA,UAAUA,CAACC,QAAa,EAAW;EACzD,OACEA,QAAQ,IACR,IAAAC,QAAA,CAAAC,OAAA,EAAOF,QAAQ,MAAK,QAAQ,IAC5BA,QAAQ,CAACG,IAAI,IACbH,QAAQ,CAACI,UAAU,IACnB,IAAAH,QAAA,CAAAC,OAAA,EAAOF,QAAQ,CAACI,UAAU,MAAK,QAAQ;AAE3C"}

package/dist/es5/geometry/iterators/attribute-iterator.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeAttributeIterator = makeAttributeIterator;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _marked = _regenerator.default.mark(makeAttributeIterator);
+function makeAttributeIterator(values, size) {
+  var ArrayType, element, i, j;
+  return _regenerator.default.wrap(function makeAttributeIterator$(_context) {
+    while (1) switch (_context.prev = _context.next) {
+      case 0:
+        ArrayType = values.constructor;
+        element = new ArrayType(size);
+        i = 0;
+      case 3:
+        if (!(i < values.length)) {
+          _context.next = 10;
+          break;
+        }
+        for (j = 0; j < size; j++) {
+          element[j] = element[i + j];
+        }
+        _context.next = 7;
+        return element;
+      case 7:
+        i += size;
+        _context.next = 3;
+        break;
+      case 10:
+      case "end":
+        return _context.stop();
+    }
+  }, _marked);
+}
+//# sourceMappingURL=attribute-iterator.js.map

package/dist/es5/geometry/iterators/attribute-iterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribute-iterator.js","names":["makeAttributeIterator","values","size","ArrayType","element","i","j","_regenerator","default","wrap","makeAttributeIterator$","_context","prev","next","constructor","length","stop","_marked"],"sources":["../../../../src/geometry/iterators/attribute-iterator.ts"],"sourcesContent":["/**\n * Iterates over a single attribute\n * NOTE: For performance, re-yields the same modified element\n * @param param0\n */\nexport function* makeAttributeIterator(values: any, size: number): Iterable<any> {\n  const ArrayType = values.constructor;\n  const element = new ArrayType(size);\n  for (let i = 0; i < values.length; i += size) {\n    for (let j = 0; j < size; j++) {\n      element[j] = element[i + j];\n    }\n    yield element;\n  }\n}\n"],"mappings":";;;;;;;;wCAKiBA,qBAAqB;AAA/B,SAAUA,qBAAqBA,CAACC,MAAW,EAAEC,IAAY;EAAA,IAAAC,SAAA,EAAAC,OAAA,EAAAC,CAAA,EAAAC,CAAA;EAAA,OAAAC,YAAA,CAAAC,OAAA,CAAAC,IAAA,UAAAC,uBAAAC,QAAA;IAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;MAAA;QACxDV,SAAS,GAAGF,MAAM,CAACa,WAAW;QAC9BV,OAAO,GAAG,IAAID,SAAS,CAACD,IAAI,CAAC;QAC1BG,CAAC,GAAG,CAAC;MAAA;QAAA,MAAEA,CAAC,GAAGJ,MAAM,CAACc,MAAM;UAAAJ,QAAA,CAAAE,IAAA;UAAA;QAAA;QAC/B,KAASP,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGJ,IAAI,EAAEI,CAAC,EAAE,EAAE;UAC7BF,OAAO,CAACE,CAAC,CAAC,GAAGF,OAAO,CAACC,CAAC,GAAGC,CAAC,CAAC;QAC7B;QAACK,QAAA,CAAAE,IAAA;QACD,OAAMT,OAAO;MAAA;QAJoBC,CAAC,IAAIH,IAAI;QAAAS,QAAA,CAAAE,IAAA;QAAA;MAAA;MAAA;QAAA,OAAAF,QAAA,CAAAK,IAAA;IAAA;EAAA,GAAAC,OAAA;AAAA"}

package/dist/es5/geometry/iterators/primitive-iterator.js

@@ -0,0 +1,102 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makePrimitiveIterator = makePrimitiveIterator;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _constants = require("../constants");
+var _modes = require("../primitives/modes");
+var _loaderUtils = require("@loaders.gl/loader-utils");
+function makePrimitiveIterator(indices) {
+  var attributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var mode = arguments.length > 2 ? arguments[2] : undefined;
+  var start = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  var end = arguments.length > 4 ? arguments[4] : undefined;
+  return _regenerator.default.mark(function _callee() {
+    var info, i;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (indices) {
+            indices = indices.values || indices.value || indices;
+          }
+          if (end === undefined) {
+            end = indices ? indices.length : start;
+          }
+          info = {
+            attributes: attributes,
+            type: (0, _modes.getPrimitiveModeType)(mode),
+            i1: 0,
+            i2: 0,
+            i3: 0
+          };
+          i = start;
+        case 4:
+          if (!(i < end)) {
+            _context.next = 43;
+            break;
+          }
+          _context.t0 = mode;
+          _context.next = _context.t0 === _constants.GL.POINTS ? 8 : _context.t0 === _constants.GL.LINES ? 11 : _context.t0 === _constants.GL.LINE_STRIP ? 15 : _context.t0 === _constants.GL.LINE_LOOP ? 19 : _context.t0 === _constants.GL.TRIANGLES ? 23 : _context.t0 === _constants.GL.TRIANGLE_STRIP ? 28 : _context.t0 === _constants.GL.TRIANGLE_FAN ? 32 : 37;
+          break;
+        case 8:
+          info.i1 = i;
+          i += 1;
+          return _context.abrupt("break", 38);
+        case 11:
+          info.i1 = i;
+          info.i2 = i + 1;
+          i += 2;
+          return _context.abrupt("break", 38);
+        case 15:
+          info.i1 = i;
+          info.i2 = i + 1;
+          i += 1;
+          return _context.abrupt("break", 38);
+        case 19:
+          info.i1 = i;
+          info.i2 = i + 1;
+          i += 1;
+          return _context.abrupt("break", 38);
+        case 23:
+          info.i1 = i;
+          info.i2 = i + 1;
+          info.i3 = i + 2;
+          i += 3;
+          return _context.abrupt("break", 38);
+        case 28:
+          info.i1 = i;
+          info.i2 = i + 1;
+          i += 1;
+          return _context.abrupt("break", 38);
+        case 32:
+          info.i1 = 1;
+          info.i2 = i;
+          info.i3 = i + 1;
+          i += 1;
+          return _context.abrupt("break", 38);
+        case 37:
+          (0, _loaderUtils.assert)(false);
+        case 38:
+          if (indices) {
+            if ('i1' in info) {
+              info.i1 = indices[info.i1];
+              info.i2 = indices[info.i2];
+              info.i3 = indices[info.i3];
+            }
+          }
+          _context.next = 41;
+          return info;
+        case 41:
+          _context.next = 4;
+          break;
+        case 43:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })();
+}
+//# sourceMappingURL=primitive-iterator.js.map

package/dist/es5/geometry/iterators/primitive-iterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitive-iterator.js","names":["_constants","require","_modes","_loaderUtils","makePrimitiveIterator","indices","attributes","arguments","length","undefined","mode","start","end","_regenerator","default","mark","_callee","info","i","wrap","_callee$","_context","prev","next","values","value","type","getPrimitiveModeType","i1","i2","i3","t0","GL","POINTS","LINES","LINE_STRIP","LINE_LOOP","TRIANGLES","TRIANGLE_STRIP","TRIANGLE_FAN","abrupt","assert","stop"],"sources":["../../../../src/geometry/iterators/primitive-iterator.ts"],"sourcesContent":["import {GL} from '../constants';\nimport {getPrimitiveModeType} from '../primitives/modes';\nimport {assert} from '@loaders.gl/loader-utils';\n\n/**\n * Iteration info for making primitive iterator\n */\ntype Information = {\n  attributes: object;\n  type: number | void;\n  i1: number;\n  i2: number;\n  i3: number;\n  primitiveIndex?: object;\n};\n/**\n * Will iterate over each primitive, expanding (dereferencing) indices\n * @param indices\n * @param attributes\n * @param mode\n * @param start\n * @param end\n */\n// eslint-disable-next-line complexity\nexport function* makePrimitiveIterator(\n  indices?: any,\n  attributes: object = {},\n  mode?: number,\n  start = 0,\n  end?: number\n): Iterable<{attributes: object; type: number; i1: number; i2: number; i3: number}> {\n  // support indices being an object with a values array\n  if (indices) {\n    indices = indices.values || indices.value || indices;\n  }\n\n  // Autodeduce length from indices\n  if (end === undefined) {\n    end = indices ? indices.length : start;\n  }\n\n  // iteration info\n  const info: Information = {\n    attributes,\n    type: getPrimitiveModeType(mode),\n    i1: 0,\n    i2: 0,\n    i3: 0\n  };\n\n  let i = start;\n  // @ts-ignore\n  while (i < end) {\n    switch (mode) {\n      case GL.POINTS: // draw single points.\n        info.i1 = i;\n        i += 1;\n        break;\n      case GL.LINES: // draw lines. Each set of two vertices is treated as a separate line segment.\n        info.i1 = i;\n        info.i2 = i + 1;\n        i += 2;\n        break;\n      case GL.LINE_STRIP: // draw lines. Each vertex connects to the one after it.\n        info.i1 = i;\n        info.i2 = i + 1;\n        i += 1;\n        break;\n      case GL.LINE_LOOP: // draw a connected group of line segments from the first vertex to the last\n        info.i1 = i;\n        info.i2 = i + 1;\n        i += 1;\n        break;\n      case GL.TRIANGLES: // draw triangles. Each set of three vertices creates a separate triangle.\n        info.i1 = i;\n        info.i2 = i + 1;\n        info.i3 = i + 2;\n        i += 3;\n        break;\n      case GL.TRIANGLE_STRIP: // draw a connected group of triangles.\n        info.i1 = i;\n        info.i2 = i + 1;\n        i += 1;\n        break;\n      case GL.TRIANGLE_FAN: // draw a connected group of triangles.\n        info.i1 = 1;\n        info.i2 = i;\n        info.i3 = i + 1;\n        i += 1;\n        break;\n\n      default:\n        assert(false);\n    }\n\n    // if indices are present, lookup actual vertices in indices\n    if (indices) {\n      if ('i1' in info) {\n        info.i1 = indices[info.i1];\n        info.i2 = indices[info.i2];\n        info.i3 = indices[info.i3];\n      }\n    }\n    // @ts-ignore\n    yield info;\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPrimitiveModeExpandedLength = getPrimitiveModeExpandedLength;
+exports.getPrimitiveModeType = getPrimitiveModeType;
+exports.isPrimitiveModeExpandable = isPrimitiveModeExpandable;
+var _constants = require("../constants");
+function getPrimitiveModeType(mode) {
+  switch (mode) {
+    case _constants.GL.POINTS:
+      return _constants.GL.POINTS;
+    case _constants.GL.LINES:
+    case _constants.GL.LINE_STRIP:
+    case _constants.GL.LINE_LOOP:
+      return _constants.GL.LINES;
+    case _constants.GL.TRIANGLES:
+    case _constants.GL.TRIANGLE_STRIP:
+    case _constants.GL.TRIANGLE_FAN:
+      return _constants.GL.TRIANGLES;
+    default:
+      throw new Error('Unknown primitive mode');
+  }
+}
+function isPrimitiveModeExpandable(mode) {
+  switch (mode) {
+    case _constants.GL.LINE_STRIP:
+    case _constants.GL.LINE_LOOP:
+    case _constants.GL.TRIANGLE_STRIP:
+    case _constants.GL.TRIANGLE_FAN:
+      return true;
+    default:
+      return false;
+  }
+}
+function getPrimitiveModeExpandedLength(mode, length) {
+  switch (mode) {
+    case _constants.GL.POINTS:
+      return length;
+    case _constants.GL.LINES:
+      return length;
+    case _constants.GL.LINE_STRIP:
+      return length;
+    case _constants.GL.LINE_LOOP:
+      return length + 1;
+    case _constants.GL.TRIANGLES:
+      return length;
+    case _constants.GL.TRIANGLE_STRIP:
+    case _constants.GL.TRIANGLE_FAN:
+      return (length - 2) * 3;
+    default:
+      throw new Error('Unknown length');
+  }
+}
+//# sourceMappingURL=modes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"modes.js","names":["_constants","require","getPrimitiveModeType","mode","GL","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,IAAAA,UAAA,GAAAC,OAAA;AAUO,SAASC,oBAAoBA,CAACC,IAAa,EAAU;EAC1D,QAAQA,IAAI;IACV,KAAKC,aAAE,CAACC,MAAM;MACZ,OAAOD,aAAE,CAACC,MAAM;IAClB,KAAKD,aAAE,CAACE,KAAK;IACb,KAAKF,aAAE,CAACG,UAAU;IAClB,KAAKH,aAAE,CAACI,SAAS;MACf,OAAOJ,aAAE,CAACE,KAAK;IACjB,KAAKF,aAAE,CAACK,SAAS;IACjB,KAAKL,aAAE,CAACM,cAAc;IACtB,KAAKN,aAAE,CAACO,YAAY;MAClB,OAAOP,aAAE,CAACK,SAAS;IACrB;MACE,MAAM,IAAIG,KAAK,CAAC,wBAAwB,CAAC;EAC7C;AACF;AAKO,SAASC,yBAAyBA,CAACV,IAAY,EAAW;EAC/D,QAAQA,IAAI;IACV,KAAKC,aAAE,CAACG,UAAU;IAClB,KAAKH,aAAE,CAACI,SAAS;IACjB,KAAKJ,aAAE,CAACM,cAAc;IACtB,KAAKN,aAAE,CAACO,YAAY;MAClB,OAAO,IAAI;IACb;MACE,OAAO,KAAK;EAChB;AACF;AAOO,SAASG,8BAA8BA,CAACX,IAAY,EAAEY,MAAc,EAAU;EACnF,QAAQZ,IAAI;IACV,KAAKC,aAAE,CAACC,MAAM;MACZ,OAAOU,MAAM;IACf,KAAKX,aAAE,CAACE,KAAK;MACX,OAAOS,MAAM;IACf,KAAKX,aAAE,CAACG,UAAU;MAChB,OAAOQ,MAAM;IACf,KAAKX,aAAE,CAACI,SAAS;MACf,OAAOO,MAAM,GAAG,CAAC;IACnB,KAAKX,aAAE,CAACK,SAAS;MACf,OAAOM,MAAM;IACf,KAAKX,aAAE,CAACM,cAAc;IACtB,KAAKN,aAAE,CAACO,YAAY;MAClB,OAAO,CAACI,MAAM,GAAG,CAAC,IAAI,CAAC;IACzB;MACE,MAAM,IAAIH,KAAK,CAAC,gBAAgB,CAAC;EACrC;AACF"}

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

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.concatTypedArrays = concatTypedArrays;
+function concatTypedArrays() {
+  var arrays = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var byteLength = 0;
+  for (var i = 0; i < arrays.length; ++i) {
+    byteLength += arrays[i].byteLength;
+  }
+  var buffer = new Uint8Array(byteLength);
+  var byteOffset = 0;
+  for (var _i = 0; _i < arrays.length; ++_i) {
+    var data = new Uint8Array(arrays[_i].buffer);
+    byteLength = data.length;
+    for (var j = 0; j < byteLength; ++j) {
+      buffer[byteOffset++] = data[j];
+    }
+  }
+  return buffer;
+}
+//# sourceMappingURL=typed-array-utils.js.map

package/dist/es5/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":";;;;;;AAKO,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,IAAME,MAAM,GAAG,IAAIC,UAAU,CAACH,UAAU,CAAC;EAEzC,IAAII,UAAU,GAAG,CAAC;EAClB,KAAK,IAAIH,EAAC,GAAG,CAAC,EAAEA,EAAC,GAAGL,MAAM,CAACE,MAAM,EAAE,EAAEG,EAAC,EAAE;IACtC,IAAMI,IAAI,GAAG,IAAIF,UAAU,CAACP,MAAM,CAACK,EAAC,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/es5/geometry/utils/assert.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assert = assert;
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error("math.gl assertion failed. ".concat(message));
+  }
+}
+//# sourceMappingURL=assert.js.map

package/dist/es5/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":";;;;;;AAKO,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/es5/index.js

@@ -0,0 +1,160 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "GL", {
+  enumerable: true,
+  get: function get() {
+    return _constants.GL;
+  }
+});
+Object.defineProperty(exports, "GLType", {
+  enumerable: true,
+  get: function get() {
+    return _glType.default;
+  }
+});
+Object.defineProperty(exports, "GL_TYPE", {
+  enumerable: true,
+  get: function get() {
+    return _constants.GL_TYPE;
+  }
+});
+Object.defineProperty(exports, "compressTextureCoordinates", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.compressTextureCoordinates;
+  }
+});
+Object.defineProperty(exports, "computeVertexNormals", {
+  enumerable: true,
+  get: function get() {
+    return _computeVertexNormals.computeVertexNormals;
+  }
+});
+Object.defineProperty(exports, "concatTypedArrays", {
+  enumerable: true,
+  get: function get() {
+    return _typedArrayUtils.concatTypedArrays;
+  }
+});
+Object.defineProperty(exports, "decodeRGB565", {
+  enumerable: true,
+  get: function get() {
+    return _rgb.decodeRGB565;
+  }
+});
+Object.defineProperty(exports, "decompressTextureCoordinates", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.decompressTextureCoordinates;
+  }
+});
+Object.defineProperty(exports, "encodeRGB565", {
+  enumerable: true,
+  get: function get() {
+    return _rgb.encodeRGB565;
+  }
+});
+Object.defineProperty(exports, "isGeometry", {
+  enumerable: true,
+  get: function get() {
+    return _isGeometry.default;
+  }
+});
+Object.defineProperty(exports, "makeAttributeIterator", {
+  enumerable: true,
+  get: function get() {
+    return _attributeIterator.makeAttributeIterator;
+  }
+});
+Object.defineProperty(exports, "makePrimitiveIterator", {
+  enumerable: true,
+  get: function get() {
+    return _primitiveIterator.makePrimitiveIterator;
+  }
+});
+Object.defineProperty(exports, "octDecode", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.octDecode;
+  }
+});
+Object.defineProperty(exports, "octDecodeFloat", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.octDecodeFloat;
+  }
+});
+Object.defineProperty(exports, "octDecodeFromVector4", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.octDecodeFromVector4;
+  }
+});
+Object.defineProperty(exports, "octDecodeInRange", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.octDecodeInRange;
+  }
+});
+Object.defineProperty(exports, "octEncode", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.octEncode;
+  }
+});
+Object.defineProperty(exports, "octEncodeFloat", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.octEncodeFloat;
+  }
+});
+Object.defineProperty(exports, "octEncodeInRange", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.octEncodeInRange;
+  }
+});
+Object.defineProperty(exports, "octEncodeToVector4", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.octEncodeToVector4;
+  }
+});
+Object.defineProperty(exports, "octPack", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.octPack;
+  }
+});
+Object.defineProperty(exports, "octPackFloat", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.octPackFloat;
+  }
+});
+Object.defineProperty(exports, "octUnpack", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.octUnpack;
+  }
+});
+Object.defineProperty(exports, "zigZagDeltaDecode", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.zigZagDeltaDecode;
+  }
+});
+var _constants = require("./geometry/constants");
+var _glType = _interopRequireDefault(require("./geometry/gl/gl-type"));
+var _isGeometry = _interopRequireDefault(require("./geometry/is-geometry"));
+var _attributeIterator = require("./geometry/iterators/attribute-iterator");
+var _primitiveIterator = require("./geometry/iterators/primitive-iterator");
+var _computeVertexNormals = require("./geometry/attributes/compute-vertex-normals");
+var _rgb = require("./geometry/colors/rgb565");
+var _typedArrayUtils = require("./geometry/typed-arrays/typed-array-utils");
+var _attributeCompression = require("./geometry/compression/attribute-compression");
+//# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_constants","require","_glType","_interopRequireDefault","_isGeometry","_attributeIterator","_primitiveIterator","_computeVertexNormals","_rgb","_typedArrayUtils","_attributeCompression"],"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,IAAAA,UAAA,GAAAC,OAAA;AAIA,IAAAC,OAAA,GAAAC,sBAAA,CAAAF,OAAA;AAGA,IAAAG,WAAA,GAAAD,sBAAA,CAAAF,OAAA;AAGA,IAAAI,kBAAA,GAAAJ,OAAA;AACA,IAAAK,kBAAA,GAAAL,OAAA;AAGA,IAAAM,qBAAA,GAAAN,OAAA;AAEA,IAAAO,IAAA,GAAAP,OAAA;AAGA,IAAAQ,gBAAA,GAAAR,OAAA;AAGA,IAAAS,qBAAA,GAAAT,OAAA"}

package/dist/es5/utils/assert.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assert = assert;
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || '3d-tile loader: assertion failed.');
+  }
+}
+//# sourceMappingURL=assert.js.map

package/dist/es5/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":";;;;;;AAGO,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/esm/geometry/attributes/compute-bounding-box.js

@@ -0,0 +1,28 @@
+import { makeAttributeIterator } from '../iterators/attribute-iterator';
+import { assert } from '../utils/assert';
+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;
+}
+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]));
+}
+//# sourceMappingURL=compute-bounding-box.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compute-bounding-box.js","names":["makeAttributeIterator","assert","computeBoundingBox","positions","arguments","length","undefined","min","Number","Infinity","max","position","x","y","z","boundingBox","validateBoundingBox","isFinite"],"sources":["../../../../src/geometry/attributes/compute-bounding-box.ts"],"sourcesContent":["import {makeAttributeIterator} from '../iterators/attribute-iterator';\nimport {assert} from '../utils/assert';\n\n/**\n * Type for Bounding Box computing\n */\ntype BoundingBox = {\n  min: number[];\n  max: number[];\n};\n/**\n * Getting bounding box geometry according to positions parameters\n * @param positions\n * @returns Bounding Box\n */\nexport function computeBoundingBox(positions: any = []) {\n  const min = [Number(Infinity), Number(Infinity), Number(Infinity)];\n  const max = [-Infinity, -Infinity, -Infinity];\n  // @ts-ignore\n  for (const position of makeAttributeIterator(positions)) {\n    const x = position[0];\n    const y = position[1];\n    const z = position[2];\n\n    if (x < min[0]) min[0] = x;\n    if (y < min[1]) min[1] = y;\n    if (z < min[2]) min[2] = z;\n\n    if (x > max[0]) max[0] = x;\n    if (y > max[1]) max[1] = y;\n    if (z > max[2]) max[2] = z;\n  }\n\n  const boundingBox = {min, max};\n  validateBoundingBox(boundingBox);\n  return boundingBox;\n}\n\nfunction validateBoundingBox(boundingBox: BoundingBox) {\n  assert(\n    Number.isFinite(boundingBox.min[0]) &&\n      Number.isFinite(boundingBox.min[1]) &&\n      Number.isFinite(boundingBox.min[2]) &&\n      Number.isFinite(boundingBox.max[0]) &&\n      Number.isFinite(boundingBox.max[1]) &&\n      Number.isFinite(boundingBox.max[2])\n  );\n}\n"],"mappings":"AAAA,SAAQA,qBAAqB,QAAO,iCAAiC;AACrE,SAAQC,MAAM,QAAO,iBAAiB;AActC,OAAO,SAASC,kBAAkBA,CAAA,EAAsB;EAAA,IAArBC,SAAc,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,EAAE;EACpD,MAAMG,GAAG,GAAG,CAACC,MAAM,CAACC,QAAQ,CAAC,EAAED,MAAM,CAACC,QAAQ,CAAC,EAAED,MAAM,CAACC,QAAQ,CAAC,CAAC;EAClE,MAAMC,GAAG,GAAG,CAAC,CAACD,QAAQ,EAAE,CAACA,QAAQ,EAAE,CAACA,QAAQ,CAAC;EAE7C,KAAK,MAAME,QAAQ,IAAIX,qBAAqB,CAACG,SAAS,CAAC,EAAE;IACvD,MAAMS,CAAC,GAAGD,QAAQ,CAAC,CAAC,CAAC;IACrB,MAAME,CAAC,GAAGF,QAAQ,CAAC,CAAC,CAAC;IACrB,MAAMG,CAAC,GAAGH,QAAQ,CAAC,CAAC,CAAC;IAErB,IAAIC,CAAC,GAAGL,GAAG,CAAC,CAAC,CAAC,EAAEA,GAAG,CAAC,CAAC,CAAC,GAAGK,CAAC;IAC1B,IAAIC,CAAC,GAAGN,GAAG,CAAC,CAAC,CAAC,EAAEA,GAAG,CAAC,CAAC,CAAC,GAAGM,CAAC;IAC1B,IAAIC,CAAC,GAAGP,GAAG,CAAC,CAAC,CAAC,EAAEA,GAAG,CAAC,CAAC,CAAC,GAAGO,CAAC;IAE1B,IAAIF,CAAC,GAAGF,GAAG,CAAC,CAAC,CAAC,EAAEA,GAAG,CAAC,CAAC,CAAC,GAAGE,CAAC;IAC1B,IAAIC,CAAC,GAAGH,GAAG,CAAC,CAAC,CAAC,EAAEA,GAAG,CAAC,CAAC,CAAC,GAAGG,CAAC;IAC1B,IAAIC,CAAC,GAAGJ,GAAG,CAAC,CAAC,CAAC,EAAEA,GAAG,CAAC,CAAC,CAAC,GAAGI,CAAC;EAC5B;EAEA,MAAMC,WAAW,GAAG;IAACR,GAAG;IAAEG;EAAG,CAAC;EAC9BM,mBAAmB,CAACD,WAAW,CAAC;EAChC,OAAOA,WAAW;AACpB;AAEA,SAASC,mBAAmBA,CAACD,WAAwB,EAAE;EACrDd,MAAM,CACJO,MAAM,CAACS,QAAQ,CAACF,WAAW,CAACR,GAAG,CAAC,CAAC,CAAC,CAAC,IACjCC,MAAM,CAACS,QAAQ,CAACF,WAAW,CAACR,GAAG,CAAC,CAAC,CAAC,CAAC,IACnCC,MAAM,CAACS,QAAQ,CAACF,WAAW,CAACR,GAAG,CAAC,CAAC,CAAC,CAAC,IACnCC,MAAM,CAACS,QAAQ,CAACF,WAAW,CAACL,GAAG,CAAC,CAAC,CAAC,CAAC,IACnCF,MAAM,CAACS,QAAQ,CAACF,WAAW,CAACL,GAAG,CAAC,CAAC,CAAC,CAAC,IACnCF,MAAM,CAACS,QAAQ,CAACF,WAAW,CAACL,GAAG,CAAC,CAAC,CAAC,CACtC,CAAC;AACH"}

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

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=compute-bounding-sphere.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compute-bounding-sphere.js","names":[],"sources":["../../../../src/geometry/attributes/compute-bounding-sphere.ts"],"sourcesContent":["/* eslint-disable */\n/**\nimport {getPositions} from './get-attribute-from-geometry';\n\nexport function computeBoundingSphere(geometry: any, boundingBox: object, vector: Vector3 ) {\n  const positions = getPositions(geometry);\n\n  const center = getBoundingBox(center);\n  box.setFromBufferAttribute(position);\n  box.getCenter(center);\n\n  // hoping to find a boundingSphere with a radius smaller than the\n  // boundingSphere of the boundingBox: sqrt(3) smaller in the best case\n\n  var maxRadiusSq = 0;\n\n  for (const position of makeAttributeIterator(positions)) {\n    vector.x = position[0];\n    vector.y = position[1];\n    vector.z = position[2];\n    maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(vector));\n  }\n\n  const radius = Math.sqrt(maxRadiusSq);\n  assert(Number.isFinite(radius));\n\n  return {center, radius};\n}\n*/\n"],"mappings":""}

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

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=compute-tangents.js.map