@loaders.gl/math 3.1.0-alpha.3 → 3.1.0-beta.2

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

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeBoundingBox = computeBoundingBox;
+
+var _attributeIterator = require("../iterators/attribute-iterator");
+
+var _assert = require("../utils/assert");
+
+function computeBoundingBox(positions = []) {
+  const min = [Number(Infinity), Number(Infinity), Number(Infinity)];
+  const max = [-Infinity, -Infinity, -Infinity];
+
+  for (const position of (0, _attributeIterator.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) {
+  (0, _assert.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/es5/geometry/attributes/compute-bounding-box.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/geometry/attributes/compute-bounding-box.ts"],"names":["computeBoundingBox","positions","min","Number","Infinity","max","position","x","y","z","boundingBox","validateBoundingBox","isFinite"],"mappings":";;;;;;;AAAA;;AACA;;AAcO,SAASA,kBAAT,CAA4BC,SAAc,GAAG,EAA7C,EAAiD;AACtD,QAAMC,GAAG,GAAG,CAACC,MAAM,CAACC,QAAD,CAAP,EAAmBD,MAAM,CAACC,QAAD,CAAzB,EAAqCD,MAAM,CAACC,QAAD,CAA3C,CAAZ;AACA,QAAMC,GAAG,GAAG,CAAC,CAACD,QAAF,EAAY,CAACA,QAAb,EAAuB,CAACA,QAAxB,CAAZ;;AAEA,OAAK,MAAME,QAAX,IAAuB,8CAAsBL,SAAtB,CAAvB,EAAyD;AACvD,UAAMM,CAAC,GAAGD,QAAQ,CAAC,CAAD,CAAlB;AACA,UAAME,CAAC,GAAGF,QAAQ,CAAC,CAAD,CAAlB;AACA,UAAMG,CAAC,GAAGH,QAAQ,CAAC,CAAD,CAAlB;AAEA,QAAIC,CAAC,GAAGL,GAAG,CAAC,CAAD,CAAX,EAAgBA,GAAG,CAAC,CAAD,CAAH,GAASK,CAAT;AAChB,QAAIC,CAAC,GAAGN,GAAG,CAAC,CAAD,CAAX,EAAgBA,GAAG,CAAC,CAAD,CAAH,GAASM,CAAT;AAChB,QAAIC,CAAC,GAAGP,GAAG,CAAC,CAAD,CAAX,EAAgBA,GAAG,CAAC,CAAD,CAAH,GAASO,CAAT;AAEhB,QAAIF,CAAC,GAAGF,GAAG,CAAC,CAAD,CAAX,EAAgBA,GAAG,CAAC,CAAD,CAAH,GAASE,CAAT;AAChB,QAAIC,CAAC,GAAGH,GAAG,CAAC,CAAD,CAAX,EAAgBA,GAAG,CAAC,CAAD,CAAH,GAASG,CAAT;AAChB,QAAIC,CAAC,GAAGJ,GAAG,CAAC,CAAD,CAAX,EAAgBA,GAAG,CAAC,CAAD,CAAH,GAASI,CAAT;AACjB;;AAED,QAAMC,WAAW,GAAG;AAACR,IAAAA,GAAD;AAAMG,IAAAA;AAAN,GAApB;AACAM,EAAAA,mBAAmB,CAACD,WAAD,CAAnB;AACA,SAAOA,WAAP;AACD;;AAED,SAASC,mBAAT,CAA6BD,WAA7B,EAAuD;AACrD,sBACEP,MAAM,CAACS,QAAP,CAAgBF,WAAW,CAACR,GAAZ,CAAgB,CAAhB,CAAhB,KACEC,MAAM,CAACS,QAAP,CAAgBF,WAAW,CAACR,GAAZ,CAAgB,CAAhB,CAAhB,CADF,IAEEC,MAAM,CAACS,QAAP,CAAgBF,WAAW,CAACR,GAAZ,CAAgB,CAAhB,CAAhB,CAFF,IAGEC,MAAM,CAACS,QAAP,CAAgBF,WAAW,CAACL,GAAZ,CAAgB,CAAhB,CAAhB,CAHF,IAIEF,MAAM,CAACS,QAAP,CAAgBF,WAAW,CAACL,GAAZ,CAAgB,CAAhB,CAAhB,CAJF,IAKEF,MAAM,CAACS,QAAP,CAAgBF,WAAW,CAACL,GAAZ,CAAgB,CAAhB,CAAhB,CANJ;AAQD","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"],"file":"compute-bounding-box.js"}

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

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

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

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

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

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeVertexNormals = computeVertexNormals;
+
+var _core = require("@math.gl/core");
+
+var _constants = require("../constants");
+
+var _assert = require("../utils/assert");
+
+var _primitiveIterator = require("../iterators/primitive-iterator");
+
+var _modes = require("../primitives/modes");
+
+var _getAttributeFromGeometry = require("./get-attribute-from-geometry");
+
+function computeVertexNormals(geometry) {
+  (0, _assert.assert)((0, _modes.getPrimitiveModeType)(geometry.mode) === _constants.GL.TRIANGLES, 'TRIANGLES required');
+  const {
+    values: positions
+  } = (0, _getAttributeFromGeometry.getPositions)(geometry);
+  const normals = new Float32Array(positions.length);
+  const vectorA = new _core.Vector3();
+  const vectorB = new _core.Vector3();
+  const vectorC = new _core.Vector3();
+  const vectorCB = new _core.Vector3();
+  const vectorAB = new _core.Vector3();
+
+  for (const primitive of (0, _primitiveIterator.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;
+}
+//# sourceMappingURL=compute-vertex-normals.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/geometry/attributes/compute-vertex-normals.ts"],"names":["computeVertexNormals","geometry","mode","GL","TRIANGLES","values","positions","normals","Float32Array","length","vectorA","Vector3","vectorB","vectorC","vectorCB","vectorAB","primitive","fromArray","i1","i2","i3","subVectors","normal","cross","normalize","primitiveIndex","x","y","z"],"mappings":";;;;;;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAaO,SAASA,oBAAT,CAA8BC,QAA9B,EAAgE;AAErE,sBAAO,iCAAqBA,QAAQ,CAACC,IAA9B,MAAwCC,cAAGC,SAAlD,EAA6D,oBAA7D;AAEA,QAAM;AAACC,IAAAA,MAAM,EAAEC;AAAT,MAAsB,4CAAaL,QAAb,CAA5B;AAEA,QAAMM,OAAO,GAAG,IAAIC,YAAJ,CAAiBF,SAAS,CAACG,MAA3B,CAAhB;AAEA,QAAMC,OAAO,GAAG,IAAIC,aAAJ,EAAhB;AACA,QAAMC,OAAO,GAAG,IAAID,aAAJ,EAAhB;AACA,QAAME,OAAO,GAAG,IAAIF,aAAJ,EAAhB;AAEA,QAAMG,QAAQ,GAAG,IAAIH,aAAJ,EAAjB;AACA,QAAMI,QAAQ,GAAG,IAAIJ,aAAJ,EAAjB;;AAEA,OAAK,MAAMK,SAAX,IAAwB,8CAAsBf,QAAtB,CAAxB,EAAyD;AACvDS,IAAAA,OAAO,CAACO,SAAR,CAAkBX,SAAlB,EAA6BU,SAAS,CAACE,EAAV,GAAe,CAA5C;AACAN,IAAAA,OAAO,CAACK,SAAR,CAAkBX,SAAlB,EAA6BU,SAAS,CAACG,EAAV,GAAe,CAAf,GAAmB,CAAhD;AACAN,IAAAA,OAAO,CAACI,SAAR,CAAkBX,SAAlB,EAA6BU,SAAS,CAACI,EAAV,GAAe,CAAf,GAAmB,CAAhD;AAEAN,IAAAA,QAAQ,CAACO,UAAT,CAAoBR,OAApB,EAA6BD,OAA7B;AACAG,IAAAA,QAAQ,CAACM,UAAT,CAAoBX,OAApB,EAA6BE,OAA7B;AACA,UAAMU,MAAM,GAAGR,QAAQ,CAACS,KAAT,CAAeR,QAAf,CAAf;AACAO,IAAAA,MAAM,CAACE,SAAP;AAEA,UAAM;AAACC,MAAAA;AAAD,QAAmBT,SAAzB;AAEAT,IAAAA,OAAO,CAACkB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACI,CAAzC;AACAnB,IAAAA,OAAO,CAACkB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACK,CAAzC;AACApB,IAAAA,OAAO,CAACkB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACM,CAAzC;AAEArB,IAAAA,OAAO,CAACkB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACI,CAAzC;AACAnB,IAAAA,OAAO,CAACkB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACK,CAAzC;AACApB,IAAAA,OAAO,CAACkB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACM,CAAzC;AAEArB,IAAAA,OAAO,CAACkB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACI,CAAzC;AACAnB,IAAAA,OAAO,CAACkB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACK,CAAzC;AACApB,IAAAA,OAAO,CAACkB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACM,CAAzC;AACD;;AAED,SAAOrB,OAAP;AACD","sourcesContent":["import type {TypedArray} from '../types';\nimport {Vector3} from '@math.gl/core';\nimport {GL} from '../constants';\nimport {assert} from '../utils/assert';\nimport {makePrimitiveIterator} from '../iterators/primitive-iterator';\nimport {getPrimitiveModeType} from '../primitives/modes';\nimport {getPositions} from './get-attribute-from-geometry';\n\ntype Geometry = {\n  mode: any;\n  indices?: {size: number; values: TypedArray};\n  attributes?: {};\n};\n/**\n * Computes vertex normals for a geometry\n * @param param0\n * @returns\n */\n// eslint-disable-next-line max-statements\nexport function computeVertexNormals(geometry: Geometry): Float32Array {\n  // Only support GL.TRIANGLES, GL.TRIANGLE_STRIP, GL.TRIANGLE_FAN\n  assert(getPrimitiveModeType(geometry.mode) === GL.TRIANGLES, 'TRIANGLES required');\n\n  const {values: positions} = getPositions(geometry);\n\n  const normals = new Float32Array(positions.length);\n\n  const vectorA = new Vector3();\n  const vectorB = new Vector3();\n  const vectorC = new Vector3();\n\n  const vectorCB = new Vector3();\n  const vectorAB = new Vector3();\n\n  for (const primitive of makePrimitiveIterator(geometry)) {\n    vectorA.fromArray(positions, primitive.i1 * 3);\n    vectorB.fromArray(positions, primitive.i2 * 3 + 3);\n    vectorC.fromArray(positions, primitive.i3 * 3 + 6);\n\n    vectorCB.subVectors(vectorC, vectorB);\n    vectorAB.subVectors(vectorA, vectorB);\n    const normal = vectorCB.cross(vectorAB);\n    normal.normalize();\n    // @ts-ignore\n    const {primitiveIndex} = primitive;\n\n    normals[primitiveIndex * 9 + 0] = normal.x;\n    normals[primitiveIndex * 9 + 1] = normal.y;\n    normals[primitiveIndex * 9 + 2] = normal.z;\n\n    normals[primitiveIndex * 9 + 3] = normal.x;\n    normals[primitiveIndex * 9 + 4] = normal.y;\n    normals[primitiveIndex * 9 + 5] = normal.z;\n\n    normals[primitiveIndex * 9 + 6] = normal.x;\n    normals[primitiveIndex * 9 + 7] = normal.y;\n    normals[primitiveIndex * 9 + 8] = normal.z;\n  }\n\n  return normals;\n}\n"],"file":"compute-vertex-normals.js"}

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

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertBuffersToNonIndexed = convertBuffersToNonIndexed;
+
+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));
+  }
+
+  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/es5/geometry/attributes/convert-to-non-indexed.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/geometry/attributes/convert-to-non-indexed.ts"],"names":["convertBuffersToNonIndexed","indices","attributes","geometry2","BufferGeometry","name","attribute","array","itemSize","array2","constructor","length","index","index2","i","l","j","addAttribute","BufferAttribute","group","groups","addGroup","start","count","materialIndex"],"mappings":";;;;;;;AAQO,SAASA,0BAAT,CAAoC;AAACC,EAAAA,OAAD;AAAUC,EAAAA;AAAV,CAApC,EAAgE;AACrE,QAAMC,SAAS,GAAG,IAAIC,cAAJ,EAAlB;;AAEA,OAAK,MAAMC,IAAX,IAAmBH,UAAnB,EAA+B;AAC7B,UAAMI,SAAS,GAAGJ,UAAU,CAACG,IAAD,CAA5B;AAEA,UAAME,KAAK,GAAGD,SAAS,CAACC,KAAxB;AACA,UAAMC,QAAQ,GAAGF,SAAS,CAACE,QAA3B;AAEA,UAAMC,MAAM,GAAG,IAAIF,KAAK,CAACG,WAAV,CAAsBT,OAAO,CAACU,MAAR,GAAiBH,QAAvC,CAAf;AACA,QAAII,KAAK,GAAG,CAAZ;AAAA,QACEC,MAAM,GAAG,CADX;;AAGA,SAAK,IAAIC,CAAC,GAAG,CAAR,EAAWC,CAAC,GAAGd,OAAO,CAACU,MAA5B,EAAoCG,CAAC,GAAGC,CAAxC,EAA2CD,CAAC,EAA5C,EAAgD;AAC9CF,MAAAA,KAAK,GAAGX,OAAO,CAACa,CAAD,CAAP,GAAaN,QAArB;;AACA,WAAK,IAAIQ,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGR,QAApB,EAA8BQ,CAAC,EAA/B,EAAmC;AACjCP,QAAAA,MAAM,CAACI,MAAM,EAAP,CAAN,GAAmBN,KAAK,CAACK,KAAK,EAAN,CAAxB;AACD;AACF;;AACDT,IAAAA,SAAS,CAACc,YAAV,CAAuBZ,IAAvB,EAA6B,IAAIa,eAAJ,CAAoBT,MAApB,EAA4BD,QAA5B,CAA7B;AACD;;AAED,OAAK,MAAMW,KAAX,IAAoB,KAAKC,MAAzB,EAAiC;AAC/BjB,IAAAA,SAAS,CAACkB,QAAV,CAAmBF,KAAK,CAACG,KAAzB,EAAgCH,KAAK,CAACI,KAAtC,EAA6CJ,KAAK,CAACK,aAAnD;AACD;;AAED,SAAOrB,SAAP;AACD","sourcesContent":["/* eslint-disable */\n// @ts-nocheck\n/**\n * Converts indices of geometry.\n *\n * @param param0\n * @returns no indexed geometry\n */\nexport function convertBuffersToNonIndexed({indices, attributes}): any {\n  const geometry2 = new BufferGeometry();\n\n  for (const name in attributes) {\n    const attribute = attributes[name];\n\n    const array = attribute.array;\n    const itemSize = attribute.itemSize;\n\n    const array2 = new array.constructor(indices.length * itemSize);\n    let index = 0,\n      index2 = 0;\n\n    for (var i = 0, l = indices.length; i < l; i++) {\n      index = indices[i] * itemSize;\n      for (var j = 0; j < itemSize; j++) {\n        array2[index2++] = array[index++];\n      }\n    }\n    geometry2.addAttribute(name, new BufferAttribute(array2, itemSize));\n  }\n\n  for (const group of this.groups) {\n    geometry2.addGroup(group.start, group.count, group.materialIndex);\n  }\n\n  return geometry2;\n}\n"],"file":"convert-to-non-indexed.js"}

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

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPositions = getPositions;
+
+var _isGeometry = _interopRequireDefault(require("../is-geometry"));
+
+var _assert = require("../utils/assert");
+
+function getPositions(geometry) {
+  if ((0, _isGeometry.default)(geometry)) {
+    const {
+      attributes
+    } = geometry;
+    const position = attributes.POSITION || attributes.positions;
+    (0, _assert.assert)(position);
+    return position;
+  }
+
+  if (ArrayBuffer.isView(geometry)) {
+    return {
+      values: geometry,
+      size: 3
+    };
+  }
+
+  if (geometry) {
+    (0, _assert.assert)(geometry.values);
+    return geometry;
+  }
+
+  return (0, _assert.assert)(false);
+}
+//# sourceMappingURL=get-attribute-from-geometry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/geometry/attributes/get-attribute-from-geometry.ts"],"names":["getPositions","geometry","attributes","position","POSITION","positions","ArrayBuffer","isView","values","size"],"mappings":";;;;;;;;;AAAA;;AACA;;AASO,SAASA,YAAT,CAAsBC,QAAtB,EAAqC;AAE1C,MAAI,yBAAWA,QAAX,CAAJ,EAA0B;AACxB,UAAM;AAACC,MAAAA;AAAD,QAAeD,QAArB;AACA,UAAME,QAAQ,GAAGD,UAAU,CAACE,QAAX,IAAuBF,UAAU,CAACG,SAAnD;AACA,wBAAOF,QAAP;AACA,WAAOA,QAAP;AACD;;AAGD,MAAIG,WAAW,CAACC,MAAZ,CAAmBN,QAAnB,CAAJ,EAAkC;AAChC,WAAO;AAACO,MAAAA,MAAM,EAAEP,QAAT;AAAmBQ,MAAAA,IAAI,EAAE;AAAzB,KAAP;AACD;;AAGD,MAAIR,QAAJ,EAAc;AACZ,wBAAOA,QAAQ,CAACO,MAAhB;AACA,WAAOP,QAAP;AACD;;AAED,SAAO,oBAAO,KAAP,CAAP;AACD","sourcesContent":["import isGeometry from '../is-geometry';\nimport {assert} from '../utils/assert';\n\n/**\n * analyze positions of geometry\n *\n * @param geometry\n * @returns Position| New geometry |assert\n */\n\nexport function getPositions(geometry: any) {\n  // If geometry, extract positions\n  if (isGeometry(geometry)) {\n    const {attributes} = geometry;\n    const position = attributes.POSITION || attributes.positions;\n    assert(position);\n    return position;\n  }\n\n  // If arraybuffer, assume 3 components\n  if (ArrayBuffer.isView(geometry)) {\n    return {values: geometry, size: 3};\n  }\n\n  // Else assume accessor object\n  if (geometry) {\n    assert(geometry.values);\n    return geometry;\n  }\n\n  return assert(false);\n}\n"],"file":"get-attribute-from-geometry.js"}

package/dist/es5/geometry/attributes/normalize.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalize = normalize;
+
+function normalize(normals = {}, vector) {
+  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/es5/geometry/attributes/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/geometry/attributes/normalize.ts"],"names":["normalize","normals","vector","attributes","normal","i","il","count","x","getX","y","getY","z","getZ","setXYZ"],"mappings":";;;;;;;AAQO,SAASA,SAAT,CAAmBC,OAAY,GAAG,EAAlC,EAAsCC,MAAtC,EAAuD;AAE5DD,EAAAA,OAAO,GAAG,KAAKE,UAAL,CAAgBC,MAA1B;;AACA,OAAK,IAAIC,CAAC,GAAG,CAAR,EAAWC,EAAE,GAAGL,OAAO,CAACM,KAA7B,EAAoCF,CAAC,GAAGC,EAAxC,EAA4CD,CAAC,EAA7C,EAAiD;AAC/CH,IAAAA,MAAM,CAACM,CAAP,GAAWP,OAAO,CAACQ,IAAR,CAAaJ,CAAb,CAAX;AACAH,IAAAA,MAAM,CAACQ,CAAP,GAAWT,OAAO,CAACU,IAAR,CAAaN,CAAb,CAAX;AACAH,IAAAA,MAAM,CAACU,CAAP,GAAWX,OAAO,CAACY,IAAR,CAAaR,CAAb,CAAX;AACAH,IAAAA,MAAM,CAACF,SAAP;AACAC,IAAAA,OAAO,CAACa,MAAR,CAAeT,CAAf,EAAkBH,MAAM,CAACM,CAAzB,EAA4BN,MAAM,CAACQ,CAAnC,EAAsCR,MAAM,CAACU,CAA7C;AACD;AACF","sourcesContent":["/* eslint-disable */\nimport {Vector3} from '@math.gl/core';\n\n/**\n * Setting X, Y, Z for Vector\n * @param normals\n * @param vector\n */\nexport function normalize(normals: any = {}, vector: Vector3) {\n  //@ts-ignore\n  normals = this.attributes.normal;\n  for (let i = 0, il = normals.count; i < il; i++) {\n    vector.x = normals.getX(i);\n    vector.y = normals.getY(i);\n    vector.z = normals.getZ(i);\n    vector.normalize();\n    normals.setXYZ(i, vector.x, vector.y, vector.z);\n  }\n}\n"],"file":"normalize.js"}

package/dist/es5/geometry/colors/rgb565.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decodeRGB565 = decodeRGB565;
+exports.encodeRGB565 = encodeRGB565;
+
+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;
+}
+
+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);
+}
+//# sourceMappingURL=rgb565.js.map

package/dist/es5/geometry/colors/rgb565.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/geometry/colors/rgb565.ts"],"names":["decodeRGB565","rgb565","target","r5","g6","b5","encodeRGB565","rgb","Math","floor"],"mappings":";;;;;;;;AAMO,SAASA,YAAT,CAAsBC,MAAtB,EAAsCC,MAAgB,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAzD,EAA8E;AACnF,QAAMC,EAAE,GAAIF,MAAM,IAAI,EAAX,GAAiB,EAA5B;AACA,QAAMG,EAAE,GAAIH,MAAM,IAAI,CAAX,GAAgB,EAA3B;AACA,QAAMI,EAAE,GAAGJ,MAAM,GAAG,EAApB;AAEAC,EAAAA,MAAM,CAAC,CAAD,CAAN,GAAYC,EAAE,IAAI,CAAlB;AACAD,EAAAA,MAAM,CAAC,CAAD,CAAN,GAAYE,EAAE,IAAI,CAAlB;AACAF,EAAAA,MAAM,CAAC,CAAD,CAAN,GAAYG,EAAE,IAAI,CAAlB;AAEA,SAAOH,MAAP;AACD;;AAOM,SAASI,YAAT,CAAsBC,GAAtB,EAA6C;AAClD,QAAMJ,EAAE,GAAGK,IAAI,CAACC,KAAL,CAAWF,GAAG,CAAC,CAAD,CAAH,GAAS,CAApB,IAAyB,CAApC;AACA,QAAMH,EAAE,GAAGI,IAAI,CAACC,KAAL,CAAWF,GAAG,CAAC,CAAD,CAAH,GAAS,CAApB,IAAyB,CAApC;AACA,QAAMF,EAAE,GAAGG,IAAI,CAACC,KAAL,CAAWF,GAAG,CAAC,CAAD,CAAH,GAAS,CAApB,IAAyB,CAApC;AACA,SAAOJ,EAAE,IAAIC,EAAE,IAAI,CAAV,CAAF,IAAkBC,EAAE,IAAI,EAAxB,CAAP;AACD","sourcesContent":["/**\n * Decode color values\n * @param rgb565\n * @param target\n * @returns target\n */\nexport function decodeRGB565(rgb565: number, target: number[] = [0, 0, 0]): number[] {\n  const r5 = (rgb565 >> 11) & 31;\n  const g6 = (rgb565 >> 5) & 63;\n  const b5 = rgb565 & 31;\n\n  target[0] = r5 << 3;\n  target[1] = g6 << 2;\n  target[2] = b5 << 3;\n\n  return target;\n}\n\n/**\n * Encode color values\n * @param rgb\n * @returns color\n */\nexport function encodeRGB565(rgb: number[]): number {\n  const r5 = Math.floor(rgb[0] / 8) + 4;\n  const g6 = Math.floor(rgb[1] / 4) + 2;\n  const b5 = Math.floor(rgb[2] / 8) + 4;\n  return r5 + (g6 << 5) + (b5 << 11);\n}\n"],"file":"rgb565.js"}

package/dist/es5/geometry/compression/attribute-compression.js

@@ -0,0 +1,210 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.octEncodeInRange = octEncodeInRange;
+exports.octEncode = octEncode;
+exports.octEncodeToVector4 = octEncodeToVector4;
+exports.octDecodeInRange = octDecodeInRange;
+exports.octDecode = octDecode;
+exports.octDecodeFromVector4 = octDecodeFromVector4;
+exports.octPackFloat = octPackFloat;
+exports.octEncodeFloat = octEncodeFloat;
+exports.octDecodeFloat = octDecodeFloat;
+exports.octPack = octPack;
+exports.octUnpack = octUnpack;
+exports.compressTextureCoordinates = compressTextureCoordinates;
+exports.decompressTextureCoordinates = decompressTextureCoordinates;
+exports.zigZagDeltaDecode = zigZagDeltaDecode;
+
+var _core = require("@math.gl/core");
+
+var _assert = require("../utils/assert");
+
+const RIGHT_SHIFT = 1.0 / 256.0;
+const LEFT_SHIFT = 256.0;
+const scratchVector2 = new _core.Vector2();
+const scratchVector3 = new _core.Vector3();
+const scratchEncodeVector2 = new _core.Vector2();
+const octEncodeScratch = new _core.Vector2();
+const uint8ForceArray = new Uint8Array(1);
+
+function forceUint8(value) {
+  uint8ForceArray[0] = value;
+  return uint8ForceArray[0];
+}
+
+function fromSNorm(value, rangeMaximum = 255) {
+  return (0, _core.clamp)(value, 0.0, rangeMaximum) / rangeMaximum * 2.0 - 1.0;
+}
+
+function toSNorm(value, rangeMaximum = 255) {
+  return Math.round(((0, _core.clamp)(value, -1.0, 1.0) * 0.5 + 0.5) * rangeMaximum);
+}
+
+function signNotZero(value) {
+  return value < 0.0 ? -1.0 : 1.0;
+}
+
+function octEncodeInRange(vector, rangeMax, result) {
+  (0, _assert.assert)(vector);
+  (0, _assert.assert)(result);
+  const vector3 = scratchVector3.from(vector);
+  (0, _assert.assert)(Math.abs(vector3.magnitudeSquared() - 1.0) <= _core._MathUtils.EPSILON6);
+  result.x = vector.x / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
+  result.y = vector.y / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
+
+  if (vector.z < 0) {
+    const x = result.x;
+    const y = result.y;
+    result.x = (1.0 - Math.abs(y)) * signNotZero(x);
+    result.y = (1.0 - Math.abs(x)) * signNotZero(y);
+  }
+
+  result.x = toSNorm(result.x, rangeMax);
+  result.y = toSNorm(result.y, rangeMax);
+  return result;
+}
+
+function octEncode(vector, result) {
+  return octEncodeInRange(vector, 255, result);
+}
+
+function octEncodeToVector4(vector, result) {
+  octEncodeInRange(vector, 65535, octEncodeScratch);
+  result.x = forceUint8(octEncodeScratch.x * RIGHT_SHIFT);
+  result.y = forceUint8(octEncodeScratch.x);
+  result.z = forceUint8(octEncodeScratch.y * RIGHT_SHIFT);
+  result.w = forceUint8(octEncodeScratch.y);
+  return result;
+}
+
+function octDecodeInRange(x, y, rangeMax, result) {
+  (0, _assert.assert)(result);
+
+  if (x < 0 || x > rangeMax || y < 0 || y > rangeMax) {
+    throw new Error("x and y must be unsigned normalized integers between 0 and ".concat(rangeMax));
+  }
+
+  result.x = fromSNorm(x, rangeMax);
+  result.y = fromSNorm(y, rangeMax);
+  result.z = 1.0 - (Math.abs(result.x) + Math.abs(result.y));
+
+  if (result.z < 0.0) {
+    const oldVX = result.x;
+    result.x = (1.0 - Math.abs(result.y)) * signNotZero(oldVX);
+    result.y = (1.0 - Math.abs(oldVX)) * signNotZero(result.y);
+  }
+
+  return result.normalize();
+}
+
+function octDecode(x, y, result) {
+  return octDecodeInRange(x, y, 255, result);
+}
+
+function octDecodeFromVector4(encoded, result) {
+  (0, _assert.assert)(encoded);
+  (0, _assert.assert)(result);
+  const x = encoded.x;
+  const y = encoded.y;
+  const z = encoded.z;
+  const w = encoded.w;
+
+  if (x < 0 || x > 255 || y < 0 || y > 255 || z < 0 || z > 255 || w < 0 || w > 255) {
+    throw new Error('x, y, z, and w must be unsigned normalized integers between 0 and 255');
+  }
+
+  const xOct16 = x * LEFT_SHIFT + y;
+  const yOct16 = z * LEFT_SHIFT + w;
+  return octDecodeInRange(xOct16, yOct16, 65535, result);
+}
+
+function octPackFloat(encoded) {
+  const vector2 = scratchVector2.from(encoded);
+  return 256.0 * vector2.x + vector2.y;
+}
+
+function octEncodeFloat(vector) {
+  octEncode(vector, scratchEncodeVector2);
+  return octPackFloat(scratchEncodeVector2);
+}
+
+function octDecodeFloat(value, result) {
+  (0, _assert.assert)(Number.isFinite(value));
+  const temp = value / 256.0;
+  const x = Math.floor(temp);
+  const y = (temp - x) * 256.0;
+  return octDecode(x, y, result);
+}
+
+function octPack(v1, v2, v3, result) {
+  (0, _assert.assert)(v1);
+  (0, _assert.assert)(v2);
+  (0, _assert.assert)(v3);
+  (0, _assert.assert)(result);
+  const encoded1 = octEncodeFloat(v1);
+  const encoded2 = octEncodeFloat(v2);
+  const encoded3 = octEncode(v3, scratchEncodeVector2);
+  result.x = 65536.0 * encoded3.x + encoded1;
+  result.y = 65536.0 * encoded3.y + encoded2;
+  return result;
+}
+
+function octUnpack(packed, v1, v2, v3) {
+  let temp = packed.x / 65536.0;
+  const x = Math.floor(temp);
+  const encodedFloat1 = (temp - x) * 65536.0;
+  temp = packed.y / 65536.0;
+  const y = Math.floor(temp);
+  const encodedFloat2 = (temp - y) * 65536.0;
+  octDecodeFloat(encodedFloat1, v1);
+  octDecodeFloat(encodedFloat2, v2);
+  octDecode(x, y, v3);
+}
+
+function compressTextureCoordinates(textureCoordinates) {
+  const x = textureCoordinates.x * 4095.0 | 0;
+  const y = textureCoordinates.y * 4095.0 | 0;
+  return 4096.0 * x + y;
+}
+
+function decompressTextureCoordinates(compressed, result) {
+  const temp = compressed / 4096.0;
+  const xZeroTo4095 = Math.floor(temp);
+  result.x = xZeroTo4095 / 4095.0;
+  result.y = (compressed - xZeroTo4095 * 4096) / 4095;
+  return result;
+}
+
+function zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer) {
+  (0, _assert.assert)(uBuffer);
+  (0, _assert.assert)(vBuffer);
+  (0, _assert.assert)(uBuffer.length === vBuffer.length);
+
+  if (heightBuffer) {
+    (0, _assert.assert)(uBuffer.length === heightBuffer.length);
+  }
+
+  function zigZagDecode(value) {
+    return value >> 1 ^ -(value & 1);
+  }
+
+  let u = 0;
+  let v = 0;
+  let height = 0;
+
+  for (let i = 0; i < uBuffer.length; ++i) {
+    u += zigZagDecode(uBuffer[i]);
+    v += zigZagDecode(vBuffer[i]);
+    uBuffer[i] = u;
+    vBuffer[i] = v;
+
+    if (heightBuffer) {
+      height += zigZagDecode(heightBuffer[i]);
+      heightBuffer[i] = height;
+    }
+  }
+}
+//# sourceMappingURL=attribute-compression.js.map

package/dist/es5/geometry/compression/attribute-compression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/geometry/compression/attribute-compression.ts"],"names":["RIGHT_SHIFT","LEFT_SHIFT","scratchVector2","Vector2","scratchVector3","Vector3","scratchEncodeVector2","octEncodeScratch","uint8ForceArray","Uint8Array","forceUint8","value","fromSNorm","rangeMaximum","toSNorm","Math","round","signNotZero","octEncodeInRange","vector","rangeMax","result","vector3","from","abs","magnitudeSquared","_MathUtils","EPSILON6","x","y","z","octEncode","octEncodeToVector4","w","octDecodeInRange","Error","oldVX","normalize","octDecode","octDecodeFromVector4","encoded","xOct16","yOct16","octPackFloat","vector2","octEncodeFloat","octDecodeFloat","Number","isFinite","temp","floor","octPack","v1","v2","v3","encoded1","encoded2","encoded3","octUnpack","packed","encodedFloat1","encodedFloat2","compressTextureCoordinates","textureCoordinates","decompressTextureCoordinates","compressed","xZeroTo4095","zigZagDeltaDecode","uBuffer","vBuffer","heightBuffer","length","zigZagDecode","u","v","height","i"],"mappings":"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","sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\n// Attribute compression and decompression functions.\n\nimport {Vector2, Vector3, clamp, _MathUtils} from '@math.gl/core';\nimport {Vector4} from '../types';\nimport {assert} from '../utils/assert';\n\nconst RIGHT_SHIFT = 1.0 / 256.0;\nconst LEFT_SHIFT = 256.0;\n\nconst scratchVector2 = new Vector2();\nconst scratchVector3 = new Vector3();\nconst scratchEncodeVector2 = new Vector2();\nconst octEncodeScratch = new Vector2();\n\nconst uint8ForceArray = new Uint8Array(1);\n\n/**\n * Force a value to Uint8\n *\n * @param value\n * @returns\n */\nfunction forceUint8(value: number): number {\n  uint8ForceArray[0] = value;\n  return uint8ForceArray[0];\n}\n\n/**\n * Converts a SNORM value in the range [0, rangeMaximum] to a scalar in the range [-1.0, 1.0].\n *\n * @param value SNORM value in the range [0, rangeMaximum]\n * @param [rangeMaximum=255] The maximum value in the SNORM range, 255 by default.\n * @returns Scalar in the range [-1.0, 1.0].\n *\n * @see CesiumMath.toSNorm\n */\nfunction fromSNorm(value: number, rangeMaximum = 255): number {\n  return (clamp(value, 0.0, rangeMaximum) / rangeMaximum) * 2.0 - 1.0;\n}\n\n/**\n * Converts a scalar value in the range [-1.0, 1.0] to a SNORM in the range [0, rangeMaximum].\n *\n * @param value The scalar value in the range [-1.0, 1.0]\n * @param [rangeMaximum=255] The maximum value in the mapped range, 255 by default.\n * @returns A SNORM value, where 0 maps to -1.0 and rangeMaximum maps to 1.0.\n *\n * @see CesiumMath.fromSNorm\n */\nfunction toSNorm(value: number, rangeMaximum = 255): number {\n  return Math.round((clamp(value, -1.0, 1.0) * 0.5 + 0.5) * rangeMaximum);\n}\n\n/**\n * Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative.\n * This is similar to `Math.sign` except that returns 1.0 instead of\n * 0.0 when the input value is 0.0.\n *\n * @param value The value to return the sign of.\n * @returns The sign of value.\n */\nfunction signNotZero(value: number): number {\n  return value < 0.0 ? -1.0 : 1.0;\n}\n\n/**\n * Encodes a normalized vector into 2 SNORM values in the range of [0-rangeMax] following the 'oct' encoding.\n *\n * Oct encoding is a compact representation of unit length vectors.\n * The 'oct' encoding is described in \"A Survey of Efficient Representations of Independent Unit Vectors\",\n * Cigolle et al 2014: {@link http://jcgt.org/published/0003/02/01/}\n *\n * @param vector The normalized vector to be compressed into 2 component 'oct' encoding.\n * @param result The 2 component oct-encoded unit length vector.\n * @param rangeMax The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.\n * @returns The 2 component oct-encoded unit length vector.\n *\n * @exception vector must be normalized.\n *\n * @see octDecodeInRange\n */\nexport function octEncodeInRange(vector: Vector3, rangeMax: number, result: Vector2): Vector2 {\n  assert(vector);\n  assert(result);\n\n  const vector3 = scratchVector3.from(vector);\n\n  assert(Math.abs(vector3.magnitudeSquared() - 1.0) <= _MathUtils.EPSILON6);\n\n  result.x = vector.x / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));\n  result.y = vector.y / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));\n\n  if (vector.z < 0) {\n    const x = result.x;\n    const y = result.y;\n    result.x = (1.0 - Math.abs(y)) * signNotZero(x);\n    result.y = (1.0 - Math.abs(x)) * signNotZero(y);\n  }\n\n  result.x = toSNorm(result.x, rangeMax);\n  result.y = toSNorm(result.y, rangeMax);\n\n  return result;\n}\n\n/**\n * Encodes a normalized vector into 2 SNORM values in the range of [0-255] following the 'oct' encoding.\n *\n * @param vector The normalized vector to be compressed into 2 byte 'oct' encoding.\n * @param result The 2 byte oct-encoded unit length vector.\n * @returns he 2 byte oct-encoded unit length vector.\n *\n * @exception vector must be normalized.\n *\n * @see octEncodeInRange\n * @see octDecode\n */\nexport function octEncode(vector: Vector3, result: Vector2): Vector2 {\n  return octEncodeInRange(vector, 255, result);\n}\n\n/**\n * Encodes a normalized vector into 4-byte vector\n * @param vector The normalized vector to be compressed into 4 byte 'oct' encoding.\n * @param result The 4 byte oct-encoded unit length vector.\n * @returns The 4 byte oct-encoded unit length vector.\n *\n * @exception vector must be normalized.\n *\n * @see octEncodeInRange\n * @see octDecodeFromVector4\n */\nexport function octEncodeToVector4(vector: Vector3, result: Vector4): Vector4 {\n  octEncodeInRange(vector, 65535, octEncodeScratch);\n  result.x = forceUint8(octEncodeScratch.x * RIGHT_SHIFT);\n  result.y = forceUint8(octEncodeScratch.x);\n  result.z = forceUint8(octEncodeScratch.y * RIGHT_SHIFT);\n  result.w = forceUint8(octEncodeScratch.y);\n  return result;\n}\n\n/**\n * Decodes a unit-length vector in 'oct' encoding to a normalized 3-component vector.\n *\n * @param x The x component of the oct-encoded unit length vector.\n * @param y The y component of the oct-encoded unit length vector.\n * @param rangeMax The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.\n * @param result The decoded and normalized vector\n * @returns The decoded and normalized vector.\n *\n * @exception x and y must be unsigned normalized integers between 0 and rangeMax.\n *\n * @see octEncodeInRange\n */\nexport function octDecodeInRange(x: number, y: number, rangeMax: number, result: Vector3): Vector3 {\n  assert(result);\n  if (x < 0 || x > rangeMax || y < 0 || y > rangeMax) {\n    throw new Error(`x and y must be unsigned normalized integers between 0 and ${rangeMax}`);\n  }\n\n  result.x = fromSNorm(x, rangeMax);\n  result.y = fromSNorm(y, rangeMax);\n  result.z = 1.0 - (Math.abs(result.x) + Math.abs(result.y));\n\n  if (result.z < 0.0) {\n    const oldVX = result.x;\n    result.x = (1.0 - Math.abs(result.y)) * signNotZero(oldVX);\n    result.y = (1.0 - Math.abs(oldVX)) * signNotZero(result.y);\n  }\n\n  return result.normalize();\n}\n\n/**\n * Decodes a unit-length vector in 2 byte 'oct' encoding to a normalized 3-component vector.\n *\n * @param x The x component of the oct-encoded unit length vector.\n * @param y The y component of the oct-encoded unit length vector.\n * @param result The decoded and normalized vector.\n * @returns he decoded and normalized vector.\n *\n * @exception x and y must be an unsigned normalized integer between 0 and 255.\n *\n * @see octDecodeInRange\n */\nexport function octDecode(x: number, y: number, result: Vector3): Vector3 {\n  return octDecodeInRange(x, y, 255, result);\n}\n\n/**\n * Decodes a unit-length vector in 4 byte 'oct' encoding to a normalized 3-component vector.\n *\n * @param encoded The oct-encoded unit length vector.\n * @param esult The decoded and normalized vector.\n * @returns The decoded and normalized vector.\n *\n * @exception x, y, z, and w must be unsigned normalized integers between 0 and 255.\n *\n * @see octDecodeInRange\n * @see octEncodeToVector4\n */\nexport function octDecodeFromVector4(encoded: Vector4, result: Vector3): Vector3 {\n  assert(encoded);\n  assert(result);\n  const x = encoded.x;\n  const y = encoded.y;\n  const z = encoded.z;\n  const w = encoded.w;\n\n  if (x < 0 || x > 255 || y < 0 || y > 255 || z < 0 || z > 255 || w < 0 || w > 255) {\n    throw new Error('x, y, z, and w must be unsigned normalized integers between 0 and 255');\n  }\n\n  const xOct16 = x * LEFT_SHIFT + y;\n  const yOct16 = z * LEFT_SHIFT + w;\n  return octDecodeInRange(xOct16, yOct16, 65535, result);\n}\n\n/**\n * Packs an oct encoded vector into a single floating-point number.\n *\n * @param encoded The oct encoded vector.\n * @returns The oct encoded vector packed into a single float.\n *\n */\nexport function octPackFloat(encoded: Vector2): number {\n  const vector2 = scratchVector2.from(encoded);\n  return 256.0 * vector2.x + vector2.y;\n}\n\n/**\n * Encodes a normalized vector into 2 SNORM values in the range of [0-255] following the 'oct' encoding and\n * stores those values in a single float-point number.\n *\n * @param vector The normalized vector to be compressed into 2 byte 'oct' encoding.\n * @returns The 2 byte oct-encoded unit length vector.\n *\n * @exception vector must be normalized.\n */\nexport function octEncodeFloat(vector: Vector3): number {\n  octEncode(vector, scratchEncodeVector2);\n  return octPackFloat(scratchEncodeVector2);\n}\n\n/**\n * Decodes a unit-length vector in 'oct' encoding packed in a floating-point number to a normalized 3-component vector.\n *\n * @param value The oct-encoded unit length vector stored as a single floating-point number.\n * @param result The decoded and normalized vector\n * @returns The decoded and normalized vector.\n *\n */\nexport function octDecodeFloat(value: number, result: Vector3): Vector3 {\n  assert(Number.isFinite(value));\n\n  const temp = value / 256.0;\n  const x = Math.floor(temp);\n  const y = (temp - x) * 256.0;\n\n  return octDecode(x, y, result);\n}\n\n/**\n * Encodes three normalized vectors into 6 SNORM values in the range of [0-255] following the 'oct' encoding and\n * packs those into two floating-point numbers.\n *\n * @param v1 A normalized vector to be compressed.\n * @param v2 A normalized vector to be compressed.\n * @param v3 A normalized vector to be compressed.\n * @param result The 'oct' encoded vectors packed into two floating-point numbers.\n * @returns The 'oct' encoded vectors packed into two floating-point numbers.\n *\n */\nexport function octPack(v1: Vector3, v2: Vector3, v3: Vector3, result: Vector2): Vector2 {\n  assert(v1);\n  assert(v2);\n  assert(v3);\n  assert(result);\n\n  const encoded1 = octEncodeFloat(v1);\n  const encoded2 = octEncodeFloat(v2);\n\n  const encoded3 = octEncode(v3, scratchEncodeVector2);\n  result.x = 65536.0 * encoded3.x + encoded1;\n  result.y = 65536.0 * encoded3.y + encoded2;\n  return result;\n}\n\n/**\n * Decodes three unit-length vectors in 'oct' encoding packed into a floating-point number to a normalized 3-component vector.\n *\n * @param packed The three oct-encoded unit length vectors stored as two floating-point number.\n * @param v1 One decoded and normalized vector.\n * @param v2 One decoded and normalized vector.\n * @param v3 One decoded and normalized vector.\n */\nexport function octUnpack(packed: Vector2, v1: Vector3, v2: Vector3, v3: Vector3): void {\n  let temp = packed.x / 65536.0;\n  const x = Math.floor(temp);\n  const encodedFloat1 = (temp - x) * 65536.0;\n\n  temp = packed.y / 65536.0;\n  const y = Math.floor(temp);\n  const encodedFloat2 = (temp - y) * 65536.0;\n\n  octDecodeFloat(encodedFloat1, v1);\n  octDecodeFloat(encodedFloat2, v2);\n  octDecode(x, y, v3);\n}\n\n/**\n * Pack texture coordinates into a single float. The texture coordinates will only preserve 12 bits of precision.\n *\n * @param textureCoordinates The texture coordinates to compress.  Both coordinates must be in the range 0.0-1.0.\n * @returns The packed texture coordinates.\n *\n */\nexport function compressTextureCoordinates(textureCoordinates: Vector2): number {\n  // Move x and y to the range 0-4095;\n  const x = (textureCoordinates.x * 4095.0) | 0;\n  const y = (textureCoordinates.y * 4095.0) | 0;\n  return 4096.0 * x + y;\n}\n\n/**\n * Decompresses texture coordinates that were packed into a single float.\n *\n * @param compressed The compressed texture coordinates.\n * @param result The decompressed texture coordinates.\n * @returns The modified result parameter.\n *\n */\nexport function decompressTextureCoordinates(compressed: number, result: Vector2): Vector2 {\n  const temp = compressed / 4096.0;\n  const xZeroTo4095 = Math.floor(temp);\n  result.x = xZeroTo4095 / 4095.0;\n  result.y = (compressed - xZeroTo4095 * 4096) / 4095;\n  return result;\n}\n\n/**\n * Decodes delta and ZigZag encoded vertices. This modifies the buffers in place.\n *\n * @param uBuffer The buffer view of u values.\n * @param vBuffer The buffer view of v values.\n * @param [heightBuffer] The buffer view of height values.\n *\n * @link https://github.com/AnalyticalGraphicsInc/quantized-mesh|quantized-mesh-1.0 terrain format\n */\nexport function zigZagDeltaDecode(\n  uBuffer: Uint16Array,\n  vBuffer: Uint16Array,\n  heightBuffer?: Uint16Array | number[]\n) {\n  assert(uBuffer);\n  assert(vBuffer);\n  assert(uBuffer.length === vBuffer.length);\n  if (heightBuffer) {\n    assert(uBuffer.length === heightBuffer.length);\n  }\n\n  function zigZagDecode(value: number) {\n    return (value >> 1) ^ -(value & 1);\n  }\n\n  let u = 0;\n  let v = 0;\n  let height = 0;\n\n  for (let i = 0; i < uBuffer.length; ++i) {\n    u += zigZagDecode(uBuffer[i]);\n    v += zigZagDecode(vBuffer[i]);\n\n    uBuffer[i] = u;\n    vBuffer[i] = v;\n\n    if (heightBuffer) {\n      height += zigZagDecode(heightBuffer[i]);\n      heightBuffer[i] = height;\n    }\n  }\n}\n"],"file":"attribute-compression.js"}

package/dist/es5/geometry/constants.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GL = exports.GL_TYPE = exports.GL_PRIMITIVE_MODE = exports.GL_PRIMITIVE = void 0;
+const GL_PRIMITIVE = {
+  POINTS: 0x0000,
+  LINES: 0x0001,
+  TRIANGLES: 0x0004
+};
+exports.GL_PRIMITIVE = GL_PRIMITIVE;
+const GL_PRIMITIVE_MODE = {
+  POINTS: 0x0000,
+  LINES: 0x0001,
+  LINE_LOOP: 0x0002,
+  LINE_STRIP: 0x0003,
+  TRIANGLES: 0x0004,
+  TRIANGLE_STRIP: 0x0005,
+  TRIANGLE_FAN: 0x0006
+};
+exports.GL_PRIMITIVE_MODE = GL_PRIMITIVE_MODE;
+const GL_TYPE = {
+  BYTE: 5120,
+  UNSIGNED_BYTE: 5121,
+  SHORT: 5122,
+  UNSIGNED_SHORT: 5123,
+  INT: 5124,
+  UNSIGNED_INT: 5125,
+  FLOAT: 5126,
+  DOUBLE: 5130
+};
+exports.GL_TYPE = GL_TYPE;
+const GL = { ...GL_PRIMITIVE_MODE,
+  ...GL_TYPE
+};
+exports.GL = GL;
+//# sourceMappingURL=constants.js.map

package/dist/es5/geometry/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/geometry/constants.ts"],"names":["GL_PRIMITIVE","POINTS","LINES","TRIANGLES","GL_PRIMITIVE_MODE","LINE_LOOP","LINE_STRIP","TRIANGLE_STRIP","TRIANGLE_FAN","GL_TYPE","BYTE","UNSIGNED_BYTE","SHORT","UNSIGNED_SHORT","INT","UNSIGNED_INT","FLOAT","DOUBLE","GL"],"mappings":";;;;;;AAEO,MAAMA,YAAY,GAAG;AAC1BC,EAAAA,MAAM,EAAE,MADkB;AAE1BC,EAAAA,KAAK,EAAE,MAFmB;AAG1BC,EAAAA,SAAS,EAAE;AAHe,CAArB;;AAOA,MAAMC,iBAAiB,GAAG;AAC/BH,EAAAA,MAAM,EAAE,MADuB;AAE/BC,EAAAA,KAAK,EAAE,MAFwB;AAG/BG,EAAAA,SAAS,EAAE,MAHoB;AAI/BC,EAAAA,UAAU,EAAE,MAJmB;AAK/BH,EAAAA,SAAS,EAAE,MALoB;AAM/BI,EAAAA,cAAc,EAAE,MANe;AAO/BC,EAAAA,YAAY,EAAE;AAPiB,CAA1B;;AAsBA,MAAMC,OAAe,GAAG;AAC7BC,EAAAA,IAAI,EAAE,IADuB;AAE7BC,EAAAA,aAAa,EAAE,IAFc;AAG7BC,EAAAA,KAAK,EAAE,IAHsB;AAI7BC,EAAAA,cAAc,EAAE,IAJa;AAK7BC,EAAAA,GAAG,EAAE,IALwB;AAM7BC,EAAAA,YAAY,EAAE,IANe;AAO7BC,EAAAA,KAAK,EAAE,IAPsB;AAQ7BC,EAAAA,MAAM,EAAE;AARqB,CAAxB;;AAWA,MAAMC,EAAE,GAAG,EAChB,GAAGd,iBADa;AAEhB,KAAGK;AAFa,CAAX","sourcesContent":["// Subset of WebGL constants\n\nexport const GL_PRIMITIVE = {\n  POINTS: 0x0000, // Points. single points.\n  LINES: 0x0001, // Lines. Each vertex connects to the one after it.\n  TRIANGLES: 0x0004 // Triangles. Each set of three vertices creates a separate triangle.\n};\n\n// Primitive modes\nexport const GL_PRIMITIVE_MODE = {\n  POINTS: 0x0000, // Points. single points.\n  LINES: 0x0001, // Lines. Each vertex connects to the one after it.\n  LINE_LOOP: 0x0002, // Lines. Each set of two vertices is treated as a separate line segment.\n  LINE_STRIP: 0x0003, // Lines/ a connected group of line segments from the first vertex to the last\n  TRIANGLES: 0x0004, // Triangles. Each set of three vertices creates a separate triangle.\n  TRIANGLE_STRIP: 0x0005, // Triangles. A connected group of triangles.\n  TRIANGLE_FAN: 0x0006 // Triangles. A connected group of triangles.\n  // Each vertex connects to the previous and the first vertex in the fan.\n};\n\ntype glType = {\n  BYTE: number;\n  UNSIGNED_BYTE: number;\n  SHORT: number;\n  UNSIGNED_SHORT: number;\n  INT: number;\n  UNSIGNED_INT: number;\n  FLOAT: number;\n  DOUBLE: number;\n};\n\nexport const GL_TYPE: glType = {\n  BYTE: 5120,\n  UNSIGNED_BYTE: 5121,\n  SHORT: 5122,\n  UNSIGNED_SHORT: 5123,\n  INT: 5124,\n  UNSIGNED_INT: 5125,\n  FLOAT: 5126,\n  DOUBLE: 5130\n};\n\nexport const GL = {\n  ...GL_PRIMITIVE_MODE,\n  ...GL_TYPE\n};\n"],"file":"constants.js"}