@luma.gl/engine 9.0.0-alpha.24 → 9.0.0-alpha.25

package/dist/dist.dev.js

@@ -39,11 +39,14 @@ var __exports__ = (() => {
     CubeGeometry: () => CubeGeometry,
     CylinderGeometry: () => CylinderGeometry,
     Geometry: () => Geometry,
+    GroupNode: () => GroupNode,
     IcoSphereGeometry: () => IcoSphereGeometry,
     KeyFrames: () => KeyFrames,
     Model: () => Model,
+    ModelNode: () => ModelNode,
     PipelineFactory: () => PipelineFactory,
     PlaneGeometry: () => PlaneGeometry,
+    ScenegraphNode: () => ScenegraphNode,
     SphereGeometry: () => SphereGeometry,
     Timeline: () => Timeline,
     Transform: () => Transform,
@@ -294,52 +297,6 @@ var __exports__ = (() => {
     return "Unknown";
   }
 
-  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
-  function _typeof(obj) {
-    "@babel/helpers - typeof";
-    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
-      return typeof obj2;
-    } : function(obj2) {
-      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
-    }, _typeof(obj);
-  }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
-  function _toPrimitive(input, hint2) {
-    if (_typeof(input) !== "object" || input === null)
-      return input;
-    var prim = input[Symbol.toPrimitive];
-    if (prim !== void 0) {
-      var res = prim.call(input, hint2 || "default");
-      if (_typeof(res) !== "object")
-        return res;
-      throw new TypeError("@@toPrimitive must return a primitive value.");
-    }
-    return (hint2 === "string" ? String : Number)(input);
-  }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
-  function _toPropertyKey(arg) {
-    var key = _toPrimitive(arg, "string");
-    return _typeof(key) === "symbol" ? key : String(key);
-  }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
-  function _defineProperty(obj, key, value) {
-    key = _toPropertyKey(key);
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else {
-      obj[key] = value;
-    }
-    return obj;
-  }
-
   // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
   function getStorage(type) {
     try {
@@ -355,9 +312,9 @@ var __exports__ = (() => {
   var LocalStorage = class {
     constructor(id, defaultConfig) {
       let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage";
-      _defineProperty(this, "storage", void 0);
-      _defineProperty(this, "id", void 0);
-      _defineProperty(this, "config", void 0);
+      this.storage = void 0;
+      this.id = void 0;
+      this.config = void 0;
       this.storage = getStorage(type);
       this.id = id;
       this.config = defaultConfig;
@@ -403,14 +360,14 @@ var __exports__ = (() => {
     const padLength = Math.max(length - string.length, 0);
     return "".concat(" ".repeat(padLength)).concat(string);
   }
-  function formatImage(image, message2, scale) {
+  function formatImage(image, message2, scale2) {
     let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600;
     const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29");
     if (image.width > maxWidth) {
-      scale = Math.min(scale, maxWidth / image.width);
+      scale2 = Math.min(scale2, maxWidth / image.width);
     }
-    const width = image.width * scale;
-    const height = image.height * scale;
+    const width = image.width * scale2;
+    const height = image.height * scale2;
     const style = ["font-size:1px;", "padding:".concat(Math.floor(height / 2), "px ").concat(Math.floor(width / 2), "px;"), "line-height:".concat(height, "px;"), "background:url(".concat(imageUrl, ");"), "background-size:".concat(width, "px ").concat(height, "px;"), "color:transparent;"].join("");
     return ["".concat(message2, " %c+"), style];
   }
@@ -521,13 +478,13 @@ var __exports__ = (() => {
       } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
         id: ""
       };
-      _defineProperty(this, "id", void 0);
-      _defineProperty(this, "VERSION", VERSION);
-      _defineProperty(this, "_startTs", getHiResTimestamp());
-      _defineProperty(this, "_deltaTs", getHiResTimestamp());
-      _defineProperty(this, "_storage", void 0);
-      _defineProperty(this, "userData", {});
-      _defineProperty(this, "LOG_THROTTLE_TIMEOUT", 0);
+      this.id = void 0;
+      this.VERSION = VERSION;
+      this._startTs = getHiResTimestamp();
+      this._deltaTs = getHiResTimestamp();
+      this._storage = void 0;
+      this.userData = {};
+      this.LOG_THROTTLE_TIMEOUT = 0;
       this.id = id;
       this.userData = {};
       this._storage = new LocalStorage("__probe-".concat(this.id, "__"), DEFAULT_LOG_CONFIGURATION);
@@ -634,7 +591,7 @@ var __exports__ = (() => {
         priority,
         image,
         message: message2 = "",
-        scale = 1
+        scale: scale2 = 1
       } = _ref;
       if (!this._shouldLog(logLevel || priority)) {
         return noop;
@@ -642,11 +599,11 @@ var __exports__ = (() => {
       return isBrowser() ? logImageInBrowser({
         image,
         message: message2,
-        scale
+        scale: scale2
       }) : logImageInNode({
         image,
         message: message2,
-        scale
+        scale: scale2
       });
     }
     time(logLevel, message2) {
@@ -725,7 +682,7 @@ var __exports__ = (() => {
       return noop;
     }
   };
-  _defineProperty(Log, "VERSION", VERSION);
+  Log.VERSION = VERSION;
   function normalizeLogLevel(logLevel) {
     if (!logLevel) {
       return 0;
@@ -787,7 +744,7 @@ var __exports__ = (() => {
     let {
       image,
       message: message2 = "",
-      scale = 1
+      scale: scale2 = 1
     } = _ref2;
     console.warn("removed");
     return noop;
@@ -796,12 +753,12 @@ var __exports__ = (() => {
     let {
       image,
       message: message2 = "",
-      scale = 1
+      scale: scale2 = 1
     } = _ref3;
     if (typeof image === "string") {
       const img = new Image();
       img.onload = () => {
-        const args = formatImage(img, message2, scale);
+        const args = formatImage(img, message2, scale2);
         console.log(...args);
       };
       img.src = image;
@@ -809,12 +766,12 @@ var __exports__ = (() => {
     }
     const element = image.nodeName || "";
     if (element.toLowerCase() === "img") {
-      console.log(...formatImage(image, message2, scale));
+      console.log(...formatImage(image, message2, scale2));
       return noop;
     }
     if (element.toLowerCase() === "canvas") {
       const img = new Image();
-      img.onload = () => console.log(...formatImage(img, message2, scale));
+      img.onload = () => console.log(...formatImage(img, message2, scale2));
       img.src = image.toDataURL();
       return noop;
     }
@@ -856,20 +813,20 @@ var __exports__ = (() => {
   // ../../node_modules/@probe.gl/stats/dist/lib/stat.js
   var Stat = class {
     constructor(name, type) {
-      _defineProperty(this, "name", void 0);
-      _defineProperty(this, "type", void 0);
-      _defineProperty(this, "sampleSize", 1);
-      _defineProperty(this, "time", 0);
-      _defineProperty(this, "count", 0);
-      _defineProperty(this, "samples", 0);
-      _defineProperty(this, "lastTiming", 0);
-      _defineProperty(this, "lastSampleTime", 0);
-      _defineProperty(this, "lastSampleCount", 0);
-      _defineProperty(this, "_count", 0);
-      _defineProperty(this, "_time", 0);
-      _defineProperty(this, "_samples", 0);
-      _defineProperty(this, "_startTime", 0);
-      _defineProperty(this, "_timerPending", false);
+      this.name = void 0;
+      this.type = void 0;
+      this.sampleSize = 1;
+      this.time = 0;
+      this.count = 0;
+      this.samples = 0;
+      this.lastTiming = 0;
+      this.lastSampleTime = 0;
+      this.lastSampleCount = 0;
+      this._count = 0;
+      this._time = 0;
+      this._samples = 0;
+      this._startTime = 0;
+      this._timerPending = false;
       this.name = name;
       this.type = type;
       this.reset();
@@ -968,8 +925,8 @@ var __exports__ = (() => {
   // ../../node_modules/@probe.gl/stats/dist/lib/stats.js
   var Stats = class {
     constructor(options) {
-      _defineProperty(this, "id", void 0);
-      _defineProperty(this, "stats", {});
+      this.id = void 0;
+      this.stats = {};
       this.id = options.id;
       this.stats = {};
       this._initializeStats(options.stats);
@@ -3989,14 +3946,14 @@ void main() {
       }
       return this.check();
     }
-    scale(scale) {
-      if (typeof scale === "number") {
+    scale(scale2) {
+      if (typeof scale2 === "number") {
         for (let i = 0; i < this.ELEMENTS; ++i) {
-          this[i] *= scale;
+          this[i] *= scale2;
         }
       } else {
-        for (let i = 0; i < this.ELEMENTS && i < scale.length; ++i) {
-          this[i] *= scale[i];
+        for (let i = 0; i < this.ELEMENTS && i < scale2.length; ++i) {
+          this[i] *= scale2[i];
         }
       }
       return this.check();
@@ -4059,12 +4016,29 @@ void main() {
   };
 
   // ../../node_modules/@math.gl/core/dist/lib/validators.js
+  function validateVector(v, length) {
+    if (v.length !== length) {
+      return false;
+    }
+    for (let i = 0; i < v.length; ++i) {
+      if (!Number.isFinite(v[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
   function checkNumber(value) {
     if (!Number.isFinite(value)) {
       throw new Error("Invalid number ".concat(JSON.stringify(value)));
     }
     return value;
   }
+  function checkVector(v, length, callerName = "") {
+    if (config.debug && !validateVector(v, length)) {
+      throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'"));
+    }
+    return v;
+  }
 
   // ../../node_modules/@math.gl/core/dist/lib/assert.js
   function assert4(condition, message2) {
@@ -4179,10 +4153,62 @@ void main() {
   };
 
   // ../../node_modules/@math.gl/core/dist/gl-matrix/common.js
+  var EPSILON = 1e-6;
   var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
   var degree = Math.PI / 180;
 
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/vec2.js
+  function create() {
+    const out = new ARRAY_TYPE(2);
+    if (ARRAY_TYPE != Float32Array) {
+      out[0] = 0;
+      out[1] = 0;
+    }
+    return out;
+  }
+  function transformMat4(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    out[0] = m[0] * x + m[4] * y + m[12];
+    out[1] = m[1] * x + m[5] * y + m[13];
+    return out;
+  }
+  var forEach = function() {
+    const vec = create();
+    return function(a, stride, offset, count, fn, arg) {
+      let i;
+      let l;
+      if (!stride) {
+        stride = 2;
+      }
+      if (!offset) {
+        offset = 0;
+      }
+      if (count) {
+        l = Math.min(count * stride + offset, a.length);
+      } else {
+        l = a.length;
+      }
+      for (i = offset; i < l; i += stride) {
+        vec[0] = a[i];
+        vec[1] = a[i + 1];
+        fn(vec, vec, arg);
+        a[i] = vec[0];
+        a[i + 1] = vec[1];
+      }
+      return a;
+    };
+  }();
+
   // ../../node_modules/@math.gl/core/dist/lib/gl-matrix-extras.js
+  function vec2_transformMat4AsVector(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const w = m[3] * x + m[7] * y || 1;
+    out[0] = (m[0] * x + m[4] * y) / w;
+    out[1] = (m[1] * x + m[5] * y) / w;
+    return out;
+  }
   function vec3_transformMat4AsVector(out, a, m) {
     const x = a[0];
     const y = a[1];
@@ -4203,7 +4229,7 @@ void main() {
   }
 
   // ../../node_modules/@math.gl/core/dist/gl-matrix/vec3.js
-  function create() {
+  function create2() {
     const out = new ARRAY_TYPE(3);
     if (ARRAY_TYPE != Float32Array) {
       out[0] = 0;
@@ -4227,7 +4253,7 @@ void main() {
     out[2] = ax * by - ay * bx;
     return out;
   }
-  function transformMat4(out, a, m) {
+  function transformMat42(out, a, m) {
     const x = a[0];
     const y = a[1];
     const z = a[2];
@@ -4326,8 +4352,8 @@ void main() {
     const cosine = mag && dot(a, b) / mag;
     return Math.acos(Math.min(Math.max(cosine, -1), 1));
   }
-  var forEach = function() {
-    const vec = create();
+  var forEach2 = function() {
+    const vec = create2();
     return function(a, stride, offset, count, fn, arg) {
       let i;
       let l;
@@ -4451,7 +4477,7 @@ void main() {
       return this.transformAsPoint(matrix4);
     }
     transformAsPoint(matrix4) {
-      transformMat4(this, this, matrix4);
+      transformMat42(this, this, matrix4);
       return this.check();
     }
     transformAsVector(matrix4) {
@@ -4472,6 +4498,1139 @@ void main() {
     }
   };
 
+  // ../../node_modules/@math.gl/core/dist/classes/base/matrix.js
+  var Matrix = class extends MathArray {
+    toString() {
+      let string = "[";
+      if (config.printRowMajor) {
+        string += "row-major:";
+        for (let row = 0; row < this.RANK; ++row) {
+          for (let col = 0; col < this.RANK; ++col) {
+            string += " ".concat(this[col * this.RANK + row]);
+          }
+        }
+      } else {
+        string += "column-major:";
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          string += " ".concat(this[i]);
+        }
+      }
+      string += "]";
+      return string;
+    }
+    getElementIndex(row, col) {
+      return col * this.RANK + row;
+    }
+    getElement(row, col) {
+      return this[col * this.RANK + row];
+    }
+    setElement(row, col, value) {
+      this[col * this.RANK + row] = checkNumber(value);
+      return this;
+    }
+    getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) {
+      const firstIndex = columnIndex * this.RANK;
+      for (let i = 0; i < this.RANK; ++i) {
+        result[i] = this[firstIndex + i];
+      }
+      return result;
+    }
+    setColumn(columnIndex, columnVector) {
+      const firstIndex = columnIndex * this.RANK;
+      for (let i = 0; i < this.RANK; ++i) {
+        this[firstIndex + i] = columnVector[i];
+      }
+      return this;
+    }
+  };
+
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/mat4.js
+  function identity(out) {
+    out[0] = 1;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[4] = 0;
+    out[5] = 1;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = 0;
+    out[9] = 0;
+    out[10] = 1;
+    out[11] = 0;
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = 0;
+    out[15] = 1;
+    return out;
+  }
+  function transpose(out, a) {
+    if (out === a) {
+      const a01 = a[1];
+      const a02 = a[2];
+      const a03 = a[3];
+      const a12 = a[6];
+      const a13 = a[7];
+      const a23 = a[11];
+      out[1] = a[4];
+      out[2] = a[8];
+      out[3] = a[12];
+      out[4] = a01;
+      out[6] = a[9];
+      out[7] = a[13];
+      out[8] = a02;
+      out[9] = a12;
+      out[11] = a[14];
+      out[12] = a03;
+      out[13] = a13;
+      out[14] = a23;
+    } else {
+      out[0] = a[0];
+      out[1] = a[4];
+      out[2] = a[8];
+      out[3] = a[12];
+      out[4] = a[1];
+      out[5] = a[5];
+      out[6] = a[9];
+      out[7] = a[13];
+      out[8] = a[2];
+      out[9] = a[6];
+      out[10] = a[10];
+      out[11] = a[14];
+      out[12] = a[3];
+      out[13] = a[7];
+      out[14] = a[11];
+      out[15] = a[15];
+    }
+    return out;
+  }
+  function invert(out, a) {
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a03 = a[3];
+    const a10 = a[4];
+    const a11 = a[5];
+    const a12 = a[6];
+    const a13 = a[7];
+    const a20 = a[8];
+    const a21 = a[9];
+    const a22 = a[10];
+    const a23 = a[11];
+    const a30 = a[12];
+    const a31 = a[13];
+    const a32 = a[14];
+    const a33 = a[15];
+    const b00 = a00 * a11 - a01 * a10;
+    const b01 = a00 * a12 - a02 * a10;
+    const b02 = a00 * a13 - a03 * a10;
+    const b03 = a01 * a12 - a02 * a11;
+    const b04 = a01 * a13 - a03 * a11;
+    const b05 = a02 * a13 - a03 * a12;
+    const b06 = a20 * a31 - a21 * a30;
+    const b07 = a20 * a32 - a22 * a30;
+    const b08 = a20 * a33 - a23 * a30;
+    const b09 = a21 * a32 - a22 * a31;
+    const b10 = a21 * a33 - a23 * a31;
+    const b11 = a22 * a33 - a23 * a32;
+    let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    if (!det) {
+      return null;
+    }
+    det = 1 / det;
+    out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+    out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+    out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+    out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+    out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+    out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+    out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+    out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+    out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+    out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+    out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+    out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+    out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+    out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+    out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+    out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+    return out;
+  }
+  function determinant(a) {
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a03 = a[3];
+    const a10 = a[4];
+    const a11 = a[5];
+    const a12 = a[6];
+    const a13 = a[7];
+    const a20 = a[8];
+    const a21 = a[9];
+    const a22 = a[10];
+    const a23 = a[11];
+    const a30 = a[12];
+    const a31 = a[13];
+    const a32 = a[14];
+    const a33 = a[15];
+    const b0 = a00 * a11 - a01 * a10;
+    const b1 = a00 * a12 - a02 * a10;
+    const b2 = a01 * a12 - a02 * a11;
+    const b3 = a20 * a31 - a21 * a30;
+    const b4 = a20 * a32 - a22 * a30;
+    const b5 = a21 * a32 - a22 * a31;
+    const b6 = a00 * b5 - a01 * b4 + a02 * b3;
+    const b7 = a10 * b5 - a11 * b4 + a12 * b3;
+    const b8 = a20 * b2 - a21 * b1 + a22 * b0;
+    const b9 = a30 * b2 - a31 * b1 + a32 * b0;
+    return a13 * b6 - a03 * b7 + a33 * b8 - a23 * b9;
+  }
+  function multiply(out, a, b) {
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a03 = a[3];
+    const a10 = a[4];
+    const a11 = a[5];
+    const a12 = a[6];
+    const a13 = a[7];
+    const a20 = a[8];
+    const a21 = a[9];
+    const a22 = a[10];
+    const a23 = a[11];
+    const a30 = a[12];
+    const a31 = a[13];
+    const a32 = a[14];
+    const a33 = a[15];
+    let b0 = b[0];
+    let b1 = b[1];
+    let b2 = b[2];
+    let b3 = b[3];
+    out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+    b0 = b[4];
+    b1 = b[5];
+    b2 = b[6];
+    b3 = b[7];
+    out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+    b0 = b[8];
+    b1 = b[9];
+    b2 = b[10];
+    b3 = b[11];
+    out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+    b0 = b[12];
+    b1 = b[13];
+    b2 = b[14];
+    b3 = b[15];
+    out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+    return out;
+  }
+  function translate(out, a, v) {
+    const x = v[0];
+    const y = v[1];
+    const z = v[2];
+    let a00;
+    let a01;
+    let a02;
+    let a03;
+    let a10;
+    let a11;
+    let a12;
+    let a13;
+    let a20;
+    let a21;
+    let a22;
+    let a23;
+    if (a === out) {
+      out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];
+      out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];
+      out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];
+      out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];
+    } else {
+      a00 = a[0];
+      a01 = a[1];
+      a02 = a[2];
+      a03 = a[3];
+      a10 = a[4];
+      a11 = a[5];
+      a12 = a[6];
+      a13 = a[7];
+      a20 = a[8];
+      a21 = a[9];
+      a22 = a[10];
+      a23 = a[11];
+      out[0] = a00;
+      out[1] = a01;
+      out[2] = a02;
+      out[3] = a03;
+      out[4] = a10;
+      out[5] = a11;
+      out[6] = a12;
+      out[7] = a13;
+      out[8] = a20;
+      out[9] = a21;
+      out[10] = a22;
+      out[11] = a23;
+      out[12] = a00 * x + a10 * y + a20 * z + a[12];
+      out[13] = a01 * x + a11 * y + a21 * z + a[13];
+      out[14] = a02 * x + a12 * y + a22 * z + a[14];
+      out[15] = a03 * x + a13 * y + a23 * z + a[15];
+    }
+    return out;
+  }
+  function scale(out, a, v) {
+    const x = v[0];
+    const y = v[1];
+    const z = v[2];
+    out[0] = a[0] * x;
+    out[1] = a[1] * x;
+    out[2] = a[2] * x;
+    out[3] = a[3] * x;
+    out[4] = a[4] * y;
+    out[5] = a[5] * y;
+    out[6] = a[6] * y;
+    out[7] = a[7] * y;
+    out[8] = a[8] * z;
+    out[9] = a[9] * z;
+    out[10] = a[10] * z;
+    out[11] = a[11] * z;
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+    return out;
+  }
+  function rotate(out, a, rad, axis) {
+    let x = axis[0];
+    let y = axis[1];
+    let z = axis[2];
+    let len = Math.sqrt(x * x + y * y + z * z);
+    let c;
+    let s;
+    let t;
+    let a00;
+    let a01;
+    let a02;
+    let a03;
+    let a10;
+    let a11;
+    let a12;
+    let a13;
+    let a20;
+    let a21;
+    let a22;
+    let a23;
+    let b00;
+    let b01;
+    let b02;
+    let b10;
+    let b11;
+    let b12;
+    let b20;
+    let b21;
+    let b22;
+    if (len < EPSILON) {
+      return null;
+    }
+    len = 1 / len;
+    x *= len;
+    y *= len;
+    z *= len;
+    s = Math.sin(rad);
+    c = Math.cos(rad);
+    t = 1 - c;
+    a00 = a[0];
+    a01 = a[1];
+    a02 = a[2];
+    a03 = a[3];
+    a10 = a[4];
+    a11 = a[5];
+    a12 = a[6];
+    a13 = a[7];
+    a20 = a[8];
+    a21 = a[9];
+    a22 = a[10];
+    a23 = a[11];
+    b00 = x * x * t + c;
+    b01 = y * x * t + z * s;
+    b02 = z * x * t - y * s;
+    b10 = x * y * t - z * s;
+    b11 = y * y * t + c;
+    b12 = z * y * t + x * s;
+    b20 = x * z * t + y * s;
+    b21 = y * z * t - x * s;
+    b22 = z * z * t + c;
+    out[0] = a00 * b00 + a10 * b01 + a20 * b02;
+    out[1] = a01 * b00 + a11 * b01 + a21 * b02;
+    out[2] = a02 * b00 + a12 * b01 + a22 * b02;
+    out[3] = a03 * b00 + a13 * b01 + a23 * b02;
+    out[4] = a00 * b10 + a10 * b11 + a20 * b12;
+    out[5] = a01 * b10 + a11 * b11 + a21 * b12;
+    out[6] = a02 * b10 + a12 * b11 + a22 * b12;
+    out[7] = a03 * b10 + a13 * b11 + a23 * b12;
+    out[8] = a00 * b20 + a10 * b21 + a20 * b22;
+    out[9] = a01 * b20 + a11 * b21 + a21 * b22;
+    out[10] = a02 * b20 + a12 * b21 + a22 * b22;
+    out[11] = a03 * b20 + a13 * b21 + a23 * b22;
+    if (a !== out) {
+      out[12] = a[12];
+      out[13] = a[13];
+      out[14] = a[14];
+      out[15] = a[15];
+    }
+    return out;
+  }
+  function rotateX2(out, a, rad) {
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    const a10 = a[4];
+    const a11 = a[5];
+    const a12 = a[6];
+    const a13 = a[7];
+    const a20 = a[8];
+    const a21 = a[9];
+    const a22 = a[10];
+    const a23 = a[11];
+    if (a !== out) {
+      out[0] = a[0];
+      out[1] = a[1];
+      out[2] = a[2];
+      out[3] = a[3];
+      out[12] = a[12];
+      out[13] = a[13];
+      out[14] = a[14];
+      out[15] = a[15];
+    }
+    out[4] = a10 * c + a20 * s;
+    out[5] = a11 * c + a21 * s;
+    out[6] = a12 * c + a22 * s;
+    out[7] = a13 * c + a23 * s;
+    out[8] = a20 * c - a10 * s;
+    out[9] = a21 * c - a11 * s;
+    out[10] = a22 * c - a12 * s;
+    out[11] = a23 * c - a13 * s;
+    return out;
+  }
+  function rotateY2(out, a, rad) {
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a03 = a[3];
+    const a20 = a[8];
+    const a21 = a[9];
+    const a22 = a[10];
+    const a23 = a[11];
+    if (a !== out) {
+      out[4] = a[4];
+      out[5] = a[5];
+      out[6] = a[6];
+      out[7] = a[7];
+      out[12] = a[12];
+      out[13] = a[13];
+      out[14] = a[14];
+      out[15] = a[15];
+    }
+    out[0] = a00 * c - a20 * s;
+    out[1] = a01 * c - a21 * s;
+    out[2] = a02 * c - a22 * s;
+    out[3] = a03 * c - a23 * s;
+    out[8] = a00 * s + a20 * c;
+    out[9] = a01 * s + a21 * c;
+    out[10] = a02 * s + a22 * c;
+    out[11] = a03 * s + a23 * c;
+    return out;
+  }
+  function rotateZ2(out, a, rad) {
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a03 = a[3];
+    const a10 = a[4];
+    const a11 = a[5];
+    const a12 = a[6];
+    const a13 = a[7];
+    if (a !== out) {
+      out[8] = a[8];
+      out[9] = a[9];
+      out[10] = a[10];
+      out[11] = a[11];
+      out[12] = a[12];
+      out[13] = a[13];
+      out[14] = a[14];
+      out[15] = a[15];
+    }
+    out[0] = a00 * c + a10 * s;
+    out[1] = a01 * c + a11 * s;
+    out[2] = a02 * c + a12 * s;
+    out[3] = a03 * c + a13 * s;
+    out[4] = a10 * c - a00 * s;
+    out[5] = a11 * c - a01 * s;
+    out[6] = a12 * c - a02 * s;
+    out[7] = a13 * c - a03 * s;
+    return out;
+  }
+  function fromQuat(out, q) {
+    const x = q[0];
+    const y = q[1];
+    const z = q[2];
+    const w = q[3];
+    const x2 = x + x;
+    const y2 = y + y;
+    const z2 = z + z;
+    const xx = x * x2;
+    const yx = y * x2;
+    const yy = y * y2;
+    const zx = z * x2;
+    const zy = z * y2;
+    const zz = z * z2;
+    const wx = w * x2;
+    const wy = w * y2;
+    const wz = w * z2;
+    out[0] = 1 - yy - zz;
+    out[1] = yx + wz;
+    out[2] = zx - wy;
+    out[3] = 0;
+    out[4] = yx - wz;
+    out[5] = 1 - xx - zz;
+    out[6] = zy + wx;
+    out[7] = 0;
+    out[8] = zx + wy;
+    out[9] = zy - wx;
+    out[10] = 1 - xx - yy;
+    out[11] = 0;
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = 0;
+    out[15] = 1;
+    return out;
+  }
+  function frustum(out, left, right, bottom, top, near, far) {
+    const rl = 1 / (right - left);
+    const tb = 1 / (top - bottom);
+    const nf = 1 / (near - far);
+    out[0] = near * 2 * rl;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[4] = 0;
+    out[5] = near * 2 * tb;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = (right + left) * rl;
+    out[9] = (top + bottom) * tb;
+    out[10] = (far + near) * nf;
+    out[11] = -1;
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = far * near * 2 * nf;
+    out[15] = 0;
+    return out;
+  }
+  function perspectiveNO(out, fovy, aspect, near, far) {
+    const f = 1 / Math.tan(fovy / 2);
+    out[0] = f / aspect;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[4] = 0;
+    out[5] = f;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = 0;
+    out[9] = 0;
+    out[11] = -1;
+    out[12] = 0;
+    out[13] = 0;
+    out[15] = 0;
+    if (far != null && far !== Infinity) {
+      const nf = 1 / (near - far);
+      out[10] = (far + near) * nf;
+      out[14] = 2 * far * near * nf;
+    } else {
+      out[10] = -1;
+      out[14] = -2 * near;
+    }
+    return out;
+  }
+  var perspective = perspectiveNO;
+  function orthoNO(out, left, right, bottom, top, near, far) {
+    const lr = 1 / (left - right);
+    const bt = 1 / (bottom - top);
+    const nf = 1 / (near - far);
+    out[0] = -2 * lr;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[4] = 0;
+    out[5] = -2 * bt;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = 0;
+    out[9] = 0;
+    out[10] = 2 * nf;
+    out[11] = 0;
+    out[12] = (left + right) * lr;
+    out[13] = (top + bottom) * bt;
+    out[14] = (far + near) * nf;
+    out[15] = 1;
+    return out;
+  }
+  var ortho = orthoNO;
+  function lookAt(out, eye, center, up) {
+    let len;
+    let x0;
+    let x1;
+    let x2;
+    let y0;
+    let y1;
+    let y2;
+    let z0;
+    let z1;
+    let z2;
+    const eyex = eye[0];
+    const eyey = eye[1];
+    const eyez = eye[2];
+    const upx = up[0];
+    const upy = up[1];
+    const upz = up[2];
+    const centerx = center[0];
+    const centery = center[1];
+    const centerz = center[2];
+    if (Math.abs(eyex - centerx) < EPSILON && Math.abs(eyey - centery) < EPSILON && Math.abs(eyez - centerz) < EPSILON) {
+      return identity(out);
+    }
+    z0 = eyex - centerx;
+    z1 = eyey - centery;
+    z2 = eyez - centerz;
+    len = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
+    z0 *= len;
+    z1 *= len;
+    z2 *= len;
+    x0 = upy * z2 - upz * z1;
+    x1 = upz * z0 - upx * z2;
+    x2 = upx * z1 - upy * z0;
+    len = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
+    if (!len) {
+      x0 = 0;
+      x1 = 0;
+      x2 = 0;
+    } else {
+      len = 1 / len;
+      x0 *= len;
+      x1 *= len;
+      x2 *= len;
+    }
+    y0 = z1 * x2 - z2 * x1;
+    y1 = z2 * x0 - z0 * x2;
+    y2 = z0 * x1 - z1 * x0;
+    len = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
+    if (!len) {
+      y0 = 0;
+      y1 = 0;
+      y2 = 0;
+    } else {
+      len = 1 / len;
+      y0 *= len;
+      y1 *= len;
+      y2 *= len;
+    }
+    out[0] = x0;
+    out[1] = y0;
+    out[2] = z0;
+    out[3] = 0;
+    out[4] = x1;
+    out[5] = y1;
+    out[6] = z1;
+    out[7] = 0;
+    out[8] = x2;
+    out[9] = y2;
+    out[10] = z2;
+    out[11] = 0;
+    out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
+    out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
+    out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
+    out[15] = 1;
+    return out;
+  }
+
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/vec4.js
+  function create3() {
+    const out = new ARRAY_TYPE(4);
+    if (ARRAY_TYPE != Float32Array) {
+      out[0] = 0;
+      out[1] = 0;
+      out[2] = 0;
+      out[3] = 0;
+    }
+    return out;
+  }
+  function transformMat43(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    const w = a[3];
+    out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;
+    out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;
+    out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w;
+    out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w;
+    return out;
+  }
+  var forEach3 = function() {
+    const vec = create3();
+    return function(a, stride, offset, count, fn, arg) {
+      let i;
+      let l;
+      if (!stride) {
+        stride = 4;
+      }
+      if (!offset) {
+        offset = 0;
+      }
+      if (count) {
+        l = Math.min(count * stride + offset, a.length);
+      } else {
+        l = a.length;
+      }
+      for (i = offset; i < l; i += stride) {
+        vec[0] = a[i];
+        vec[1] = a[i + 1];
+        vec[2] = a[i + 2];
+        vec[3] = a[i + 3];
+        fn(vec, vec, arg);
+        a[i] = vec[0];
+        a[i + 1] = vec[1];
+        a[i + 2] = vec[2];
+        a[i + 3] = vec[3];
+      }
+      return a;
+    };
+  }();
+
+  // ../../node_modules/@math.gl/core/dist/classes/matrix4.js
+  var INDICES;
+  (function(INDICES2) {
+    INDICES2[INDICES2["COL0ROW0"] = 0] = "COL0ROW0";
+    INDICES2[INDICES2["COL0ROW1"] = 1] = "COL0ROW1";
+    INDICES2[INDICES2["COL0ROW2"] = 2] = "COL0ROW2";
+    INDICES2[INDICES2["COL0ROW3"] = 3] = "COL0ROW3";
+    INDICES2[INDICES2["COL1ROW0"] = 4] = "COL1ROW0";
+    INDICES2[INDICES2["COL1ROW1"] = 5] = "COL1ROW1";
+    INDICES2[INDICES2["COL1ROW2"] = 6] = "COL1ROW2";
+    INDICES2[INDICES2["COL1ROW3"] = 7] = "COL1ROW3";
+    INDICES2[INDICES2["COL2ROW0"] = 8] = "COL2ROW0";
+    INDICES2[INDICES2["COL2ROW1"] = 9] = "COL2ROW1";
+    INDICES2[INDICES2["COL2ROW2"] = 10] = "COL2ROW2";
+    INDICES2[INDICES2["COL2ROW3"] = 11] = "COL2ROW3";
+    INDICES2[INDICES2["COL3ROW0"] = 12] = "COL3ROW0";
+    INDICES2[INDICES2["COL3ROW1"] = 13] = "COL3ROW1";
+    INDICES2[INDICES2["COL3ROW2"] = 14] = "COL3ROW2";
+    INDICES2[INDICES2["COL3ROW3"] = 15] = "COL3ROW3";
+  })(INDICES || (INDICES = {}));
+  var DEFAULT_FOVY = 45 * Math.PI / 180;
+  var DEFAULT_ASPECT = 1;
+  var DEFAULT_NEAR = 0.1;
+  var DEFAULT_FAR = 500;
+  var IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+  var Matrix4 = class extends Matrix {
+    static get IDENTITY() {
+      return getIdentityMatrix();
+    }
+    static get ZERO() {
+      return getZeroMatrix();
+    }
+    get ELEMENTS() {
+      return 16;
+    }
+    get RANK() {
+      return 4;
+    }
+    get INDICES() {
+      return INDICES;
+    }
+    constructor(array) {
+      super(-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0);
+      if (arguments.length === 1 && Array.isArray(array)) {
+        this.copy(array);
+      } else {
+        this.identity();
+      }
+    }
+    copy(array) {
+      this[0] = array[0];
+      this[1] = array[1];
+      this[2] = array[2];
+      this[3] = array[3];
+      this[4] = array[4];
+      this[5] = array[5];
+      this[6] = array[6];
+      this[7] = array[7];
+      this[8] = array[8];
+      this[9] = array[9];
+      this[10] = array[10];
+      this[11] = array[11];
+      this[12] = array[12];
+      this[13] = array[13];
+      this[14] = array[14];
+      this[15] = array[15];
+      return this.check();
+    }
+    set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) {
+      this[0] = m00;
+      this[1] = m10;
+      this[2] = m20;
+      this[3] = m30;
+      this[4] = m01;
+      this[5] = m11;
+      this[6] = m21;
+      this[7] = m31;
+      this[8] = m02;
+      this[9] = m12;
+      this[10] = m22;
+      this[11] = m32;
+      this[12] = m03;
+      this[13] = m13;
+      this[14] = m23;
+      this[15] = m33;
+      return this.check();
+    }
+    setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
+      this[0] = m00;
+      this[1] = m10;
+      this[2] = m20;
+      this[3] = m30;
+      this[4] = m01;
+      this[5] = m11;
+      this[6] = m21;
+      this[7] = m31;
+      this[8] = m02;
+      this[9] = m12;
+      this[10] = m22;
+      this[11] = m32;
+      this[12] = m03;
+      this[13] = m13;
+      this[14] = m23;
+      this[15] = m33;
+      return this.check();
+    }
+    toRowMajor(result) {
+      result[0] = this[0];
+      result[1] = this[4];
+      result[2] = this[8];
+      result[3] = this[12];
+      result[4] = this[1];
+      result[5] = this[5];
+      result[6] = this[9];
+      result[7] = this[13];
+      result[8] = this[2];
+      result[9] = this[6];
+      result[10] = this[10];
+      result[11] = this[14];
+      result[12] = this[3];
+      result[13] = this[7];
+      result[14] = this[11];
+      result[15] = this[15];
+      return result;
+    }
+    identity() {
+      return this.copy(IDENTITY_MATRIX);
+    }
+    fromObject(object) {
+      return this.check();
+    }
+    fromQuaternion(quaternion) {
+      fromQuat(this, quaternion);
+      return this.check();
+    }
+    frustum(view) {
+      const {
+        left,
+        right,
+        bottom,
+        top,
+        near = DEFAULT_NEAR,
+        far = DEFAULT_FAR
+      } = view;
+      if (far === Infinity) {
+        computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
+      } else {
+        frustum(this, left, right, bottom, top, near, far);
+      }
+      return this.check();
+    }
+    lookAt(view) {
+      const {
+        eye,
+        center = [0, 0, 0],
+        up = [0, 1, 0]
+      } = view;
+      lookAt(this, eye, center, up);
+      return this.check();
+    }
+    ortho(view) {
+      const {
+        left,
+        right,
+        bottom,
+        top,
+        near = DEFAULT_NEAR,
+        far = DEFAULT_FAR
+      } = view;
+      ortho(this, left, right, bottom, top, near, far);
+      return this.check();
+    }
+    orthographic(view) {
+      const {
+        fovy = DEFAULT_FOVY,
+        aspect = DEFAULT_ASPECT,
+        focalDistance = 1,
+        near = DEFAULT_NEAR,
+        far = DEFAULT_FAR
+      } = view;
+      checkRadians(fovy);
+      const halfY = fovy / 2;
+      const top = focalDistance * Math.tan(halfY);
+      const right = top * aspect;
+      return this.ortho({
+        left: -right,
+        right,
+        bottom: -top,
+        top,
+        near,
+        far
+      });
+    }
+    perspective(view) {
+      const {
+        fovy = 45 * Math.PI / 180,
+        aspect = 1,
+        near = 0.1,
+        far = 500
+      } = view;
+      checkRadians(fovy);
+      perspective(this, fovy, aspect, near, far);
+      return this.check();
+    }
+    determinant() {
+      return determinant(this);
+    }
+    getScale(result = [-0, -0, -0]) {
+      result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]);
+      result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]);
+      result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]);
+      return result;
+    }
+    getTranslation(result = [-0, -0, -0]) {
+      result[0] = this[12];
+      result[1] = this[13];
+      result[2] = this[14];
+      return result;
+    }
+    getRotation(result, scaleResult) {
+      result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
+      scaleResult = scaleResult || [-0, -0, -0];
+      const scale2 = this.getScale(scaleResult);
+      const inverseScale0 = 1 / scale2[0];
+      const inverseScale1 = 1 / scale2[1];
+      const inverseScale2 = 1 / scale2[2];
+      result[0] = this[0] * inverseScale0;
+      result[1] = this[1] * inverseScale1;
+      result[2] = this[2] * inverseScale2;
+      result[3] = 0;
+      result[4] = this[4] * inverseScale0;
+      result[5] = this[5] * inverseScale1;
+      result[6] = this[6] * inverseScale2;
+      result[7] = 0;
+      result[8] = this[8] * inverseScale0;
+      result[9] = this[9] * inverseScale1;
+      result[10] = this[10] * inverseScale2;
+      result[11] = 0;
+      result[12] = 0;
+      result[13] = 0;
+      result[14] = 0;
+      result[15] = 1;
+      return result;
+    }
+    getRotationMatrix3(result, scaleResult) {
+      result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0];
+      scaleResult = scaleResult || [-0, -0, -0];
+      const scale2 = this.getScale(scaleResult);
+      const inverseScale0 = 1 / scale2[0];
+      const inverseScale1 = 1 / scale2[1];
+      const inverseScale2 = 1 / scale2[2];
+      result[0] = this[0] * inverseScale0;
+      result[1] = this[1] * inverseScale1;
+      result[2] = this[2] * inverseScale2;
+      result[3] = this[4] * inverseScale0;
+      result[4] = this[5] * inverseScale1;
+      result[5] = this[6] * inverseScale2;
+      result[6] = this[8] * inverseScale0;
+      result[7] = this[9] * inverseScale1;
+      result[8] = this[10] * inverseScale2;
+      return result;
+    }
+    transpose() {
+      transpose(this, this);
+      return this.check();
+    }
+    invert() {
+      invert(this, this);
+      return this.check();
+    }
+    multiplyLeft(a) {
+      multiply(this, a, this);
+      return this.check();
+    }
+    multiplyRight(a) {
+      multiply(this, this, a);
+      return this.check();
+    }
+    rotateX(radians) {
+      rotateX2(this, this, radians);
+      return this.check();
+    }
+    rotateY(radians) {
+      rotateY2(this, this, radians);
+      return this.check();
+    }
+    rotateZ(radians) {
+      rotateZ2(this, this, radians);
+      return this.check();
+    }
+    rotateXYZ(angleXYZ) {
+      return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]);
+    }
+    rotateAxis(radians, axis) {
+      rotate(this, this, radians, axis);
+      return this.check();
+    }
+    scale(factor) {
+      scale(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
+      return this.check();
+    }
+    translate(vector) {
+      translate(this, this, vector);
+      return this.check();
+    }
+    transform(vector, result) {
+      if (vector.length === 4) {
+        result = transformMat43(result || [-0, -0, -0, -0], vector, this);
+        checkVector(result, 4);
+        return result;
+      }
+      return this.transformAsPoint(vector, result);
+    }
+    transformAsPoint(vector, result) {
+      const {
+        length
+      } = vector;
+      let out;
+      switch (length) {
+        case 2:
+          out = transformMat4(result || [-0, -0], vector, this);
+          break;
+        case 3:
+          out = transformMat42(result || [-0, -0, -0], vector, this);
+          break;
+        default:
+          throw new Error("Illegal vector");
+      }
+      checkVector(out, vector.length);
+      return out;
+    }
+    transformAsVector(vector, result) {
+      let out;
+      switch (vector.length) {
+        case 2:
+          out = vec2_transformMat4AsVector(result || [-0, -0], vector, this);
+          break;
+        case 3:
+          out = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this);
+          break;
+        default:
+          throw new Error("Illegal vector");
+      }
+      checkVector(out, vector.length);
+      return out;
+    }
+    transformPoint(vector, result) {
+      return this.transformAsPoint(vector, result);
+    }
+    transformVector(vector, result) {
+      return this.transformAsPoint(vector, result);
+    }
+    transformDirection(vector, result) {
+      return this.transformAsVector(vector, result);
+    }
+    makeRotationX(radians) {
+      return this.identity().rotateX(radians);
+    }
+    makeTranslation(x, y, z) {
+      return this.identity().translate([x, y, z]);
+    }
+  };
+  var ZERO2;
+  var IDENTITY;
+  function getZeroMatrix() {
+    if (!ZERO2) {
+      ZERO2 = new Matrix4([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+      Object.freeze(ZERO2);
+    }
+    return ZERO2;
+  }
+  function getIdentityMatrix() {
+    if (!IDENTITY) {
+      IDENTITY = new Matrix4();
+      Object.freeze(IDENTITY);
+    }
+    return IDENTITY;
+  }
+  function checkRadians(possiblyDegrees) {
+    if (possiblyDegrees > Math.PI * 2) {
+      throw Error("expected radians");
+    }
+  }
+  function computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, near) {
+    const column0Row0 = 2 * near / (right - left);
+    const column1Row1 = 2 * near / (top - bottom);
+    const column2Row0 = (right + left) / (right - left);
+    const column2Row1 = (top + bottom) / (top - bottom);
+    const column2Row2 = -1;
+    const column2Row3 = -1;
+    const column3Row2 = -2 * near;
+    result[0] = column0Row0;
+    result[1] = 0;
+    result[2] = 0;
+    result[3] = 0;
+    result[4] = 0;
+    result[5] = column1Row1;
+    result[6] = 0;
+    result[7] = 0;
+    result[8] = column2Row0;
+    result[9] = column2Row1;
+    result[10] = column2Row2;
+    result[11] = column2Row3;
+    result[12] = 0;
+    result[13] = 0;
+    result[14] = column3Row2;
+    result[15] = 0;
+    return result;
+  }
+
   // src/lib/pipeline-factory.ts
   var DEFAULT_RENDER_PIPELINE_OPTIONS = {
     vs: "",
@@ -6516,9 +7675,9 @@ void main() {
       [GL.POLYGON_OFFSET_FACTOR]: factor,
       [GL.POLYGON_OFFSET_UNITS]: units
     }),
-    sampleCoverage: (update, value, invert) => update({
+    sampleCoverage: (update, value, invert2) => update({
       [GL.SAMPLE_COVERAGE_VALUE]: value,
-      [GL.SAMPLE_COVERAGE_INVERT]: invert
+      [GL.SAMPLE_COVERAGE_INVERT]: invert2
     }),
     scissor: (update, x, y, width, height) => update({
       [GL.SCISSOR_BOX]: new Int32Array([x, y, width, height])
@@ -10158,7 +11317,7 @@ void main(void) {}`;
     }
   };
 
-  // ../webgl/src/classic/buffer.ts
+  // ../webgl/src/classic/buffer-with-accessor.ts
   var DEBUG_DATA_LENGTH2 = 10;
   var DEPRECATED_PROPS = {
     offset: "accessor.offset",
@@ -10202,7 +11361,7 @@ void main(void) {}`;
     }
     return bufferProps;
   }
-  var ClassicBuffer = class extends WEBGLBuffer {
+  var BufferWithAccessor = class extends WEBGLBuffer {
     constructor(device, props = {}) {
       super(WebGLDevice.attach(device), getWEBGLBufferProps(props));
       this.setAccessor(Object.assign({}, props, props.accessor));
@@ -12023,7 +13182,7 @@ ${formattedLog}`)();
     }
     createBuffer(props) {
       const newProps = this._getBufferProps(props);
-      return new ClassicBuffer(this, newProps);
+      return new BufferWithAccessor(this, newProps);
     }
     _createTexture(props) {
       return new WEBGLTexture(this, props);
@@ -12421,6 +13580,281 @@ void main(void) {
     }
   };
 
+  // src/scenegraph/scenegraph-node.ts
+  var ScenegraphNode = class {
+    matrix = new Matrix4();
+    display = true;
+    position = new Vector3();
+    rotation = new Vector3();
+    scale = new Vector3(1, 1, 1);
+    userData = {};
+    props = {};
+    constructor(props = {}) {
+      const {
+        id
+      } = props;
+      this.id = id || uid(this.constructor.name);
+      this._setScenegraphNodeProps(props);
+    }
+    getBounds() {
+      return null;
+    }
+    destroy() {
+    }
+    /** @deprecated use .destroy() */
+    delete() {
+      this.destroy();
+    }
+    setProps(props) {
+      this._setScenegraphNodeProps(props);
+      return this;
+    }
+    toString() {
+      return `{type: ScenegraphNode, id: ${this.id})}`;
+    }
+    setPosition(position) {
+      assert2(position.length === 3, "setPosition requires vector argument");
+      this.position = position;
+      return this;
+    }
+    setRotation(rotation) {
+      assert2(rotation.length === 3, "setRotation requires vector argument");
+      this.rotation = rotation;
+      return this;
+    }
+    setScale(scale2) {
+      assert2(scale2.length === 3, "setScale requires vector argument");
+      this.scale = scale2;
+      return this;
+    }
+    setMatrix(matrix, copyMatrix = true) {
+      if (copyMatrix) {
+        this.matrix.copy(matrix);
+      } else {
+        this.matrix = matrix;
+      }
+    }
+    setMatrixComponents(components) {
+      const {
+        position,
+        rotation,
+        scale: scale2,
+        update = true
+      } = components;
+      if (position) {
+        this.setPosition(position);
+      }
+      if (rotation) {
+        this.setRotation(rotation);
+      }
+      if (scale2) {
+        this.setScale(scale2);
+      }
+      if (update) {
+        this.updateMatrix();
+      }
+      return this;
+    }
+    updateMatrix() {
+      const pos = this.position;
+      const rot = this.rotation;
+      const scale2 = this.scale;
+      this.matrix.identity();
+      this.matrix.translate(pos);
+      this.matrix.rotateXYZ(rot);
+      this.matrix.scale(scale2);
+      return this;
+    }
+    update(options = {}) {
+      const {
+        position,
+        rotation,
+        scale: scale2
+      } = options;
+      if (position) {
+        this.setPosition(position);
+      }
+      if (rotation) {
+        this.setRotation(rotation);
+      }
+      if (scale2) {
+        this.setScale(scale2);
+      }
+      this.updateMatrix();
+      return this;
+    }
+    getCoordinateUniforms(viewMatrix, modelMatrix) {
+      assert2(viewMatrix);
+      modelMatrix = modelMatrix || this.matrix;
+      const worldMatrix = new Matrix4(viewMatrix).multiplyRight(modelMatrix);
+      const worldInverse = worldMatrix.invert();
+      const worldInverseTranspose = worldInverse.transpose();
+      return {
+        viewMatrix,
+        modelMatrix,
+        objectMatrix: modelMatrix,
+        worldMatrix,
+        worldInverseMatrix: worldInverse,
+        worldInverseTransposeMatrix: worldInverseTranspose
+      };
+    }
+    // TODO - copied code, not yet vetted
+    /*
+    transform() {
+      if (!this.parent) {
+        this.endPosition.set(this.position);
+        this.endRotation.set(this.rotation);
+        this.endScale.set(this.scale);
+      } else {
+        const parent = this.parent;
+        this.endPosition.set(this.position.add(parent.endPosition));
+        this.endRotation.set(this.rotation.add(parent.endRotation));
+        this.endScale.set(this.scale.add(parent.endScale));
+      }
+       const ch = this.children;
+      for (let i = 0; i < ch.length; ++i) {
+        ch[i].transform();
+      }
+       return this;
+    }
+    */
+    _setScenegraphNodeProps(props) {
+      if ("display" in props) {
+        this.display = props.display;
+      }
+      if ("position" in props) {
+        this.setPosition(props.position);
+      }
+      if ("rotation" in props) {
+        this.setRotation(props.rotation);
+      }
+      if ("scale" in props) {
+        this.setScale(props.scale);
+      }
+      if ("matrix" in props) {
+        this.setMatrix(props.matrix);
+      }
+      Object.assign(this.props, props);
+    }
+  };
+
+  // src/scenegraph/group-node.ts
+  var GroupNode = class extends ScenegraphNode {
+    constructor(props = {}) {
+      props = Array.isArray(props) ? {
+        children: props
+      } : props;
+      const {
+        children = []
+      } = props;
+      log.assert(children.every((child) => child instanceof ScenegraphNode), "every child must an instance of ScenegraphNode");
+      super(props);
+      this.children = children;
+    }
+    getBounds() {
+      const result = [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]];
+      this.traverse((node, {
+        worldMatrix
+      }) => {
+        const bounds = node.getBounds();
+        if (!bounds) {
+          return;
+        }
+        const [min, max] = bounds;
+        const center = new Vector3(min).add(max).divide([2, 2, 2]);
+        worldMatrix.transformAsPoint(center, center);
+        const halfSize = new Vector3(max).subtract(min).divide([2, 2, 2]);
+        worldMatrix.transformAsVector(halfSize, halfSize);
+        for (let v = 0; v < 8; v++) {
+          const position = new Vector3(v & 1 ? -1 : 1, v & 2 ? -1 : 1, v & 4 ? -1 : 1).multiply(halfSize).add(center);
+          for (let i = 0; i < 3; i++) {
+            result[0][i] = Math.min(result[0][i], position[i]);
+            result[1][i] = Math.max(result[1][i], position[i]);
+          }
+        }
+      });
+      if (!Number.isFinite(result[0][0])) {
+        return null;
+      }
+      return result;
+    }
+    destroy() {
+      this.children.forEach((child) => child.destroy());
+      this.removeAll();
+      super.destroy();
+    }
+    // Unpacks arrays and nested arrays of children
+    add(...children) {
+      for (const child of children) {
+        if (Array.isArray(child)) {
+          this.add(...child);
+        } else {
+          this.children.push(child);
+        }
+      }
+      return this;
+    }
+    remove(child) {
+      const children = this.children;
+      const indexOf = children.indexOf(child);
+      if (indexOf > -1) {
+        children.splice(indexOf, 1);
+      }
+      return this;
+    }
+    removeAll() {
+      this.children = [];
+      return this;
+    }
+    traverse(visitor, {
+      worldMatrix = new Matrix4()
+    } = {}) {
+      const modelMatrix = new Matrix4(worldMatrix).multiplyRight(this.matrix);
+      for (const child of this.children) {
+        if (child instanceof GroupNode) {
+          child.traverse(visitor, {
+            worldMatrix: modelMatrix
+          });
+        } else {
+          visitor(child, {
+            worldMatrix: modelMatrix
+          });
+        }
+      }
+    }
+  };
+
+  // src/scenegraph/model-node.ts
+  var ModelNode = class extends ScenegraphNode {
+    bounds = null;
+    // TODO - is this used? override callbacks to make sure we call them with this
+    // onBeforeRender = null;
+    // onAfterRender = null;
+    // AfterRender = null;
+    constructor(props) {
+      super(props);
+      this.model = props.model;
+      this.managedResources = props.managedResources || [];
+      this.bounds = props.bounds || null;
+      this.setProps(props);
+    }
+    getBounds() {
+      return this.bounds;
+    }
+    destroy() {
+      if (this.model) {
+        this.model.destroy();
+        this.model = null;
+      }
+      this.managedResources.forEach((resource) => resource.destroy());
+      this.managedResources = [];
+    }
+    // Expose model methods
+    draw(renderPass) {
+      return this.model.draw(renderPass);
+    }
+  };
+
   // src/geometries/truncated-cone-geometry.ts
   var INDEX_OFFSETS = {
     x: [2, 0, 1],