@luma.gl/shadertools 9.0.0-beta.4 → 9.0.0-beta.6

package/dist/dist.dev.js

@@ -10,6 +10,7 @@ var __exports__ = (() => {
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -23,6 +24,10 @@ var __exports__ = (() => {
     return to;
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
 
   // src/index.ts
   var src_exports = {};
@@ -121,7 +126,10 @@ var __exports__ = (() => {
     for (const [key, propsValidator] of Object.entries(propValidators)) {
       if (properties && key in properties && !propsValidator.private) {
         if (propsValidator.validate) {
-          assert(propsValidator.validate(properties[key], propsValidator), `${errorMessage}: invalid ${key}`);
+          assert(
+            propsValidator.validate(properties[key], propsValidator),
+            `${errorMessage}: invalid ${key}`
+          );
         }
         validated[key] = properties[key];
       } else {
@@ -133,38 +141,20 @@ var __exports__ = (() => {
   function makePropValidator(propType) {
     let type = getTypeOf(propType);
     if (type !== "object") {
-      return {
-        value: propType,
-        ...DEFAULT_PROP_VALIDATORS[type],
-        type
-      };
+      return { value: propType, ...DEFAULT_PROP_VALIDATORS[type], type };
     }
     if (typeof propType === "object") {
       if (!propType) {
-        return {
-          type: "object",
-          value: null
-        };
+        return { type: "object", value: null };
       }
       if (propType.type !== void 0) {
-        return {
-          ...propType,
-          ...DEFAULT_PROP_VALIDATORS[propType.type],
-          type: propType.type
-        };
+        return { ...propType, ...DEFAULT_PROP_VALIDATORS[propType.type], type: propType.type };
       }
       if (propType.value === void 0) {
-        return {
-          type: "object",
-          value: propType
-        };
+        return { type: "object", value: propType };
       }
       type = getTypeOf(propType.value);
-      return {
-        ...propType,
-        ...DEFAULT_PROP_VALIDATORS[type],
-        type
-      };
+      return { ...propType, ...DEFAULT_PROP_VALIDATORS[type], type };
     }
     throw new Error("props");
   }
@@ -214,10 +204,7 @@ var __exports__ = (() => {
   var fragments = [];
   var DECLARATION_INJECT_MARKER = "__LUMA_INJECT_DECLARATIONS__";
   function normalizeInjections(injections) {
-    const result = {
-      vertex: {},
-      fragment: {}
-    };
+    const result = { vertex: {}, fragment: {} };
     for (const hook in injections) {
       let injection = injections[hook];
       const stage = getHookStage(hook);
@@ -309,6 +296,14 @@ ${inject[key]}` : inject[key];
   // src/lib/shader-module/shader-module-instance.ts
   var index = 1;
   var ShaderModuleInstance = class {
+    name;
+    vs;
+    fs;
+    getModuleUniforms;
+    dependencies;
+    deprecations;
+    defines;
+    injections;
     uniforms = {};
     uniformTypes = {};
     static instantiateModules(modules) {
@@ -316,13 +311,20 @@ ${inject[key]}` : inject[key];
         if (module instanceof ShaderModuleInstance) {
           return module;
         }
-        assert(typeof module !== "string", `Shader module use by name is deprecated. Import shader module '${JSON.stringify(module)}' and use it directly.`);
+        assert(
+          typeof module !== "string",
+          `Shader module use by name is deprecated. Import shader module '${JSON.stringify(
+            module
+          )}' and use it directly.`
+        );
         if (!module.name) {
           console.warn("shader module has no name");
           module.name = `shader-module-${index++}`;
         }
         const moduleObject = new ShaderModuleInstance(module);
-        moduleObject.dependencies = ShaderModuleInstance.instantiateModules(module.dependencies || []);
+        moduleObject.dependencies = ShaderModuleInstance.instantiateModules(
+          module.dependencies || []
+        );
         return moduleObject;
       });
     }
@@ -351,6 +353,7 @@ ${inject[key]}` : inject[key];
         this.uniforms = makePropValidators(uniformPropTypes);
       }
     }
+    // Extracts the source code chunk for the specified shader type from the named shader module
     getModuleSource(stage) {
       let moduleSource;
       switch (stage) {
@@ -380,6 +383,7 @@ ${moduleSource}
     getDefines() {
       return this.defines;
     }
+    // Warn about deprecated uniforms or functions
     checkDeprecations(shaderSource, log) {
       this.deprecations.forEach((def) => {
         if (def.regex?.test(shaderSource)) {
@@ -429,21 +433,11 @@ ${moduleSource}
   function getShaderDependencies(modules) {
     const moduleMap = {};
     const moduleDepth = {};
-    getDependencyGraph({
-      modules,
-      level: 0,
-      moduleMap,
-      moduleDepth
-    });
+    getDependencyGraph({ modules, level: 0, moduleMap, moduleDepth });
     return Object.keys(moduleDepth).sort((a, b) => moduleDepth[b] - moduleDepth[a]).map((name) => moduleMap[name]);
   }
   function getDependencyGraph(options) {
-    const {
-      modules,
-      level,
-      moduleMap,
-      moduleDepth
-    } = options;
+    const { modules, level, moduleMap, moduleDepth } = options;
     if (level >= 5) {
       throw new Error("Possible loop in shader dependency graph");
     }
@@ -455,12 +449,7 @@ ${moduleSource}
     }
     for (const module of modules) {
       if (module.dependencies) {
-        getDependencyGraph({
-          modules: module.dependencies,
-          level: level + 1,
-          moduleMap,
-          moduleDepth
-        });
+        getDependencyGraph({ modules: module.dependencies, level: level + 1, moduleMap, moduleDepth });
       }
     }
   }
@@ -567,62 +556,47 @@ ${moduleSource}
   }
 
   // src/lib/shader-transpiler/transpile-glsl-shader.ts
-  function transpileGLSLShader(source, targetGLSLVersion, stage) {
+  function transpileGLSLShader(source, stage) {
     const sourceGLSLVersion = Number(source.match(/^#version[ \t]+(\d+)/m)?.[1] || 100);
     if (sourceGLSLVersion !== 300) {
       throw new Error("luma.gl v9 only supports GLSL 3.00 shader sources");
     }
-    switch (targetGLSLVersion) {
-      case 300:
-        switch (stage) {
-          case "vertex":
-            source = convertShader(source, ES300_VERTEX_REPLACEMENTS);
-            return source;
-          case "fragment":
-            source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);
-            return source;
-          default:
-            throw new Error(stage);
-        }
-      case 100:
-        switch (stage) {
-          case "vertex":
-            source = convertShader(source, ES100_VERTEX_REPLACEMENTS);
-            return source;
-          case "fragment":
-            source = convertShader(source, ES100_FRAGMENT_REPLACEMENTS);
-            source = convertFragmentShaderTo100(source);
-            return source;
-          default:
-            throw new Error(stage);
-        }
+    switch (stage) {
+      case "vertex":
+        source = convertShader(source, ES300_VERTEX_REPLACEMENTS);
+        return source;
+      case "fragment":
+        source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);
+        return source;
       default:
-        throw new Error(String(targetGLSLVersion));
-    }
-  }
-  var ES300_REPLACEMENTS = [[/^(#version[ \t]+(100|300[ \t]+es))?[ \t]*\n/, "#version 300 es\n"], [/\btexture(2D|2DProj|Cube)Lod(EXT)?\(/g, "textureLod("], [/\btexture(2D|2DProj|Cube)(EXT)?\(/g, "texture("]];
-  var ES300_VERTEX_REPLACEMENTS = [...ES300_REPLACEMENTS, [makeVariableTextRegExp("attribute"), "in $1"], [makeVariableTextRegExp("varying"), "out $1"]];
-  var ES300_FRAGMENT_REPLACEMENTS = [...ES300_REPLACEMENTS, [makeVariableTextRegExp("varying"), "in $1"]];
-  var ES100_REPLACEMENTS = [[/^#version[ \t]+300[ \t]+es/, "#version 100"], [/\btexture(2D|2DProj|Cube)Lod\(/g, "texture$1LodEXT("], [/\btexture\(/g, "texture2D("], [/\btextureLod\(/g, "texture2DLodEXT("]];
-  var ES100_VERTEX_REPLACEMENTS = [...ES100_REPLACEMENTS, [makeVariableTextRegExp("in"), "attribute $1"], [makeVariableTextRegExp("out"), "varying $1"]];
-  var ES100_FRAGMENT_REPLACEMENTS = [...ES100_REPLACEMENTS, [makeVariableTextRegExp("in"), "varying $1"]];
-  var ES100_FRAGMENT_OUTPUT_NAME = "gl_FragColor";
-  var ES300_FRAGMENT_OUTPUT_REGEX = /\bout[ \t]+vec4[ \t]+(\w+)[ \t]*;\n?/;
+        throw new Error(stage);
+    }
+  }
+  var ES300_REPLACEMENTS = [
+    // Fix poorly formatted version directive
+    [/^(#version[ \t]+(100|300[ \t]+es))?[ \t]*\n/, "#version 300 es\n"],
+    // The individual `texture...()` functions were replaced with `texture()` overloads
+    [/\btexture(2D|2DProj|Cube)Lod(EXT)?\(/g, "textureLod("],
+    [/\btexture(2D|2DProj|Cube)(EXT)?\(/g, "texture("]
+  ];
+  var ES300_VERTEX_REPLACEMENTS = [
+    ...ES300_REPLACEMENTS,
+    // `attribute` keyword replaced with `in`
+    [makeVariableTextRegExp("attribute"), "in $1"],
+    // `varying` keyword replaced with `out`
+    [makeVariableTextRegExp("varying"), "out $1"]
+  ];
+  var ES300_FRAGMENT_REPLACEMENTS = [
+    ...ES300_REPLACEMENTS,
+    // `varying` keyword replaced with `in`
+    [makeVariableTextRegExp("varying"), "in $1"]
+  ];
   function convertShader(source, replacements) {
     for (const [pattern, replacement] of replacements) {
       source = source.replace(pattern, replacement);
     }
     return source;
   }
-  function convertFragmentShaderTo100(source) {
-    source = convertShader(source, ES100_FRAGMENT_REPLACEMENTS);
-    const outputMatch = ES300_FRAGMENT_OUTPUT_REGEX.exec(source);
-    if (outputMatch) {
-      const outputName = outputMatch[1];
-      source = source.replace(ES300_FRAGMENT_OUTPUT_REGEX, "").replace(new RegExp(`\\b${outputName}\\b`, "g"), ES100_FRAGMENT_OUTPUT_NAME);
-    }
-    return source;
-  }
   function makeVariableTextRegExp(qualifier) {
     return new RegExp(`\\b${qualifier}[ \\t]+(\\w+[ \\t]+\\w+(\\[\\w+\\])?;)`, "g");
   }
@@ -653,10 +627,7 @@ ${moduleSource}
     return result;
   }
   function normalizeShaderHooks(hookFunctions) {
-    const result = {
-      vertex: {},
-      fragment: {}
-    };
+    const result = { vertex: {}, fragment: {} };
     for (const hookFunction of hookFunctions) {
       let opts;
       let hook;
@@ -670,9 +641,7 @@ ${moduleSource}
       hook = hook.trim();
       const [shaderStage, signature] = hook.split(":");
       const name = hook.replace(/\(.+/, "");
-      const normalizedHook = Object.assign(opts, {
-        signature
-      });
+      const normalizedHook = Object.assign(opts, { signature });
       switch (shaderStage) {
         case "vs":
           result.vertex[name] = normalizedHook;
@@ -724,10 +693,7 @@ ${DECLARATION_INJECT_MARKER}
 precision highp float;
 `;
   function assembleShaders(options) {
-    const {
-      vs: vs6,
-      fs: fs28
-    } = options;
+    const { vs: vs6, fs: fs28 } = options;
     const modules = resolveModules(options.modules || []);
     switch (options.platformInfo.shaderLanguage) {
       case "glsl":
@@ -766,9 +732,11 @@ precision highp float;
   }
   function assembleWGSLShader(platformInfo, options) {
     const {
+      // id,
       source,
       stage,
       modules,
+      // defines = {},
       hookFunctions = [],
       inject = {},
       log
@@ -781,10 +749,7 @@ precision highp float;
     const declInjections = {};
     const mainInjections = {};
     for (const key in inject) {
-      const injection = typeof inject[key] === "string" ? {
-        injection: inject[key],
-        order: 0
-      } : inject[key];
+      const injection = typeof inject[key] === "string" ? { injection: inject[key], order: 0 } : inject[key];
       const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key);
       if (match) {
         const hash = match[2];
@@ -862,11 +827,7 @@ precision highp float;
         assembledSource = prologue ? `${sourceVersionDirective}
 
 // ----- PROLOGUE -------------------------
-${getShaderNameDefine({
-          id,
-          source,
-          stage
-        })}
+${getShaderNameDefine({ id, source, stage })}
 ${`#define SHADER_TYPE_${stage.toUpperCase()}`}
 ${getPlatformShaderDefines(platformInfo)}
 ${getVersionDefines(platformInfo)}
@@ -885,10 +846,7 @@ ${getApplicationDefines(allDefines)}
     const declInjections = {};
     const mainInjections = {};
     for (const key in inject) {
-      const injection = typeof inject[key] === "string" ? {
-        injection: inject[key],
-        order: 0
-      } : inject[key];
+      const injection = typeof inject[key] === "string" ? { injection: inject[key], order: 0 } : inject[key];
       const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key);
       if (match) {
         const hash = match[2];
@@ -933,7 +891,7 @@ ${getApplicationDefines(allDefines)}
     assembledSource += coreSource;
     assembledSource = injectShader(assembledSource, stage, mainInjections);
     if (language === "glsl" && sourceVersion !== targetVersion) {
-      assembledSource = transpileGLSLShader(assembledSource, targetVersion, stage);
+      assembledSource = transpileGLSLShader(assembledSource, stage);
     }
     return assembledSource.trim();
   }
@@ -948,11 +906,7 @@ ${getApplicationDefines(allDefines)}
     };
   }
   function getShaderNameDefine(options) {
-    const {
-      id,
-      source,
-      stage
-    } = options;
+    const { id, source, stage } = options;
     const injectShaderName = id && source.indexOf("SHADER_NAME") === -1;
     return injectShaderName ? `
 #define SHADER_NAME ${id}_${stage}
@@ -981,11 +935,7 @@ ${getApplicationDefines(allDefines)}
     if (props.fs) {
       fs28 = getShaderSource(props.platformInfo, props.fs);
     }
-    return {
-      ...props,
-      vs: vs6,
-      fs: fs28
-    };
+    return { ...props, vs: vs6, fs: fs28 };
   }
   function getShaderSource(platformInfo, shader) {
     if (typeof shader === "string") {
@@ -1006,30 +956,53 @@ ${getApplicationDefines(allDefines)}
   }
 
   // src/lib/shader-assembler.ts
-  var ShaderAssembler = class {
+  var _ShaderAssembler = class {
+    /** Hook functions */
     _hookFunctions = [];
+    /** Shader modules */
     _defaultModules = [];
+    /**
+     * A default shader assembler instance - the natural place to register default modules and hooks
+     * @returns
+     */
     static getDefaultShaderAssembler() {
-      ShaderAssembler.defaultShaderAssembler = ShaderAssembler.defaultShaderAssembler || new ShaderAssembler();
-      return ShaderAssembler.defaultShaderAssembler;
+      _ShaderAssembler.defaultShaderAssembler = _ShaderAssembler.defaultShaderAssembler || new _ShaderAssembler();
+      return _ShaderAssembler.defaultShaderAssembler;
     }
+    /**
+     * Add a default module that does not have to be provided with every call to assembleShaders()
+     */
     addDefaultModule(module) {
-      if (!this._defaultModules.find((m) => m.name === (typeof module === "string" ? module : module.name))) {
+      if (!this._defaultModules.find(
+        (m) => m.name === (typeof module === "string" ? module : module.name)
+      )) {
         this._defaultModules.push(module);
       }
     }
+    /**
+     * Remove a default module
+     */
     removeDefaultModule(module) {
       const moduleName = typeof module === "string" ? module : module.name;
       this._defaultModules = this._defaultModules.filter((m) => m.name !== moduleName);
     }
+    /**
+     * Register a shader hook
+     * @param hook
+     * @param opts
+     */
     addShaderHook(hook, opts) {
       if (opts) {
-        hook = Object.assign(opts, {
-          hook
-        });
+        hook = Object.assign(opts, { hook });
       }
       this._hookFunctions.push(hook);
     }
+    /**
+     * Assemble a pair of shaders into a single shader program
+     * @param platformInfo
+     * @param props
+     * @returns
+     */
     assembleShaders(props) {
       const modules = this._getModuleList(props.modules);
       const hookFunctions = this._hookFunctions;
@@ -1040,13 +1013,15 @@ ${getApplicationDefines(allDefines)}
         modules,
         hookFunctions
       });
-      return {
-        ...assembled,
-        modules
-      };
+      return { ...assembled, modules };
     }
+    /**
+     * Dedupe and combine with default modules
+     */
     _getModuleList(appModules = []) {
-      const modules = new Array(this._defaultModules.length + appModules.length);
+      const modules = new Array(
+        this._defaultModules.length + appModules.length
+      );
       const seen = {};
       let count = 0;
       for (let i = 0, len = this._defaultModules.length; i < len; ++i) {
@@ -1067,6 +1042,9 @@ ${getApplicationDefines(allDefines)}
       return ShaderModuleInstance.instantiateModules(modules);
     }
   };
+  var ShaderAssembler = _ShaderAssembler;
+  /** Default ShaderAssembler instance */
+  __publicField(ShaderAssembler, "defaultShaderAssembler");
 
   // src/lib/shader-module/normalize-shader-module.ts
   function normalizeShaderModule(module) {
@@ -1081,7 +1059,6 @@ ${getApplicationDefines(allDefines)}
   }
 
   // src/lib/glsl-utils/shader-utils.ts
-  var FS100 = glsl`void main() {gl_FragColor = vec4(0);}`;
   var FS_GLES = glsl`\
 out vec4 transform_output;
 void main() {
@@ -1097,44 +1074,23 @@ ${FS_GLES}`;
       return null;
     }
     const name = definition.split(";")[0];
-    return {
-      qualifier,
-      type,
-      name
-    };
+    return { qualifier, type, name };
   }
   function getPassthroughFS(options) {
-    const {
-      version = 100,
-      input,
-      inputChannels,
-      output
-    } = options || {};
+    const { input, inputChannels, output } = options || {};
     if (!input) {
-      if (version === 300) {
-        return FS300;
-      } else if (version > 300) {
-        return `#version ${version}
-${FS_GLES}`;
-      }
-      return FS100;
+      return FS300;
     }
     if (!inputChannels) {
       throw new Error("inputChannels");
     }
     const inputType = channelCountToType(inputChannels);
     const outputValue = convertToVec4(input, inputChannels);
-    if (version >= 300) {
-      return `#version ${version} ${version === 300 ? "es" : ""}
+    return `#version 300 es
 in ${inputType} ${input};
 out vec4 ${output};
 void main() {
   ${output} = ${outputValue};
-}`;
-    }
-    return `varying ${inputType} ${input};
-void main() {
-  gl_FragColor = ${outputValue};
 }`;
   }
   function typeToChannelSuffix(type) {
@@ -1239,9 +1195,9 @@ void main() {
   }
   function getGLSLUniformType(uniformFormat) {
     const UNIFORM_TYPE_TO_GLSL = {
-      "f32": "float",
-      "i32": "int",
-      "u32": "uint",
+      f32: "float",
+      i32: "int",
+      u32: "uint",
       "vec2<f32>": "vec2",
       "vec3<f32>": "vec3",
       "vec4<f32>": "vec4",
@@ -1603,6 +1559,7 @@ void main() {
     get isStruct() {
       return true;
     }
+    /// Return the index of the member with the given name, or -1 if not found.
     getMemberIndex(name) {
       for (let i = 0; i < this.members.length; i++) {
         if (this.members[i].name == name)
@@ -2153,6 +2110,12 @@ void main() {
     rgba32sint: new TokenType("rgba32sint", TokenClass.keyword, "rgba32sint"),
     rgba32float: new TokenType("rgba32float", TokenClass.keyword, "rgba32float"),
     static_assert: new TokenType("static_assert", TokenClass.keyword, "static_assert")
+    // WGSL grammar has a few keywords that have different token names than the strings they
+    // represent. Aliasing them here.
+    /*int32: new TokenType("i32", TokenClass.keyword, "i32"),
+        uint32: new TokenType("u32", TokenClass.keyword, "u32"),
+        float32: new TokenType("f32", TokenClass.keyword, "f32"),
+        pointer: new TokenType("ptr", TokenClass.keyword, "ptr"),*/
   };
   TokenTypes.tokens = {
     decimal_float_literal: new TokenType("decimal_float_literal", TokenClass.token, /((-?[0-9]*\.[0-9]+|-?[0-9]+\.[0-9]*)((e|E)(\+|-)?[0-9]+)?f?)|(-?[0-9]+(e|E)(\+|-)?[0-9]+f?)|([0-9]+f)/),
@@ -2209,23 +2172,146 @@ void main() {
     shift_right_equal: new TokenType("shift_right_equal", TokenClass.token, ">>="),
     shift_left_equal: new TokenType("shift_left_equal", TokenClass.token, "<<=")
   };
-  TokenTypes.storage_class = [_a.keywords.function, _a.keywords.private, _a.keywords.workgroup, _a.keywords.uniform, _a.keywords.storage];
-  TokenTypes.access_mode = [_a.keywords.read, _a.keywords.write, _a.keywords.read_write];
-  TokenTypes.sampler_type = [_a.keywords.sampler, _a.keywords.sampler_comparison];
-  TokenTypes.sampled_texture_type = [_a.keywords.texture_1d, _a.keywords.texture_2d, _a.keywords.texture_2d_array, _a.keywords.texture_3d, _a.keywords.texture_cube, _a.keywords.texture_cube_array];
-  TokenTypes.multisampled_texture_type = [_a.keywords.texture_multisampled_2d];
-  TokenTypes.storage_texture_type = [_a.keywords.texture_storage_1d, _a.keywords.texture_storage_2d, _a.keywords.texture_storage_2d_array, _a.keywords.texture_storage_3d];
-  TokenTypes.depth_texture_type = [_a.keywords.texture_depth_2d, _a.keywords.texture_depth_2d_array, _a.keywords.texture_depth_cube, _a.keywords.texture_depth_cube_array, _a.keywords.texture_depth_multisampled_2d];
+  TokenTypes.storage_class = [
+    _a.keywords.function,
+    _a.keywords.private,
+    _a.keywords.workgroup,
+    _a.keywords.uniform,
+    _a.keywords.storage
+  ];
+  TokenTypes.access_mode = [
+    _a.keywords.read,
+    _a.keywords.write,
+    _a.keywords.read_write
+  ];
+  TokenTypes.sampler_type = [
+    _a.keywords.sampler,
+    _a.keywords.sampler_comparison
+  ];
+  TokenTypes.sampled_texture_type = [
+    _a.keywords.texture_1d,
+    _a.keywords.texture_2d,
+    _a.keywords.texture_2d_array,
+    _a.keywords.texture_3d,
+    _a.keywords.texture_cube,
+    _a.keywords.texture_cube_array
+  ];
+  TokenTypes.multisampled_texture_type = [
+    _a.keywords.texture_multisampled_2d
+  ];
+  TokenTypes.storage_texture_type = [
+    _a.keywords.texture_storage_1d,
+    _a.keywords.texture_storage_2d,
+    _a.keywords.texture_storage_2d_array,
+    _a.keywords.texture_storage_3d
+  ];
+  TokenTypes.depth_texture_type = [
+    _a.keywords.texture_depth_2d,
+    _a.keywords.texture_depth_2d_array,
+    _a.keywords.texture_depth_cube,
+    _a.keywords.texture_depth_cube_array,
+    _a.keywords.texture_depth_multisampled_2d
+  ];
   TokenTypes.texture_external_type = [_a.keywords.texture_external];
-  TokenTypes.any_texture_type = [..._a.sampled_texture_type, ..._a.multisampled_texture_type, ..._a.storage_texture_type, ..._a.depth_texture_type, ..._a.texture_external_type];
-  TokenTypes.texel_format = [_a.keywords.r8unorm, _a.keywords.r8snorm, _a.keywords.r8uint, _a.keywords.r8sint, _a.keywords.r16uint, _a.keywords.r16sint, _a.keywords.r16float, _a.keywords.rg8unorm, _a.keywords.rg8snorm, _a.keywords.rg8uint, _a.keywords.rg8sint, _a.keywords.r32uint, _a.keywords.r32sint, _a.keywords.r32float, _a.keywords.rg16uint, _a.keywords.rg16sint, _a.keywords.rg16float, _a.keywords.rgba8unorm, _a.keywords.rgba8unorm_srgb, _a.keywords.rgba8snorm, _a.keywords.rgba8uint, _a.keywords.rgba8sint, _a.keywords.bgra8unorm, _a.keywords.bgra8unorm_srgb, _a.keywords.rgb10a2unorm, _a.keywords.rg11b10float, _a.keywords.rg32uint, _a.keywords.rg32sint, _a.keywords.rg32float, _a.keywords.rgba16uint, _a.keywords.rgba16sint, _a.keywords.rgba16float, _a.keywords.rgba32uint, _a.keywords.rgba32sint, _a.keywords.rgba32float];
-  TokenTypes.const_literal = [_a.tokens.int_literal, _a.tokens.uint_literal, _a.tokens.decimal_float_literal, _a.tokens.hex_float_literal, _a.keywords.true, _a.keywords.false];
-  TokenTypes.literal_or_ident = [_a.tokens.ident, _a.tokens.int_literal, _a.tokens.uint_literal, _a.tokens.decimal_float_literal, _a.tokens.hex_float_literal];
-  TokenTypes.element_count_expression = [_a.tokens.int_literal, _a.tokens.uint_literal, _a.tokens.ident];
-  TokenTypes.template_types = [_a.keywords.vec2, _a.keywords.vec3, _a.keywords.vec4, _a.keywords.mat2x2, _a.keywords.mat2x3, _a.keywords.mat2x4, _a.keywords.mat3x2, _a.keywords.mat3x3, _a.keywords.mat3x4, _a.keywords.mat4x2, _a.keywords.mat4x3, _a.keywords.mat4x4, _a.keywords.atomic, _a.keywords.bitcast, ..._a.any_texture_type];
+  TokenTypes.any_texture_type = [
+    ..._a.sampled_texture_type,
+    ..._a.multisampled_texture_type,
+    ..._a.storage_texture_type,
+    ..._a.depth_texture_type,
+    ..._a.texture_external_type
+  ];
+  TokenTypes.texel_format = [
+    _a.keywords.r8unorm,
+    _a.keywords.r8snorm,
+    _a.keywords.r8uint,
+    _a.keywords.r8sint,
+    _a.keywords.r16uint,
+    _a.keywords.r16sint,
+    _a.keywords.r16float,
+    _a.keywords.rg8unorm,
+    _a.keywords.rg8snorm,
+    _a.keywords.rg8uint,
+    _a.keywords.rg8sint,
+    _a.keywords.r32uint,
+    _a.keywords.r32sint,
+    _a.keywords.r32float,
+    _a.keywords.rg16uint,
+    _a.keywords.rg16sint,
+    _a.keywords.rg16float,
+    _a.keywords.rgba8unorm,
+    _a.keywords.rgba8unorm_srgb,
+    _a.keywords.rgba8snorm,
+    _a.keywords.rgba8uint,
+    _a.keywords.rgba8sint,
+    _a.keywords.bgra8unorm,
+    _a.keywords.bgra8unorm_srgb,
+    _a.keywords.rgb10a2unorm,
+    _a.keywords.rg11b10float,
+    _a.keywords.rg32uint,
+    _a.keywords.rg32sint,
+    _a.keywords.rg32float,
+    _a.keywords.rgba16uint,
+    _a.keywords.rgba16sint,
+    _a.keywords.rgba16float,
+    _a.keywords.rgba32uint,
+    _a.keywords.rgba32sint,
+    _a.keywords.rgba32float
+  ];
+  TokenTypes.const_literal = [
+    _a.tokens.int_literal,
+    _a.tokens.uint_literal,
+    _a.tokens.decimal_float_literal,
+    _a.tokens.hex_float_literal,
+    _a.keywords.true,
+    _a.keywords.false
+  ];
+  TokenTypes.literal_or_ident = [
+    _a.tokens.ident,
+    _a.tokens.int_literal,
+    _a.tokens.uint_literal,
+    _a.tokens.decimal_float_literal,
+    _a.tokens.hex_float_literal
+  ];
+  TokenTypes.element_count_expression = [
+    _a.tokens.int_literal,
+    _a.tokens.uint_literal,
+    _a.tokens.ident
+  ];
+  TokenTypes.template_types = [
+    _a.keywords.vec2,
+    _a.keywords.vec3,
+    _a.keywords.vec4,
+    _a.keywords.mat2x2,
+    _a.keywords.mat2x3,
+    _a.keywords.mat2x4,
+    _a.keywords.mat3x2,
+    _a.keywords.mat3x3,
+    _a.keywords.mat3x4,
+    _a.keywords.mat4x2,
+    _a.keywords.mat4x3,
+    _a.keywords.mat4x4,
+    _a.keywords.atomic,
+    _a.keywords.bitcast,
+    ..._a.any_texture_type
+  ];
   TokenTypes.attribute_name = [_a.tokens.ident, _a.keywords.block];
-  TokenTypes.assignment_operators = [_a.tokens.equal, _a.tokens.plus_equal, _a.tokens.minus_equal, _a.tokens.times_equal, _a.tokens.division_equal, _a.tokens.modulo_equal, _a.tokens.and_equal, _a.tokens.or_equal, _a.tokens.xor_equal, _a.tokens.shift_right_equal, _a.tokens.shift_left_equal];
-  TokenTypes.increment_operators = [_a.tokens.plus_plus, _a.tokens.minus_minus];
+  TokenTypes.assignment_operators = [
+    _a.tokens.equal,
+    _a.tokens.plus_equal,
+    _a.tokens.minus_equal,
+    _a.tokens.times_equal,
+    _a.tokens.division_equal,
+    _a.tokens.modulo_equal,
+    _a.tokens.and_equal,
+    _a.tokens.or_equal,
+    _a.tokens.xor_equal,
+    _a.tokens.shift_right_equal,
+    _a.tokens.shift_left_equal
+  ];
+  TokenTypes.increment_operators = [
+    _a.tokens.plus_plus,
+    _a.tokens.minus_minus
+  ];
   var Token = class {
     constructor(type, lexeme, line) {
       this.type = type;
@@ -2253,6 +2339,7 @@ void main() {
       this._line = 1;
       this._source = source !== null && source !== void 0 ? source : "";
     }
+    /// Scan all tokens from the source.
     scanTokens() {
       while (!this._isAtEnd()) {
         this._start = this._current;
@@ -2262,6 +2349,7 @@ void main() {
       this._tokens.push(new Token(TokenTypes.eof, "", this._line));
       return this._tokens;
     }
+    /// Scan a single token from the source.
     scanToken() {
       let lexeme = this._advance();
       if (lexeme == "\n") {
@@ -2618,7 +2706,11 @@ void main() {
       let result = null;
       if (this._check(TokenTypes.keywords.return))
         result = this._return_statement();
-      else if (this._check([TokenTypes.keywords.var, TokenTypes.keywords.let, TokenTypes.keywords.const]))
+      else if (this._check([
+        TokenTypes.keywords.var,
+        TokenTypes.keywords.let,
+        TokenTypes.keywords.const
+      ]))
         result = this._variable_statement();
       else if (this._match(TokenTypes.keywords.discard))
         result = new Discard();
@@ -2803,7 +2895,9 @@ void main() {
     }
     _case_selectors() {
       var _a2, _b, _c, _d;
-      const selectors = [(_b = (_a2 = this._shift_expression()) === null || _a2 === void 0 ? void 0 : _a2.evaluate(this._context).toString()) !== null && _b !== void 0 ? _b : ""];
+      const selectors = [
+        (_b = (_a2 = this._shift_expression()) === null || _a2 === void 0 ? void 0 : _a2.evaluate(this._context).toString()) !== null && _b !== void 0 ? _b : ""
+      ];
       while (this._match(TokenTypes.tokens.comma)) {
         selectors.push((_d = (_c = this._shift_expression()) === null || _c === void 0 ? void 0 : _c.evaluate(this._context).toString()) !== null && _d !== void 0 ? _d : "");
       }
@@ -2906,7 +3000,12 @@ void main() {
     }
     _relational_expression() {
       let expr = this._shift_expression();
-      while (this._match([TokenTypes.tokens.less_than, TokenTypes.tokens.greater_than, TokenTypes.tokens.less_than_equal, TokenTypes.tokens.greater_than_equal])) {
+      while (this._match([
+        TokenTypes.tokens.less_than,
+        TokenTypes.tokens.greater_than,
+        TokenTypes.tokens.less_than_equal,
+        TokenTypes.tokens.greater_than_equal
+      ])) {
         expr = new BinaryOperator(this._previous().toString(), expr, this._shift_expression());
       }
       return expr;
@@ -2927,13 +3026,23 @@ void main() {
     }
     _multiplicative_expression() {
       let expr = this._unary_expression();
-      while (this._match([TokenTypes.tokens.star, TokenTypes.tokens.forward_slash, TokenTypes.tokens.modulo])) {
+      while (this._match([
+        TokenTypes.tokens.star,
+        TokenTypes.tokens.forward_slash,
+        TokenTypes.tokens.modulo
+      ])) {
         expr = new BinaryOperator(this._previous().toString(), expr, this._unary_expression());
       }
       return expr;
     }
     _unary_expression() {
-      if (this._match([TokenTypes.tokens.minus, TokenTypes.tokens.bang, TokenTypes.tokens.tilde, TokenTypes.tokens.star, TokenTypes.tokens.and])) {
+      if (this._match([
+        TokenTypes.tokens.minus,
+        TokenTypes.tokens.bang,
+        TokenTypes.tokens.tilde,
+        TokenTypes.tokens.star,
+        TokenTypes.tokens.and
+      ])) {
         return new UnaryOperator(this._previous().toString(), this._unary_expression());
       }
       return this._singular_expression();
@@ -3187,7 +3296,14 @@ void main() {
       return aliasNode;
     }
     _type_decl() {
-      if (this._check([TokenTypes.tokens.ident, ...TokenTypes.texel_format, TokenTypes.keywords.bool, TokenTypes.keywords.f32, TokenTypes.keywords.i32, TokenTypes.keywords.u32])) {
+      if (this._check([
+        TokenTypes.tokens.ident,
+        ...TokenTypes.texel_format,
+        TokenTypes.keywords.bool,
+        TokenTypes.keywords.f32,
+        TokenTypes.keywords.i32,
+        TokenTypes.keywords.u32
+      ])) {
         const type2 = this._advance();
         const typeName = type2.toString();
         if (this._context.structs.has(typeName)) {
@@ -3298,7 +3414,9 @@ void main() {
             const name = this._consume(TokenTypes.attribute_name, "Expected attribute name");
             const attr = new Attribute(name.toString(), null);
             if (this._match(TokenTypes.tokens.paren_left)) {
-              attr.value = [this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString()];
+              attr.value = [
+                this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString()
+              ];
               if (this._check(TokenTypes.tokens.comma)) {
                 this._advance();
                 do {
@@ -3921,74 +4039,23 @@ void main() {
     }
   };
   WgslReflect._typeInfo = {
-    f16: {
-      align: 2,
-      size: 2
-    },
-    i32: {
-      align: 4,
-      size: 4
-    },
-    u32: {
-      align: 4,
-      size: 4
-    },
-    f32: {
-      align: 4,
-      size: 4
-    },
-    atomic: {
-      align: 4,
-      size: 4
-    },
-    vec2: {
-      align: 8,
-      size: 8
-    },
-    vec3: {
-      align: 16,
-      size: 12
-    },
-    vec4: {
-      align: 16,
-      size: 16
-    },
-    mat2x2: {
-      align: 8,
-      size: 16
-    },
-    mat3x2: {
-      align: 8,
-      size: 24
-    },
-    mat4x2: {
-      align: 8,
-      size: 32
-    },
-    mat2x3: {
-      align: 16,
-      size: 32
-    },
-    mat3x3: {
-      align: 16,
-      size: 48
-    },
-    mat4x3: {
-      align: 16,
-      size: 64
-    },
-    mat2x4: {
-      align: 16,
-      size: 32
-    },
-    mat3x4: {
-      align: 16,
-      size: 48
-    },
-    mat4x4: {
-      align: 16,
-      size: 64
-    }
+    f16: { align: 2, size: 2 },
+    i32: { align: 4, size: 4 },
+    u32: { align: 4, size: 4 },
+    f32: { align: 4, size: 4 },
+    atomic: { align: 4, size: 4 },
+    vec2: { align: 8, size: 8 },
+    vec3: { align: 16, size: 12 },
+    vec4: { align: 16, size: 16 },
+    mat2x2: { align: 8, size: 16 },
+    mat3x2: { align: 8, size: 24 },
+    mat4x2: { align: 8, size: 32 },
+    mat2x3: { align: 16, size: 32 },
+    mat3x3: { align: 16, size: 48 },
+    mat4x3: { align: 16, size: 64 },
+    mat2x4: { align: 16, size: 32 },
+    mat3x4: { align: 16, size: 48 },
+    mat4x4: { align: 16, size: 64 }
   };
   WgslReflect._textureTypes = TokenTypes.any_texture_type.map((t) => {
     return t.name;
@@ -3999,10 +4066,7 @@ void main() {
 
   // src/lib/wgsl/get-shader-layout-wgsl.ts
   function getShaderLayoutFromWGSL(source) {
-    const shaderLayout = {
-      attributes: [],
-      bindings: []
-    };
+    const shaderLayout = { attributes: [], bindings: [] };
     const parsedWGSL = parseWGSL(source);
     for (const uniform of parsedWGSL.uniforms) {
       const members = [];
@@ -4016,6 +4080,7 @@ void main() {
         type: "uniform",
         name: uniform.name,
         location: uniform.binding,
+        // @ts-expect-error
         group: uniform.group,
         members
       });
@@ -4052,9 +4117,7 @@ void main() {
       if (typeof error === "object" && error?.token) {
         message += error.token.line || "";
       }
-      throw new Error(message, {
-        cause: error
-      });
+      throw new Error(message, { cause: error });
     }
   }
 
@@ -4410,7 +4473,7 @@ vec4 picking_filterColor(vec4 color) {
     return uniforms;
   }
 
-  // src/modules/lighting/lights/lighting-uniforms.glsl.ts
+  // src/modules/lighting/lights/lighting-uniforms-glsl.ts
   var lightingUniforms = glsl`\
 precision highp int;
 
@@ -4468,11 +4531,6 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
   // src/modules/lighting/lights/lighting-uniforms.ts
   var MAX_LIGHTS = 5;
   var COLOR_FACTOR = 255;
-  var LIGHT_TYPE = function(LIGHT_TYPE2) {
-    LIGHT_TYPE2[LIGHT_TYPE2["POINT"] = 0] = "POINT";
-    LIGHT_TYPE2[LIGHT_TYPE2["DIRECTIONAL"] = 1] = "DIRECTIONAL";
-    return LIGHT_TYPE2;
-  }(LIGHT_TYPE || {});
   var lighting = {
     name: "lighting",
     vs: lightingUniforms,
@@ -4487,59 +4545,48 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
       enabled: "i32",
       ambientLightColor: "vec3<f32>",
       numberOfLights: "i32",
+      // , array: MAX_LIGHTS,
       lightType: "i32",
+      // , array: MAX_LIGHTS,
       lightColor: "vec3<f32>",
+      // , array: MAX_LIGHTS,
       lightPosition: "vec3<f32>",
+      // , array: MAX_LIGHTS,
+      // TODO - could combine direction and attenuation
       lightDirection: "vec3<f32>",
+      // , array: MAX_LIGHTS,
       lightAttenuation: "vec3<f32>"
+      // , array: MAX_LIGHTS},
     },
     defaultUniforms: {
       enabled: 1,
       ambientLightColor: [0.1, 0.1, 0.1],
       numberOfLights: 0,
-      lightType: LIGHT_TYPE.POINT,
+      lightType: 0 /* POINT */,
       lightColor: [1, 1, 1],
       lightPosition: [1, 1, 2],
+      // TODO - could combine direction and attenuation
       lightDirection: [1, 1, 1],
       lightAttenuation: [1, 1, 1]
     }
   };
   function getUniforms2(props, prevUniforms = {}) {
-    props = props ? {
-      ...props
-    } : props;
+    props = props ? { ...props } : props;
     if (!props) {
-      return {
-        ...lighting.defaultUniforms
-      };
+      return { ...lighting.defaultUniforms };
     }
     if (props.lights) {
-      props = {
-        ...props,
-        ...extractLightTypes(props.lights),
-        lights: void 0
-      };
+      props = { ...props, ...extractLightTypes(props.lights), lights: void 0 };
     }
-    const {
-      ambientLight,
-      pointLights,
-      directionalLights
-    } = props || {};
+    const { ambientLight, pointLights, directionalLights } = props || {};
     const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0;
     if (!hasLights) {
-      return {
-        ...lighting.defaultUniforms,
-        enabled: 0
-      };
+      return { ...lighting.defaultUniforms, enabled: 0 };
     }
     const uniforms = {
       ...lighting.defaultUniforms,
       ...prevUniforms,
-      ...getLightSourceUniforms({
-        ambientLight,
-        pointLights,
-        directionalLights
-      })
+      ...getLightSourceUniforms({ ambientLight, pointLights, directionalLights })
     };
     if (props.enabled !== void 0) {
       uniforms.enabled = props.enabled ? 1 : 0;
@@ -4551,18 +4598,24 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     pointLights = [],
     directionalLights = []
   }) {
-    const lightSourceUniforms = {};
+    const lightSourceUniforms = {
+      // lightType: new Array(MAX_LIGHTS).fill(0),
+      // lightColor: new Array(MAX_LIGHTS).fill([0, 0, 0]),
+      // lightPosition: new Array(MAX_LIGHTS).fill([0, 0, 0]),
+      // lightDirection: new Array(MAX_LIGHTS).fill([0, 0, 0]),
+      // lightAttenuation: new Array(MAX_LIGHTS).fill([0, 0, 0])
+    };
     lightSourceUniforms.ambientLightColor = convertColor(ambientLight);
     let currentLight = 0;
     for (const pointLight of pointLights) {
-      lightSourceUniforms.lightType = LIGHT_TYPE.POINT;
+      lightSourceUniforms.lightType = 0 /* POINT */;
       lightSourceUniforms.lightColor = convertColor(pointLight);
       lightSourceUniforms.lightPosition = pointLight.position;
       lightSourceUniforms.lightAttenuation = [pointLight.attenuation || 1, 0, 0];
       currentLight++;
     }
     for (const directionalLight of directionalLights) {
-      lightSourceUniforms.lightType = LIGHT_TYPE.DIRECTIONAL;
+      lightSourceUniforms.lightType = 1 /* DIRECTIONAL */;
       lightSourceUniforms.lightColor = convertColor(directionalLight);
       lightSourceUniforms.lightPosition = directionalLight.position;
       lightSourceUniforms.lightDirection = directionalLight.direction;
@@ -4572,10 +4625,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     return lightSourceUniforms;
   }
   function extractLightTypes(lights2) {
-    const lightSources = {
-      pointLights: [],
-      directionalLights: []
-    };
+    const lightSources = { pointLights: [], directionalLights: [] };
     for (const light of lights2 || []) {
       switch (light.type) {
         case "ambient":
@@ -4593,10 +4643,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     return lightSources;
   }
   function convertColor(colorDef = {}) {
-    const {
-      color = [0, 0, 0],
-      intensity = 1
-    } = colorDef;
+    const { color = [0, 0, 0], intensity = 1 } = colorDef;
     return color.map((component) => component * intensity / COLOR_FACTOR);
   }
 
@@ -4626,6 +4673,14 @@ vec4 dirlight_filterColor(vec4 color) {
     dependencies: [],
     vs: VS_GLSL,
     fs: FS_GLSL,
+    // vs: {glsl: VS_GLSL, wgsl: VS_WGSL},
+    // fs: {glsl: FS_GLSL, wgsl: FS_WGSL},
+    // fragmentInputs: [
+    //   {
+    //     name: 'dirlight_vNormal',
+    //     type: 'vec3<f32>'
+    //   }
+    // ],
     uniformTypes: {
       lightDirection: "vec3<f32>"
     },
@@ -4642,7 +4697,7 @@ vec4 dirlight_filterColor(vec4 color) {
     return uniforms;
   }
 
-  // src/modules/lighting/gouraud-material/gouraud-shaders.glsl.ts
+  // src/modules/lighting/gouraud-material/gouraud-shaders-glsl.ts
   var GOURAUD_VS = glsl`\
 uniform materialUniforms {
   uniform float ambient;
@@ -4738,6 +4793,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   // src/modules/lighting/gouraud-material/gouraud-material.ts
   var gouraudMaterial = {
     name: "gouraud-lighting",
+    // Note these are switched between phong and gouraud
     vs: GOURAUD_VS,
     fs: GOURAUD_FS,
     defines: {
@@ -4757,14 +4813,11 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
       specularColor: [0.15, 0.15, 0.15]
     },
     getUniforms(props) {
-      return {
-        ...gouraudMaterial.defaultUniforms,
-        ...props
-      };
+      return { ...gouraudMaterial.defaultUniforms, ...props };
     }
   };
 
-  // src/modules/lighting/phong-material/phong-shaders.glsl.ts
+  // src/modules/lighting/phong-material/phong-shaders-glsl.ts
   var PHONG_VS = glsl`\
 uniform phongMaterialUniforms {
   uniform float ambient;
@@ -4863,6 +4916,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   // src/modules/lighting/phong-material/phong-material.ts
   var phongMaterial = {
     name: "phong-lighting",
+    // Note these are switched between phong and gouraud
     vs: PHONG_VS,
     fs: PHONG_FS,
     defines: {
@@ -4882,14 +4936,11 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
       specularColor: [0.15, 0.15, 0.15]
     },
     getUniforms(props) {
-      return {
-        ...phongMaterial.defaultUniforms,
-        ...props
-      };
+      return { ...phongMaterial.defaultUniforms, ...props };
     }
   };
 
-  // src/modules/lighting/pbr-material/pbr-vertex.glsl.ts
+  // src/modules/lighting/pbr-material/pbr-vertex-glsl.ts
   var vs2 = glsl`\
 uniform projection {
   mat4 u_MVPMatrix;
@@ -4934,7 +4985,7 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 }
 `;
 
-  // src/modules/lighting/pbr-material/pbr-fragment.glsl.ts
+  // src/modules/lighting/pbr-material/pbr-fragment-glsl.ts
   var fs3 = glsl`\
 #if defined(USE_TEX_LOD) && !defined(FEATURE_GLSL_TEXTURE_LOD)
 # error PBR fragment shader: Texture LOD is not available
@@ -4944,15 +4995,6 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 # error PBR fragment shader: Derivatives are not available
 #endif
 
-// WebGL 1.0 does not support non-constant in for loops
-// This provides an easy way to handle these cases
-// and still take advantage of WebGL 2.0
-#if (__VERSION__ < 300)
-  #define SMART_FOR(INIT, WEBGL1COND, WEBGL2COND, INCR) for (INIT; WEBGL1COND; INCR)
-#else
-  #define SMART_FOR(INIT, WEBGL1COND, WEBGL2COND, INCR) for (INIT; WEBGL2COND; INCR)
-#endif
-
 precision highp float;
 
 uniform Projection {
@@ -5299,7 +5341,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     color += calculateFinalColor(pbrInfo, lighting_uAmbientLight.color);
 
     // Apply directional light
-    SMART_FOR(int i = 0, i < MAX_LIGHTS, i < lighting_uDirectionalLightCount, i++) {
+    for(int i = 0,  i < lighting_uDirectionalLightCount, i++) {
       if (i < lighting_uDirectionalLightCount) {
         PBRInfo_setDirectionalLight(pbrInfo, lighting_uDirectionalLight[i].direction);
         color += calculateFinalColor(pbrInfo, lighting_uDirectionalLight[i].color);
@@ -5307,7 +5349,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     }
 
     // Apply point light
-    SMART_FOR(int i = 0, i < MAX_LIGHTS, i < lighting_uPointLightCount, i++) {
+    for(int i = 0, i < lighting_uPointLightCount, i++) {
       if (i < lighting_uPointLightCount) {
         PBRInfo_setPointLight(pbrInfo, lighting_uPointLight[i]);
         float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));
@@ -5377,57 +5419,52 @@ vec4 pbr_filterColor(vec4 colorUnused)
       PBR_DEBUG: 0
     },
     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>"
     },
     bindings: {
-      baseColorSampler: {
-        type: "texture",
-        location: 8
-      },
-      normalSampler: {
-        type: "texture",
-        location: 9
-      },
-      emissiveSampler: {
-        type: "texture",
-        location: 10
-      },
-      metallicRoughnessSampler: {
-        type: "texture",
-        location: 11
-      },
-      occlusionSampler: {
-        type: "texture",
-        location: 12
-      },
-      diffuseEnvSampler: {
-        type: "texture",
-        location: 13
-      },
-      specularEnvSampler: {
-        type: "texture",
-        location: 14
-      },
-      brdfLUT: {
-        type: "texture",
-        location: 15
-      }
+      baseColorSampler: { type: "texture", location: 8 },
+      // #ifdef HAS_BASECOLORMAP
+      normalSampler: { type: "texture", location: 9 },
+      // #ifdef HAS_NORMALMAP
+      emissiveSampler: { type: "texture", location: 10 },
+      // #ifdef HAS_EMISSIVEMAP
+      metallicRoughnessSampler: { type: "texture", location: 11 },
+      // #ifdef HAS_METALROUGHNESSMAP
+      occlusionSampler: { type: "texture", location: 12 },
+      // #ifdef HAS_OCCLUSIONMAP
+      // IBL Samplers
+      diffuseEnvSampler: { type: "texture", location: 13 },
+      // #ifdef USE_IBL (samplerCube)
+      specularEnvSampler: { type: "texture", location: 14 },
+      // #ifdef USE_IBL (samplerCube)
+      brdfLUT: { type: "texture", location: 15 }
+      // #ifdef USE_IBL
     },
     dependencies: [lighting]
   };
@@ -5461,23 +5498,11 @@ vec4 brightnessContrast_filterColor(vec4 color, vec2 texSize, vec2 texCoords) {
       contrast: "f32"
     },
     uniformPropTypes: {
-      brightness: {
-        format: "f32",
-        value: 0,
-        min: -1,
-        max: 1
-      },
-      contrast: {
-        format: "f32",
-        value: 0,
-        min: -1,
-        max: 1
-      }
+      brightness: { format: "f32", value: 0, min: -1, max: 1 },
+      contrast: { format: "f32", value: 0, min: -1, max: 1 }
     },
     fs: fs4,
-    passes: [{
-      filter: true
-    }]
+    passes: [{ filter: true }]
   };
 
   // src/modules/postprocessing/image-adjust-filters/denoise.ts
@@ -5511,19 +5536,11 @@ vec4 denoise_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       strength: "f32"
     },
     uniformPropTypes: {
-      strength: {
-        format: "f32",
-        value: 0.5,
-        min: 0,
-        max: 1
-      }
+      strength: { format: "f32", value: 0.5, min: 0, max: 1 }
+      // strength: {..., adjust: (strength: number): number => 0.53 + 200 * Math.pow(1 - strength, 4) // TODO - JS preprocessing
     },
     fs: fs5,
-    passes: [{
-      sampler: true
-    }, {
-      sampler: true
-    }]
+    passes: [{ sampler: true }, { sampler: true }]
   };
 
   // src/modules/postprocessing/image-adjust-filters/huesaturation.ts
@@ -5567,21 +5584,11 @@ vec4 hueSaturation_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
       saturation: "f32"
     },
     uniformPropTypes: {
-      hue: {
-        value: 0,
-        min: -1,
-        max: 1
-      },
-      saturation: {
-        value: 0,
-        min: -1,
-        max: 1
-      }
+      hue: { value: 0, min: -1, max: 1 },
+      saturation: { value: 0, min: -1, max: 1 }
     },
     fs: fs6,
-    passes: [{
-      filter: true
-    }]
+    passes: [{ filter: true }]
   };
 
   // src/modules/postprocessing/image-adjust-filters/noise.ts
@@ -5612,16 +5619,10 @@ vec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
       amount: "f32"
     },
     uniformPropTypes: {
-      amount: {
-        value: 0.5,
-        min: 0,
-        max: 1
-      }
+      amount: { value: 0.5, min: 0, max: 1 }
     },
     fs: fs7,
-    passes: [{
-      filter: true
-    }]
+    passes: [{ filter: true }]
   };
 
   // src/modules/postprocessing/image-adjust-filters/sepia.ts
@@ -5653,16 +5654,10 @@ vec4 sepia_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
       amount: "f32"
     },
     uniformPropTypes: {
-      amount: {
-        value: 0.5,
-        min: 0,
-        max: 1
-      }
+      amount: { value: 0.5, min: 0, max: 1 }
     },
     fs: fs8,
-    passes: [{
-      filter: true
-    }]
+    passes: [{ filter: true }]
   };
 
   // src/modules/postprocessing/image-adjust-filters/vibrance.ts
@@ -5686,16 +5681,10 @@ vec4 vibrance_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   var vibrance = {
     name: "vibrance",
     uniformPropTypes: {
-      amount: {
-        value: 0,
-        min: -1,
-        max: 1
-      }
+      amount: { value: 0, min: -1, max: 1 }
     },
     fs: fs9,
-    passes: [{
-      filter: true
-    }]
+    passes: [{ filter: true }]
   };
 
   // src/modules/postprocessing/image-adjust-filters/vignette.ts
@@ -5723,20 +5712,10 @@ vec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
       amount: "f32"
     },
     uniformPropTypes: {
-      radius: {
-        value: 0.5,
-        min: 0,
-        max: 1
-      },
-      amount: {
-        value: 0.5,
-        min: 0,
-        max: 1
-      }
+      radius: { value: 0.5, min: 0, max: 1 },
+      amount: { value: 0.5, min: 0, max: 1 }
     },
-    passes: [{
-      filter: true
-    }]
+    passes: [{ filter: true }]
   };
 
   // src/modules/postprocessing/image-blur-filters/tiltshift.ts
@@ -5795,38 +5774,16 @@ vec4 tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       invert: "i32"
     },
     uniformPropTypes: {
-      blurRadius: {
-        value: 15,
-        min: 0,
-        max: 50
-      },
-      gradientRadius: {
-        value: 200,
-        min: 0,
-        max: 400
-      },
-      start: {
-        value: [0, 0]
-      },
-      end: {
-        value: [1, 1]
-      },
-      invert: {
-        value: false,
-        private: true
-      }
+      blurRadius: { value: 15, min: 0, max: 50 },
+      gradientRadius: { value: 200, min: 0, max: 400 },
+      start: { value: [0, 0] },
+      end: { value: [1, 1] },
+      invert: { value: false, private: true }
     },
-    passes: [{
-      sampler: true,
-      uniforms: {
-        invert: false
-      }
-    }, {
-      sampler: true,
-      uniforms: {
-        invert: true
-      }
-    }],
+    passes: [
+      { sampler: true, uniforms: { invert: false } },
+      { sampler: true, uniforms: { invert: true } }
+    ],
     dependencies: [random],
     fs: fs11
   };
@@ -5874,29 +5831,15 @@ vec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       delta: "vec2<f32>"
     },
     uniformPropTypes: {
-      radius: {
-        value: 20,
-        min: 0,
-        softMax: 100
-      },
-      delta: {
-        value: [1, 0],
-        private: true
-      }
+      radius: { value: 20, min: 0, softMax: 100 },
+      delta: { value: [1, 0], private: true }
     },
     fs: fs12,
     dependencies: [random],
-    passes: [{
-      sampler: true,
-      uniforms: {
-        delta: [1, 0]
-      }
-    }, {
-      sampler: true,
-      uniforms: {
-        delta: [0, 1]
-      }
-    }]
+    passes: [
+      { sampler: true, uniforms: { delta: [1, 0] } },
+      { sampler: true, uniforms: { delta: [0, 1] } }
+    ]
   };
 
   // src/modules/postprocessing/image-blur-filters/zoomblur.ts
@@ -5941,20 +5884,12 @@ vec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       strength: "f32"
     },
     uniformPropTypes: {
-      center: {
-        value: [0.5, 0.5]
-      },
-      strength: {
-        value: 0.3,
-        min: 0,
-        softMax: 1
-      }
+      center: { value: [0.5, 0.5] },
+      strength: { value: 0.3, min: 0, softMax: 1 }
     },
     fs: fs13,
     dependencies: [random],
-    passes: [{
-      sampler: true
-    }]
+    passes: [{ sampler: true }]
   };
 
   // src/modules/postprocessing/image-fun-filters/colorhalftone.ts
@@ -6002,25 +5937,12 @@ vec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
       size: "f32"
     },
     uniformPropTypes: {
-      center: {
-        value: [0.5, 0.5]
-      },
-      angle: {
-        value: 1.1,
-        softMin: 0,
-        softMax: Math.PI / 2
-      },
-      size: {
-        value: 4,
-        min: 1,
-        softMin: 3,
-        softMax: 20
-      }
+      center: { value: [0.5, 0.5] },
+      angle: { value: 1.1, softMin: 0, softMax: Math.PI / 2 },
+      size: { value: 4, min: 1, softMin: 3, softMax: 20 }
     },
     fs: fs14,
-    passes: [{
-      filter: true
-    }]
+    passes: [{ filter: true }]
   };
 
   // src/modules/postprocessing/image-fun-filters/dotscreen.ts
@@ -6056,25 +5978,12 @@ vec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
       size: "f32"
     },
     uniformPropTypes: {
-      center: {
-        value: [0.5, 0.5]
-      },
-      angle: {
-        value: 1.1,
-        softMin: 0,
-        softMax: Math.PI / 2
-      },
-      size: {
-        value: 3,
-        min: 1,
-        softMin: 3,
-        softMax: 20
-      }
+      center: { value: [0.5, 0.5] },
+      angle: { value: 1.1, softMin: 0, softMax: Math.PI / 2 },
+      size: { value: 3, min: 1, softMin: 3, softMax: 20 }
     },
     fs: fs15,
-    passes: [{
-      filter: true
-    }]
+    passes: [{ filter: true }]
   };
 
   // src/modules/postprocessing/image-fun-filters/edgework.ts
@@ -6137,29 +6046,23 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
   var edgeWork = {
     name: "edgeWork",
     uniformPropTypes: {
-      radius: {
-        value: 2,
-        min: 1,
-        softMax: 50
-      },
-      delta: {
-        value: [1, 0],
-        private: true
-      }
+      radius: { value: 2, min: 1, softMax: 50 },
+      delta: { value: [1, 0], private: true }
     },
     fs: fs16,
     dependencies: [random],
-    passes: [{
-      sampler: "edgeWork_sampleColor1",
-      uniformPropTypes: {
-        delta: [1, 0]
-      }
-    }, {
-      sampler: "edgeWork_sampleColor2",
-      uniformPropTypes: {
-        delta: [0, 1]
+    passes: [
+      {
+        // @ts-expect-error
+        sampler: "edgeWork_sampleColor1",
+        uniformPropTypes: { delta: [1, 0] }
+      },
+      {
+        // @ts-expect-error
+        sampler: "edgeWork_sampleColor2",
+        uniformPropTypes: { delta: [0, 1] }
       }
-    }]
+    ]
   };
 
   // src/modules/postprocessing/image-fun-filters/hexagonalpixelate.ts
@@ -6214,21 +6117,11 @@ vec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord
       scale: "f32"
     },
     uniformPropTypes: {
-      center: {
-        value: [0.5, 0.5],
-        hint: "screenspace"
-      },
-      scale: {
-        value: 10,
-        min: 1,
-        softMin: 5,
-        softMax: 50
-      }
+      center: { value: [0.5, 0.5], hint: "screenspace" },
+      scale: { value: 10, min: 1, softMin: 5, softMax: 50 }
     },
     fs: fs17,
-    passes: [{
-      sampler: true
-    }]
+    passes: [{ sampler: true }]
   };
 
   // src/modules/postprocessing/image-fun-filters/ink.ts
@@ -6267,16 +6160,10 @@ vec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       strength: "f32"
     },
     uniformPropTypes: {
-      strength: {
-        value: 0.25,
-        min: 0,
-        softMax: 1
-      }
+      strength: { value: 0.25, min: 0, softMax: 1 }
     },
     fs: fs18,
-    passes: [{
-      sampler: true
-    }]
+    passes: [{ sampler: true }]
   };
 
   // src/modules/postprocessing/image-fun-filters/magnify.ts
@@ -6312,20 +6199,15 @@ vec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       borderColor: "vec4<f32>"
     },
     uniformPropTypes: {
-      screenXY: {
-        value: [0, 0]
-      },
+      // range 0 to 1
+      screenXY: { value: [0, 0] },
       radiusPixels: 200,
       zoom: 2,
       borderWidthPixels: 0,
-      borderColor: {
-        value: [255, 255, 255, 255]
-      }
+      borderColor: { value: [255, 255, 255, 255] }
     },
     fs: fs19,
-    passes: [{
-      sampler: true
-    }]
+    passes: [{ sampler: true }]
   };
 
   // src/modules/postprocessing/image-warp-filters/warp.ts
@@ -6386,24 +6268,12 @@ vec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       strength: "f32"
     },
     uniformPropTypes: {
-      center: {
-        value: [0.5, 0.5]
-      },
-      radius: {
-        value: 200,
-        min: 1,
-        softMax: 600
-      },
-      strength: {
-        value: 0.5,
-        min: -1,
-        max: 1
-      }
+      center: { value: [0.5, 0.5] },
+      radius: { value: 200, min: 1, softMax: 600 },
+      strength: { value: 0.5, min: -1, max: 1 }
     },
     dependencies: [warp],
-    passes: [{
-      sampler: true
-    }]
+    passes: [{ sampler: true }]
   };
 
   // src/modules/postprocessing/image-warp-filters/swirl.ts
@@ -6447,24 +6317,12 @@ vec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       angle: "f32"
     },
     uniformPropTypes: {
-      center: {
-        value: [0.5, 0.5]
-      },
-      radius: {
-        value: 200,
-        min: 1,
-        softMax: 600
-      },
-      angle: {
-        value: 3,
-        softMin: -25,
-        softMax: 25
-      }
+      center: { value: [0.5, 0.5] },
+      radius: { value: 200, min: 1, softMax: 600 },
+      angle: { value: 3, softMin: -25, softMax: 25 }
     },
     dependencies: [warp],
-    passes: [{
-      sampler: true
-    }]
+    passes: [{ sampler: true }]
   };
 
   // src/modules/postprocessing/fxaa/fxaa.ts
@@ -7053,9 +6911,7 @@ vec4 fxaa_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
     name: "fxaa",
     uniformPropTypes: {},
     fs: fs23,
-    passes: [{
-      sampler: true
-    }]
+    passes: [{ sampler: true }]
   };
 
   // src/modules-webgl1/math/fp64/fp64-utils.ts
@@ -7080,7 +6936,7 @@ vec4 fxaa_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
     return matrixFP64;
   }
 
-  // src/modules-webgl1/math/fp64/fp64-arithmetic.glsl.ts
+  // src/modules-webgl1/math/fp64/fp64-arithmetic-glsl.ts
   var fp64arithmeticShader = glsl`\
 uniform float ONE;
 
@@ -7249,7 +7105,7 @@ vec2 sqrt_fp64(vec2 a) {
 }
 `;
 
-  // src/modules-webgl1/math/fp64/fp64-functions.glsl.ts
+  // src/modules-webgl1/math/fp64/fp64-functions-glsl.ts
   var fp64functionShader = glsl`\
 const vec2 E_FP64 = vec2(2.7182817459106445e+00, 8.254840366817007e-08);
 const vec2 LOG2_FP64 = vec2(0.6931471824645996e+00, -1.9046542121259336e-09);
@@ -7924,6 +7780,7 @@ void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
 
   // src/modules-webgl1/math/fp64/fp64.ts
   var CONST_UNIFORMS = {
+    // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND
     ONE: 1
   };
   function getUniforms4() {
@@ -7941,6 +7798,7 @@ void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
     name: "fp64",
     vs: fp64functionShader,
     dependencies: [fp64arithmetic],
+    // Additional Functions
     fp64ify,
     fp64LowPart,
     fp64ifyMatrix4
@@ -9553,7 +9411,9 @@ vec3 geometry_getNormal() {
       uniforms.cameraPositionWorld = opts.cameraPositionWorld;
     }
     if (opts.projectionMatrix !== void 0 || opts.viewMatrix !== void 0) {
-      uniforms.viewProjectionMatrix = new Matrix4(opts.projectionMatrix).multiplyRight(opts.viewMatrix);
+      uniforms.viewProjectionMatrix = new Matrix4(opts.projectionMatrix).multiplyRight(
+        opts.viewMatrix
+      );
     }
     return uniforms;
   }
@@ -9632,7 +9492,7 @@ ${common}`;
     fs: fs25
   };
 
-  // src/modules-webgl1/lighting/lights/lights.glsl.ts
+  // 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))
 
@@ -9675,10 +9535,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     lightSources: {}
   };
   function convertColor2(colorDef = {}) {
-    const {
-      color = [0, 0, 0],
-      intensity = 1
-    } = colorDef;
+    const { color = [0, 0, 0], intensity = 1 } = colorDef;
     return color.map((component) => component * intensity / 255);
   }
   function getLightSourceUniforms2({
@@ -9695,7 +9552,11 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     pointLights.forEach((pointLight, index2) => {
       lightSourceUniforms[`lighting_uPointLight[${index2}].color`] = convertColor2(pointLight);
       lightSourceUniforms[`lighting_uPointLight[${index2}].position`] = pointLight.position;
-      lightSourceUniforms[`lighting_uPointLight[${index2}].attenuation`] = pointLight.attenuation || [1, 0, 0];
+      lightSourceUniforms[`lighting_uPointLight[${index2}].attenuation`] = pointLight.attenuation || [
+        1,
+        0,
+        0
+      ];
     });
     lightSourceUniforms.lighting_uPointLightCount = pointLights.length;
     directionalLights.forEach((directionalLight, index2) => {
@@ -9707,30 +9568,21 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
   }
   function getUniforms6(opts = INITIAL_MODULE_OPTIONS) {
     if ("lightSources" in opts) {
-      const {
-        ambientLight,
-        pointLights,
-        directionalLights
-      } = opts.lightSources || {};
+      const { ambientLight, pointLights, directionalLights } = opts.lightSources || {};
       const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0;
       if (!hasLights) {
-        return {
-          lighting_uEnabled: false
-        };
+        return { lighting_uEnabled: false };
       }
-      return Object.assign({}, getLightSourceUniforms2({
-        ambientLight,
-        pointLights,
-        directionalLights
-      }), {
-        lighting_uEnabled: true
-      });
+      return Object.assign(
+        {},
+        getLightSourceUniforms2({ ambientLight, pointLights, directionalLights }),
+        {
+          lighting_uEnabled: true
+        }
+      );
     }
     if ("lights" in opts) {
-      const lightSources = {
-        pointLights: [],
-        directionalLights: []
-      };
+      const lightSources = { pointLights: [], directionalLights: [] };
       for (const light of opts.lights || []) {
         switch (light.type) {
           case "ambient":
@@ -9745,9 +9597,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
           default:
         }
       }
-      return getUniforms6({
-        lightSources
-      });
+      return getUniforms6({ lightSources });
     }
     return {};
   }
@@ -9786,12 +9636,13 @@ vec4 dirlight_filterColor(vec4 color) {
 `;
   var dirlight2 = {
     name: "dirlight",
+    // vs // TODO - reuse normal from geometry module
     fs: fs26,
     getUniforms: getUniforms7,
     dependencies: [project]
   };
 
-  // src/modules-webgl1/lighting/phong-lighting/phong-lighting.glsl.ts
+  // src/modules-webgl1/lighting/phong-lighting/phong-lighting-glsl.ts
   var lightingShader2 = glsl`\
 
 uniform float lighting_uAmbient;
@@ -9871,12 +9722,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   // 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;
+    const { ambient = 0.35, diffuse = 0.6, shininess = 32, specularColor = [30, 30, 30] } = material;
     return {
       lighting_uAmbient: ambient,
       lighting_uDiffuse: diffuse,
@@ -9888,13 +9734,9 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
     if (!("material" in opts)) {
       return {};
     }
-    const {
-      material
-    } = opts;
+    const { material } = opts;
     if (!material) {
-      return {
-        lighting_uEnabled: false
-      };
+      return { lighting_uEnabled: false };
     }
     return getMaterialUniforms(material);
   }
@@ -9917,7 +9759,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
     getUniforms: getUniforms8
   };
 
-  // src/modules-webgl1/lighting/pbr/pbr-vertex.glsl.ts
+  // src/modules-webgl1/lighting/pbr/pbr-vertex-glsl.ts
   var vs5 = glsl`\
 uniform mat4 u_MVPMatrix;
 uniform mat4 u_ModelMatrix;
@@ -9958,7 +9800,7 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 }
 `;
 
-  // src/modules-webgl1/lighting/pbr/pbr-fragment.glsl.ts
+  // src/modules-webgl1/lighting/pbr/pbr-fragment-glsl.ts
   var fs27 = glsl`\
 #if defined(USE_TEX_LOD) && !defined(FEATURE_GLSL_TEXTURE_LOD)
 # error PBR fragment shader: Texture LOD is not available
@@ -9968,15 +9810,6 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 # error PBR fragment shader: Derivatives are not available
 #endif
 
-// WebGL 1.0 does not support non-constant in for loops
-// This provides an easy way to handle these cases
-// and still take advantage of WebGL 2.0
-#if (__VERSION__ < 300)
-  #define SMART_FOR(INIT, WEBGL1COND, WEBGL2COND, INCR) for (INIT; WEBGL1COND; INCR)
-#else
-  #define SMART_FOR(INIT, WEBGL1COND, WEBGL2COND, INCR) for (INIT; WEBGL2COND; INCR)
-#endif
-
 precision highp float;
 
 uniform bool pbr_uUnlit;
@@ -10305,7 +10138,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     color += calculateFinalColor(pbrInputs, lighting_uAmbientLight.color);
 
     // Apply directional light
-    SMART_FOR(int i = 0, i < MAX_LIGHTS, i < lighting_uDirectionalLightCount, i++) {
+    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);
@@ -10313,7 +10146,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     }
 
     // Apply point light
-    SMART_FOR(int i = 0, i < MAX_LIGHTS, i < lighting_uPointLightCount, i++) {
+    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));