@luma.gl/shadertools 9.0.0-beta.3 → 9.0.0-beta.5

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 = {};
@@ -133,38 +138,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 +201,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 +293,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,7 +308,10 @@ ${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++}`;
@@ -351,6 +346,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 +376,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 +426,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 +442,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 +549,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 +620,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 +634,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,51 +686,30 @@ ${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":
         return {
-          vs: assembleGLSLShader(options.platformInfo, {
-            ...options,
-            source: vs6,
-            stage: "vertex",
-            modules
-          }),
-          fs: assembleGLSLShader(options.platformInfo, {
-            ...options,
-            source: fs28,
-            stage: "fragment",
-            modules
-          }),
+          vs: assembleGLSLShader(options.platformInfo, { ...options, source: vs6, stage: "vertex", modules }),
+          fs: assembleGLSLShader(options.platformInfo, { ...options, source: fs28, stage: "fragment", modules }),
           getUniforms: assembleGetUniforms(modules)
         };
       case "wgsl":
         return {
-          vs: assembleWGSLShader(options.platformInfo, {
-            ...options,
-            source: vs6,
-            stage: "vertex",
-            modules
-          }),
-          fs: assembleWGSLShader(options.platformInfo, {
-            ...options,
-            source: fs28,
-            stage: "fragment",
-            modules
-          }),
+          vs: assembleWGSLShader(options.platformInfo, { ...options, source: vs6, stage: "vertex", modules }),
+          fs: assembleWGSLShader(options.platformInfo, { ...options, source: fs28, stage: "fragment", modules }),
           getUniforms: assembleGetUniforms(modules)
         };
     }
   }
   function assembleWGSLShader(platformInfo, options) {
     const {
+      // id,
       source,
       stage,
       modules,
+      // defines = {},
       hookFunctions = [],
       inject = {},
       log
@@ -781,10 +722,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 +800,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 +819,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 +864,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 +879,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 +908,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,45 +929,63 @@ ${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;
       const options = selectShaders(props);
-      const assembled = assembleShaders({
-        platformInfo: props.platformInfo,
-        ...options,
-        modules,
-        hookFunctions
-      });
-      return {
-        ...assembled,
-        modules
-      };
+      const assembled = assembleShaders({ platformInfo: props.platformInfo, ...options, modules, hookFunctions });
+      return { ...assembled, modules };
     }
+    /** 
+     * Dedupe and combine with default modules
+     */
     _getModuleList(appModules = []) {
       const modules = new Array(this._defaultModules.length + appModules.length);
       const seen = {};
@@ -1067,6 +1008,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 +1025,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 +1040,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) {
@@ -1603,6 +1525,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 +2076,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 +2138,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 +2305,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 +2315,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 +2672,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 +2861,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 +2966,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 +2992,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 +3262,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 +3380,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 +4005,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 +4032,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 +4046,7 @@ void main() {
         type: "uniform",
         name: uniform.name,
         location: uniform.binding,
+        // @ts-expect-error
         group: uniform.group,
         members
       });
@@ -4052,9 +4083,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 +4439,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 +4497,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 +4511,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 +4564,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 +4591,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 +4609,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 +4639,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 +4663,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 +4759,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 +4779,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 +4882,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 +4902,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 +4951,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,14 +4961,8 @@ 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
+// TODO - remove we only support WebGL2
+#define SMART_FOR(INIT, WEBGL1COND, WEBGL2COND, INCR) for (INIT; WEBGL2COND; INCR)
 
 precision highp float;
 
@@ -5377,57 +5388,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]
   };
@@ -5435,14 +5441,14 @@ vec4 pbr_filterColor(vec4 colorUnused)
   // src/modules/postprocessing/image-adjust-filters/brightnesscontrast.ts
   var fs4 = glsl`\
 
-uniform BrightnessContrast{
+uniform brightnessContrastUniforms {
   float brightness;
   float contrast;
 } brightnessContrast;
 
 vec4 brightnessContrast_filterColor(vec4 color) {
   color.rgb += brightnessContrast.brightness;
-  if (contrast > 0.0) {
+  if (brightnessContrast.contrast > 0.0) {
     color.rgb = (color.rgb - 0.5) / (1.0 - brightnessContrast.contrast) + 0.5;
   } else {
     color.rgb = (color.rgb - 0.5) * (1.0 + brightnessContrast.contrast) + 0.5;
@@ -5461,43 +5467,31 @@ 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
   var fs5 = glsl`\
-uniform Noise {
+uniform denoiseUniforms {
   float strength;
 } noise;
 
-vec4 denoise_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 denoise_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   float adjustedExponent = 3. + 200. * pow(1. - noise.strength, 4.);
 
-  vec4 center = texture2D(texture, texCoord);
+  vec4 center = texture(source, texCoord);
   vec4 color = vec4(0.0);
   float total = 0.0;
   for (float x = -4.0; x <= 4.0; x += 1.0) {
     for (float y = -4.0; y <= 4.0; y += 1.0) {
-      vec4 sample = texture2D(texture, texCoord + vec2(x, y) / texSize);
-      float weight = 1.0 - abs(dot(sample.rgb - center.rgb, vec3(0.25)));
+      vec4 offsetColor = texture(source, texCoord + vec2(x, y) / texSize);
+      float weight = 1.0 - abs(dot(offsetColor.rgb - center.rgb, vec3(0.25)));
       weight = pow(weight, adjustedExponent);
-      color += sample * weight;
+      color += offsetColor * weight;
       total += weight;
     }
   }
@@ -5511,31 +5505,23 @@ vec4 denoise_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
       strength: "f32"
     },
     uniformPropTypes: {
-      strength: {
-        format: "f32",
-        value: 0.5,
-        min: 0,
-        max: 0.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
   var fs6 = glsl`\
-uniform HueSaturation {
+uniform hueSaturationUniforms {
   float hue;
   float saturation;
 } hueSaturation;
 
 vec4 hueSaturation_filterColor(vec4 color) {
   // hue adjustment, wolfram alpha: RotationTransform[angle, {1, 1, 1}][{x, y, z}]
-  float angle = hue * 3.14159265;
+  float angle = hueSaturation.hue * 3.14159265;
   float s = sin(angle), c = cos(angle);
   vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;
   float len = length(color.rgb);
@@ -5547,10 +5533,10 @@ vec4 hueSaturation_filterColor(vec4 color) {
 
   // saturation adjustment
   float average = (color.r + color.g + color.b) / 3.0;
-  if (saturation > 0.0) {
-    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - saturation));
+  if (hueSaturation.saturation > 0.0) {
+    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));
   } else {
-    color.rgb += (average - color.rgb) * (-saturation);
+    color.rgb += (average - color.rgb) * (-hueSaturation.saturation);
   }
 
   return color;
@@ -5567,26 +5553,16 @@ 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
   var fs7 = glsl`\
-uniform Noise {
+uniform noiseUniforms {
   float amount;
 } noise;
 
@@ -5612,21 +5588,15 @@ 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
   var fs8 = glsl`\
-uniform Sepia {
+uniform sepiaUniforms {
   float amount;
 } sepia;
 
@@ -5653,21 +5623,15 @@ 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
   var fs9 = glsl`\
-uniform Vibrance {
+uniform vibranceUniforms {
   float amount;
 } vibrance;
 
@@ -5686,21 +5650,15 @@ 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
   var fs10 = glsl`\
-uniform Vignette {
+uniform vignetteUniforms {
   float radius;
   float amount;
 } vignette;
@@ -5723,25 +5681,15 @@ 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
   var fs11 = glsl`\
-uniform TiltShift {
+uniform tiltShiftUniforms {
   float blurRadius;
   float gradientRadius;
   vec2 start;
@@ -5754,26 +5702,26 @@ vec2 tiltShift_getDelta(vec2 texSize) {
   return tiltShift.invert ? vec2(-vector.y, vector.x) : vector;
 }
 
-vec4 tiltShift_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec4 color = vec4(0.0);
   float total = 0.0;
 
   /* randomize the lookup values to hide the fixed number of samples */
   float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
 
-  vec2 normal = normalize(vec2((start.y - end.y) * texSize.y, (end.x - start.x) * texSize.x));
+  vec2 normal = normalize(vec2((tiltShift.start.y - tiltShift.end.y) * texSize.y, (tiltShift.end.x - tiltShift.start.x) * texSize.x));
   float radius = smoothstep(0.0, 1.0,
-    abs(dot(texCoord * texSize - start * texSize, normal)) / tiltShift.gradientRadius) * tiltShift.blurRadius;
+    abs(dot(texCoord * texSize - tiltShift.start * texSize, normal)) / tiltShift.gradientRadius) * tiltShift.blurRadius;
 
   for (float t = -30.0; t <= 30.0; t++) {
     float percent = (t + offset - 0.5) / 30.0;
     float weight = 1.0 - abs(percent);
-    vec4 sample = texture2D(texture, texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius);
+    vec4 offsetColor = texture(source, texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius);
 
     /* switch to pre-multiplied alpha to correctly blur transparent images */
-    sample.rgb *= sample.a;
+    offsetColor.rgb *= offsetColor.a;
 
-    color += sample * weight;
+    color += offsetColor * weight;
     total += weight;
   }
 
@@ -5795,49 +5743,29 @@ vec4 tiltShift_sampleColor(sampler2D texture, 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
   };
 
   // src/modules/postprocessing/image-blur-filters/triangleblur.ts
   var fs12 = glsl`\
-uniform float radius;
-uniform vec2 delta;
+uniform triangleBlurUniforms {
+  float radius;
+  vec2 delta;
+} triangleBlur;
 
-vec4 triangleBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
-  vec2 adjustedDelta = delta * radius / texSize;
+vec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec2 adjustedDelta = triangleBlur.delta * triangleBlur.radius / texSize;
 
   vec4 color = vec4(0.0);
   float total = 0.0;
@@ -5848,12 +5776,12 @@ vec4 triangleBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   for (float t = -30.0; t <= 30.0; t++) {
     float percent = (t + offset - 0.5) / 30.0;
     float weight = 1.0 - abs(percent);
-    vec4 sample = texture2D(texture, texCoord + adjustedDelta * percent);
+    vec4 offsetColor = texture(source, texCoord + adjustedDelta * percent);
 
     /* switch to pre-multiplied alpha to correctly blur transparent images */
-    sample.rgb *= sample.a;
+    offsetColor.rgb *= offsetColor.a;
 
-    color += sample * weight;
+    color += offsetColor * weight;
     total += weight;
   }
 
@@ -5872,40 +5800,28 @@ vec4 triangleBlur_sampleColor(sampler2D texture, 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
   var fs13 = `
-uniform vec2 center;
-uniform float strength;
+uniform zoomBlurUniforms {
+  vec2 center;
+  float strength;
+} zoomBlur;
 
-vec4 zoomBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec4 color = vec4(0.0);
   float total = 0.0;
-  vec2 toCenter = center * texSize - texCoord * texSize;
+  vec2 toCenter = zoomBlur.center * texSize - texCoord * texSize;
 
   /* randomize the lookup values to hide the fixed number of samples */
   float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
@@ -5913,12 +5829,12 @@ vec4 zoomBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   for (float t = 0.0; t <= 40.0; t++) {
     float percent = (t + offset) / 40.0;
     float weight = 4.0 * (percent - percent * percent);
-    vec4 sample = texture2D(texture, texCoord + toCenter * percent * strength / texSize);
+    vec4 offsetColor = texture(source, texCoord + toCenter * percent * zoomBlur.strength / texSize);
 
     /* switch to pre-multiplied alpha to correctly blur transparent images */
-    sample.rgb *= sample.a;
+    offsetColor.rgb *= offsetColor.a;
 
-    color += sample * weight;
+    color += offsetColor * weight;
     total += weight;
   }
 
@@ -5937,34 +5853,24 @@ vec4 zoomBlur_sampleColor(sampler2D texture, 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
   var fs14 = glsl`\
-uniform ColorHalftone {
+uniform colorHalftoneUniforms {
   vec2 center;
   float angle;
   float size;
 } colorHalftone;
 
-float scale = 3.1514 / colorHalftone.size;
-
-float pattern(float angle, vec2 texSize, vec2 texCoord) {
-  float s = sin(colorHalftone.angle), c = cos(colorHalftone.angle);
+float pattern(float angle, float scale, vec2 texSize, vec2 texCoord) {
+  float s = sin(angle), c = cos(angle);
   vec2 tex = texCoord * texSize - colorHalftone.center * texSize;
   vec2 point = vec2(
 	c * tex.x - s * tex.y,
@@ -5974,19 +5880,21 @@ float pattern(float angle, vec2 texSize, vec2 texCoord) {
 }
 
 vec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
+  float scale = 3.1514 / colorHalftone.size;
   vec3 cmy = 1.0 - color.rgb;
   float k = min(cmy.x, min(cmy.y, cmy.z));
+
   cmy = (cmy - k) / (1.0 - k);
   cmy = clamp(
-	cmy * 10.0 - 3.0 + vec3(
-    pattern(angle + 0.26179, texSize, texCoord),
-	  pattern(angle + 1.30899, texSize, texCoord),
-    pattern(angle, texSize, texCoord)
-  ),
-	0.0,
-	1.0
+	  cmy * 10.0 - 3.0 + vec3(
+      pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),
+	    pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),
+      pattern(colorHalftone.angle, scale, texSize, texCoord)
+    ),
+	  0.0,
+	  1.0
   );
-  k = clamp(k * 10.0 - 5.0 + pattern(angle + 0.78539, texSize, texCoord), 0.0, 1.0);
+  k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);
   return vec4(1.0 - cmy - k, color.a);
 }
 `;
@@ -5998,30 +5906,17 @@ 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
   var fs15 = glsl`\
-uniform DotScreen {
+uniform dotScreenUniforms {
   vec2 center;
   float angle;
   float size;
@@ -6052,30 +5947,17 @@ 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
   var fs16 = glsl`\
-uniform EdgeWork {
+uniform edgeWorkUniforms {
   float radius;
   vec2 delta;
 } edgeWork;
@@ -6092,7 +5974,7 @@ vec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {
   for (float t = -30.0; t <= 30.0; t++) {
     float percent = (t + offset - 0.5) / 30.0;
     float weight = 1.0 - abs(percent);
-    vec3 sampleColor = texture2D(source, texCoord + relativeDelta * percent).rgb;
+    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;
     float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;
     color.x += average * weight;
     total.x += weight;
@@ -6117,7 +5999,7 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
   for (float t = -30.0; t <= 30.0; t++) {
     float percent = (t + offset - 0.5) / 30.0;
     float weight = 1.0 - abs(percent);
-    vec2 sampleColor = texture2D(source, texCoord + relativeDelta * percent).xy;
+    vec2 sampleColor = texture(source, texCoord + relativeDelta * percent).xy;
     color.x += sampleColor.x * weight;
     total.x += weight;
     if (abs(t) < 15.0) {
@@ -6133,39 +6015,33 @@ 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
   var fs17 = glsl`\
-uniform HexagonalPixelate {
+uniform hexagonalPixelateUniforms {
   vec2 center;
   float scale;
 } hexagonalPixelate;
 
-vec4 hexagonalPixelate_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;
   tex.y /= 0.866025404;
   tex.x -= tex.y * 0.5;
@@ -6200,7 +6076,7 @@ vec4 hexagonalPixelate_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoor
   choice.y *= 0.866025404;
   choice *= hexagonalPixelate.scale / texSize;
 
-  return texture2D(texture, choice + hexagonalPixelate.center);
+  return texture(source, choice + hexagonalPixelate.center);
 }
 `;
   var hexagonalPixelate = {
@@ -6210,44 +6086,34 @@ vec4 hexagonalPixelate_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoor
       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
   var fs18 = glsl`\
-uniform Ink {
+uniform inkUniforms {
   float strength;
 } ink;
 
-vec4 ink_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec2 dx = vec2(1.0 / texSize.x, 0.0);
   vec2 dy = vec2(0.0, 1.0 / texSize.y);
-  vec4 color = texture2D(texture, texCoord);
+  vec4 color = texture(source, texCoord);
   float bigTotal = 0.0;
   float smallTotal = 0.0;
   vec3 bigAverage = vec3(0.0);
   vec3 smallAverage = vec3(0.0);
   for (float x = -2.0; x <= 2.0; x += 1.0) {
     for (float y = -2.0; y <= 2.0; y += 1.0) {
-      vec3 sample = texture2D(texture, texCoord + dx * x + dy * y).rgb;
-      bigAverage += sample;
+      vec3 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;
+      bigAverage += offsetColor;
       bigTotal += 1.0;
       if (abs(x) + abs(y) < 2.0) {
-        smallAverage += sample;
+        smallAverage += offsetColor;
         smallTotal += 1.0;
       }
     }
@@ -6263,21 +6129,15 @@ vec4 ink_sampleColor(sampler2D texture, 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
   var fs19 = glsl`\
-uniform Magnify {
+uniform magnifyUniforms {
   vec2 screenXY;
   float radiusPixels;
   float zoom;
@@ -6285,17 +6145,17 @@ uniform Magnify {
   vec4 borderColor;
 } magnify;
 
-vec4 magnify_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec2 pos = vec2(magnify.screenXY.x, 1.0 - magnify.screenXY.y);
   float dist = distance(texCoord * texSize, pos * texSize);
   if (dist < magnify.radiusPixels) {
-    return texture2D(texture, (texCoord - pos) / magnify.zoom + pos);
+    return texture(source, (texCoord - pos) / magnify.zoom + pos);
   }
 
   if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {
     return magnify.borderColor;
   }
-  return texture2D(texture, texCoord);
+  return texture(source, texCoord);
 }
 `;
   var magnify = {
@@ -6308,26 +6168,21 @@ vec4 magnify_sampleColor(sampler2D texture, 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
   var fs20 = glsl`\
-vec4 warp_sampleColor(sampler2D texture, vec2 texSize, vec2 coord) {
-  vec4 color = texture2D(texture, coord / texSize);
+vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {
+  vec4 color = texture(source, coord / texSize);
   vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);
   if (coord != clampedCoord) {
     /* fade to transparent if we are outside the image */
@@ -6339,12 +6194,13 @@ vec4 warp_sampleColor(sampler2D texture, vec2 texSize, vec2 coord) {
 `;
   var warp = {
     name: "warp",
+    passes: [],
     fs: fs20
   };
 
   // src/modules/postprocessing/image-warp-filters/bulgepinch.ts
   var fs21 = glsl`\
-uniform BulgePinch {
+uniform bulgePinchUniforms {
   float radius;
   float strength;
   vec2 center;
@@ -6355,7 +6211,7 @@ vec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {
   float distance = length(coord);
   if (distance < bulgePinch.radius) {
     float percent = distance / bulgePinch.radius;
-    if (strength > 0.0) {
+    if (bulgePinch.strength > 0.0) {
       coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);
     } else {
       coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);
@@ -6365,11 +6221,11 @@ vec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {
   return coord;
 }
 
-vec4 bulgePinch_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec2 coord = texCoord * texSize;
   coord = bulgePinch_warp(coord, bulgePinch.center * texSize);
 
-  return warp_sampleColor(texture, texSize, coord);
+  return warp_sampleColor(source, texSize, coord);
 }
 `;
   var bulgePinch = {
@@ -6381,29 +6237,17 @@ vec4 bulgePinch_sampleColor(sampler2D texture, 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
   var fs22 = glsl`\
-uniform Swirl {
+uniform swirlUniforms {
   float radius;
   float angle;
   vec2 center;
@@ -6426,11 +6270,11 @@ vec2 swirl_warp(vec2 coord, vec2 texCenter) {
   return coord;
 }
 
-vec4 swirl_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec2 coord = texCoord * texSize;
   coord = swirl_warp(coord, swirl.center * texSize);
 
-  return warp_sampleColor(texture, texSize, coord);
+  return warp_sampleColor(source, texSize, coord);
 }
 `;
   var swirl = {
@@ -6442,24 +6286,12 @@ vec4 swirl_sampleColor(sampler2D texture, 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
@@ -6651,8 +6483,8 @@ vec4 swirl_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
 #define FxaaTex sampler2D
 
 #define FxaaSat(x) clamp(x, 0.0, 1.0)
-#define FxaaTexTop(t, p) texture2D(t, p)
-#define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r))
+#define FxaaTexTop(t, p) texture(t, p)
+#define FxaaTexOff(t, p, o, r) texture(t, p + (o * r))
 
 FxaaFloat FxaaLuma_(FxaaFloat4 rgba) { return dot(rgba.rgb, vec3(0.2126, 0.7152, 0.0722)); }
 
@@ -7029,14 +6861,14 @@ FxaaFloat4 FxaaPixelShader_(
     return FxaaTexTop(tex, posM);
 }
 
-vec4 fxaa_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 fxaa_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
     const float fxaa_QualitySubpix = 0.5;
     const float fxaa_QualityEdgeThreshold = 0.125;
     const float fxaa_QualityEdgeThresholdMin = 0.0833;
 
     return FxaaPixelShader_(
         texCoord,
-        texture,
+        source,
         vec2(1.0) / texSize,
         fxaa_QualitySubpix,
         fxaa_QualityEdgeThreshold,
@@ -7048,9 +6880,7 @@ vec4 fxaa_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
     name: "fxaa",
     uniformPropTypes: {},
     fs: fs23,
-    passes: [{
-      sampler: true
-    }]
+    passes: [{ sampler: true }]
   };
 
   // src/modules-webgl1/math/fp64/fp64-utils.ts
@@ -7075,7 +6905,7 @@ vec4 fxaa_sampleColor(sampler2D texture, 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;
 
@@ -7244,7 +7074,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);
@@ -7919,6 +7749,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() {
@@ -7936,6 +7767,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
@@ -9548,7 +9380,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;
   }
@@ -9627,7 +9461,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))
 
@@ -9670,10 +9504,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({
@@ -9690,7 +9521,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) => {
@@ -9702,30 +9537,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":
@@ -9740,9 +9566,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
           default:
         }
       }
-      return getUniforms6({
-        lightSources
-      });
+      return getUniforms6({ lightSources });
     }
     return {};
   }
@@ -9781,12 +9605,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;
@@ -9866,12 +9691,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,
@@ -9883,13 +9703,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);
   }
@@ -9912,7 +9728,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;
@@ -9953,7 +9769,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
@@ -9963,14 +9779,8 @@ 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
+// TODO - remove we no longer support WebGL1
+#define SMART_FOR(INIT, WEBGL1COND, WEBGL2COND, INCR) for (INIT; WEBGL2COND; INCR)
 
 precision highp float;