@luma.gl/gltf 9.1.0-alpha.2 → 9.1.0-beta.1

package/dist/dist.dev.js

@@ -51,6 +51,13 @@ var __exports__ = (() => {
     }
   });
 
+  // external-global-plugin:@luma.gl/shadertools
+  var require_shadertools = __commonJS({
+    "external-global-plugin:@luma.gl/shadertools"(exports, module) {
+      module.exports = globalThis.luma;
+    }
+  });
+
   // bundle.ts
   var bundle_exports = {};
   __export(bundle_exports, {
@@ -73,9 +80,9 @@ var __exports__ = (() => {
       bindings: {},
       uniforms: {
         // TODO: find better values?
-        u_Camera: [0, 0, 0],
+        camera: [0, 0, 0],
         // Model should override
-        u_MetallicRoughnessValues: [1, 1]
+        metallicRoughnessValues: [1, 1]
         // Default is 1 and 1
       },
       parameters: {},
@@ -85,15 +92,15 @@ var __exports__ = (() => {
     parsedMaterial.defines.USE_TEX_LOD = 1;
     const { imageBasedLightingEnvironment } = options;
     if (imageBasedLightingEnvironment) {
-      parsedMaterial.bindings.u_DiffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler.texture;
-      parsedMaterial.bindings.u_SpecularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler.texture;
-      parsedMaterial.bindings.u_brdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
-      parsedMaterial.uniforms.u_ScaleIBLAmbient = [1, 1];
+      parsedMaterial.bindings.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler.texture;
+      parsedMaterial.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler.texture;
+      parsedMaterial.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
+      parsedMaterial.uniforms.scaleIBLAmbient = [1, 1];
     }
     if (options?.pbrDebug) {
       parsedMaterial.defines.PBR_DEBUG = 1;
-      parsedMaterial.uniforms.u_ScaleDiffBaseMR = [0, 0, 0, 0];
-      parsedMaterial.uniforms.u_ScaleFGDSpec = [0, 0, 0, 0];
+      parsedMaterial.uniforms.scaleDiffBaseMR = [0, 0, 0, 0];
+      parsedMaterial.uniforms.scaleFGDSpec = [0, 0, 0, 0];
     }
     if (attributes.NORMAL)
       parsedMaterial.defines.HAS_NORMALS = 1;
@@ -111,41 +118,47 @@ var __exports__ = (() => {
     return parsedMaterial;
   }
   function parseMaterial(device, material, parsedMaterial) {
-    parsedMaterial.uniforms.pbr_uUnlit = Boolean(material.unlit);
+    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
     if (material.pbrMetallicRoughness) {
       parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
     }
     if (material.normalTexture) {
-      addTexture(device, material.normalTexture, "u_NormalSampler", "HAS_NORMALMAP", parsedMaterial);
+      addTexture(
+        device,
+        material.normalTexture,
+        "pbr_normalSampler",
+        "HAS_NORMALMAP",
+        parsedMaterial
+      );
       const { scale: scale4 = 1 } = material.normalTexture;
-      parsedMaterial.uniforms.u_NormalScale = scale4;
+      parsedMaterial.uniforms.normalScale = scale4;
     }
     if (material.occlusionTexture) {
       addTexture(
         device,
         material.occlusionTexture,
-        "u_OcclusionSampler",
+        "pbr_occlusionSampler",
         "HAS_OCCLUSIONMAP",
         parsedMaterial
       );
       const { strength = 1 } = material.occlusionTexture;
-      parsedMaterial.uniforms.u_OcclusionStrength = strength;
+      parsedMaterial.uniforms.occlusionStrength = strength;
     }
     if (material.emissiveTexture) {
       addTexture(
         device,
         material.emissiveTexture,
-        "u_EmissiveSampler",
+        "pbr_emissiveSampler",
         "HAS_EMISSIVEMAP",
         parsedMaterial
       );
-      parsedMaterial.uniforms.u_EmissiveFactor = material.emissiveFactor || [0, 0, 0];
+      parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
     }
     switch (material.alphaMode) {
       case "MASK":
         const { alphaCutoff = 0.5 } = material;
         parsedMaterial.defines.ALPHA_CUTOFF = 1;
-        parsedMaterial.uniforms.u_AlphaCutoff = alphaCutoff;
+        parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
         break;
       case "BLEND":
         import_core.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
@@ -171,23 +184,23 @@ var __exports__ = (() => {
       addTexture(
         device,
         pbrMetallicRoughness.baseColorTexture,
-        "u_BaseColorSampler",
+        "pbr_baseColorSampler",
         "HAS_BASECOLORMAP",
         parsedMaterial
       );
     }
-    parsedMaterial.uniforms.u_BaseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
+    parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
     if (pbrMetallicRoughness.metallicRoughnessTexture) {
       addTexture(
         device,
         pbrMetallicRoughness.metallicRoughnessTexture,
-        "u_MetallicRoughnessSampler",
+        "pbr_metallicRoughnessSampler",
         "HAS_METALROUGHNESSMAP",
         parsedMaterial
       );
     }
     const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
-    parsedMaterial.uniforms.u_MetallicRoughnessValues = [metallicFactor, roughnessFactor];
+    parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
   }
   function addTexture(device, gltfTexture, uniformName, define = null, parsedMaterial) {
     const parameters = gltfTexture?.texture?.sampler?.parameters || {};
@@ -264,7 +277,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/images/dist/lib/utils/version.js
-  var VERSION = true ? "4.2.0-beta.2" : "latest";
+  var VERSION = true ? "4.2.1" : "latest";
 
   // ../../node_modules/@loaders.gl/images/dist/lib/category-api/image-type.js
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -837,17 +850,11 @@ var __exports__ = (() => {
     printRowMajor: true,
     _cartographicRadians: false
   };
-  globalThis.mathgl = globalThis.mathgl || {
-    config: {
-      ...DEFAULT_CONFIG
-    }
-  };
+  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
   var config = globalThis.mathgl.config;
-  function formatValue(value, {
-    precision = config.precision
-  } = {}) {
+  function formatValue(value, { precision = config.precision } = {}) {
     value = round(value);
-    return "".concat(parseFloat(value.toPrecision(precision)));
+    return `${parseFloat(value.toPrecision(precision))}`;
   }
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
@@ -891,28 +898,12 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
-  function _extendableBuiltin(cls) {
-    function ExtendableBuiltin() {
-      var instance = Reflect.construct(cls, Array.from(arguments));
-      Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-      return instance;
-    }
-    ExtendableBuiltin.prototype = Object.create(cls.prototype, {
-      constructor: {
-        value: cls,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(ExtendableBuiltin, cls);
-    } else {
-      ExtendableBuiltin.__proto__ = cls;
-    }
-    return ExtendableBuiltin;
-  }
-  var MathArray = class extends _extendableBuiltin(Array) {
+  var MathArray = class extends Array {
+    // Common methods
+    /**
+     * Clone the current object
+     * @returns a new copy of this object
+     */
     clone() {
       return new this.constructor().copy(this);
     }
@@ -932,7 +923,10 @@ var __exports__ = (() => {
       return targetObject;
     }
     from(arrayOrObject) {
-      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
+        // @ts-ignore
+        this.fromObject(arrayOrObject)
+      );
     }
     to(arrayOrObject) {
       if (arrayOrObject === this) {
@@ -943,18 +937,20 @@ var __exports__ = (() => {
     toTarget(target) {
       return target ? this.to(target) : this;
     }
+    /** @deprecated */
     toFloat32Array() {
       return new Float32Array(this);
     }
     toString() {
       return this.formatString(config);
     }
+    /** Formats string according to options */
     formatString(opts) {
       let string = "";
       for (let i = 0; i < this.ELEMENTS; ++i) {
         string += (i > 0 ? ", " : "") + formatValue(this[i], opts);
       }
-      return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]");
+      return `${opts.printTypes ? this.constructor.name : ""}[${string}]`;
     }
     equals(array) {
       if (!array || this.length !== array.length) {
@@ -978,6 +974,8 @@ var __exports__ = (() => {
       }
       return true;
     }
+    // Modifiers
+    /** Negates all values in this object */
     negate() {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = -this[i];
@@ -995,12 +993,14 @@ var __exports__ = (() => {
       }
       return this.check();
     }
+    /** Minimal */
     min(vector) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.min(vector[i], this[i]);
       }
       return this.check();
     }
+    /** Maximal */
     max(vector) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.max(vector[i], this[i]);
@@ -1041,18 +1041,25 @@ var __exports__ = (() => {
       }
       return this.check();
     }
+    /**
+     * Multiplies all elements by `scale`
+     * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
+     */
     multiplyByScalar(scalar) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] *= scalar;
       }
       return this.check();
     }
+    // Debug checks
+    /** Throws an error if array length is incorrect or contains illegal values */
     check() {
       if (config.debug && !this.validate()) {
-        throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
+        throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
       }
       return this;
     }
+    /** Returns false if the array length is incorrect or contains illegal values */
     validate() {
       let valid = this.length === this.ELEMENTS;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -1060,39 +1067,48 @@ var __exports__ = (() => {
       }
       return valid;
     }
+    // three.js compatibility
+    /** @deprecated */
     sub(a) {
       return this.subtract(a);
     }
+    /** @deprecated */
     setScalar(a) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = a;
       }
       return this.check();
     }
+    /** @deprecated */
     addScalar(a) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] += a;
       }
       return this.check();
     }
+    /** @deprecated */
     subScalar(a) {
       return this.addScalar(-a);
     }
+    /** @deprecated */
     multiplyScalar(scalar) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] *= scalar;
       }
       return this.check();
     }
+    /** @deprecated */
     divideScalar(a) {
       return this.multiplyByScalar(1 / a);
     }
+    /** @deprecated */
     clampScalar(min, max) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.min(Math.max(this[i], min), max);
       }
       return this.check();
     }
+    /** @deprecated */
     get elements() {
       return this;
     }
@@ -1112,13 +1128,13 @@ var __exports__ = (() => {
   }
   function checkNumber(value) {
     if (!Number.isFinite(value)) {
-      throw new Error("Invalid number ".concat(JSON.stringify(value)));
+      throw new Error(`Invalid number ${JSON.stringify(value)}`);
     }
     return value;
   }
   function checkVector(v, length4, callerName = "") {
     if (config.debug && !validateVector(v, length4)) {
-      throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'"));
+      throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
     }
     return v;
   }
@@ -1126,12 +1142,13 @@ var __exports__ = (() => {
   // ../../node_modules/@math.gl/core/dist/lib/assert.js
   function assert2(condition, message) {
     if (!condition) {
-      throw new Error("math.gl assertion ".concat(message));
+      throw new Error(`math.gl assertion ${message}`);
     }
   }
 
   // ../../node_modules/@math.gl/core/dist/classes/base/vector.js
   var Vector = class extends MathArray {
+    // ACCESSORS
     get x() {
       return this[0];
     }
@@ -1144,12 +1161,24 @@ var __exports__ = (() => {
     set y(value) {
       this[1] = checkNumber(value);
     }
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     *
+     * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements
+     * Instead we provide `len` and `magnitude`
+     */
     len() {
       return Math.sqrt(this.lengthSquared());
     }
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     */
     magnitude() {
       return this.len();
     }
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
     lengthSquared() {
       let length4 = 0;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -1157,6 +1186,9 @@ var __exports__ = (() => {
       }
       return length4;
     }
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
     magnitudeSquared() {
       return this.lengthSquared();
     }
@@ -1178,6 +1210,7 @@ var __exports__ = (() => {
       }
       return checkNumber(product);
     }
+    // MODIFIERS
     normalize() {
       const length4 = this.magnitude();
       if (length4 !== 0) {
@@ -1203,6 +1236,7 @@ var __exports__ = (() => {
       }
       return this.check();
     }
+    // THREE.js compatibility
     lengthSq() {
       return this.lengthSquared();
     }
@@ -1501,6 +1535,8 @@ var __exports__ = (() => {
       object.w = this[3];
       return object;
     }
+    // Getters/setters
+    /* eslint-disable no-multi-spaces, brace-style, no-return-assign */
     get ELEMENTS() {
       return 4;
     }
@@ -1532,6 +1568,7 @@ var __exports__ = (() => {
       transformQuat(this, this, quaternion2);
       return this.check();
     }
+    // three.js compatibility
     applyMatrix4(m) {
       m.transform(this, this);
       return this;
@@ -1540,19 +1577,29 @@ var __exports__ = (() => {
 
   // ../../node_modules/@math.gl/core/dist/classes/base/matrix.js
   var Matrix = class extends MathArray {
+    // fromObject(object) {
+    //   const array = object.elements;
+    //   return this.fromRowMajor(array);
+    // }
+    // toObject(object) {
+    //   const array = object.elements;
+    //   this.toRowMajor(array);
+    //   return object;
+    // }
+    // TODO better override formatString?
     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]);
+            string += ` ${this[col * this.RANK + row]}`;
           }
         }
       } else {
         string += "column-major:";
         for (let i = 0; i < this.ELEMENTS; ++i) {
-          string += " ".concat(this[i]);
+          string += ` ${this[i]}`;
         }
       }
       string += "]";
@@ -1561,9 +1608,11 @@ var __exports__ = (() => {
     getElementIndex(row, col) {
       return col * this.RANK + row;
     }
+    // By default assumes row major indices
     getElement(row, col) {
       return this[col * this.RANK + row];
     }
+    // By default assumes row major indices
     setElement(row, col, value) {
       this[col * this.RANK + row] = checkNumber(value);
       return this;
@@ -2421,6 +2470,7 @@ var __exports__ = (() => {
       this[15] = array[15];
       return this.check();
     }
+    // eslint-disable-next-line max-params
     set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) {
       this[0] = m00;
       this[1] = m10;
@@ -2440,6 +2490,8 @@ var __exports__ = (() => {
       this[15] = m33;
       return this.check();
     }
+    // accepts row major order, stores as column major
+    // eslint-disable-next-line max-params
     setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
       this[0] = m00;
       this[1] = m10;
@@ -2478,25 +2530,41 @@ var __exports__ = (() => {
       result[15] = this[15];
       return result;
     }
+    // Constructors
+    /** Set to identity matrix */
     identity() {
       return this.copy(IDENTITY_MATRIX);
     }
+    /**
+     *
+     * @param object
+     * @returns self
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     fromObject(object) {
       return this.check();
     }
+    /**
+     * Calculates a 4x4 matrix from the given quaternion
+     * @param quaternion Quaternion to create matrix from
+     * @returns self
+     */
     fromQuaternion(quaternion2) {
       fromQuat(this, quaternion2);
       return this.check();
     }
+    /**
+     * Generates a frustum matrix with the given bounds
+     * @param view.left - Left bound of the frustum
+     * @param view.right - Right bound of the frustum
+     * @param view.bottom - Bottom bound of the frustum
+     * @param view.top - Top bound of the frustum
+     * @param view.near - Near bound of the frustum
+     * @param view.far - Far bound of the frustum. Can be set to Infinity.
+     * @returns self
+     */
     frustum(view) {
-      const {
-        left,
-        right,
-        bottom,
-        top,
-        near = DEFAULT_NEAR,
-        far = DEFAULT_FAR
-      } = view;
+      const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
       if (far === Infinity) {
         computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
       } else {
@@ -2504,35 +2572,47 @@ var __exports__ = (() => {
       }
       return this.check();
     }
+    /**
+     * Generates a look-at matrix with the given eye position, focal point,
+     * and up axis
+     * @param view.eye - (vector) Position of the viewer
+     * @param view.center - (vector) Point the viewer is looking at
+     * @param view.up - (vector) Up axis
+     * @returns self
+     */
     lookAt(view) {
-      const {
-        eye,
-        center = [0, 0, 0],
-        up = [0, 1, 0]
-      } = view;
+      const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view;
       lookAt(this, eye, center, up);
       return this.check();
     }
+    /**
+     * Generates a orthogonal projection matrix with the given bounds
+     * from "traditional" view space parameters
+     * @param view.left - Left bound of the frustum
+     * @param view.right number  Right bound of the frustum
+     * @param view.bottom - Bottom bound of the frustum
+     * @param view.top number  Top bound of the frustum
+     * @param view.near - Near bound of the frustum
+     * @param view.far number  Far bound of the frustum
+     * @returns self
+     */
     ortho(view) {
-      const {
-        left,
-        right,
-        bottom,
-        top,
-        near = DEFAULT_NEAR,
-        far = DEFAULT_FAR
-      } = view;
+      const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
       ortho(this, left, right, bottom, top, near, far);
       return this.check();
     }
+    /**
+     * Generates an orthogonal projection matrix with the same parameters
+     * as a perspective matrix (plus focalDistance)
+     * @param view.fovy Vertical field of view in radians
+     * @param view.aspect Aspect ratio. Typically viewport width / viewport height
+     * @param view.focalDistance Distance in the view frustum used for extent calculations
+     * @param view.near Near bound of the frustum
+     * @param view.far Far bound of the frustum
+     * @returns self
+     */
     orthographic(view) {
-      const {
-        fovy = DEFAULT_FOVY,
-        aspect = DEFAULT_ASPECT,
-        focalDistance = 1,
-        near = DEFAULT_NEAR,
-        far = DEFAULT_FAR
-      } = 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);
@@ -2546,32 +2626,53 @@ var __exports__ = (() => {
         far
       });
     }
+    /**
+     * Generates a perspective projection matrix with the given bounds
+     * @param view.fovy Vertical field of view in radians
+     * @param view.aspect Aspect ratio. typically viewport width/height
+     * @param view.near Near bound of the frustum
+     * @param view.far Far bound of the frustum
+     * @returns self
+     */
     perspective(view) {
-      const {
-        fovy = 45 * Math.PI / 180,
-        aspect = 1,
-        near = 0.1,
-        far = 500
-      } = 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();
     }
+    // Accessors
     determinant() {
       return determinant(this);
     }
+    /**
+     * Extracts the non-uniform scale assuming the matrix is an affine transformation.
+     * The scales are the "lengths" of the column vectors in the upper-left 3x3 matrix.
+     * @param result
+     * @returns self
+     */
     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;
     }
+    /**
+     * Gets the translation portion, assuming the matrix is a affine transformation matrix.
+     * @param result
+     * @returns self
+     */
     getTranslation(result = [-0, -0, -0]) {
       result[0] = this[12];
       result[1] = this[13];
       result[2] = this[14];
       return result;
     }
+    /**
+     * Gets upper left 3x3 pure rotation matrix (non-scaling), assume affine transformation matrix
+     * @param result
+     * @param scaleResult
+     * @returns self
+     */
     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];
@@ -2597,6 +2698,12 @@ var __exports__ = (() => {
       result[15] = 1;
       return result;
     }
+    /**
+     *
+     * @param result
+     * @param scaleResult
+     * @returns self
+     */
     getRotationMatrix3(result, scaleResult) {
       result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0];
       scaleResult = scaleResult || [-0, -0, -0];
@@ -2615,6 +2722,7 @@ var __exports__ = (() => {
       result[8] = this[10] * inverseScale2;
       return result;
     }
+    // Modifiers
     transpose() {
       transpose(this, this);
       return this.check();
@@ -2623,6 +2731,7 @@ var __exports__ = (() => {
       invert(this, this);
       return this.check();
     }
+    // Operations
     multiplyLeft(a) {
       multiply(this, a, this);
       return this.check();
@@ -2631,33 +2740,68 @@ var __exports__ = (() => {
       multiply(this, this, a);
       return this.check();
     }
+    // Rotates a matrix by the given angle around the X axis
     rotateX(radians) {
       rotateX(this, this, radians);
       return this.check();
     }
+    // Rotates a matrix by the given angle around the Y axis.
     rotateY(radians) {
       rotateY(this, this, radians);
       return this.check();
     }
+    /**
+     * Rotates a matrix by the given angle around the Z axis.
+     * @param radians
+     * @returns self
+     */
     rotateZ(radians) {
       rotateZ(this, this, radians);
       return this.check();
     }
+    /**
+     *
+     * @param param0
+     * @returns self
+     */
     rotateXYZ(angleXYZ) {
       return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]);
     }
+    /**
+     *
+     * @param radians
+     * @param axis
+     * @returns self
+     */
     rotateAxis(radians, axis) {
       rotate(this, this, radians, axis);
       return this.check();
     }
+    /**
+     *
+     * @param factor
+     * @returns self
+     */
     scale(factor) {
       scale(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
       return this.check();
     }
+    /**
+     *
+     * @param vec
+     * @returns self
+     */
     translate(vector) {
       translate(this, this, vector);
       return this.check();
     }
+    // Transforms
+    /**
+     * Transforms any 2, 3 or 4 element vector. 2 and 3 elements are treated as points
+     * @param vector
+     * @param result
+     * @returns self
+     */
     transform(vector, result) {
       if (vector.length === 4) {
         result = transformMat43(result || [-0, -0, -0, -0], vector, this);
@@ -2666,10 +2810,14 @@ var __exports__ = (() => {
       }
       return this.transformAsPoint(vector, result);
     }
+    /**
+     * Transforms any 2 or 3 element array as point (w implicitly 1)
+     * @param vector
+     * @param result
+     * @returns self
+     */
     transformAsPoint(vector, result) {
-      const {
-        length: length4
-      } = vector;
+      const { length: length4 } = vector;
       let out;
       switch (length4) {
         case 2:
@@ -2684,6 +2832,12 @@ var __exports__ = (() => {
       checkVector(out, vector.length);
       return out;
     }
+    /**
+     * Transforms any 2 or 3 element array as vector (w implicitly 0)
+     * @param vector
+     * @param result
+     * @returns self
+     */
     transformAsVector(vector, result) {
       let out;
       switch (vector.length) {
@@ -2699,15 +2853,19 @@ var __exports__ = (() => {
       checkVector(out, vector.length);
       return out;
     }
+    /** @deprecated */
     transformPoint(vector, result) {
       return this.transformAsPoint(vector, result);
     }
+    /** @deprecated */
     transformVector(vector, result) {
       return this.transformAsPoint(vector, result);
     }
+    /** @deprecated */
     transformDirection(vector, result) {
       return this.transformAsVector(vector, result);
     }
+    // three.js math API compatibility
     makeRotationX(radians) {
       return this.identity().rotateX(radians);
     }
@@ -3034,6 +3192,13 @@ var __exports__ = (() => {
       this[3] = object.w;
       return this.check();
     }
+    /**
+     * Creates a quaternion from the given 3x3 rotation matrix.
+     * NOTE: The resultant quaternion is not normalized, so you should
+     * be sure to renormalize the quaternion yourself where necessary.
+     * @param m
+     * @returns
+     */
     fromMatrix3(m) {
       fromMat3(this, m);
       return this.check();
@@ -3042,13 +3207,21 @@ var __exports__ = (() => {
       setAxisAngle(this, axis, rad);
       return this.check();
     }
+    /** Set a quat to the identity quaternion */
     identity() {
       identity2(this);
       return this.check();
     }
+    // Set the components of a quat to the given values
+    // set(i, j, k, l) {
+    //   quat_set(this, i, j, k, l);
+    //   return this.check();
+    // }
+    // Sets a quat from the given angle and rotation axis, then returns it.
     setAxisAngle(axis, rad) {
       return this.fromAxisRotation(axis, rad);
     }
+    // Getters/setters
     get ELEMENTS() {
       return 4;
     }
@@ -3076,35 +3249,72 @@ var __exports__ = (() => {
     set w(value) {
       this[3] = checkNumber(value);
     }
+    // Calculates the length of a quat
     len() {
       return length3(this);
     }
+    // Calculates the squared length of a quat
     lengthSquared() {
       return squaredLength2(this);
     }
+    // Calculates the dot product of two quat's
+    // @return {Number}
     dot(a) {
       return dot3(this, a);
     }
+    // Gets the rotation axis and angle for a given quaternion.
+    // If a quaternion is created with setAxisAngle, this method will
+    // return the same values as providied in the original parameter
+    // list OR functionally equivalent values.
+    // Example: The quaternion formed by axis [0, 0, 1] and angle -90
+    // is the same as the quaternion formed by [0, 0, 1] and 270.
+    // This method favors the latter.
+    // @return {{[x,y,z], Number}}
+    // getAxisAngle() {
+    //   const axis = [];
+    // //   const angle = quat_getAxisAngle(axis, this);
+    //   return {axis, angle};
+    // }
+    // MODIFIERS
+    // Sets a quaternion to represent the shortest rotation from one vector
+    // to another. Both vectors are assumed to be unit length.
     rotationTo(vectorA, vectorB) {
       rotationTo(this, vectorA, vectorB);
       return this.check();
     }
+    // Sets the specified quaternion with values corresponding to the given axes.
+    // Each axis is a vec3 and is expected to be unit length and perpendicular
+    // to all other specified axes.
+    // setAxes() {
+    //   Number
+    // }
+    // Performs a spherical linear interpolation with two control points
+    // sqlerp() {
+    //   Number;
+    // }
+    // Adds two quat's
     add(a) {
       add2(this, this, a);
       return this.check();
     }
+    // Calculates the W component of a quat from the X, Y, and Z components.
+    // Any existing W component will be ignored.
     calculateW() {
       calculateW(this, this);
       return this.check();
     }
+    // Calculates the conjugate of a quat If the quaternion is normalized,
+    // this function is faster than quat_invert and produces the same result.
     conjugate() {
       conjugate(this, this);
       return this.check();
     }
+    // Calculates the inverse of a quat
     invert() {
       invert2(this, this);
       return this.check();
     }
+    // Performs a linear interpolation between two quat's
     lerp(a, b, t) {
       if (t === void 0) {
         return this.lerp(this, a, b);
@@ -3112,6 +3322,7 @@ var __exports__ = (() => {
       lerp2(this, a, b, t);
       return this.check();
     }
+    // Multiplies two quat's
     multiplyRight(a) {
       multiply2(this, this, a);
       return this.check();
@@ -3120,6 +3331,7 @@ var __exports__ = (() => {
       multiply2(this, a, this);
       return this.check();
     }
+    // Normalize a quat
     normalize() {
       const length4 = this.len();
       const l = length4 > 0 ? 1 / length4 : 0;
@@ -3132,22 +3344,27 @@ var __exports__ = (() => {
       }
       return this.check();
     }
+    // Rotates a quaternion by the given angle about the X axis
     rotateX(rad) {
       rotateX2(this, this, rad);
       return this.check();
     }
+    // Rotates a quaternion by the given angle about the Y axis
     rotateY(rad) {
       rotateY2(this, this, rad);
       return this.check();
     }
+    // Rotates a quaternion by the given angle about the Z axis
     rotateZ(rad) {
       rotateZ2(this, this, rad);
       return this.check();
     }
+    // Scales a quat by a scalar number
     scale(b) {
       scale3(this, this, b);
       return this.check();
     }
+    // Performs a spherical linear interpolation between two quat
     slerp(arg0, arg1, arg2) {
       let start;
       let target;
@@ -3177,6 +3394,7 @@ var __exports__ = (() => {
       transformQuat2(result, vector, this);
       return checkVector(result, 4);
     }
+    // THREE.js Math API compatibility
     lengthSq() {
       return this.lengthSquared();
     }
@@ -3369,568 +3587,7 @@ var __exports__ = (() => {
 
   // src/gltf/create-gltf-model.ts
   var import_core4 = __toESM(require_core(), 1);
-
-  // ../shadertools/src/lib/glsl-utils/highlight.ts
-  var glsl = (x) => `${x}`;
-
-  // ../shadertools/src/modules-webgl1/lighting/lights/lights-glsl.ts
-  var lightingShader = glsl`\
-#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
-
-struct AmbientLight {
- vec3 color;
-};
-
-struct PointLight {
- vec3 color;
- vec3 position;
-
- // Constant-Linear-Exponential
- vec3 attenuation;
-};
-
-struct DirectionalLight {
-  vec3 color;
-  vec3 direction;
-};
-
-uniform AmbientLight lighting_uAmbientLight;
-uniform PointLight lighting_uPointLight[MAX_LIGHTS];
-uniform DirectionalLight lighting_uDirectionalLight[MAX_LIGHTS];
-uniform int lighting_uPointLightCount;
-uniform int lighting_uDirectionalLightCount;
-
-uniform bool lighting_uEnabled;
-
-float getPointLightAttenuation(PointLight pointLight, float distance) {
-  return pointLight.attenuation.x
-       + pointLight.attenuation.y * distance
-       + pointLight.attenuation.z * distance * distance;
-}
-
-#endif
-`;
-
-  // ../shadertools/src/modules-webgl1/lighting/lights/lights.ts
-  var INITIAL_MODULE_OPTIONS = {
-    lightSources: {}
-  };
-  function convertColor(colorDef = {}) {
-    const { color = [0, 0, 0], intensity = 1 } = colorDef;
-    return color.map((component) => component * intensity / 255);
-  }
-  function getLightSourceUniforms({
-    ambientLight,
-    pointLights = [],
-    directionalLights = []
-  }) {
-    const lightSourceUniforms = {};
-    if (ambientLight) {
-      lightSourceUniforms["lighting_uAmbientLight.color"] = convertColor(ambientLight);
-    } else {
-      lightSourceUniforms["lighting_uAmbientLight.color"] = [0, 0, 0];
-    }
-    pointLights.forEach((pointLight, index) => {
-      lightSourceUniforms[`lighting_uPointLight[${index}].color`] = convertColor(pointLight);
-      lightSourceUniforms[`lighting_uPointLight[${index}].position`] = pointLight.position;
-      lightSourceUniforms[`lighting_uPointLight[${index}].attenuation`] = pointLight.attenuation || [
-        1,
-        0,
-        0
-      ];
-    });
-    lightSourceUniforms.lighting_uPointLightCount = pointLights.length;
-    directionalLights.forEach((directionalLight, index) => {
-      lightSourceUniforms[`lighting_uDirectionalLight[${index}].color`] = convertColor(directionalLight);
-      lightSourceUniforms[`lighting_uDirectionalLight[${index}].direction`] = directionalLight.direction;
-    });
-    lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length;
-    return lightSourceUniforms;
-  }
-  function getUniforms(opts = INITIAL_MODULE_OPTIONS) {
-    if ("lightSources" in opts) {
-      const { ambientLight, pointLights, directionalLights } = opts.lightSources || {};
-      const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0;
-      if (!hasLights) {
-        return { lighting_uEnabled: false };
-      }
-      return Object.assign(
-        {},
-        getLightSourceUniforms({ ambientLight, pointLights, directionalLights }),
-        {
-          lighting_uEnabled: true
-        }
-      );
-    }
-    if ("lights" in opts) {
-      const lightSources = { pointLights: [], directionalLights: [] };
-      for (const light of opts.lights || []) {
-        switch (light.type) {
-          case "ambient":
-            lightSources.ambientLight = light;
-            break;
-          case "directional":
-            lightSources.directionalLights?.push(light);
-            break;
-          case "point":
-            lightSources.pointLights?.push(light);
-            break;
-          default:
-        }
-      }
-      return getUniforms({ lightSources });
-    }
-    return {};
-  }
-  var lights = {
-    name: "lights",
-    vs: lightingShader,
-    fs: lightingShader,
-    getUniforms,
-    defines: {
-      MAX_LIGHTS: 3
-    }
-  };
-
-  // ../shadertools/src/modules-webgl1/lighting/pbr/pbr-vertex-glsl.ts
-  var vs = glsl`\
-uniform mat4 u_MVPMatrix;
-uniform mat4 u_ModelMatrix;
-uniform mat4 u_NormalMatrix;
-
-out vec3 pbr_vPosition;
-out vec2 pbr_vUV;
-
-#ifdef HAS_NORMALS
-# ifdef HAS_TANGENTS
-out mat3 pbr_vTBN;
-# else
-out vec3 pbr_vNormal;
-# endif
-#endif
-
-void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
-{
-  vec4 pos = u_ModelMatrix * position;
-  pbr_vPosition = vec3(pos.xyz) / pos.w;
-
-#ifdef HAS_NORMALS
-#ifdef HAS_TANGENTS
-  vec3 normalW = normalize(vec3(u_NormalMatrix * vec4(normal.xyz, 0.0)));
-  vec3 tangentW = normalize(vec3(u_ModelMatrix * vec4(tangent.xyz, 0.0)));
-  vec3 bitangentW = cross(normalW, tangentW) * tangent.w;
-  pbr_vTBN = mat3(tangentW, bitangentW, normalW);
-#else // HAS_TANGENTS != 1
-  pbr_vNormal = normalize(vec3(u_ModelMatrix * vec4(normal.xyz, 0.0)));
-#endif
-#endif
-
-#ifdef HAS_UV
-  pbr_vUV = uv;
-#else
-  pbr_vUV = vec2(0.,0.);
-#endif
-}
-`;
-
-  // ../shadertools/src/modules-webgl1/lighting/pbr/pbr-fragment-glsl.ts
-  var fs = glsl`\
-precision highp float;
-
-uniform bool pbr_uUnlit;
-
-#ifdef USE_IBL
-uniform samplerCube u_DiffuseEnvSampler;
-uniform samplerCube u_SpecularEnvSampler;
-uniform sampler2D u_brdfLUT;
-uniform vec2 u_ScaleIBLAmbient;
-#endif
-
-#ifdef HAS_BASECOLORMAP
-uniform sampler2D u_BaseColorSampler;
-#endif
-#ifdef HAS_NORMALMAP
-uniform sampler2D u_NormalSampler;
-uniform float u_NormalScale;
-#endif
-#ifdef HAS_EMISSIVEMAP
-uniform sampler2D u_EmissiveSampler;
-uniform vec3 u_EmissiveFactor;
-#endif
-#ifdef HAS_METALROUGHNESSMAP
-uniform sampler2D u_MetallicRoughnessSampler;
-#endif
-#ifdef HAS_OCCLUSIONMAP
-uniform sampler2D u_OcclusionSampler;
-uniform float u_OcclusionStrength;
-#endif
-
-#ifdef ALPHA_CUTOFF
-uniform float u_AlphaCutoff;
-#endif
-
-uniform vec2 u_MetallicRoughnessValues;
-uniform vec4 u_BaseColorFactor;
-
-uniform vec3 u_Camera;
-
-// debugging flags used for shader output of intermediate PBR variables
-#ifdef PBR_DEBUG
-uniform vec4 u_ScaleDiffBaseMR;
-uniform vec4 u_ScaleFGDSpec;
-#endif
-
-in vec3 pbr_vPosition;
-
-in vec2 pbr_vUV;
-
-#ifdef HAS_NORMALS
-#ifdef HAS_TANGENTS
-in mat3 pbr_vTBN;
-#else
-in vec3 pbr_vNormal;
-#endif
-#endif
-
-// Encapsulate the various inputs used by the various functions in the shading equation
-// We store values in this struct to simplify the integration of alternative implementations
-// of the shading terms, outlined in the Readme.MD Appendix.
-struct PBRInfo
-{
-  float NdotL;                  // cos angle between normal and light direction
-  float NdotV;                  // cos angle between normal and view direction
-  float NdotH;                  // cos angle between normal and half vector
-  float LdotH;                  // cos angle between light direction and half vector
-  float VdotH;                  // cos angle between view direction and half vector
-  float perceptualRoughness;    // roughness value, as authored by the model creator (input to shader)
-  float metalness;              // metallic value at the surface
-  vec3 reflectance0;            // full reflectance color (normal incidence angle)
-  vec3 reflectance90;           // reflectance color at grazing angle
-  float alphaRoughness;         // roughness mapped to a more linear change in the roughness (proposed by [2])
-  vec3 diffuseColor;            // color contribution from diffuse lighting
-  vec3 specularColor;           // color contribution from specular lighting
-  vec3 n;                       // normal at surface point
-  vec3 v;                       // vector from surface point to camera
-};
-
-const float M_PI = 3.141592653589793;
-const float c_MinRoughness = 0.04;
-
-vec4 SRGBtoLINEAR(vec4 srgbIn)
-{
-#ifdef MANUAL_SRGB
-#ifdef SRGB_FAST_APPROXIMATION
-  vec3 linOut = pow(srgbIn.xyz,vec3(2.2));
-#else //SRGB_FAST_APPROXIMATION
-  vec3 bLess = step(vec3(0.04045),srgbIn.xyz);
-  vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
-#endif //SRGB_FAST_APPROXIMATION
-  return vec4(linOut,srgbIn.w);;
-#else //MANUAL_SRGB
-  return srgbIn;
-#endif //MANUAL_SRGB
-}
-
-// Find the normal for this fragment, pulling either from a predefined normal map
-// or from the interpolated mesh normal and tangent attributes.
-vec3 getNormal()
-{
-  // Retrieve the tangent space matrix
-#ifndef HAS_TANGENTS
-  vec3 pos_dx = dFdx(pbr_vPosition);
-  vec3 pos_dy = dFdy(pbr_vPosition);
-  vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));
-  vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));
-  vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
-
-#ifdef HAS_NORMALS
-  vec3 ng = normalize(pbr_vNormal);
-#else
-  vec3 ng = cross(pos_dx, pos_dy);
-#endif
-
-  t = normalize(t - ng * dot(ng, t));
-  vec3 b = normalize(cross(ng, t));
-  mat3 tbn = mat3(t, b, ng);
-#else // HAS_TANGENTS
-  mat3 tbn = pbr_vTBN;
-#endif
-
-#ifdef HAS_NORMALMAP
-  vec3 n = texture(u_NormalSampler, pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_NormalScale, u_NormalScale, 1.0)));
-#else
-  // The tbn matrix is linearly interpolated, so we need to re-normalize
-  vec3 n = normalize(tbn[2].xyz);
-#endif
-
-  return n;
-}
-
-// Calculation of the lighting contribution from an optional Image Based Light source.
-// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
-// See our README.md on Environment Maps [3] for additional discussion.
-#ifdef USE_IBL
-vec3 getIBLContribution(PBRInfo pbrInputs, vec3 n, vec3 reflection)
-{
-  float mipCount = 9.0; // resolution of 512x512
-  float lod = (pbrInputs.perceptualRoughness * mipCount);
-  // retrieve a scale and bias to F0. See [1], Figure 3
-  vec3 brdf = SRGBtoLINEAR(texture(u_brdfLUT,
-    vec2(pbrInputs.NdotV, 1.0 - pbrInputs.perceptualRoughness))).rgb;
-  vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;
-
-#ifdef USE_TEX_LOD
-  vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;
-#else
-  vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;
-#endif
-
-  vec3 diffuse = diffuseLight * pbrInputs.diffuseColor;
-  vec3 specular = specularLight * (pbrInputs.specularColor * brdf.x + brdf.y);
-
-  // For presentation, this allows us to disable IBL terms
-  diffuse *= u_ScaleIBLAmbient.x;
-  specular *= u_ScaleIBLAmbient.y;
-
-  return diffuse + specular;
-}
-#endif
-
-// Basic Lambertian diffuse
-// Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog
-// See also [1], Equation 1
-vec3 diffuse(PBRInfo pbrInputs)
-{
-  return pbrInputs.diffuseColor / M_PI;
-}
-
-// The following equation models the Fresnel reflectance term of the spec equation (aka F())
-// Implementation of fresnel from [4], Equation 15
-vec3 specularReflection(PBRInfo pbrInputs)
-{
-  return pbrInputs.reflectance0 +
-    (pbrInputs.reflectance90 - pbrInputs.reflectance0) *
-    pow(clamp(1.0 - pbrInputs.VdotH, 0.0, 1.0), 5.0);
-}
-
-// This calculates the specular geometric attenuation (aka G()),
-// where rougher material will reflect less light back to the viewer.
-// This implementation is based on [1] Equation 4, and we adopt their modifications to
-// alphaRoughness as input as originally proposed in [2].
-float geometricOcclusion(PBRInfo pbrInputs)
-{
-  float NdotL = pbrInputs.NdotL;
-  float NdotV = pbrInputs.NdotV;
-  float r = pbrInputs.alphaRoughness;
-
-  float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
-  float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
-  return attenuationL * attenuationV;
-}
-
-// The following equation(s) model the distribution of microfacet normals across
-// the area being drawn (aka D())
-// Implementation from "Average Irregularity Representation of a Roughened Surface
-// for Ray Reflection" by T. S. Trowbridge, and K. P. Reitz
-// Follows the distribution function recommended in the SIGGRAPH 2013 course notes
-// from EPIC Games [1], Equation 3.
-float microfacetDistribution(PBRInfo pbrInputs)
-{
-  float roughnessSq = pbrInputs.alphaRoughness * pbrInputs.alphaRoughness;
-  float f = (pbrInputs.NdotH * roughnessSq - pbrInputs.NdotH) * pbrInputs.NdotH + 1.0;
-  return roughnessSq / (M_PI * f * f);
-}
-
-void PBRInfo_setAmbientLight(inout PBRInfo pbrInputs) {
-  pbrInputs.NdotL = 1.0;
-  pbrInputs.NdotH = 0.0;
-  pbrInputs.LdotH = 0.0;
-  pbrInputs.VdotH = 1.0;
-}
-
-void PBRInfo_setDirectionalLight(inout PBRInfo pbrInputs, vec3 lightDirection) {
-  vec3 n = pbrInputs.n;
-  vec3 v = pbrInputs.v;
-  vec3 l = normalize(lightDirection);             // Vector from surface point to light
-  vec3 h = normalize(l+v);                        // Half vector between both l and v
-
-  pbrInputs.NdotL = clamp(dot(n, l), 0.001, 1.0);
-  pbrInputs.NdotH = clamp(dot(n, h), 0.0, 1.0);
-  pbrInputs.LdotH = clamp(dot(l, h), 0.0, 1.0);
-  pbrInputs.VdotH = clamp(dot(v, h), 0.0, 1.0);
-}
-
-void PBRInfo_setPointLight(inout PBRInfo pbrInputs, PointLight pointLight) {
-  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
-  PBRInfo_setDirectionalLight(pbrInputs, light_direction);
-}
-
-vec3 calculateFinalColor(PBRInfo pbrInputs, vec3 lightColor) {
-  // Calculate the shading terms for the microfacet specular shading model
-  vec3 F = specularReflection(pbrInputs);
-  float G = geometricOcclusion(pbrInputs);
-  float D = microfacetDistribution(pbrInputs);
-
-  // Calculation of analytical lighting contribution
-  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInputs);
-  vec3 specContrib = F * G * D / (4.0 * pbrInputs.NdotL * pbrInputs.NdotV);
-  // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)
-  return pbrInputs.NdotL * lightColor * (diffuseContrib + specContrib);
-}
-
-vec4 pbr_filterColor(vec4 colorUnused)
-{
-  // The albedo may be defined from a base texture or a flat color
-#ifdef HAS_BASECOLORMAP
-  vec4 baseColor = SRGBtoLINEAR(texture(u_BaseColorSampler, pbr_vUV)) * u_BaseColorFactor;
-#else
-  vec4 baseColor = u_BaseColorFactor;
-#endif
-
-#ifdef ALPHA_CUTOFF
-  if (baseColor.a < u_AlphaCutoff) {
-    discard;
-  }
-#endif
-
-  vec3 color = vec3(0, 0, 0);
-
-  if(pbr_uUnlit){
-    color.rgb = baseColor.rgb;
-  }
-  else{
-    // Metallic and Roughness material properties are packed together
-    // In glTF, these factors can be specified by fixed scalar values
-    // or from a metallic-roughness map
-    float perceptualRoughness = u_MetallicRoughnessValues.y;
-    float metallic = u_MetallicRoughnessValues.x;
-#ifdef HAS_METALROUGHNESSMAP
-    // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
-    // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
-    vec4 mrSample = texture(u_MetallicRoughnessSampler, pbr_vUV);
-    perceptualRoughness = mrSample.g * perceptualRoughness;
-    metallic = mrSample.b * metallic;
-#endif
-    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
-    metallic = clamp(metallic, 0.0, 1.0);
-    // Roughness is authored as perceptual roughness; as is convention,
-    // convert to material roughness by squaring the perceptual roughness [2].
-    float alphaRoughness = perceptualRoughness * perceptualRoughness;
-
-    vec3 f0 = vec3(0.04);
-    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
-    diffuseColor *= 1.0 - metallic;
-    vec3 specularColor = mix(f0, baseColor.rgb, metallic);
-
-    // Compute reflectance.
-    float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
-
-    // For typical incident reflectance range (between 4% to 100%) set the grazing
-    // reflectance to 100% for typical fresnel effect.
-    // For very low reflectance range on highly diffuse objects (below 4%),
-    // incrementally reduce grazing reflecance to 0%.
-    float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
-    vec3 specularEnvironmentR0 = specularColor.rgb;
-    vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
-
-    vec3 n = getNormal();                          // normal at surface point
-    vec3 v = normalize(u_Camera - pbr_vPosition);  // Vector from surface point to camera
-
-    float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
-    vec3 reflection = -normalize(reflect(v, n));
-
-    PBRInfo pbrInputs = PBRInfo(
-      0.0, // NdotL
-      NdotV,
-      0.0, // NdotH
-      0.0, // LdotH
-      0.0, // VdotH
-      perceptualRoughness,
-      metallic,
-      specularEnvironmentR0,
-      specularEnvironmentR90,
-      alphaRoughness,
-      diffuseColor,
-      specularColor,
-      n,
-      v
-    );
-
-#ifdef USE_LIGHTS
-    // Apply ambient light
-    PBRInfo_setAmbientLight(pbrInputs);
-    color += calculateFinalColor(pbrInputs, lighting_uAmbientLight.color);
-
-    // Apply directional light
-    for(int i = 0; i < lighting_uDirectionalLightCount; i++) {
-      if (i < lighting_uDirectionalLightCount) {
-        PBRInfo_setDirectionalLight(pbrInputs, lighting_uDirectionalLight[i].direction);
-        color += calculateFinalColor(pbrInputs, lighting_uDirectionalLight[i].color);
-      }
-    }
-
-    // Apply point light
-    for(int i = 0; i < lighting_uPointLightCount; i++) {
-      if (i < lighting_uPointLightCount) {
-        PBRInfo_setPointLight(pbrInputs, lighting_uPointLight[i]);
-        float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));
-        color += calculateFinalColor(pbrInputs, lighting_uPointLight[i].color / attenuation);
-      }
-    }
-#endif
-
-    // Calculate lighting contribution from image based lighting source (IBL)
-#ifdef USE_IBL
-    color += getIBLContribution(pbrInputs, n, reflection);
-#endif
-
-    // Apply optional PBR terms for additional (optional) shading
-#ifdef HAS_OCCLUSIONMAP
-    float ao = texture(u_OcclusionSampler, pbr_vUV).r;
-    color = mix(color, color * ao, u_OcclusionStrength);
-#endif
-
-#ifdef HAS_EMISSIVEMAP
-    vec3 emissive = SRGBtoLINEAR(texture(u_EmissiveSampler, pbr_vUV)).rgb * u_EmissiveFactor;
-    color += emissive;
-#endif
-
-    // This section uses mix to override final color for reference app visualization
-    // of various parameters in the lighting equation.
-#ifdef PBR_DEBUG
-    // TODO: Figure out how to debug multiple lights
-
-    // color = mix(color, F, u_ScaleFGDSpec.x);
-    // color = mix(color, vec3(G), u_ScaleFGDSpec.y);
-    // color = mix(color, vec3(D), u_ScaleFGDSpec.z);
-    // color = mix(color, specContrib, u_ScaleFGDSpec.w);
-
-    // color = mix(color, diffuseContrib, u_ScaleDiffBaseMR.x);
-    color = mix(color, baseColor.rgb, u_ScaleDiffBaseMR.y);
-    color = mix(color, vec3(metallic), u_ScaleDiffBaseMR.z);
-    color = mix(color, vec3(perceptualRoughness), u_ScaleDiffBaseMR.w);
-#endif
-
-  }
-
-  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
-}
-`;
-
-  // ../shadertools/src/modules-webgl1/lighting/pbr/pbr.ts
-  var pbr = {
-    name: "pbr",
-    vs,
-    fs,
-    defines: {
-      LIGHTING_FRAGMENT: 1
-    },
-    dependencies: [lights],
-    getUniforms: (props) => props
-  };
-
-  // src/gltf/create-gltf-model.ts
+  var import_shadertools = __toESM(require_shadertools(), 1);
   var import_engine2 = __toESM(require_engine(), 1);
   var SHADER = (
     /* WGSL */
@@ -3981,8 +3638,9 @@ layout(0) positions: vec4; // in vec4 POSITION;
   }
 `
   );
-  var vs2 = import_core4.glsl`\
-#version 300 es
+  var vs = (
+    /* glsl */
+    `#version 300 es
 
   // in vec4 POSITION;
   in vec4 positions;
@@ -4019,18 +3677,21 @@ layout(0) positions: vec4; // in vec4 POSITION;
     #endif
 
     pbr_setPositionNormalTangentUV(positions, _NORMAL, _TANGENT, _TEXCOORD_0);
-    gl_Position = u_MVPMatrix * positions;
+    gl_Position = pbrProjection.modelViewProjectionMatrix * positions;
   }
-`;
-  var fs2 = import_core4.glsl`\
-#version 300 es
+`
+  );
+  var fs = (
+    /* glsl */
+    `#version 300 es
   out vec4 fragmentColor;
 
   void main(void) {
     vec3 pos = pbr_vPosition;
     fragmentColor = pbr_filterColor(vec4(1.0));
   }
-`;
+`
+  );
   function createGLTFModel(device, options) {
     const { id, geometry, material, vertexCount, materialOptions, modelOptions } = options;
     const parsedMaterial = parsePBRMaterial(device, material, geometry.attributes, materialOptions);
@@ -4045,19 +3706,24 @@ layout(0) positions: vec4; // in vec4 POSITION;
     const modelProps = {
       id,
       source: SHADER,
-      vs: vs2,
-      fs: fs2,
+      vs,
+      fs,
       geometry,
       topology: geometry.topology,
       vertexCount,
-      modules: [pbr],
+      modules: [import_shadertools.pbrMaterial],
       ...modelOptions,
-      bindings: { ...parsedMaterial.bindings, ...modelOptions.bindings },
       defines: { ...parsedMaterial.defines, ...modelOptions.defines },
-      parameters: { ...parameters, ...parsedMaterial.parameters, ...modelOptions.parameters },
-      uniforms: { ...parsedMaterial.uniforms, ...modelOptions.uniforms }
+      parameters: { ...parameters, ...parsedMaterial.parameters, ...modelOptions.parameters }
     };
     const model = new import_engine2.Model(device, modelProps);
+    const { camera, ...pbrMaterialProps } = {
+      ...parsedMaterial.uniforms,
+      ...modelOptions.uniforms,
+      ...parsedMaterial.bindings,
+      ...modelOptions.bindings
+    };
+    model.shaderInputs.setProps({ pbrMaterial: pbrMaterialProps, pbrProjection: { camera } });
     return new import_engine2.ModelNode({ managedResources, model });
   }
 
@@ -4096,8 +3762,8 @@ layout(0) positions: vec4; // in vec4 POSITION;
       this.options = { ...DEFAULT_OPTIONS, ...options };
     }
     instantiate(gltf) {
-      this.gltf = gltf;
-      const scenes = (gltf.scenes || []).map((scene) => this.createScene(scene));
+      this.gltf = deepCopy(gltf);
+      const scenes = (this.gltf.scenes || []).map((scene) => this.createScene(scene));
       return scenes;
     }
     createAnimator() {
@@ -4143,6 +3809,8 @@ layout(0) positions: vec4; // in vec4 POSITION;
         }
         gltfNode._node = node;
       }
+      const topLevelNode = this.gltf.nodes.find((node) => node.id === gltfNode.id);
+      topLevelNode._node = gltfNode._node;
       return gltfNode._node;
     }
     createMesh(gltfMesh) {
@@ -4219,6 +3887,22 @@ layout(0) positions: vec4; // in vec4 POSITION;
       return false;
     }
   };
+  function deepCopy(object) {
+    if (ArrayBuffer.isView(object) || object instanceof ArrayBuffer) {
+      return object;
+    }
+    if (Array.isArray(object)) {
+      return object.map(deepCopy);
+    }
+    if (object && typeof object === "object") {
+      const result = {};
+      for (const key in object) {
+        result[key] = deepCopy(object[key]);
+      }
+      return result;
+    }
+    return object;
+  }
 
   // src/gltf/create-gltf-objects.ts
   function createScenegraphsFromGLTF(device, gltf, options) {