@luma.gl/shadertools 9.1.0-beta.9 → 9.2.0-alpha.1

package/dist/dist.dev.js

@@ -62,7 +62,6 @@ var __exports__ = (() => {
     combineInjects: () => combineInjects,
     convertToVec4: () => convertToVec4,
     dirlight: () => dirlight,
-    dirlight1: () => dirlight2,
     fp32: () => fp32,
     fp64: () => fp64,
     fp64LowPart: () => fp64LowPart,
@@ -71,7 +70,6 @@ var __exports__ = (() => {
     fp64ifyMatrix4: () => fp64ifyMatrix4,
     fromHalfFloat: () => fromHalfFloat,
     generateShaderForModule: () => generateShaderForModule,
-    geometry1: () => geometry,
     getPassthroughFS: () => getPassthroughFS,
     getQualifierDetails: () => getQualifierDetails,
     getShaderInfo: () => getShaderInfo,
@@ -79,19 +77,14 @@ var __exports__ = (() => {
     getShaderModuleDependencies: () => getShaderModuleDependencies,
     getShaderModuleSource: () => getShaderModuleSource,
     getShaderModuleUniforms: () => getShaderModuleUniforms,
-    gouraudLighting: () => gouraudLighting,
     gouraudMaterial: () => gouraudMaterial,
     initializeShaderModule: () => initializeShaderModule,
     initializeShaderModules: () => initializeShaderModules,
     lighting: () => lighting,
-    lights1: () => lights,
-    pbr: () => pbr,
     pbrMaterial: () => pbrMaterial,
-    phongLighting: () => phongLighting,
     phongMaterial: () => phongMaterial,
     picking: () => picking,
     preprocess: () => preprocess,
-    project1: () => project,
     random: () => random,
     toHalfFloat: () => toHalfFloat,
     typeToChannelCount: () => typeToChannelCount,
@@ -240,7 +233,7 @@ var __exports__ = (() => {
         throw new Error(type);
     }
   }
-  function injectShader(source, stage, inject, injectStandardStubs = false) {
+  function injectShader(source3, stage, inject, injectStandardStubs = false) {
     const isVertex = stage === "vertex";
     for (const key in inject) {
       const fragmentData = inject[key];
@@ -254,43 +247,43 @@ var __exports__ = (() => {
       switch (key) {
         case "vs:#decl":
           if (isVertex) {
-            source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);
+            source3 = source3.replace(DECLARATION_INJECT_MARKER, fragmentString);
           }
           break;
         case "vs:#main-start":
           if (isVertex) {
-            source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
+            source3 = source3.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
           }
           break;
         case "vs:#main-end":
           if (isVertex) {
-            source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
+            source3 = source3.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
           }
           break;
         case "fs:#decl":
           if (!isVertex) {
-            source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);
+            source3 = source3.replace(DECLARATION_INJECT_MARKER, fragmentString);
           }
           break;
         case "fs:#main-start":
           if (!isVertex) {
-            source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
+            source3 = source3.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
           }
           break;
         case "fs:#main-end":
           if (!isVertex) {
-            source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
+            source3 = source3.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
           }
           break;
         default:
-          source = source.replace(key, (match) => match + fragmentString);
+          source3 = source3.replace(key, (match) => match + fragmentString);
       }
     }
-    source = source.replace(DECLARATION_INJECT_MARKER, "");
+    source3 = source3.replace(DECLARATION_INJECT_MARKER, "");
     if (injectStandardStubs) {
-      source = source.replace(/\}\s*$/, (match) => match + MODULE_INJECTORS[stage]);
+      source3 = source3.replace(/\}\s*$/, (match) => match + MODULE_INJECTORS[stage]);
     }
-    return source;
+    return source3;
   }
   function combineInjects(injects) {
     const result = {};
@@ -470,18 +463,18 @@ ${inject[key]}` : inject[key];
   }
 
   // src/lib/shader-transpiler/transpile-glsl-shader.ts
-  function transpileGLSLShader(source, stage) {
-    const sourceGLSLVersion = Number(source.match(/^#version[ \t]+(\d+)/m)?.[1] || 100);
+  function transpileGLSLShader(source3, stage) {
+    const sourceGLSLVersion = Number(source3.match(/^#version[ \t]+(\d+)/m)?.[1] || 100);
     if (sourceGLSLVersion !== 300) {
       throw new Error("luma.gl v9 only supports GLSL 3.00 shader sources");
     }
     switch (stage) {
       case "vertex":
-        source = convertShader(source, ES300_VERTEX_REPLACEMENTS);
-        return source;
+        source3 = convertShader(source3, ES300_VERTEX_REPLACEMENTS);
+        return source3;
       case "fragment":
-        source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);
-        return source;
+        source3 = convertShader(source3, ES300_FRAGMENT_REPLACEMENTS);
+        return source3;
       default:
         throw new Error(stage);
     }
@@ -505,11 +498,11 @@ ${inject[key]}` : inject[key];
     // `varying` keyword replaced with `in`
     [makeVariableTextRegExp("varying"), "in $1"]
   ];
-  function convertShader(source, replacements) {
+  function convertShader(source3, replacements) {
     for (const [pattern, replacement] of replacements) {
-      source = source.replace(pattern, replacement);
+      source3 = source3.replace(pattern, replacement);
     }
-    return source;
+    return source3;
   }
   function makeVariableTextRegExp(qualifier) {
     return new RegExp(`\\b${qualifier}[ \\t]+(\\w+[ \\t]+\\w+(\\[\\w+\\])?;)`, "g");
@@ -571,11 +564,11 @@ ${inject[key]}` : inject[key];
   }
 
   // src/lib/glsl-utils/get-shader-info.ts
-  function getShaderInfo(source, defaultName) {
+  function getShaderInfo(source3, defaultName) {
     return {
-      name: getShaderName(source, defaultName),
+      name: getShaderName(source3, defaultName),
       language: "glsl",
-      version: getShaderVersion(source)
+      version: getShaderVersion(source3)
     };
   }
   function getShaderName(shader, defaultName = "unnamed") {
@@ -583,9 +576,9 @@ ${inject[key]}` : inject[key];
     const match = SHADER_NAME_REGEXP.exec(shader);
     return match ? match[1] : defaultName;
   }
-  function getShaderVersion(source) {
+  function getShaderVersion(source3) {
     let version = 100;
-    const words = source.match(/[^\s]+/g);
+    const words = source3.match(/[^\s]+/g);
     if (words && words.length >= 2 && words[0] === "#version") {
       const parsedVersion = parseInt(words[1], 10);
       if (Number.isFinite(parsedVersion)) {
@@ -621,19 +614,19 @@ ${DECLARATION_INJECT_MARKER}
     };
   }
   function assembleGLSLShaderPair(options) {
-    const { vs: vs6, fs: fs8 } = options;
+    const { vs: vs3, fs: fs4 } = options;
     const modules = getShaderModuleDependencies(options.modules || []);
     return {
       vs: assembleShaderGLSL(options.platformInfo, {
         ...options,
-        source: vs6,
+        source: vs3,
         stage: "vertex",
         modules
       }),
       fs: assembleShaderGLSL(options.platformInfo, {
         ...options,
         // @ts-expect-error
-        source: fs8,
+        source: fs4,
         stage: "fragment",
         modules
       }),
@@ -643,7 +636,7 @@ ${DECLARATION_INJECT_MARKER}
   function assembleShaderWGSL(platformInfo, options) {
     const {
       // id,
-      source,
+      source: source3,
       stage,
       modules,
       // defines = {},
@@ -651,8 +644,8 @@ ${DECLARATION_INJECT_MARKER}
       inject = {},
       log: log3
     } = options;
-    assert(typeof source === "string", "shader source must be a string");
-    const coreSource = source;
+    assert(typeof source3 === "string", "shader source must be a string");
+    const coreSource = source3;
     let assembledSource = "";
     const hookFunctionMap = normalizeShaderHooks(hookFunctions);
     const hookInjections = {};
@@ -707,8 +700,7 @@ ${DECLARATION_INJECT_MARKER}
   }
   function assembleShaderGLSL(platformInfo, options) {
     const {
-      id,
-      source,
+      source: source3,
       stage,
       language = "glsl",
       modules,
@@ -718,11 +710,11 @@ ${DECLARATION_INJECT_MARKER}
       prologue = true,
       log: log3
     } = options;
-    assert(typeof source === "string", "shader source must be a string");
-    const sourceVersion = language === "glsl" ? getShaderInfo(source).version : -1;
+    assert(typeof source3 === "string", "shader source must be a string");
+    const sourceVersion = language === "glsl" ? getShaderInfo(source3).version : -1;
     const targetVersion = platformInfo.shaderLanguageVersion;
     const sourceVersionDirective = sourceVersion === 100 ? "#version 100" : "#version 300 es";
-    const sourceLines = source.split("\n");
+    const sourceLines = source3.split("\n");
     const coreSource = sourceLines.slice(1).join("\n");
     const allDefines = {};
     modules.forEach((module) => {
@@ -737,7 +729,6 @@ ${DECLARATION_INJECT_MARKER}
         assembledSource = prologue ? `${sourceVersionDirective}
 
 // ----- PROLOGUE -------------------------
-${getShaderNameDefine({ id, source, stage })}
 ${`#define SHADER_TYPE_${stage.toUpperCase()}`}
 
 ${getPlatformShaderDefines(platformInfo)}
@@ -806,7 +797,7 @@ ${getApplicationDefines(allDefines)}
     return assembledSource.trim();
   }
   function assembleGetUniforms(modules) {
-    return function getUniforms8(opts) {
+    return function getUniforms4(opts) {
       const uniforms = {};
       for (const module of modules) {
         const moduleUniforms = module.getUniforms?.(opts, uniforms);
@@ -815,12 +806,6 @@ ${getApplicationDefines(allDefines)}
       return uniforms;
     };
   }
-  function getShaderNameDefine(options) {
-    const { id, source, stage } = options;
-    const injectShaderName = id && source.indexOf("SHADER_NAME") === -1;
-    return injectShaderName ? `
-#define SHADER_NAME ${id}_${stage}` : "";
-  }
   function getApplicationDefines(defines = {}) {
     let sourceText = "";
     for (const define in defines) {
@@ -851,23 +836,23 @@ ${getApplicationDefines(allDefines)}
       throw new Error("Shader module must have a name");
     }
     const moduleName = module.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
-    let source = `// ----- MODULE ${module.name} ---------------
+    let source3 = `// ----- MODULE ${module.name} ---------------
 
 `;
     if (stage !== "wgsl") {
-      source += `#define MODULE_${moduleName}
+      source3 += `#define MODULE_${moduleName}
 `;
     }
-    source += `${moduleSource}
+    source3 += `${moduleSource}
 `;
-    return source;
+    return source3;
   }
 
   // src/lib/preprocessor/preprocessor.ts
   var IFDEF_REGEXP = /^\s*\#\s*ifdef\s*([a-zA-Z_]+)\s*$/;
   var ENDIF_REGEXP = /^\s*\#\s*endif\s*$/;
-  function preprocess(source, options) {
-    const lines = source.split("\n");
+  function preprocess(source3, options) {
+    const lines = source3.split("\n");
     const output = [];
     let conditional = true;
     let currentDefine = null;
@@ -937,15 +922,15 @@ ${getApplicationDefines(allDefines)}
     assembleWGSLShader(props) {
       const modules = this._getModuleList(props.modules);
       const hookFunctions = this._hookFunctions;
-      const { source, getUniforms: getUniforms8 } = assembleWGSLShader({
+      const { source: source3, getUniforms: getUniforms4 } = assembleWGSLShader({
         ...props,
         // @ts-expect-error
         source: props.source,
         modules,
         hookFunctions
       });
-      const preprocessedSource = props.platformInfo.shaderLanguage === "wgsl" ? preprocess(source) : source;
-      return { source: preprocessedSource, getUniforms: getUniforms8, modules };
+      const preprocessedSource = props.platformInfo.shaderLanguage === "wgsl" ? preprocess(source3) : source3;
+      return { source: preprocessedSource, getUniforms: getUniforms4, modules };
     }
     /**
      * Assemble a pair of shaders into a single shader program
@@ -2504,12 +2489,12 @@ void main() {
     }
   };
   var WgslScanner = class {
-    constructor(source) {
+    constructor(source3) {
       this._tokens = [];
       this._start = 0;
       this._current = 0;
       this._line = 1;
-      this._source = source !== null && source !== void 0 ? source : "";
+      this._source = source3 !== null && source3 !== void 0 ? source3 : "";
     }
     /// Scan all tokens from the source.
     scanTokens() {
@@ -2599,10 +2584,33 @@ void main() {
       for (; ; ) {
         let matchedType = this._findType(lexeme);
         const nextLexeme = this._peekAhead();
+        if (lexeme == "-" && this._tokens.length > 0) {
+          if (nextLexeme == "=") {
+            this._current++;
+            lexeme += nextLexeme;
+            this._addToken(TokenTypes.tokens.minus_equal);
+            return true;
+          }
+          if (nextLexeme == "-") {
+            this._current++;
+            lexeme += nextLexeme;
+            this._addToken(TokenTypes.tokens.minus_minus);
+            return true;
+          }
+          const ti = this._tokens.length - 1;
+          const isIdentOrLiteral = TokenTypes.literal_or_ident.indexOf(this._tokens[ti].type) != -1;
+          if ((isIdentOrLiteral || this._tokens[ti].type == TokenTypes.tokens.paren_right) && nextLexeme != ">") {
+            this._addToken(matchedType);
+            return true;
+          }
+        }
         if (lexeme == ">" && (nextLexeme == ">" || nextLexeme == "=")) {
           let foundLessThan = false;
           let ti = this._tokens.length - 1;
           for (let count = 0; count < 5 && ti >= 0; ++count, --ti) {
+            if (TokenTypes.assignment_operators.indexOf(this._tokens[ti].type) !== -1) {
+              break;
+            }
             if (this._tokens[ti].type === TokenTypes.tokens.less_than) {
               if (ti > 0 && this._tokens[ti - 1].isArrayOrTemplateType()) {
                 foundLessThan = true;
@@ -4477,7 +4485,7 @@ void main() {
       struct.align = structAlign;
     }
     _getTypeSize(type) {
-      var _a2;
+      var _a2, _b;
       if (type === null || type === void 0) {
         return null;
       }
@@ -4495,7 +4503,7 @@ void main() {
       {
         const info = WgslReflect._typeInfo[type.name];
         if (info !== void 0) {
-          const divisor = type["format"] === "f16" ? 2 : 1;
+          const divisor = ((_a2 = type["format"]) === null || _a2 === void 0 ? void 0 : _a2.name) === "f16" ? 2 : 1;
           return new _TypeSize(Math.max(explicitAlign, info.align / divisor), Math.max(explicitSize, info.size / divisor));
         }
       }
@@ -4516,7 +4524,7 @@ void main() {
           align = E.align;
         }
         const N = arrayType.count;
-        const stride = this._getAttributeNum((_a2 = type === null || type === void 0 ? void 0 : type.attributes) !== null && _a2 !== void 0 ? _a2 : null, "stride", this._roundUp(align, size));
+        const stride = this._getAttributeNum((_b = type === null || type === void 0 ? void 0 : type.attributes) !== null && _b !== void 0 ? _b : null, "stride", this._roundUp(align, size));
         size = N * stride;
         if (explicitSize) {
           size = explicitSize;
@@ -4620,11 +4628,11 @@ void main() {
   });
 
   // src/lib/wgsl/get-shader-layout-wgsl.ts
-  function getShaderLayoutFromWGSL(source) {
+  function getShaderLayoutFromWGSL(source3) {
     const shaderLayout = { attributes: [], bindings: [] };
     let parsedWGSL;
     try {
-      parsedWGSL = parseWGSL(source);
+      parsedWGSL = parseWGSL(source3);
     } catch (error) {
       import_core.log.error(error.message)();
       return shaderLayout;
@@ -4680,9 +4688,9 @@ void main() {
   function getType(type) {
     return type.format ? `${type.name}<${type.format.name}>` : type.name;
   }
-  function parseWGSL(source) {
+  function parseWGSL(source3) {
     try {
-      return new WgslReflect(source);
+      return new WgslReflect(source3);
     } catch (error) {
       if (error instanceof Error) {
         throw error;
@@ -4712,53 +4720,12 @@ void main() {
   };
   globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
   var config = globalThis.mathgl.config;
-  function formatValue(value, { precision = config.precision } = {}) {
-    value = round(value);
-    return `${parseFloat(value.toPrecision(precision))}`;
-  }
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
   }
   function clamp(value, min, max) {
     return map(value, (value2) => Math.max(min, Math.min(max, value2)));
   }
-  function equals(a, b, epsilon) {
-    const oldEpsilon = config.EPSILON;
-    if (epsilon) {
-      config.EPSILON = epsilon;
-    }
-    try {
-      if (a === b) {
-        return true;
-      }
-      if (isArray(a) && isArray(b)) {
-        if (a.length !== b.length) {
-          return false;
-        }
-        for (let i = 0; i < a.length; ++i) {
-          if (!equals(a[i], b[i])) {
-            return false;
-          }
-        }
-        return true;
-      }
-      if (a && a.equals) {
-        return a.equals(b);
-      }
-      if (b && b.equals) {
-        return b.equals(a);
-      }
-      if (typeof a === "number" && typeof b === "number") {
-        return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
-      }
-      return false;
-    } finally {
-      config.EPSILON = oldEpsilon;
-    }
-  }
-  function round(value) {
-    return Math.round(value / config.EPSILON) * config.EPSILON;
-  }
   function duplicateArray(array) {
     return array.clone ? array.clone() : new Array(array.length);
   }
@@ -4775,1739 +4742,134 @@ void main() {
     return func(value);
   }
 
-  // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
-  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);
-    }
-    fromArray(array, offset = 0) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] = array[i + offset];
-      }
-      return this.check();
-    }
-    toArray(targetArray = [], offset = 0) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        targetArray[offset + i] = this[i];
-      }
-      return targetArray;
-    }
-    toObject(targetObject) {
-      return targetObject;
-    }
-    from(arrayOrObject) {
-      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
-        // @ts-ignore
-        this.fromObject(arrayOrObject)
-      );
-    }
-    to(arrayOrObject) {
-      if (arrayOrObject === this) {
-        return this;
-      }
-      return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
-    }
-    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 `${opts.printTypes ? this.constructor.name : ""}[${string}]`;
-    }
-    equals(array) {
-      if (!array || this.length !== array.length) {
-        return false;
-      }
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        if (!equals(this[i], array[i])) {
-          return false;
-        }
-      }
-      return true;
-    }
-    exactEquals(array) {
-      if (!array || this.length !== array.length) {
-        return false;
-      }
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        if (this[i] !== array[i]) {
-          return false;
-        }
-      }
-      return true;
-    }
-    // Modifiers
-    /** Negates all values in this object */
-    negate() {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] = -this[i];
-      }
-      return this.check();
-    }
-    lerp(a, b, t) {
-      if (t === void 0) {
-        return this.lerp(this, a, b);
-      }
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        const ai = a[i];
-        const endValue = typeof b === "number" ? b : b[i];
-        this[i] = ai + t * (endValue - ai);
-      }
-      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]);
-      }
-      return this.check();
-    }
-    clamp(minVector, maxVector) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]);
-      }
-      return this.check();
-    }
-    add(...vectors) {
-      for (const vector of vectors) {
-        for (let i = 0; i < this.ELEMENTS; ++i) {
-          this[i] += vector[i];
-        }
-      }
-      return this.check();
-    }
-    subtract(...vectors) {
-      for (const vector of vectors) {
-        for (let i = 0; i < this.ELEMENTS; ++i) {
-          this[i] -= vector[i];
-        }
-      }
-      return this.check();
-    }
-    scale(scale2) {
-      if (typeof scale2 === "number") {
-        for (let i = 0; i < this.ELEMENTS; ++i) {
-          this[i] *= scale2;
-        }
+  // src/modules/math/fp16/fp16-utils.ts
+  var float16Tables = null;
+  var buffer = new ArrayBuffer(4);
+  var floatView = new Float32Array(buffer);
+  var uint32View = new Uint32Array(buffer);
+  function toHalfFloat(val) {
+    float16Tables ||= generateFloat16Tables();
+    val = clamp(val, -65504, 65504);
+    floatView[0] = val;
+    const f = uint32View[0];
+    const e = f >> 23 & 511;
+    return float16Tables.baseTable[e] + ((f & 8388607) >> float16Tables.shiftTable[e]);
+  }
+  function fromHalfFloat(val) {
+    float16Tables ||= generateFloat16Tables();
+    const m = val >> 10;
+    uint32View[0] = float16Tables.mantissaTable[float16Tables.offsetTable[m] + (val & 1023)] + float16Tables.exponentTable[m];
+    return floatView[0];
+  }
+  function generateFloat16Tables() {
+    const baseTable = new Uint32Array(512);
+    const shiftTable = new Uint32Array(512);
+    for (let i = 0; i < 256; ++i) {
+      const e = i - 127;
+      if (e < -27) {
+        baseTable[i] = 0;
+        baseTable[i | 256] = 32768;
+        shiftTable[i] = 24;
+        shiftTable[i | 256] = 24;
+      } else if (e < -14) {
+        baseTable[i] = 1024 >> -e - 14;
+        baseTable[i | 256] = 1024 >> -e - 14 | 32768;
+        shiftTable[i] = -e - 1;
+        shiftTable[i | 256] = -e - 1;
+      } else if (e <= 15) {
+        baseTable[i] = e + 15 << 10;
+        baseTable[i | 256] = e + 15 << 10 | 32768;
+        shiftTable[i] = 13;
+        shiftTable[i | 256] = 13;
+      } else if (e < 128) {
+        baseTable[i] = 31744;
+        baseTable[i | 256] = 64512;
+        shiftTable[i] = 24;
+        shiftTable[i | 256] = 24;
       } else {
-        for (let i = 0; i < this.ELEMENTS && i < scale2.length; ++i) {
-          this[i] *= scale2[i];
-        }
-      }
-      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: ${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) {
-        valid = valid && Number.isFinite(this[i]);
-      }
-      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;
+        baseTable[i] = 31744;
+        baseTable[i | 256] = 64512;
+        shiftTable[i] = 13;
+        shiftTable[i | 256] = 13;
       }
-      return this.check();
     }
-    /** @deprecated */
-    subScalar(a) {
-      return this.addScalar(-a);
-    }
-    /** @deprecated */
-    multiplyScalar(scalar) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] *= scalar;
+    const mantissaTable = new Uint32Array(2048);
+    const exponentTable = new Uint32Array(64);
+    const offsetTable = new Uint32Array(64);
+    for (let i = 1; i < 1024; ++i) {
+      let m = i << 13;
+      let e = 0;
+      while ((m & 8388608) === 0) {
+        m <<= 1;
+        e -= 8388608;
       }
-      return this.check();
-    }
-    /** @deprecated */
-    divideScalar(a) {
-      return this.multiplyByScalar(1 / a);
+      m &= ~8388608;
+      e += 947912704;
+      mantissaTable[i] = m | e;
     }
-    /** @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();
+    for (let i = 1024; i < 2048; ++i) {
+      mantissaTable[i] = 939524096 + (i - 1024 << 13);
     }
-    /** @deprecated */
-    get elements() {
-      return this;
+    for (let i = 1; i < 31; ++i) {
+      exponentTable[i] = i << 23;
     }
-  };
-
-  // ../../node_modules/@math.gl/core/dist/lib/validators.js
-  function validateVector(v, length) {
-    if (v.length !== length) {
-      return false;
+    exponentTable[31] = 1199570944;
+    exponentTable[32] = 2147483648;
+    for (let i = 33; i < 63; ++i) {
+      exponentTable[i] = 2147483648 + (i - 32 << 23);
     }
-    for (let i = 0; i < v.length; ++i) {
-      if (!Number.isFinite(v[i])) {
-        return false;
+    exponentTable[63] = 3347054592;
+    for (let i = 1; i < 64; ++i) {
+      if (i !== 32) {
+        offsetTable[i] = 1024;
       }
     }
-    return true;
-  }
-  function checkNumber(value) {
-    if (!Number.isFinite(value)) {
-      throw new Error(`Invalid number ${JSON.stringify(value)}`);
-    }
-    return value;
-  }
-  function checkVector(v, length, callerName = "") {
-    if (config.debug && !validateVector(v, length)) {
-      throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
-    }
-    return v;
+    return { baseTable, shiftTable, mantissaTable, exponentTable, offsetTable };
   }
 
-  // ../../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;
-    }
+  // src/modules/math/fp64/fp64-utils.ts
+  function fp64ify(a, out = [], startIndex = 0) {
+    const hiPart = Math.fround(a);
+    const loPart = a - hiPart;
+    out[startIndex] = hiPart;
+    out[startIndex + 1] = loPart;
     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;
+  function fp64LowPart(a) {
+    return a - Math.fround(a);
   }
-  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];
+  function fp64ifyMatrix4(matrix) {
+    const matrixFP64 = new Float32Array(32);
+    for (let i = 0; i < 4; ++i) {
+      for (let j = 0; j < 4; ++j) {
+        const index = i * 4 + j;
+        fp64ify(matrix[j * 4 + i], matrixFP64, index * 2);
       }
-      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];
-    const z = a[2];
-    const w = m[3] * x + m[7] * y + m[11] * z || 1;
-    out[0] = (m[0] * x + m[4] * y + m[8] * z) / w;
-    out[1] = (m[1] * x + m[5] * y + m[9] * z) / w;
-    out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;
-    return out;
-  }
-
-  // ../../node_modules/@math.gl/core/dist/gl-matrix/vec3.js
-  function create2() {
-    const out = new ARRAY_TYPE(3);
-    if (ARRAY_TYPE != Float32Array) {
-      out[0] = 0;
-      out[1] = 0;
-      out[2] = 0;
     }
-    return out;
-  }
-  function transformMat42(out, a, m) {
-    const x = a[0];
-    const y = a[1];
-    const z = a[2];
-    let w = m[3] * x + m[7] * y + m[11] * z + m[15];
-    w = w || 1;
-    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;
-    return out;
+    return matrixFP64;
   }
-  var forEach2 = function() {
-    const vec = create2();
-    return function(a, stride, offset, count, fn, arg) {
-      let i;
-      let l;
-      if (!stride) {
-        stride = 3;
-      }
-      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];
-        fn(vec, vec, arg);
-        a[i] = vec[0];
-        a[i + 1] = vec[1];
-        a[i + 2] = vec[2];
-      }
-      return a;
-    };
-  }();
-
-  // ../../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 += ` ${this[col * this.RANK + row]}`;
-          }
-        }
-      } else {
-        string += "column-major:";
-        for (let i = 0; i < this.ELEMENTS; ++i) {
-          string += ` ${this[i]}`;
-        }
-      }
-      string += "]";
-      return string;
-    }
-    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;
-    }
-    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 rotateX(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 rotateY(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 rotateZ(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();
-    }
-    // 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;
-      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();
-    }
-    // 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;
-      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;
-    }
-    // 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(quaternion) {
-      fromQuat(this, quaternion);
-      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;
-      if (far === Infinity) {
-        computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
-      } else {
-        frustum(this, left, right, bottom, top, near, far);
-      }
-      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;
-      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;
-      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;
-      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
-      });
-    }
-    /**
-     * 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;
-      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];
-      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;
-    }
-    /**
-     *
-     * @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];
-      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;
-    }
-    // Modifiers
-    transpose() {
-      transpose(this, this);
-      return this.check();
-    }
-    invert() {
-      invert(this, this);
-      return this.check();
-    }
-    // Operations
-    multiplyLeft(a) {
-      multiply(this, a, this);
-      return this.check();
-    }
-    multiplyRight(a) {
-      multiply(this, this, a);
-      return this.check();
-    }
-    // Rotates a matrix by the given angle around the X axis
-    rotateX(radians2) {
-      rotateX(this, this, radians2);
-      return this.check();
-    }
-    // Rotates a matrix by the given angle around the Y axis.
-    rotateY(radians2) {
-      rotateY(this, this, radians2);
-      return this.check();
-    }
-    /**
-     * Rotates a matrix by the given angle around the Z axis.
-     * @param radians
-     * @returns self
-     */
-    rotateZ(radians2) {
-      rotateZ(this, this, radians2);
-      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(radians2, axis) {
-      rotate(this, this, radians2, 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);
-        checkVector(result, 4);
-        return result;
-      }
-      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 } = 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;
-    }
-    /**
-     * 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) {
-        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;
-    }
-    /** @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(radians2) {
-      return this.identity().rotateX(radians2);
-    }
-    makeTranslation(x, y, z) {
-      return this.identity().translate([x, y, z]);
-    }
-  };
-  var ZERO;
-  var IDENTITY;
-  function getZeroMatrix() {
-    if (!ZERO) {
-      ZERO = new Matrix4([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
-      Object.freeze(ZERO);
-    }
-    return ZERO;
-  }
-  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/modules/math/fp16/fp16-utils.ts
-  var float16Tables = null;
-  var buffer = new ArrayBuffer(4);
-  var floatView = new Float32Array(buffer);
-  var uint32View = new Uint32Array(buffer);
-  function toHalfFloat(val) {
-    float16Tables ||= generateFloat16Tables();
-    val = clamp(val, -65504, 65504);
-    floatView[0] = val;
-    const f = uint32View[0];
-    const e = f >> 23 & 511;
-    return float16Tables.baseTable[e] + ((f & 8388607) >> float16Tables.shiftTable[e]);
-  }
-  function fromHalfFloat(val) {
-    float16Tables ||= generateFloat16Tables();
-    const m = val >> 10;
-    uint32View[0] = float16Tables.mantissaTable[float16Tables.offsetTable[m] + (val & 1023)] + float16Tables.exponentTable[m];
-    return floatView[0];
-  }
-  function generateFloat16Tables() {
-    const baseTable = new Uint32Array(512);
-    const shiftTable = new Uint32Array(512);
-    for (let i = 0; i < 256; ++i) {
-      const e = i - 127;
-      if (e < -27) {
-        baseTable[i] = 0;
-        baseTable[i | 256] = 32768;
-        shiftTable[i] = 24;
-        shiftTable[i | 256] = 24;
-      } else if (e < -14) {
-        baseTable[i] = 1024 >> -e - 14;
-        baseTable[i | 256] = 1024 >> -e - 14 | 32768;
-        shiftTable[i] = -e - 1;
-        shiftTable[i | 256] = -e - 1;
-      } else if (e <= 15) {
-        baseTable[i] = e + 15 << 10;
-        baseTable[i | 256] = e + 15 << 10 | 32768;
-        shiftTable[i] = 13;
-        shiftTable[i | 256] = 13;
-      } else if (e < 128) {
-        baseTable[i] = 31744;
-        baseTable[i | 256] = 64512;
-        shiftTable[i] = 24;
-        shiftTable[i | 256] = 24;
-      } else {
-        baseTable[i] = 31744;
-        baseTable[i | 256] = 64512;
-        shiftTable[i] = 13;
-        shiftTable[i | 256] = 13;
-      }
-    }
-    const mantissaTable = new Uint32Array(2048);
-    const exponentTable = new Uint32Array(64);
-    const offsetTable = new Uint32Array(64);
-    for (let i = 1; i < 1024; ++i) {
-      let m = i << 13;
-      let e = 0;
-      while ((m & 8388608) === 0) {
-        m <<= 1;
-        e -= 8388608;
-      }
-      m &= ~8388608;
-      e += 947912704;
-      mantissaTable[i] = m | e;
-    }
-    for (let i = 1024; i < 2048; ++i) {
-      mantissaTable[i] = 939524096 + (i - 1024 << 13);
-    }
-    for (let i = 1; i < 31; ++i) {
-      exponentTable[i] = i << 23;
-    }
-    exponentTable[31] = 1199570944;
-    exponentTable[32] = 2147483648;
-    for (let i = 33; i < 63; ++i) {
-      exponentTable[i] = 2147483648 + (i - 32 << 23);
-    }
-    exponentTable[63] = 3347054592;
-    for (let i = 1; i < 64; ++i) {
-      if (i !== 32) {
-        offsetTable[i] = 1024;
-      }
-    }
-    return { baseTable, shiftTable, mantissaTable, exponentTable, offsetTable };
-  }
-
-  // src/modules/math/fp64/fp64-utils.ts
-  function fp64ify(a, out = [], startIndex = 0) {
-    const hiPart = Math.fround(a);
-    const loPart = a - hiPart;
-    out[startIndex] = hiPart;
-    out[startIndex + 1] = loPart;
-    return out;
-  }
-  function fp64LowPart(a) {
-    return a - Math.fround(a);
-  }
-  function fp64ifyMatrix4(matrix) {
-    const matrixFP64 = new Float32Array(32);
-    for (let i = 0; i < 4; ++i) {
-      for (let j = 0; j < 4; ++j) {
-        const index = i * 4 + j;
-        fp64ify(matrix[j * 4 + i], matrixFP64, index * 2);
-      }
-    }
-    return matrixFP64;
-  }
-
-  // src/modules/math/random/random.ts
-  var fs = (
-    /* glsl */
-    `float random(vec3 scale, float seed) {
-  /* use the fragment position for a different seed per-pixel */
-  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
-}
-`
-  );
-  var random = {
-    name: "random",
-    fs
+
+  // src/modules/math/random/random.ts
+  var source = (
+    /* wgsl */
+    `fn random(scale: vec3f, seed: float) -> f32 {
+  /* use the fragment position for a different seed per-pixel */
+  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
+}
+`
+  );
+  var fs = (
+    /* glsl */
+    `float random(vec3 scale, float seed) {
+  /* use the fragment position for a different seed per-pixel */
+  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
+}
+`
+  );
+  var random = {
+    name: "random",
+    source,
+    fs
   };
 
   // src/modules/math/fp32/fp32.ts
@@ -7735,7 +6097,7 @@ vec4 picking_filterColor(vec4 color) {
   // src/modules/lighting/lights/lighting.ts
   var import_core3 = __toESM(require_core(), 1);
 
-  // src/modules/lighting/lights/lighting-uniforms-glsl.ts
+  // src/modules/lighting/lights/lighting-glsl.ts
   var lightingUniformsGLSL = (
     /* glsl */
     `precision highp int;
@@ -7815,7 +6177,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
 `
   );
 
-  // src/modules/lighting/lights/lighting-uniforms-wgsl.ts
+  // src/modules/lighting/lights/lighting-wgsl.ts
   var lightingUniformsWGSL = (
     /* wgsl */
     `// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
@@ -7873,14 +6235,14 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
   );
 
   // src/modules/lighting/lights/lighting.ts
-  var MAX_LIGHTS = 3;
+  var MAX_LIGHTS = 5;
   var COLOR_FACTOR = 255;
   var lighting = {
     props: {},
     uniforms: {},
     name: "lighting",
     defines: {
-      MAX_LIGHTS
+      // MAX_LIGHTS
     },
     uniformTypes: {
       enabled: "i32",
@@ -7981,9 +6343,9 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
     lightSourceUniforms.pointLightCount = pointLights.length;
     return lightSourceUniforms;
   }
-  function extractLightTypes(lights2) {
+  function extractLightTypes(lights) {
     const lightSources = { pointLights: [], directionalLights: [] };
-    for (const light of lights2 || []) {
+    for (const light of lights || []) {
       switch (light.type) {
         case "ambient":
           lightSources.ambientLight = light;
@@ -8158,7 +6520,7 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positio
     vs: PHONG_FS.replace("phongMaterial", "gouraudMaterial"),
     fs: PHONG_VS.replace("phongMaterial", "gouraudMaterial"),
     defines: {
-      LIGHTING_VERTEX: 1
+      LIGHTING_VERTEX: true
     },
     dependencies: [lighting],
     uniformTypes: {
@@ -8282,7 +6644,7 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
     vs: PHONG_VS,
     fs: PHONG_FS,
     defines: {
-      LIGHTING_FRAGMENT: 1
+      LIGHTING_FRAGMENT: true
     },
     uniformTypes: {
       ambient: "f32",
@@ -8305,7 +6667,7 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
     }
   };
 
-  // src/modules/lighting/pbr-material/pbr-vertex-glsl.ts
+  // src/modules/lighting/pbr-material/pbr-material-glsl.ts
   var vs2 = (
     /* glsl */
     `out vec3 pbr_vPosition;
@@ -8343,8 +6705,6 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 }
 `
   );
-
-  // src/modules/lighting/pbr-material/pbr-fragment-glsl.ts
   var fs3 = (
     /* glsl */
     `precision highp float;
@@ -8725,558 +7085,57 @@ vec4 pbr_filterColor(vec4 colorUnused)
     if (pbrMaterial.emissiveMapEnabled) {
       vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.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, pbr_scaleFGDSpec.x);
-    // color = mix(color, vec3(G), pbr_scaleFGDSpec.y);
-    // color = mix(color, vec3(D), pbr_scaleFGDSpec.z);
-    // color = mix(color, specContrib, pbr_scaleFGDSpec.w);
-
-    // color = mix(color, diffuseContrib, pbr_scaleDiffBaseMR.x);
-    color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
-    color = mix(color, vec3(metallic), pbrMaterial.scaleDiffBaseMR.z);
-    color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
-#endif
-
-  }
-
-  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
-}
-`
-  );
-
-  // src/modules/lighting/pbr-material/pbr-projection.ts
-  var uniformBlock = (
-    /* glsl */
-    `uniform pbrProjectionUniforms {
-  mat4 modelViewProjectionMatrix;
-  mat4 modelMatrix;
-  mat4 normalMatrix;
-  vec3 camera;
-} pbrProjection;
-`
-  );
-  var pbrProjection = {
-    name: "pbrProjection",
-    vs: uniformBlock,
-    fs: uniformBlock,
-    // TODO why is this needed?
-    getUniforms: (props) => props,
-    uniformTypes: {
-      modelViewProjectionMatrix: "mat4x4<f32>",
-      modelMatrix: "mat4x4<f32>",
-      normalMatrix: "mat4x4<f32>",
-      camera: "vec3<i32>"
-    }
-  };
-
-  // src/modules/lighting/pbr-material/pbr-material.ts
-  var pbrMaterial = {
-    props: {},
-    uniforms: {},
-    name: "pbrMaterial",
-    dependencies: [lighting, pbrProjection],
-    vs: vs2,
-    fs: fs3,
-    defines: {
-      LIGHTING_FRAGMENT: 1
-      // TODO defining these as 0 breaks shader
-      // HAS_NORMALMAP: 0
-      // HAS_EMISSIVEMAP: 0,
-      // HAS_OCCLUSIONMAP: 0,
-      // HAS_BASECOLORMAP: 0,
-      // HAS_METALROUGHNESSMAP: 0,
-      // ALPHA_CUTOFF: 0
-      // USE_IBL: 0
-      // PBR_DEBUG: 0
-    },
-    getUniforms: (props) => props,
-    uniformTypes: {
-      // Material is unlit
-      unlit: "i32",
-      // Base color map
-      baseColorMapEnabled: "i32",
-      baseColorFactor: "vec4<f32>",
-      normalMapEnabled: "i32",
-      normalScale: "f32",
-      // #ifdef HAS_NORMALMAP
-      emissiveMapEnabled: "i32",
-      emissiveFactor: "vec3<f32>",
-      // #ifdef HAS_EMISSIVEMAP
-      metallicRoughnessValues: "vec2<f32>",
-      metallicRoughnessMapEnabled: "i32",
-      occlusionMapEnabled: "i32",
-      occlusionStrength: "f32",
-      // #ifdef HAS_OCCLUSIONMAP
-      alphaCutoffEnabled: "i32",
-      alphaCutoff: "f32",
-      // #ifdef ALPHA_CUTOFF
-      // IBL
-      IBLenabled: "i32",
-      scaleIBLAmbient: "vec2<f32>",
-      // #ifdef USE_IBL
-      // debugging flags used for shader output of intermediate PBR variables
-      // #ifdef PBR_DEBUG
-      scaleDiffBaseMR: "vec4<f32>",
-      scaleFGDSpec: "vec4<f32>"
-    }
-  };
-
-  // src/modules-webgl1/geometry/geometry.ts
-  var vs3 = (
-    /* glsl */
-    `varying vec4 geometry_vPosition;
-varying vec3 geometry_vNormal;
-
-void geometry_setNormal(vec3 normal) {
-  geometry_vNormal = normal;
-}
-
-void geometry_setPosition(vec4 position) {
-  geometry_vPosition = position;
-}
-
-void geometry_setPosition(vec3 position) {
-  geometry_vPosition = vec4(position, 1.);
-}
-`
-  );
-  var fs4 = (
-    /* glsl */
-    `varying vec4 geometry_vPosition;
-varying vec3 geometry_vNormal;
-
-vec4 geometry_getPosition() {
-  return geometry_vPosition;
-}
-
-vec3 geometry_getNormal() {
-  return geometry_vNormal;
-}
-`
-  );
-  var geometry = {
-    name: "geometry",
-    vs: vs3,
-    fs: fs4
-  };
-
-  // src/modules-webgl1/project/project.ts
-  var IDENTITY_MATRIX2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
-  var DEFAULT_MODULE_OPTIONS = {
-    modelMatrix: IDENTITY_MATRIX2,
-    viewMatrix: IDENTITY_MATRIX2,
-    projectionMatrix: IDENTITY_MATRIX2,
-    cameraPositionWorld: [0, 0, 0]
-  };
-  function getUniforms4(opts = DEFAULT_MODULE_OPTIONS, prevUniforms = {}) {
-    const uniforms = {};
-    if (opts.modelMatrix !== void 0) {
-      uniforms.modelMatrix = opts.modelMatrix;
-    }
-    if (opts.viewMatrix !== void 0) {
-      uniforms.viewMatrix = opts.viewMatrix;
-    }
-    if (opts.projectionMatrix !== void 0) {
-      uniforms.projectionMatrix = opts.projectionMatrix;
-    }
-    if (opts.cameraPositionWorld !== void 0) {
-      uniforms.cameraPositionWorld = opts.cameraPositionWorld;
-    }
-    if (opts.projectionMatrix !== void 0 && opts.viewMatrix !== void 0) {
-      uniforms.viewProjectionMatrix = new Matrix4(opts.projectionMatrix).multiplyRight(
-        opts.viewMatrix
-      );
-    }
-    return uniforms;
-  }
-  var common = (
-    /* glsl */
-    `varying vec4 project_vPositionWorld;
-varying vec3 project_vNormalWorld;
-
-vec4 project_getPosition_World() {
-  return project_vPositionWorld;
-}
-
-vec3 project_getNormal_World() {
-  return project_vNormalWorld;
-}
-`
-  );
-  var vs4 = `${common}
-
-// Unprefixed uniforms
-uniform mat4 modelMatrix;
-uniform mat4 viewMatrix;
-uniform mat4 projectionMatrix;
-uniform mat4 viewProjectionMatrix;
-uniform vec3 cameraPositionWorld;
-
-struct World {
-  vec3 position;
-  vec3 normal;
-};
-
-World world;
-
-void project_setPosition(vec4 position) {
-  project_vPositionWorld = position;
-}
-
-void project_setNormal(vec3 normal) {
-  project_vNormalWorld = normal;
-}
-
-void project_setPositionAndNormal_World(vec3 position, vec3 normal) {
-  world.position = position;
-  world.normal = normal;
-}
-
-void project_setPositionAndNormal_Model(vec3 position, vec3 normal) {
-  world.position = (modelMatrix * vec4(position, 1.)).xyz;
-  world.normal = mat3(modelMatrix) * normal;
-}
-
-vec4 project_model_to_clipspace(vec4 position) {
-  return viewProjectionMatrix * modelMatrix * position;
-}
-
-vec4 project_model_to_clipspace(vec3 position) {
-  return viewProjectionMatrix * modelMatrix * vec4(position, 1.);
-}
-
-vec4 project_world_to_clipspace(vec3 position) {
-  return viewProjectionMatrix * vec4(position, 1.);
-}
-
-vec4 project_view_to_clipspace(vec3 position) {
-  return projectionMatrix * vec4(position, 1.);
-}
-
-vec4 project_to_clipspace(vec3 position) {
-  return viewProjectionMatrix * vec4(position, 1.);
-}
-`;
-  var fs5 = `
-${common}`;
-  var project = {
-    name: "project",
-    getUniforms: getUniforms4,
-    vs: vs4,
-    fs: fs5
-  };
-
-  // 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
-`
-  );
-
-  // src/modules-webgl1/lighting/lights/lights.ts
-  var INITIAL_MODULE_OPTIONS = {
-    lightSources: {}
-  };
-  function convertColor2(colorDef = {}) {
-    const { color = [0, 0, 0], intensity = 1 } = colorDef;
-    return color.map((component) => component * intensity / 255);
-  }
-  function getLightSourceUniforms2({
-    ambientLight,
-    pointLights = [],
-    directionalLights = []
-  }) {
-    const lightSourceUniforms = {};
-    if (ambientLight) {
-      lightSourceUniforms["lighting_uAmbientLight.color"] = convertColor2(ambientLight);
-    } else {
-      lightSourceUniforms["lighting_uAmbientLight.color"] = [0, 0, 0];
-    }
-    pointLights.forEach((pointLight, index) => {
-      lightSourceUniforms[`lighting_uPointLight[${index}].color`] = convertColor2(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`] = convertColor2(directionalLight);
-      lightSourceUniforms[`lighting_uDirectionalLight[${index}].direction`] = directionalLight.direction;
-    });
-    lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length;
-    return lightSourceUniforms;
-  }
-  function getUniforms5(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(
-        {},
-        getLightSourceUniforms2({ 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 getUniforms5({ lightSources });
-    }
-    return {};
-  }
-  var lights = {
-    name: "lights",
-    vs: lightingShader,
-    fs: lightingShader,
-    getUniforms: getUniforms5,
-    defines: {
-      MAX_LIGHTS: 3
-    }
-  };
-
-  // src/modules-webgl1/lighting/dirlight/dirlight.ts
-  var DEFAULT_MODULE_OPTIONS2 = {
-    lightDirection: new Float32Array([1, 1, 2])
-  };
-  function getUniforms6(opts = DEFAULT_MODULE_OPTIONS2) {
-    const uniforms = {};
-    if (opts.lightDirection) {
-      uniforms.dirlight_uLightDirection = opts.lightDirection;
-    }
-    return uniforms;
-  }
-  var fs6 = (
-    /* glsl */
-    `uniform vec3 dirlight_uLightDirection;
-
-/*
- * Returns color attenuated by angle from light source
- */
-vec4 dirlight_filterColor(vec4 color) {
-  vec3 normal = project_getNormal_World();
-  float d = abs(dot(normalize(normal), normalize(dirlight_uLightDirection)));
-  return vec4(color.rgb * d, color.a);
-}
-`
-  );
-  var dirlight2 = {
-    name: "dirlight",
-    // vs // TODO - reuse normal from geometry module
-    fs: fs6,
-    getUniforms: getUniforms6,
-    dependencies: [project]
-  };
-
-  // src/modules-webgl1/lighting/phong-lighting/phong-lighting-glsl.ts
-  var lightingShader2 = (
-    /* glsl */
-    `
-uniform float lighting_uAmbient;
-uniform float lighting_uDiffuse;
-uniform float lighting_uShininess;
-uniform vec3  lighting_uSpecularColor;
-
-vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {
-    vec3 halfway_direction = normalize(light_direction + view_direction);
-    float lambertian = dot(light_direction, normal_worldspace);
-    float specular = 0.0;
-    if (lambertian > 0.0) {
-      float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
-      specular = pow(specular_angle, lighting_uShininess);
-    }
-    lambertian = max(lambertian, 0.0);
-    return (lambertian * lighting_uDiffuse * surfaceColor + specular * lighting_uSpecularColor) * color;
-}
-
-vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-  vec3 lightColor = surfaceColor;
-
-  if (lighting_uEnabled) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
-    lightColor = lighting_uAmbient * surfaceColor * lighting_uAmbientLight.color;
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting_uPointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_uPointLight[i];
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting_uDirectionalLightCount) {
-        break;
-      }
-      DirectionalLight directionalLight = lighting_uDirectionalLight[i];
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-  }
-  return lightColor;
-}
+    }
+#endif
 
-vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-  vec3 lightColor = vec3(0, 0, 0);
-  vec3 surfaceColor = vec3(0, 0, 0);
+    // 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
 
-  if (lighting_uEnabled) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
+    // color = mix(color, F, pbr_scaleFGDSpec.x);
+    // color = mix(color, vec3(G), pbr_scaleFGDSpec.y);
+    // color = mix(color, vec3(D), pbr_scaleFGDSpec.z);
+    // color = mix(color, specContrib, pbr_scaleFGDSpec.w);
 
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting_uPointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_uPointLight[i];
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
+    // color = mix(color, diffuseContrib, pbr_scaleDiffBaseMR.x);
+    color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+    color = mix(color, vec3(metallic), pbrMaterial.scaleDiffBaseMR.z);
+    color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+#endif
 
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting_uDirectionalLightCount) {
-        break;
-      }
-      DirectionalLight directionalLight = lighting_uDirectionalLight[i];
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
   }
-  return lightColor;
+
+  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
 }
 `
   );
 
-  // src/modules-webgl1/lighting/phong-lighting/phong-lighting.ts
-  var INITIAL_MODULE_OPTIONS2 = {};
-  function getMaterialUniforms(material) {
-    const { ambient = 0.35, diffuse = 0.6, shininess = 32, specularColor = [30, 30, 30] } = material;
-    return {
-      lighting_uAmbient: ambient,
-      lighting_uDiffuse: diffuse,
-      lighting_uShininess: shininess,
-      lighting_uSpecularColor: specularColor.map((x) => x / 255)
-    };
-  }
-  function getUniforms7(opts = INITIAL_MODULE_OPTIONS2) {
-    if (!("material" in opts)) {
-      return {};
-    }
-    const { material } = opts;
-    if (!material) {
-      return { lighting_uEnabled: false };
-    }
-    return getMaterialUniforms(material);
-  }
-  var gouraudLighting = {
-    name: "gouraud-lighting",
-    dependencies: [lights],
-    vs: lightingShader2,
-    defines: {
-      LIGHTING_VERTEX: 1
-    },
-    getUniforms: getUniforms7
-  };
-  var phongLighting = {
-    name: "phong-lighting",
-    dependencies: [lights],
-    fs: lightingShader2,
-    defines: {
-      LIGHTING_FRAGMENT: 1
-    },
-    getUniforms: getUniforms7
-  };
-
-  // src/modules-webgl1/lighting/pbr/pbr-vertex-glsl.ts
-  var vs5 = (
-    /* glsl */
-    `uniform mat4 u_MVPMatrix;
-uniform mat4 u_ModelMatrix;
-uniform mat4 u_NormalMatrix;
-
-out vec3 pbr_vPosition;
-out vec2 pbr_vUV;
+  // src/modules/lighting/pbr-material/pbr-material-wgsl.ts
+  var source2 = (
+    /* wgsl */
+    `struct PBRFragmentInputs = {
+  pbr_vPosition: vec3f;
+  pbr_vUV: vec2f;
+  pbr_vTBN: mat3f;
+  pbr_vNormal: vec3f;
+};
 
-#ifdef HAS_NORMALS
-# ifdef HAS_TANGENTS
-out mat3 pbr_vTBN;
-# else
-out vec3 pbr_vNormal;
-# endif
-#endif
+var fragmentInputs: PBRFragmentInputs;
 
-void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
+fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f, vec2 uv)
 {
-  vec4 pos = u_ModelMatrix * position;
+  pos: vec4f = pbrProjection.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);
+  let normalW: vec3f = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
+  let tangentW: vec3f = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
+  let bitangentW: vec3f = cross(normalW, tangentW) * tangent.w;
+  fragmentInputs,pbr_vTBN = mat3(tangentW, bitangentW, normalW);
 #else // HAS_TANGENTS != 1
-  pbr_vNormal = normalize(vec3(u_ModelMatrix * vec4(normal.xyz, 0.0)));
+  fragmentInputs.pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
 #endif
 #endif
 
@@ -9286,84 +7145,77 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
   pbr_vUV = vec2(0.,0.);
 #endif
 }
-`
-  );
 
-  // src/modules-webgl1/lighting/pbr/pbr-fragment-glsl.ts
-  var fs7 = (
-    /* glsl */
-    `precision highp float;
+uniform pbrMaterialUniforms {
+  // Material is unlit
+  unlit: uint32;
 
-uniform bool pbr_uUnlit;
+  // Base color map
+  baseColorMapEnabled: uint32;
+  baseColorFactor: vec4f;
 
-#ifdef USE_IBL
-uniform samplerCube u_DiffuseEnvSampler;
-uniform samplerCube u_SpecularEnvSampler;
-uniform sampler2D u_brdfLUT;
-uniform vec2 u_ScaleIBLAmbient;
-#endif
+  normalMapEnabled : uint32 
+  normalScale: f32; // #ifdef HAS_NORMALMAP
+
+  emissiveMapEnabled: uint32;
+  vec3 emissiveFactor; // #ifdef HAS_EMISSIVEMAP
+
+  vec2 metallicRoughnessValues;
+  metallicRoughnessMapEnabled: uint32;
+
+  occlusionMapEnabled: uint32;
+  occlusionStrength: f32; // #ifdef HAS_OCCLUSIONMAP
+  
+  alphaCutoffEnabled: uint32;
+  alphaCutoff: f32; // #ifdef ALPHA_CUTOFF
+  
+  // IBL
+  IBLenabled: uint32;
+  vec2 scaleIBLAmbient; // #ifdef USE_IBL
+  
+  // debugging flags used for shader output of intermediate PBR variables
+  // #ifdef PBR_DEBUG
+  scaleDiffBaseMR: vec4f;
+  scaleFGDSpec: vec4f;
+  // #endif
+} pbrMaterial;
 
+// Samplers
 #ifdef HAS_BASECOLORMAP
-uniform sampler2D u_BaseColorSampler;
+uniform sampler2D pbr_baseColorSampler;
 #endif
 #ifdef HAS_NORMALMAP
-uniform sampler2D u_NormalSampler;
-uniform float u_NormalScale;
+uniform sampler2D pbr_normalSampler;
 #endif
 #ifdef HAS_EMISSIVEMAP
-uniform sampler2D u_EmissiveSampler;
-uniform vec3 u_EmissiveFactor;
+uniform sampler2D pbr_emissiveSampler;
 #endif
 #ifdef HAS_METALROUGHNESSMAP
-uniform sampler2D u_MetallicRoughnessSampler;
+uniform sampler2D pbr_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;
+uniform sampler2D pbr_occlusionSampler;
 #endif
+#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
 #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
+struct PBRInfo {
+  NdotL: f32;                  // cos angle between normal and light direction
+  NdotV: f32;                  // cos angle between normal and view direction
+  NdotH: f32;                  // cos angle between normal and half vector
+  LdotH: f32;                  // cos angle between light direction and half vector
+  VdotH: f32;                  // cos angle between view direction and half vector
+  perceptualRoughness: f32;    // roughness value, as authored by the model creator (input to shader)
+  metalness: f32;              // 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])
+  alphaRoughness: f32;         // 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
@@ -9378,7 +7230,7 @@ vec4 SRGBtoLINEAR(vec4 srgbIn)
 #ifdef MANUAL_SRGB
 #ifdef SRGB_FAST_APPROXIMATION
   vec3 linOut = pow(srgbIn.xyz,vec3(2.2));
-#else //SRGB_FAST_APPROXIMATION
+#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
@@ -9414,8 +7266,8 @@ vec3 getNormal()
 #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)));
+  vec3 n = texture(pbr_normalSampler, pbr_vUV).rgb;
+  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
 #else
   // The tbn matrix is linearly interpolated, so we need to re-normalize
   vec3 n = normalize(tbn[2].xyz);
@@ -9428,27 +7280,27 @@ vec3 getNormal()
 // 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)
+vec3 getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection)
 {
   float mipCount = 9.0; // resolution of 512x512
-  float lod = (pbrInputs.perceptualRoughness * mipCount);
+  float lod = (pbrInfo.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;
+  vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
+    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
+  vec3 diffuseLight = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, n)).rgb;
 
 #ifdef USE_TEX_LOD
-  vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
 #else
-  vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
 #endif
 
-  vec3 diffuse = diffuseLight * pbrInputs.diffuseColor;
-  vec3 specular = specularLight * (pbrInputs.specularColor * brdf.x + brdf.y);
+  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
+  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
 
   // For presentation, this allows us to disable IBL terms
-  diffuse *= u_ScaleIBLAmbient.x;
-  specular *= u_ScaleIBLAmbient.y;
+  diffuse *= pbrMaterial.scaleIBLAmbient.x;
+  specular *= pbrMaterial.scaleIBLAmbient.y;
 
   return diffuse + specular;
 }
@@ -9457,32 +7309,31 @@ vec3 getIBLContribution(PBRInfo pbrInputs, vec3 n, vec3 reflection)
 // Basic Lambertian diffuse
 // Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog
 // See also [1], Equation 1
-vec3 diffuse(PBRInfo pbrInputs)
+vec3 diffuse(PBRInfo pbrInfo)
 {
-  return pbrInputs.diffuseColor / M_PI;
+  return pbrInfo.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)
+vec3 specularReflection(PBRInfo pbrInfo)
 {
-  return pbrInputs.reflectance0 +
-    (pbrInputs.reflectance90 - pbrInputs.reflectance0) *
-    pow(clamp(1.0 - pbrInputs.VdotH, 0.0, 1.0), 5.0);
+  return pbrInfo.reflectance0 +
+    (pbrInfo.reflectance90 - pbrInfo.reflectance0) *
+    pow(clamp(1.0 - pbrInfo.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;
+fn geometricOcclusion(PBRInfo pbrInfo) -> f32 {
+  let NdotL: f32 = pbrInfo.NdotL;
+  let NdotV: f32 = pbrInfo.NdotV;
+  let r: f32 = pbrInfo.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)));
+  let attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
+  let attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
   return attenuationL * attenuationV;
 }
 
@@ -9492,80 +7343,79 @@ float geometricOcclusion(PBRInfo pbrInputs)
 // 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;
+fn microfacetDistribution(PBRInfo pbrInfo) -> float {
+  float roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
+  float f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.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;
+fn PBRInfo_setAmbientLight(inout pbrInfo: PBRInfo) {
+  pbrInfo.NdotL = 1.0;
+  pbrInfo.NdotH = 0.0;
+  pbrInfo.LdotH = 0.0;
+  pbrInfo.VdotH = 1.0;
 }
 
-void PBRInfo_setDirectionalLight(inout PBRInfo pbrInputs, vec3 lightDirection) {
-  vec3 n = pbrInputs.n;
-  vec3 v = pbrInputs.v;
+fb PBRInfo_setDirectionalLight(inout PBRInfo pbrInfo, vec3 lightDirection) {
+  vec3 n = pbrInfo.n;
+  vec3 v = pbrInfo.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);
+  pbrInfo.NdotL = clamp(dot(n, l), 0.001, 1.0);
+  pbrInfo.NdotH = clamp(dot(n, h), 0.0, 1.0);
+  pbrInfo.LdotH = clamp(dot(l, h), 0.0, 1.0);
+  pbrInfo.VdotH = clamp(dot(v, h), 0.0, 1.0);
 }
 
-void PBRInfo_setPointLight(inout PBRInfo pbrInputs, PointLight pointLight) {
+fn PBRInfo_setPointLight(inout pbrInfo: PBRInfo, pointLight: PointLight) {
   vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
-  PBRInfo_setDirectionalLight(pbrInputs, light_direction);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
 }
 
-vec3 calculateFinalColor(PBRInfo pbrInputs, vec3 lightColor) {
+fn calculateFinalColor(pbrInfo: PBRInfo , lightColor: vec3f) -> vec3f {
   // Calculate the shading terms for the microfacet specular shading model
-  vec3 F = specularReflection(pbrInputs);
-  float G = geometricOcclusion(pbrInputs);
-  float D = microfacetDistribution(pbrInputs);
+  let F: vec3f = specularReflection(pbrInfo);
+  let G: vec3f = geometricOcclusion(pbrInfo);
+  let D: vec3f = microfacetDistribution(pbrInfo);
 
   // Calculation of analytical lighting contribution
-  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInputs);
-  vec3 specContrib = F * G * D / (4.0 * pbrInputs.NdotL * pbrInputs.NdotV);
+  let diffuseContrib: vec3f = (1.0 - F) * diffuse(pbrInfo);
+  let specContrib: vec3f = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);
   // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)
-  return pbrInputs.NdotL * lightColor * (diffuseContrib + specContrib);
+  return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);
 }
 
-vec4 pbr_filterColor(vec4 colorUnused)
+fn pbr_filterColor(colorUnused: vec4f) -> vec4f
 {
   // 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;
+  vec4 baseColor = SRGBtoLINEAR(texture(pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
 #else
-  vec4 baseColor = u_BaseColorFactor;
+  vec4 baseColor = pbrMaterial.baseColorFactor;
 #endif
 
 #ifdef ALPHA_CUTOFF
-  if (baseColor.a < u_AlphaCutoff) {
+  if (baseColor.a < pbrMaterial.alphaCutoff) {
     discard;
   }
 #endif
 
   vec3 color = vec3(0, 0, 0);
 
-  if(pbr_uUnlit){
+  if(pbrMaterial.unlit){
     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;
+    float perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
+    float metallic = pbrMaterial.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);
+    vec4 mrSample = texture(pbr_metallicRoughnessSampler, pbr_vUV);
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
 #endif
@@ -9592,12 +7442,12 @@ vec4 pbr_filterColor(vec4 colorUnused)
     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
+    vec3 v = normalize(pbrProjection.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(
+    PBRInfo pbrInfo = PBRInfo(
       0.0, // NdotL
       NdotV,
       0.0, // NdotH
@@ -9616,41 +7466,47 @@ vec4 pbr_filterColor(vec4 colorUnused)
 
 #ifdef USE_LIGHTS
     // Apply ambient light
-    PBRInfo_setAmbientLight(pbrInputs);
-    color += calculateFinalColor(pbrInputs, lighting_uAmbientLight.color);
+    PBRInfo_setAmbientLight(pbrInfo);
+    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
 
     // 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);
+    for(int i = 0; i < lighting.directionalLightCount; i++) {
+      if (i < lighting.directionalLightCount) {
+        PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(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);
+    for(int i = 0; i < lighting.pointLightCount; i++) {
+      if (i < lighting.pointLightCount) {
+        PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
+        float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
       }
     }
 #endif
 
     // Calculate lighting contribution from image based lighting source (IBL)
 #ifdef USE_IBL
-    color += getIBLContribution(pbrInputs, n, reflection);
+    if (pbrMaterial.IBLenabled) {
+      color += getIBLContribution(pbrInfo, n, reflection);
+    }
 #endif
 
-    // Apply optional PBR terms for additional (optional) shading
+ // 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);
+    if (pbrMaterial.occlusionMapEnabled) {
+      float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+    }
 #endif
 
 #ifdef HAS_EMISSIVEMAP
-    vec3 emissive = SRGBtoLINEAR(texture(u_EmissiveSampler, pbr_vUV)).rgb * u_EmissiveFactor;
-    color += emissive;
+    if (pbrMaterial.emissiveMapEnabled) {
+      vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
+      color += emissive;
+    }
 #endif
 
     // This section uses mix to override final color for reference app visualization
@@ -9658,15 +7514,15 @@ vec4 pbr_filterColor(vec4 colorUnused)
 #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, F, pbr_scaleFGDSpec.x);
+    // color = mix(color, vec3(G), pbr_scaleFGDSpec.y);
+    // color = mix(color, vec3(D), pbr_scaleFGDSpec.z);
+    // color = mix(color, specContrib, pbr_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);
+    // color = mix(color, diffuseContrib, pbr_scaleDiffBaseMR.x);
+    color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+    color = mix(color, vec3(metallic), pbrMaterial.scaleDiffBaseMR.z);
+    color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
 #endif
 
   }
@@ -9676,16 +7532,81 @@ vec4 pbr_filterColor(vec4 colorUnused)
 `
   );
 
-  // src/modules-webgl1/lighting/pbr/pbr.ts
-  var pbr = {
-    name: "pbr",
-    vs: vs5,
-    fs: fs7,
+  // src/modules/lighting/pbr-material/pbr-projection.ts
+  var uniformBlock = (
+    /* glsl */
+    `uniform pbrProjectionUniforms {
+  mat4 modelViewProjectionMatrix;
+  mat4 modelMatrix;
+  mat4 normalMatrix;
+  vec3 camera;
+} pbrProjection;
+`
+  );
+  var pbrProjection = {
+    name: "pbrProjection",
+    vs: uniformBlock,
+    fs: uniformBlock,
+    // TODO why is this needed?
+    getUniforms: (props) => props,
+    uniformTypes: {
+      modelViewProjectionMatrix: "mat4x4<f32>",
+      modelMatrix: "mat4x4<f32>",
+      normalMatrix: "mat4x4<f32>",
+      camera: "vec3<i32>"
+    }
+  };
+
+  // src/modules/lighting/pbr-material/pbr-material.ts
+  var pbrMaterial = {
+    props: {},
+    uniforms: {},
+    name: "pbrMaterial",
+    dependencies: [lighting, pbrProjection],
+    source: source2,
+    vs: vs2,
+    fs: fs3,
     defines: {
-      LIGHTING_FRAGMENT: 1
+      LIGHTING_FRAGMENT: true,
+      HAS_NORMALMAP: false,
+      HAS_EMISSIVEMAP: false,
+      HAS_OCCLUSIONMAP: false,
+      HAS_BASECOLORMAP: false,
+      HAS_METALROUGHNESSMAP: false,
+      ALPHA_CUTOFF: false,
+      USE_IBL: false,
+      PBR_DEBUG: false
     },
-    dependencies: [lights],
-    getUniforms: (props) => props
+    getUniforms: (props) => props,
+    uniformTypes: {
+      // Material is unlit
+      unlit: "i32",
+      // Base color map
+      baseColorMapEnabled: "i32",
+      baseColorFactor: "vec4<f32>",
+      normalMapEnabled: "i32",
+      normalScale: "f32",
+      // #ifdef HAS_NORMALMAP
+      emissiveMapEnabled: "i32",
+      emissiveFactor: "vec3<f32>",
+      // #ifdef HAS_EMISSIVEMAP
+      metallicRoughnessValues: "vec2<f32>",
+      metallicRoughnessMapEnabled: "i32",
+      occlusionMapEnabled: "i32",
+      occlusionStrength: "f32",
+      // #ifdef HAS_OCCLUSIONMAP
+      alphaCutoffEnabled: "i32",
+      alphaCutoff: "f32",
+      // #ifdef ALPHA_CUTOFF
+      // IBL
+      IBLenabled: "i32",
+      scaleIBLAmbient: "vec2<f32>",
+      // #ifdef USE_IBL
+      // debugging flags used for shader output of intermediate PBR variables
+      // #ifdef PBR_DEBUG
+      scaleDiffBaseMR: "vec4<f32>",
+      scaleFGDSpec: "vec4<f32>"
+    }
   };
   return __toCommonJS(bundle_exports);
 })();