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

package/dist/dist.dev.js

@@ -56,20 +56,13 @@ var __exports__ = (() => {
     ShaderAssembler: () => ShaderAssembler,
     _getDependencyGraph: () => getDependencyGraph,
     _resolveModules: () => resolveModules,
-    _warp: () => warp,
     assembleGLSLShaderPair: () => assembleGLSLShaderPair,
-    brightnessContrast: () => brightnessContrast,
-    bulgePinch: () => bulgePinch,
     capitalize: () => capitalize,
     checkShaderModuleDeprecations: () => checkShaderModuleDeprecations,
-    colorHalftone: () => colorHalftone,
     combineInjects: () => combineInjects,
     convertToVec4: () => convertToVec4,
-    denoise: () => denoise,
     dirlight: () => dirlight,
     dirlight1: () => dirlight2,
-    dotScreen: () => dotScreen,
-    edgeWork: () => edgeWork,
     fp32: () => fp32,
     fp64: () => fp64,
     fp64LowPart: () => fp64LowPart,
@@ -77,7 +70,6 @@ var __exports__ = (() => {
     fp64ify: () => fp64ify,
     fp64ifyMatrix4: () => fp64ifyMatrix4,
     fromHalfFloat: () => fromHalfFloat,
-    fxaa: () => fxaa,
     generateShaderForModule: () => generateShaderForModule,
     geometry1: () => geometry,
     getPassthroughFS: () => getPassthroughFS,
@@ -89,15 +81,10 @@ var __exports__ = (() => {
     getShaderModuleUniforms: () => getShaderModuleUniforms,
     gouraudLighting: () => gouraudLighting,
     gouraudMaterial: () => gouraudMaterial,
-    hexagonalPixelate: () => hexagonalPixelate,
-    hueSaturation: () => hueSaturation,
     initializeShaderModule: () => initializeShaderModule,
     initializeShaderModules: () => initializeShaderModules,
-    ink: () => ink,
     lighting: () => lighting,
     lights1: () => lights,
-    magnify: () => magnify,
-    noise: () => noise,
     pbr: () => pbr,
     pbrMaterial: () => pbrMaterial,
     phongLighting: () => phongLighting,
@@ -106,16 +93,9 @@ var __exports__ = (() => {
     preprocess: () => preprocess,
     project1: () => project,
     random: () => random,
-    sepia: () => sepia,
-    swirl: () => swirl,
-    tiltShift: () => tiltShift,
     toHalfFloat: () => toHalfFloat,
-    triangleBlur: () => triangleBlur,
     typeToChannelCount: () => typeToChannelCount,
-    typeToChannelSuffix: () => typeToChannelSuffix,
-    vibrance: () => vibrance,
-    vignette: () => vignette,
-    zoomBlur: () => zoomBlur
+    typeToChannelSuffix: () => typeToChannelSuffix
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
@@ -203,20 +183,20 @@ var __exports__ = (() => {
   var MODULE_INJECTORS_FS = (
     /* glsl */
     `#ifdef MODULE_MATERIAL
-  gl_FragColor = material_filterColor(gl_FragColor);
+  fragColor = material_filterColor(fragColor);
 #endif
 
 #ifdef MODULE_LIGHTING
-  gl_FragColor = lighting_filterColor(gl_FragColor);
+  fragColor = lighting_filterColor(fragColor);
 #endif
 
 #ifdef MODULE_FOG
-  gl_FragColor = fog_filterColor(gl_FragColor);
+  fragColor = fog_filterColor(fragColor);
 #endif
 
 #ifdef MODULE_PICKING
-  gl_FragColor = picking_filterHighlightColor(gl_FragColor);
-  gl_FragColor = picking_filterPickingColor(gl_FragColor);
+  fragColor = picking_filterHighlightColor(fragColor);
+  fragColor = picking_filterPickingColor(fragColor);
 #endif
 
 #ifdef MODULE_LOGDEPTH
@@ -334,7 +314,7 @@ ${inject[key]}` : inject[key];
     }
     initializeShaderModules(module.dependencies || []);
     const {
-      uniformPropTypes = {},
+      propTypes = {},
       deprecations = [],
       // defines = {},
       inject = {}
@@ -343,26 +323,40 @@ ${inject[key]}` : inject[key];
       normalizedInjections: normalizeInjections(inject),
       parsedDeprecations: parseDeprecationDefinitions(deprecations)
     };
-    if (uniformPropTypes) {
-      instance.propValidators = makePropValidators(uniformPropTypes);
+    if (propTypes) {
+      instance.propValidators = makePropValidators(propTypes);
     }
     module.instance = instance;
+    let defaultProps = {};
+    if (propTypes) {
+      defaultProps = Object.entries(propTypes).reduce(
+        (obj, [key, propType]) => {
+          const value = propType?.value;
+          if (value) {
+            obj[key] = value;
+          }
+          return obj;
+        },
+        {}
+      );
+    }
+    module.defaultUniforms = { ...module.defaultUniforms, ...defaultProps };
   }
   function getShaderModuleUniforms(module, props, oldUniforms) {
     initializeShaderModule(module);
     const uniforms = oldUniforms || { ...module.defaultUniforms };
-    if (module.getUniforms) {
+    if (props && module.getUniforms) {
       return module.getUniforms(props, uniforms);
     }
     return getValidatedProperties(props, module.instance?.propValidators, module.name);
   }
-  function checkShaderModuleDeprecations(shaderModule, shaderSource, log2) {
+  function checkShaderModuleDeprecations(shaderModule, shaderSource, log3) {
     shaderModule.deprecations?.forEach((def) => {
       if (def.regex?.test(shaderSource)) {
         if (def.deprecated) {
-          log2.deprecated(def.old, def.new)();
+          log3.deprecated(def.old, def.new)();
         } else {
-          log2.removed(def.old, def.new)();
+          log3.removed(def.old, def.new)();
         }
       }
     });
@@ -627,7 +621,7 @@ ${DECLARATION_INJECT_MARKER}
     };
   }
   function assembleGLSLShaderPair(options) {
-    const { vs: vs6, fs: fs28 } = options;
+    const { vs: vs6, fs: fs8 } = options;
     const modules = getShaderModuleDependencies(options.modules || []);
     return {
       vs: assembleShaderGLSL(options.platformInfo, {
@@ -639,7 +633,7 @@ ${DECLARATION_INJECT_MARKER}
       fs: assembleShaderGLSL(options.platformInfo, {
         ...options,
         // @ts-expect-error
-        source: fs28,
+        source: fs8,
         stage: "fragment",
         modules
       }),
@@ -655,7 +649,7 @@ ${DECLARATION_INJECT_MARKER}
       // defines = {},
       hookFunctions = [],
       inject = {},
-      log: log2
+      log: log3
     } = options;
     assert(typeof source === "string", "shader source must be a string");
     const coreSource = source;
@@ -683,14 +677,14 @@ ${DECLARATION_INJECT_MARKER}
         mainInjections[key] = [injection];
       }
     }
-    const modulesToInject = platformInfo.type !== "webgpu" ? modules : [];
+    const modulesToInject = modules;
     for (const module of modulesToInject) {
-      if (log2) {
-        checkShaderModuleDeprecations(module, coreSource, log2);
+      if (log3) {
+        checkShaderModuleDeprecations(module, coreSource, log3);
       }
-      const moduleSource = getShaderModuleSource(module, stage);
+      const moduleSource = getShaderModuleSource(module, "wgsl");
       assembledSource += moduleSource;
-      const injections = module.injections[stage];
+      const injections = module.injections?.[stage] || {};
       for (const key in injections) {
         const match = /^(v|f)s:#([\w-]+)$/.exec(key);
         if (match) {
@@ -713,7 +707,6 @@ ${DECLARATION_INJECT_MARKER}
   }
   function assembleShaderGLSL(platformInfo, options) {
     const {
-      id,
       source,
       stage,
       language = "glsl",
@@ -722,7 +715,7 @@ ${DECLARATION_INJECT_MARKER}
       hookFunctions = [],
       inject = {},
       prologue = true,
-      log: log2
+      log: log3
     } = options;
     assert(typeof source === "string", "shader source must be a string");
     const sourceVersion = language === "glsl" ? getShaderInfo(source).version : -1;
@@ -743,7 +736,6 @@ ${DECLARATION_INJECT_MARKER}
         assembledSource = prologue ? `${sourceVersionDirective}
 
 // ----- PROLOGUE -------------------------
-${getShaderNameDefine({ id, source, stage })}
 ${`#define SHADER_TYPE_${stage.toUpperCase()}`}
 
 ${getPlatformShaderDefines(platformInfo)}
@@ -781,8 +773,8 @@ ${getApplicationDefines(allDefines)}
       }
     }
     for (const module of modules) {
-      if (log2) {
-        checkShaderModuleDeprecations(module, coreSource, log2);
+      if (log3) {
+        checkShaderModuleDeprecations(module, coreSource, log3);
       }
       const moduleSource = getShaderModuleSource(module, stage);
       assembledSource += moduleSource;
@@ -821,12 +813,6 @@ ${getApplicationDefines(allDefines)}
       return uniforms;
     };
   }
-  function getShaderNameDefine(options) {
-    const { id, source, stage } = options;
-    const injectShaderName = id && source.indexOf("SHADER_NAME") === -1;
-    return injectShaderName ? `
-#define SHADER_NAME ${id}_${stage}` : "";
-  }
   function getApplicationDefines(defines = {}) {
     let sourceText = "";
     for (const define in defines) {
@@ -857,12 +843,16 @@ ${getApplicationDefines(allDefines)}
       throw new Error("Shader module must have a name");
     }
     const moduleName = module.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
-    return `// ----- MODULE ${module.name} ---------------
-
-#define MODULE_${moduleName}
-${moduleSource}
+    let source = `// ----- MODULE ${module.name} ---------------
 
 `;
+    if (stage !== "wgsl") {
+      source += `#define MODULE_${moduleName}
+`;
+    }
+    source += `${moduleSource}
+`;
+    return source;
   }
 
   // src/lib/preprocessor/preprocessor.ts
@@ -4642,12 +4632,28 @@ void main() {
       shaderLayout.bindings.push({
         type: "uniform",
         name: uniform.name,
-        location: uniform.binding,
-        // @ts-expect-error
         group: uniform.group,
+        location: uniform.binding,
+        // @ts-expect-error TODO - unused for now but needs fixing
         members
       });
     }
+    for (const texture of parsedWGSL.textures) {
+      shaderLayout.bindings.push({
+        type: "texture",
+        name: texture.name,
+        group: texture.group,
+        location: texture.binding
+      });
+    }
+    for (const sampler of parsedWGSL.samplers) {
+      shaderLayout.bindings.push({
+        type: "sampler",
+        name: sampler.name,
+        group: sampler.group,
+        location: sampler.binding
+      });
+    }
     const vertex = parsedWGSL.entry.vertex[0];
     const attributeCount = vertex?.inputs.length || 0;
     for (let i = 0; i < attributeCount; i++) {
@@ -6657,7 +6663,7 @@ float tan_fp32(float a) {
   };
 
   // src/modules/engine/picking/picking.ts
-  var DEFAULT_HIGHLIGHT_COLOR = new Float32Array([0, 1, 1, 1]);
+  var DEFAULT_HIGHLIGHT_COLOR = [0, 1, 1, 1];
   var vs = (
     /* glsl */
     `uniform pickingUniforms {
@@ -6810,7 +6816,7 @@ vec4 picking_filterColor(vec4 color) {
       isAttribute: false,
       isHighlightActive: false,
       useFloatColors: true,
-      highlightedObjectColor: new Float32Array([0, 0, 0]),
+      highlightedObjectColor: [0, 0, 0],
       highlightColor: DEFAULT_HIGHLIGHT_COLOR
     },
     vs,
@@ -6844,8 +6850,11 @@ vec4 picking_filterColor(vec4 color) {
     return uniforms;
   }
 
+  // src/modules/lighting/lights/lighting.ts
+  var import_core3 = __toESM(require_core(), 1);
+
   // src/modules/lighting/lights/lighting-uniforms-glsl.ts
-  var lightingUniforms = (
+  var lightingUniformsGLSL = (
     /* glsl */
     `precision highp int;
 
@@ -6867,28 +6876,51 @@ struct DirectionalLight {
 
 uniform lightingUniforms {
   int enabled;
-  int pointLightCount;
+  int lightType;
+
   int directionalLightCount;
+  int pointLightCount;
 
   vec3 ambientColor;
 
-  int lightType;
-  vec3 lightColor;
-  vec3 lightDirection;
-  vec3 lightPosition;
-  vec3 lightAttenuation;
+  vec3 lightColor0;
+  vec3 lightPosition0;
+  vec3 lightDirection0;
+  vec3 lightAttenuation0;
 
-  // AmbientLight ambientLight;
-  // PointLight pointLight[MAX_LIGHTS];
-  // DirectionalLight directionalLight[MAX_LIGHTS];
+  vec3 lightColor1;
+  vec3 lightPosition1;
+  vec3 lightDirection1;
+  vec3 lightAttenuation1;
+
+  vec3 lightColor2;
+  vec3 lightPosition2;
+  vec3 lightDirection2;
+  vec3 lightAttenuation2;
 } lighting;
 
 PointLight lighting_getPointLight(int index) {
-  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
+  switch (index) {
+    case 0:
+      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);
+    case 1:
+      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
+    case 2:
+    default:  
+      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
+  }
 }
 
 DirectionalLight lighting_getDirectionalLight(int index) {
-  return DirectionalLight(lighting.lightColor, lighting.lightDirection);
+  switch (index) {
+    case 0:
+      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);
+    case 1:
+      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
+    case 2:
+    default:   
+      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
+  }
 } 
 
 float getPointLightAttenuation(PointLight pointLight, float distance) {
@@ -6901,8 +6933,65 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
 `
   );
 
+  // src/modules/lighting/lights/lighting-uniforms-wgsl.ts
+  var lightingUniformsWGSL = (
+    /* wgsl */
+    `// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+struct AmbientLight {
+  color: vec3<f32>,
+};
+
+struct PointLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential
+};
+
+struct DirectionalLight {
+  color: vec3<f32>,
+  direction: vec3<f32>,
+};
+
+struct lightingUniforms {
+  enabled: i32,
+  poightCount: i32,
+  directionalLightCount: i32,
+
+  ambientColor: vec3<f32>,
+
+  // TODO - support multiple lights by uncommenting arrays below
+  lightType: i32,
+  lightColor: vec3<f32>,
+  lightDirection: vec3<f32>,
+  lightPosition: vec3<f32>,
+  lightAttenuation: vec3<f32>,
+
+  // AmbientLight ambientLight;
+  // PointLight pointLight[MAX_LIGHTS];
+  // DirectionalLight directionalLight[MAX_LIGHTS];
+};
+
+// Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)
+@binding(1) @group(0) var<uniform> lighting : lightingUniforms;
+
+fn lighting_getPointLight(index: i32) -> PointLight {
+  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
+}
+
+fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
+  return DirectionalLight(lighting.lightColor, lighting.lightDirection);
+} 
+
+fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
+  return pointLight.attenuation.x
+       + pointLight.attenuation.y * distance
+       + pointLight.attenuation.z * distance * distance;
+}
+`
+  );
+
   // src/modules/lighting/lights/lighting.ts
-  var MAX_LIGHTS = 5;
+  var MAX_LIGHTS = 3;
   var COLOR_FACTOR = 255;
   var lighting = {
     props: {},
@@ -6913,34 +7002,48 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     },
     uniformTypes: {
       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,
+      directionalLightCount: "i32",
+      pointLightCount: "i32",
+      ambientLightColor: "vec3<f32>",
+      // TODO define as arrays once we have appropriate uniformTypes
+      lightColor0: "vec3<f32>",
+      lightPosition0: "vec3<f32>",
       // TODO - could combine direction and attenuation
-      lightDirection: "vec3<f32>",
-      // , array: MAX_LIGHTS,
-      lightAttenuation: "vec3<f32>"
-      // , array: MAX_LIGHTS},
+      lightDirection0: "vec3<f32>",
+      lightAttenuation0: "vec3<f32>",
+      lightColor1: "vec3<f32>",
+      lightPosition1: "vec3<f32>",
+      lightDirection1: "vec3<f32>",
+      lightAttenuation1: "vec3<f32>",
+      lightColor2: "vec3<f32>",
+      lightPosition2: "vec3<f32>",
+      lightDirection2: "vec3<f32>",
+      lightAttenuation2: "vec3<f32>"
     },
     defaultUniforms: {
       enabled: 1,
-      ambientLightColor: [0.1, 0.1, 0.1],
-      numberOfLights: 0,
       lightType: 0 /* POINT */,
-      lightColor: [1, 1, 1],
-      lightPosition: [1, 1, 2],
+      directionalLightCount: 0,
+      pointLightCount: 0,
+      ambientLightColor: [0.1, 0.1, 0.1],
+      lightColor0: [1, 1, 1],
+      lightPosition0: [1, 1, 2],
       // TODO - could combine direction and attenuation
-      lightDirection: [1, 1, 1],
-      lightAttenuation: [1, 1, 1]
+      lightDirection0: [1, 1, 1],
+      lightAttenuation0: [1, 0, 0],
+      lightColor1: [1, 1, 1],
+      lightPosition1: [1, 1, 2],
+      lightDirection1: [1, 1, 1],
+      lightAttenuation1: [1, 0, 0],
+      lightColor2: [1, 1, 1],
+      lightPosition2: [1, 1, 2],
+      lightDirection2: [1, 1, 1],
+      lightAttenuation2: [1, 0, 0]
     },
-    vs: lightingUniforms,
-    fs: lightingUniforms,
+    source: lightingUniformsWGSL,
+    vs: lightingUniformsGLSL,
+    fs: lightingUniformsGLSL,
     getUniforms: getUniforms2
   };
   function getUniforms2(props, prevUniforms = {}) {
@@ -6971,30 +7074,29 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     pointLights = [],
     directionalLights = []
   }) {
-    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])
-    };
+    const lightSourceUniforms = {};
     lightSourceUniforms.ambientLightColor = convertColor(ambientLight);
     let currentLight = 0;
     for (const pointLight of pointLights) {
       lightSourceUniforms.lightType = 0 /* POINT */;
-      lightSourceUniforms.lightColor = convertColor(pointLight);
-      lightSourceUniforms.lightPosition = pointLight.position;
-      lightSourceUniforms.lightAttenuation = [pointLight.attenuation || 1, 0, 0];
+      const i = currentLight;
+      lightSourceUniforms[`lightColor${i}`] = convertColor(pointLight);
+      lightSourceUniforms[`lightPosition${i}`] = pointLight.position;
+      lightSourceUniforms[`lightAttenuation${i}`] = pointLight.attenuation || [1, 0, 0];
       currentLight++;
     }
     for (const directionalLight of directionalLights) {
       lightSourceUniforms.lightType = 1 /* DIRECTIONAL */;
-      lightSourceUniforms.lightColor = convertColor(directionalLight);
-      lightSourceUniforms.lightPosition = directionalLight.position;
-      lightSourceUniforms.lightDirection = directionalLight.direction;
+      const i = currentLight;
+      lightSourceUniforms[`lightColor${i}`] = convertColor(directionalLight);
+      lightSourceUniforms[`lightDirection${i}`] = directionalLight.direction;
       currentLight++;
     }
-    lightSourceUniforms.numberOfLights = currentLight;
+    if (currentLight > MAX_LIGHTS) {
+      import_core3.log.warn("MAX_LIGHTS exceeded")();
+    }
+    lightSourceUniforms.directionalLightCount = directionalLights.length;
+    lightSourceUniforms.pointLightCount = pointLights.length;
     return lightSourceUniforms;
   }
   function extractLightTypes(lights2) {
@@ -7021,6 +7123,36 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
   }
 
   // src/modules/lighting/no-material/dirlight.ts
+  var SOURCE_WGSL = (
+    /* WGSL */
+    `  
+struct dirlightUniforms {
+  lightDirection: vec3<f32>,
+};
+
+alias DirlightNormal = vec3<f32>;
+
+struct DirlightInputs {
+  normal: DirlightNormal,
+};
+
+@binding(1) @group(0) var<uniform> dirlight : dirlightUniforms;
+
+// For vertex
+fn dirlight_setNormal(normal: vec3<f32>) -> DirlightNormal {
+  return normalize(normal);
+}
+
+// Returns color attenuated by angle from light source
+fn dirlight_filterColor(color: vec4<f32>, inputs: DirlightInputs) -> vec4<f32> {
+  // TODO - fix default light direction
+  // let lightDirection = dirlight.lightDirection;
+  let lightDirection = vec3<f32>(1, 1, 1);
+  let d: f32 = abs(dot(inputs.normal, normalize(lightDirection)));
+  return vec4<f32>(color.rgb * d, color.a);
+}
+`
+  );
   var VS_GLSL = (
     /* glsl */
     `out vec3 dirlight_vNormal;
@@ -7050,6 +7182,7 @@ vec4 dirlight_filterColor(vec4 color) {
     uniforms: {},
     name: "dirlight",
     dependencies: [],
+    source: SOURCE_WGSL,
     vs: VS_GLSL,
     fs: FS_GLSL,
     // fragmentInputs: [
@@ -7062,7 +7195,7 @@ vec4 dirlight_filterColor(vec4 color) {
       lightDirection: "vec3<f32>"
     },
     defaultUniforms: {
-      lightDirection: new Float32Array([1, 1, 2])
+      lightDirection: [1, 1, 2]
     },
     getUniforms: getUniforms3
   };
@@ -7074,10 +7207,10 @@ vec4 dirlight_filterColor(vec4 color) {
     return uniforms;
   }
 
-  // src/modules/lighting/gouraud-material/gouraud-shaders-glsl.ts
-  var GOURAUD_VS = (
+  // src/modules/lighting/phong-material/phong-shaders-glsl.ts
+  var PHONG_VS = (
     /* glsl */
-    `uniform materialUniforms {
+    `uniform phongMaterialUniforms {
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -7085,9 +7218,9 @@ vec4 dirlight_filterColor(vec4 color) {
 } material;
 `
   );
-  var GOURAUD_FS = (
+  var PHONG_FS = (
     /* glsl */
-    `uniform materialUniforms {
+    `uniform phongMaterialUniforms {
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -7109,63 +7242,27 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_d
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
   vec3 lightColor = surfaceColor;
 
-  if (lighting.enabled) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
-    lightColor = material.ambient * surfaceColor * lighting.ambientColor;
-
-    if (lighting.lightType == 0) {
-      PointLight pointLight = lighting_getPointLight(0);
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    } else if (lighting.lightType == 1) {
-      DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-    /*
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.pointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting.pointLight[i];
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.directionalLightCount) {
-        break;
-      }
-      DirectionalLight directionalLight = lighting.directionalLight[i];
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-    */
+  if (lighting.enabled == 0) {
+    return lightColor;
   }
-  return lightColor;
-}
-
-vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-  vec3 lightColor = vec3(0, 0, 0);
-  vec3 surfaceColor = vec3(0, 0, 0);
 
-  if (lighting.enabled) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
 
-    switch (lighting.lightType) {
-      case 0:
-        PointLight pointLight = lighting_getPointLight(0);
-        vec3 light_position_worldspace = pointLight.position;
-        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-        break;
+  for (int i = 0; i < lighting.pointLightCount; i++) {
+    PointLight pointLight = lighting_getPointLight(i);
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);
+  }
 
-      case 1:
-        DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-        break;
-    }
+  int totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
+  for (int i = lighting.pointLightCount; i < totalLights; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
   }
+  
   return lightColor;
 }
 `
@@ -7174,11 +7271,10 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   // src/modules/lighting/gouraud-material/gouraud-material.ts
   var gouraudMaterial = {
     props: {},
-    uniforms: {},
-    name: "gouraud-lighting",
+    name: "gouraudMaterial",
     // Note these are switched between phong and gouraud
-    vs: GOURAUD_VS,
-    fs: GOURAUD_FS,
+    vs: PHONG_FS.replace("phongMaterial", "gouraudMaterial"),
+    fs: PHONG_VS.replace("phongMaterial", "gouraudMaterial"),
     defines: {
       LIGHTING_VERTEX: 1
     },
@@ -7196,62 +7292,59 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
       specularColor: [0.15, 0.15, 0.15]
     },
     getUniforms(props) {
-      return { ...gouraudMaterial.defaultUniforms, ...props };
+      const uniforms = { ...props };
+      if (uniforms.specularColor) {
+        uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
+      }
+      return { ...gouraudMaterial.defaultUniforms, ...uniforms };
     }
   };
 
-  // src/modules/lighting/phong-material/phong-shaders-glsl.ts
-  var PHONG_VS = (
-    /* glsl */
-    `uniform phongMaterialUniforms {
-  uniform float ambient;
-  uniform float diffuse;
-  uniform float shininess;
-  uniform vec3  specularColor;
-} material;
-`
-  );
-  var PHONG_FS = (
-    /* glsl */
-    `uniform phongMaterialUniforms {
-  uniform float ambient;
-  uniform float diffuse;
-  uniform float shininess;
-  uniform vec3  specularColor;
-} material;
+  // src/modules/lighting/phong-material/phong-shaders-wgsl.ts
+  var PHONG_WGSL = (
+    /* wgsl */
+    `struct phongMaterialUniforms {
+  ambient: f32,
+  diffuse: f32,
+  shininess: f32,
+  specularColor: vec3<f32>,
+};
 
-vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {
-  vec3 halfway_direction = normalize(light_direction + view_direction);
-  float lambertian = dot(light_direction, normal_worldspace);
-  float specular = 0.0;
+@binding(2) @group(0) var<uniform> material : phongMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);
+  var lambertian: f32 = dot(light_direction, normal_worldspace);
+  var specular: f32 = 0.0;
   if (lambertian > 0.0) {
-    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
+    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
     specular = pow(specular_angle, material.shininess);
   }
   lambertian = max(lambertian, 0.0);
   return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
 }
 
-vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-  vec3 lightColor = surfaceColor;
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
 
   if (lighting.enabled == 0) {
     return lightColor;
   }
 
-  vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);
   lightColor = material.ambient * surfaceColor * lighting.ambientColor;
 
   if (lighting.lightType == 0) {
-    PointLight pointLight = lighting_getPointLight(0);
-    vec3 light_position_worldspace = pointLight.position;
-    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    let pointLight: PointLight  = lighting_getPointLight(0);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
     lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
   } else if (lighting.lightType == 1) {
-    DirectionalLight directionalLight = lighting_getDirectionalLight(0);
+    var directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
     lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
   }
   
+  return lightColor;
   /*
   for (int i = 0; i < MAX_LIGHTS; i++) {
     if (i >= lighting.pointLightCount) {
@@ -7271,28 +7364,26 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positio
     lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
   }
   */
-  return lightColor;
 }
 
-vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-  vec3 lightColor = vec3(0, 0, 0);
-  vec3 surfaceColor = vec3(0, 0, 0);
+fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32>{
+  var lightColor = vec3<f32>(0, 0, 0);
+  let surfaceColor = vec3<f32>(0, 0, 0);
 
   if (lighting.enabled == 0) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
+    let view_direction = normalize(cameraPosition - position_worldspace);
 
     switch (lighting.lightType) {
-      case 0:
-        PointLight pointLight = lighting_getPointLight(0);
-        vec3 light_position_worldspace = pointLight.position;
-        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+      case 0, default: {
+        let pointLight: PointLight = lighting_getPointLight(0);
+        let light_position_worldspace: vec3<f32> = pointLight.position;
+        let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
         lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-        break;
-
-      case 1:
-        DirectionalLight directionalLight = lighting_getDirectionalLight(0);
+      }
+      case 1: {
+        let directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
         lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-        break;
+      }
     }
   }
   return lightColor;
@@ -7302,11 +7393,10 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
 
   // src/modules/lighting/phong-material/phong-material.ts
   var phongMaterial = {
-    props: {},
-    uniforms: {},
-    name: "phong-lighting",
+    name: "phongMaterial",
     dependencies: [lighting],
     // Note these are switched between phong and gouraud
+    source: PHONG_WGSL,
     vs: PHONG_VS,
     fs: PHONG_FS,
     defines: {
@@ -7325,45 +7415,41 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
       specularColor: [0.15, 0.15, 0.15]
     },
     getUniforms(props) {
-      return { ...phongMaterial.defaultUniforms, ...props };
+      const uniforms = { ...props };
+      if (uniforms.specularColor) {
+        uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
+      }
+      return { ...phongMaterial.defaultUniforms, ...uniforms };
     }
   };
 
   // src/modules/lighting/pbr-material/pbr-vertex-glsl.ts
   var vs2 = (
     /* glsl */
-    `uniform projection {
-  mat4 u_MVPMatrix;
-  mat4 u_ModelMatrix;
-  mat4 u_NormalMatrix;
-  // Projection
-  vec3 u_Camera;
-}
-
-varying vec3 pbr_vPosition;
-varying vec2 pbr_vUV;
+    `out vec3 pbr_vPosition;
+out vec2 pbr_vUV;
 
 #ifdef HAS_NORMALS
 # ifdef HAS_TANGENTS
-varying mat3 pbr_vTBN;
+out mat3 pbr_vTBN;
 # else
-varying vec3 pbr_vNormal;
+out vec3 pbr_vNormal;
 # endif
 #endif
 
 void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
 {
-  vec4 pos = u_ModelMatrix * position;
+  vec4 pos = pbrProjection.modelMatrix * position;
   pbr_vPosition = vec3(pos.xyz) / pos.w;
 
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
-  vec3 normalW = normalize(vec3(u_NormalMatrix * vec4(normal.xyz, 0.0)));
-  vec3 tangentW = normalize(vec3(u_ModelMatrix * vec4(tangent.xyz, 0.0)));
+  vec3 normalW = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
+  vec3 tangentW = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
   vec3 bitangentW = cross(normalW, tangentW) * tangent.w;
   pbr_vTBN = mat3(tangentW, bitangentW, normalW);
 #else // HAS_TANGENTS != 1
-  pbr_vNormal = normalize(vec3(u_ModelMatrix * vec4(normal.xyz, 0.0)));
+  pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
 #endif
 #endif
 
@@ -7381,12 +7467,7 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
     /* glsl */
     `precision highp float;
 
-uniform Projection {
-  // Projection
-  uniform vec3 u_Camera;
-};
-
-uniform pbrMaterial {
+uniform pbrMaterialUniforms {
   // Material is unlit
   bool unlit;
 
@@ -7418,40 +7499,40 @@ uniform pbrMaterial {
   vec4 scaleDiffBaseMR;
   vec4 scaleFGDSpec;
   // #endif
-} u_pbrMaterial;
+} pbrMaterial;
 
 // Samplers
 #ifdef HAS_BASECOLORMAP
-uniform sampler2D u_BaseColorSampler;
+uniform sampler2D pbr_baseColorSampler;
 #endif
 #ifdef HAS_NORMALMAP
-uniform sampler2D u_NormalSampler;
+uniform sampler2D pbr_normalSampler;
 #endif
 #ifdef HAS_EMISSIVEMAP
-uniform sampler2D u_EmissiveSampler;
+uniform sampler2D pbr_emissiveSampler;
 #endif
 #ifdef HAS_METALROUGHNESSMAP
-uniform sampler2D u_MetallicRoughnessSampler;
+uniform sampler2D pbr_metallicRoughnessSampler;
 #endif
 #ifdef HAS_OCCLUSIONMAP
-uniform sampler2D u_OcclusionSampler;
+uniform sampler2D pbr_occlusionSampler;
 #endif
 #ifdef USE_IBL
-uniform samplerCube u_DiffuseEnvSampler;
-uniform samplerCube u_SpecularEnvSampler;
-uniform sampler2D u_brdfLUT;
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
 #endif
 
 // Inputs from vertex shader
 
-varying vec3 pbr_vPosition;
-varying vec2 pbr_vUV;
+in vec3 pbr_vPosition;
+in vec2 pbr_vUV;
 
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
-varying mat3 pbr_vTBN;
+in mat3 pbr_vTBN;
 #else
-varying vec3 pbr_vNormal;
+in vec3 pbr_vNormal;
 #endif
 #endif
 
@@ -7519,8 +7600,8 @@ vec3 getNormal()
 #endif
 
 #ifdef HAS_NORMALMAP
-  vec3 n = texture2D(u_NormalSampler, pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_pbrMaterial.normalScale, u_pbrMaterial.normalScale, 1.0)));
+  vec3 n = texture(pbr_normalSampler, pbr_vUV).rgb;
+  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
 #else
   // The tbn matrix is linearly interpolated, so we need to re-normalize
   vec3 n = normalize(tbn[2].xyz);
@@ -7538,22 +7619,22 @@ vec3 getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection)
   float mipCount = 9.0; // resolution of 512x512
   float lod = (pbrInfo.perceptualRoughness * mipCount);
   // retrieve a scale and bias to F0. See [1], Figure 3
-  vec3 brdf = SRGBtoLINEAR(texture2D(u_brdfLUT,
+  vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
     vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
-  vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;
+  vec3 diffuseLight = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, n)).rgb;
 
 #ifdef USE_TEX_LOD
-  vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
 #else
-  vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
 #endif
 
   vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
   vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
 
   // For presentation, this allows us to disable IBL terms
-  diffuse *= u_pbrMaterial.scaleIBLAmbient.x;
-  specular *= u_pbrMaterial.scaleIBLAmbient.y;
+  diffuse *= pbrMaterial.scaleIBLAmbient.x;
+  specular *= pbrMaterial.scaleIBLAmbient.y;
 
   return diffuse + specular;
 }
@@ -7645,32 +7726,32 @@ vec4 pbr_filterColor(vec4 colorUnused)
 {
   // The albedo may be defined from a base texture or a flat color
 #ifdef HAS_BASECOLORMAP
-  vec4 baseColor = SRGBtoLINEAR(texture2D(u_BaseColorSampler, pbr_vUV)) * u_pbrMaterial.baseColorFactor;
+  vec4 baseColor = SRGBtoLINEAR(texture(pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
 #else
-  vec4 baseColor = u_pbrMaterial.baseColorFactor;
+  vec4 baseColor = pbrMaterial.baseColorFactor;
 #endif
 
 #ifdef ALPHA_CUTOFF
-  if (baseColor.a < u_pbrMaterial.alphaCutoff) {
+  if (baseColor.a < pbrMaterial.alphaCutoff) {
     discard;
   }
 #endif
 
   vec3 color = vec3(0, 0, 0);
 
-  if(u_pbrMaterial.unlit){
+  if(pbrMaterial.unlit){
     color.rgb = baseColor.rgb;
   }
   else{
     // Metallic and Roughness material properties are packed together
     // In glTF, these factors can be specified by fixed scalar values
     // or from a metallic-roughness map
-    float perceptualRoughness = u_pbrMaterial.metallicRoughnessValues.y;
-    float metallic = u_pbrMaterial.metallicRoughnessValues.x;
+    float perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
+    float metallic = pbrMaterial.metallicRoughnessValues.x;
 #ifdef HAS_METALROUGHNESSMAP
     // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
     // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
-    vec4 mrSample = texture2D(u_MetallicRoughnessSampler, pbr_vUV);
+    vec4 mrSample = texture(pbr_metallicRoughnessSampler, pbr_vUV);
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
 #endif
@@ -7697,7 +7778,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
 
     vec3 n = getNormal();                          // normal at surface point
-    vec3 v = normalize(u_Camera - pbr_vPosition);  // Vector from surface point to camera
+    vec3 v = normalize(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
 
     float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
     vec3 reflection = -normalize(reflect(v, n));
@@ -7719,47 +7800,48 @@ vec4 pbr_filterColor(vec4 colorUnused)
       v
     );
 
+
 #ifdef USE_LIGHTS
     // Apply ambient light
     PBRInfo_setAmbientLight(pbrInfo);
-    color += calculateFinalColor(pbrInfo, lighting_uAmbientLight.color);
+    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
 
     // Apply directional light
-    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);
+    for(int i = 0; i < lighting.directionalLightCount; i++) {
+      if (i < lighting.directionalLightCount) {
+        PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
       }
     }
 
     // Apply point light
-    for(int i = 0; i < lighting_uPointLightCount; i++) {
-      if (i < lighting_uPointLightCount) {
-        PBRInfo_setPointLight(pbrInfo, lighting_uPointLight[i]);
-        float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));
-        color += calculateFinalColor(pbrInfo, lighting_uPointLight[i].color / attenuation);
+    for(int i = 0; i < lighting.pointLightCount; i++) {
+      if (i < lighting.pointLightCount) {
+        PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
+        float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
       }
     }
 #endif
 
     // Calculate lighting contribution from image based lighting source (IBL)
 #ifdef USE_IBL
-    if (u_pbrMateral.IBLEnabled) {
+    if (pbrMaterial.IBLenabled) {
       color += getIBLContribution(pbrInfo, n, reflection);
     }
 #endif
 
-    // Apply optional PBR terms for additional (optional) shading
+ // Apply optional PBR terms for additional (optional) shading
 #ifdef HAS_OCCLUSIONMAP
-    if (u_pbrMaterial.occlusionMapEnabled) {
-      float ao = texture2D(u_OcclusionSampler, pbr_vUV).r;
-      color = mix(color, color * ao, u_pbrMaterial.occlusionStrength);
+    if (pbrMaterial.occlusionMapEnabled) {
+      float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
     }
 #endif
 
 #ifdef HAS_EMISSIVEMAP
-    if (u_pbrMaterial.emmissiveMapEnabled) {
-      vec3 emissive = SRGBtoLINEAR(texture2D(u_EmissiveSampler, pbr_vUV)).rgb * u_pbrMaterial.emissiveFactor;
+    if (pbrMaterial.emissiveMapEnabled) {
+      vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
       color += emissive;
     }
 #endif
@@ -7769,15 +7851,15 @@ vec4 pbr_filterColor(vec4 colorUnused)
 #ifdef PBR_DEBUG
     // TODO: Figure out how to debug multiple lights
 
-    // color = mix(color, F, u_ScaleFGDSpec.x);
-    // color = mix(color, vec3(G), u_ScaleFGDSpec.y);
-    // color = mix(color, vec3(D), u_ScaleFGDSpec.z);
-    // color = mix(color, specContrib, u_ScaleFGDSpec.w);
+    // color = mix(color, F, pbr_scaleFGDSpec.x);
+    // color = mix(color, vec3(G), pbr_scaleFGDSpec.y);
+    // color = mix(color, vec3(D), pbr_scaleFGDSpec.z);
+    // color = mix(color, specContrib, pbr_scaleFGDSpec.w);
 
-    // color = mix(color, diffuseContrib, u_ScaleDiffBaseMR.x);
-    color = mix(color, baseColor.rgb, u_pbrMaterial.scaleDiffBaseMR.y);
-    color = mix(color, vec3(metallic), u_pbrMaterial.scaleDiffBaseMR.z);
-    color = mix(color, vec3(perceptualRoughness), u_pbrMaterial.scaleDiffBaseMR.w);
+    // color = mix(color, diffuseContrib, pbr_scaleDiffBaseMR.x);
+    color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+    color = mix(color, vec3(metallic), pbrMaterial.scaleDiffBaseMR.z);
+    color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
 #endif
 
   }
@@ -7787,25 +7869,52 @@ vec4 pbr_filterColor(vec4 colorUnused)
 `
   );
 
+  // src/modules/lighting/pbr-material/pbr-projection.ts
+  var uniformBlock = (
+    /* glsl */
+    `uniform pbrProjectionUniforms {
+  mat4 modelViewProjectionMatrix;
+  mat4 modelMatrix;
+  mat4 normalMatrix;
+  vec3 camera;
+} pbrProjection;
+`
+  );
+  var pbrProjection = {
+    name: "pbrProjection",
+    vs: uniformBlock,
+    fs: uniformBlock,
+    // TODO why is this needed?
+    getUniforms: (props) => props,
+    uniformTypes: {
+      modelViewProjectionMatrix: "mat4x4<f32>",
+      modelMatrix: "mat4x4<f32>",
+      normalMatrix: "mat4x4<f32>",
+      camera: "vec3<i32>"
+    }
+  };
+
   // src/modules/lighting/pbr-material/pbr-material.ts
   var pbrMaterial = {
     props: {},
     uniforms: {},
-    name: "pbr",
-    dependencies: [lighting],
+    name: "pbrMaterial",
+    dependencies: [lighting, pbrProjection],
     vs: vs2,
     fs: fs3,
     defines: {
-      LIGHTING_FRAGMENT: 1,
-      HAS_NORMALMAP: 0,
-      HAS_EMISSIVEMAP: 0,
-      HAS_OCCLUSIONMAP: 0,
-      HAS_BASECOLORMAP: 0,
-      HAS_METALROUGHNESSMAP: 0,
-      ALPHA_CUTOFF: 0,
-      USE_IBL: 0,
-      PBR_DEBUG: 0
+      LIGHTING_FRAGMENT: 1
+      // TODO defining these as 0 breaks shader
+      // HAS_NORMALMAP: 0
+      // HAS_EMISSIVEMAP: 0,
+      // HAS_OCCLUSIONMAP: 0,
+      // HAS_BASECOLORMAP: 0,
+      // HAS_METALROUGHNESSMAP: 0,
+      // ALPHA_CUTOFF: 0
+      // USE_IBL: 0
+      // PBR_DEBUG: 0
     },
+    getUniforms: (props) => props,
     uniformTypes: {
       // Material is unlit
       unlit: "i32",
@@ -7834,1548 +7943,13 @@ vec4 pbr_filterColor(vec4 colorUnused)
       // #ifdef PBR_DEBUG
       scaleDiffBaseMR: "vec4<f32>",
       scaleFGDSpec: "vec4<f32>"
-    },
-    bindings: {
-      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
     }
   };
 
-  // src/modules/postprocessing/image-adjust-filters/brightnesscontrast.ts
-  var fs4 = (
+  // src/modules-webgl1/math/fp64/fp64-arithmetic-glsl.ts
+  var fp64arithmeticShader = (
     /* glsl */
-    `
-uniform brightnessContrastUniforms {
-  float brightness;
-  float contrast;
-} brightnessContrast;
-
-vec4 brightnessContrast_filterColor(vec4 color) {
-  color.rgb += brightnessContrast.brightness;
-  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;
-  }
-  return color;
-}
-
-vec4 brightnessContrast_filterColor(vec4 color, vec2 texSize, vec2 texCoords) {
-  return brightnessContrast_filterColor(color);
-}
-`
-  );
-  var brightnessContrast = {
-    props: {},
-    uniforms: {},
-    name: "brightnessContrast",
-    uniformTypes: {
-      brightness: "f32",
-      contrast: "f32"
-    },
-    uniformPropTypes: {
-      brightness: { format: "f32", value: 0, min: -1, max: 1 },
-      contrast: { format: "f32", value: 0, min: -1, max: 1 }
-    },
-    fs: fs4,
-    passes: [{ filter: true }]
-  };
-
-  // src/modules/postprocessing/image-adjust-filters/denoise.ts
-  var fs5 = (
-    /* glsl */
-    `uniform denoiseUniforms {
-  float strength;
-} noise;
-
-vec4 denoise_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
-  float adjustedExponent = 3. + 200. * pow(1. - noise.strength, 4.);
-
-  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 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 += offsetColor * weight;
-      total += weight;
-    }
-  }
-
-  return color / total;
-}
-`
-  );
-  var denoise = {
-    props: {},
-    uniforms: {},
-    name: "denoise",
-    uniformTypes: {
-      strength: "f32"
-    },
-    uniformPropTypes: {
-      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 }]
-  };
-
-  // src/modules/postprocessing/image-adjust-filters/huesaturation.ts
-  var fs6 = (
-    /* glsl */
-    `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 = 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);
-  color.rgb = vec3(
-    dot(color.rgb, weights.xyz),
-    dot(color.rgb, weights.zxy),
-    dot(color.rgb, weights.yzx)
-  );
-
-  // saturation adjustment
-  float average = (color.r + color.g + color.b) / 3.0;
-  if (hueSaturation.saturation > 0.0) {
-    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));
-  } else {
-    color.rgb += (average - color.rgb) * (-hueSaturation.saturation);
-  }
-
-  return color;
-}
-
-vec4 hueSaturation_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
-  return hueSaturation_filterColor(color);
-}
-`
-  );
-  var hueSaturation = {
-    props: {},
-    uniforms: {},
-    name: "hueSaturation",
-    fs: fs6,
-    uniformTypes: {
-      hue: "f32",
-      saturation: "f32"
-    },
-    uniformPropTypes: {
-      hue: { value: 0, min: -1, max: 1 },
-      saturation: { value: 0, min: -1, max: 1 }
-    },
-    passes: [{ filter: true }]
-  };
-
-  // src/modules/postprocessing/image-adjust-filters/noise.ts
-  var fs7 = (
-    /* glsl */
-    `uniform noiseUniforms {
-  float amount;
-} noise;
-
-float rand(vec2 co) {
-  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-vec4 noise_filterColor(vec4 color, vec2 texCoord) {
-  float diff = (rand(texCoord) - 0.5) * noise.amount;
-  color.r += diff;
-  color.g += diff;
-  color.b += diff;
-  return color;
-}
-
-vec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
-  return noise_filterColor(color, texCoord);
-}
-`
-  );
-  var noise = {
-    props: {},
-    uniforms: {},
-    name: "noise",
-    uniformTypes: {
-      amount: "f32"
-    },
-    uniformPropTypes: {
-      amount: { value: 0.5, min: 0, max: 1 }
-    },
-    fs: fs7,
-    passes: [{ filter: true }]
-  };
-
-  // src/modules/postprocessing/image-adjust-filters/sepia.ts
-  var fs8 = (
-    /* glsl */
-    `uniform sepiaUniforms {
-  float amount;
-} sepia;
-
-vec4 sepia_filterColor(vec4 color) {
-  float r = color.r;
-  float g = color.g;
-  float b = color.b;
-
-  color.r =
-    min(1.0, (r * (1.0 - (0.607 * sepia.amount))) + (g * (0.769 * sepia.amount)) + (b * (0.189 * sepia.amount)));
-  color.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));
-  color.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));
-
-  return color;
-}
-
-vec4 sepia_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
-  return sepia_filterColor(color);
-}
-`
-  );
-  var sepia = {
-    props: {},
-    uniforms: {},
-    name: "sepia",
-    uniformTypes: {
-      amount: "f32"
-    },
-    uniformPropTypes: {
-      amount: { value: 0.5, min: 0, max: 1 }
-    },
-    fs: fs8,
-    passes: [{ filter: true }]
-  };
-
-  // src/modules/postprocessing/image-adjust-filters/vibrance.ts
-  var fs9 = (
-    /* glsl */
-    `uniform vibranceUniforms {
-  float amount;
-} vibrance;
-
-vec4 vibrance_filterColor(vec4 color) {
-  float average = (color.r + color.g + color.b) / 3.0;
-  float mx = max(color.r, max(color.g, color.b));
-  float amt = (mx - average) * (-vibrance.amount * 3.0);
-  color.rgb = mix(color.rgb, vec3(mx), amt);
-  return color;
-}
-
-vec4 vibrance_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
-  return vibrance_filterColor(color);
-}
-`
-  );
-  var vibrance = {
-    props: {},
-    uniforms: {},
-    name: "vibrance",
-    uniformPropTypes: {
-      amount: { value: 0, min: -1, max: 1 }
-    },
-    fs: fs9,
-    passes: [{ filter: true }]
-  };
-
-  // src/modules/postprocessing/image-adjust-filters/vignette.ts
-  var fs10 = (
-    /* glsl */
-    `uniform vignetteUniforms {
-  float radius;
-  float amount;
-} vignette;
-
-vec4 vignette_filterColor(vec4 color, vec2 texCoord) {
-  float dist = distance(texCoord, vec2(0.5, 0.5));
-  float ratio = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));
-  return color.rgba * ratio + (1.0 - ratio)*vec4(0.0, 0.0, 0.0, 1.0);
-}
-
-vec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
-  return vignette_filterColor(color, texCoord);
-}
-`
-  );
-  var vignette = {
-    props: {},
-    uniforms: {},
-    name: "vignette",
-    uniformTypes: {
-      radius: "f32",
-      amount: "f32"
-    },
-    uniformPropTypes: {
-      radius: { value: 0.5, min: 0, max: 1 },
-      amount: { value: 0.5, min: 0, max: 1 }
-    },
-    passes: [{ filter: true }],
-    fs: fs10
-  };
-
-  // src/modules/postprocessing/image-blur-filters/tiltshift.ts
-  var fs11 = (
-    /* glsl */
-    `uniform tiltShiftUniforms {
-  float blurRadius;
-  float gradientRadius;
-  vec2 start;
-  vec2 end;
-  bool invert;
-} tiltShift;
-
-vec2 tiltShift_getDelta(vec2 texSize) {
-  vec2 vector = normalize((tiltShift.end - tiltShift.start) * texSize);
-  return tiltShift.invert ? vec2(-vector.y, vector.x) : vector;
-}
-
-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((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 - 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 offsetColor = texture(source, texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius);
-
-    /* switch to pre-multiplied alpha to correctly blur transparent images */
-    offsetColor.rgb *= offsetColor.a;
-
-    color += offsetColor * weight;
-    total += weight;
-  }
-
-  color = color / total;
-
-  /* switch back from pre-multiplied alpha */
-  color.rgb /= color.a + 0.00001;
-
-  return color;
-}
-`
-  );
-  var tiltShift = {
-    props: {},
-    uniforms: {},
-    name: "tiltShift",
-    dependencies: [random],
-    uniformTypes: {
-      blurRadius: "f32",
-      gradientRadius: "f32",
-      start: "vec2<f32>",
-      end: "vec2<f32>",
-      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 }
-    },
-    passes: [
-      { sampler: true, uniforms: { invert: false } },
-      { sampler: true, uniforms: { invert: true } }
-    ],
-    fs: fs11
-  };
-
-  // src/modules/postprocessing/image-blur-filters/triangleblur.ts
-  var fs12 = (
-    /* glsl */
-    `uniform triangleBlurUniforms {
-  float radius;
-  vec2 delta;
-} triangleBlur;
-
-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;
-
-  /* randomize the lookup values to hide the fixed number of samples */
-  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
-
-  for (float t = -30.0; t <= 30.0; t++) {
-    float percent = (t + offset - 0.5) / 30.0;
-    float weight = 1.0 - abs(percent);
-    vec4 offsetColor = texture(source, texCoord + adjustedDelta * percent);
-
-    /* switch to pre-multiplied alpha to correctly blur transparent images */
-    offsetColor.rgb *= offsetColor.a;
-
-    color += offsetColor * weight;
-    total += weight;
-  }
-
-  color = color / total;
-
-  /* switch back from pre-multiplied alpha */
-  color.rgb /= color.a + 0.00001;
-
-  return color;
-}
-`
-  );
-  var triangleBlur = {
-    props: {},
-    uniforms: {},
-    name: "triangleBlur",
-    uniformTypes: {
-      radius: "f32",
-      delta: "vec2<f32>"
-    },
-    uniformPropTypes: {
-      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] } }
-    ]
-  };
-
-  // src/modules/postprocessing/image-blur-filters/zoomblur.ts
-  var fs13 = `
-uniform zoomBlurUniforms {
-  vec2 center;
-  float strength;
-} zoomBlur;
-
-vec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
-  vec4 color = vec4(0.0);
-  float total = 0.0;
-  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);
-
-  for (float t = 0.0; t <= 40.0; t++) {
-    float percent = (t + offset) / 40.0;
-    float weight = 4.0 * (percent - percent * percent);
-    vec4 offsetColor = texture(source, texCoord + toCenter * percent * zoomBlur.strength / texSize);
-
-    /* switch to pre-multiplied alpha to correctly blur transparent images */
-    offsetColor.rgb *= offsetColor.a;
-
-    color += offsetColor * weight;
-    total += weight;
-  }
-
-  color = color / total;
-
-  /* switch back from pre-multiplied alpha */
-  color.rgb /= color.a + 0.00001;
-
-  return color;
-}
-`;
-  var zoomBlur = {
-    props: {},
-    uniforms: {},
-    name: "zoomBlur",
-    uniformTypes: {
-      center: "vec2<f32>",
-      strength: "f32"
-    },
-    uniformPropTypes: {
-      center: { value: [0.5, 0.5] },
-      strength: { value: 0.3, min: 0, softMax: 1 }
-    },
-    fs: fs13,
-    dependencies: [random],
-    passes: [{ sampler: true }]
-  };
-
-  // src/modules/postprocessing/image-fun-filters/colorhalftone.ts
-  var fs14 = (
-    /* glsl */
-    `uniform colorHalftoneUniforms {
-  vec2 center;
-  float angle;
-  float size;
-} colorHalftone;
-
-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,
-	s * tex.x + c * tex.y
-  ) * scale;
-  return (sin(point.x) * sin(point.y)) * 4.0;
-}
-
-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(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(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);
-  return vec4(1.0 - cmy - k, color.a);
-}
-`
-  );
-  var colorHalftone = {
-    props: {},
-    uniforms: {},
-    name: "colorHalftone",
-    uniformTypes: {
-      center: "vec2<f32>",
-      angle: "f32",
-      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 }
-    },
-    fs: fs14,
-    passes: [{ filter: true }]
-  };
-
-  // src/modules/postprocessing/image-fun-filters/dotscreen.ts
-  var fs15 = (
-    /* glsl */
-    `uniform dotScreenUniforms {
-  vec2 center;
-  float angle;
-  float size;
-} dotScreen;
-
-float pattern(vec2 texSize, vec2 texCoord) {
-  float scale = 3.1415 / dotScreen.size;
-
-  float s = sin(dotScreen.angle), c = cos(dotScreen.angle);
-  vec2 tex = texCoord * texSize - dotScreen.center * texSize;
-  vec2 point = vec2(
-    c * tex.x - s * tex.y,
-    s * tex.x + c * tex.y
-  ) * scale;
-  return (sin(point.x) * sin(point.y)) * 4.0;
-}
-
-vec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
-  float average = (color.r + color.g + color.b) / 3.0;
-  return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);
-}
-`
-  );
-  var dotScreen = {
-    props: {},
-    uniforms: {},
-    name: "dotScreen",
-    uniformTypes: {
-      center: "vec2<f32>",
-      angle: "f32",
-      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 }
-    },
-    fs: fs15,
-    passes: [{ filter: true }]
-  };
-
-  // src/modules/postprocessing/image-fun-filters/edgework.ts
-  var fs16 = (
-    /* glsl */
-    `uniform edgeWorkUniforms {
-  float radius;
-  vec2 delta;
-} edgeWork;
-
-vec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {
-  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;
-
-  vec2 color = vec2(0.0);
-  vec2 total = vec2(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);
-
-  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 = texture(source, texCoord + relativeDelta * percent).rgb;
-    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;
-    color.x += average * weight;
-    total.x += weight;
-    if (abs(t) < 15.0) {
-      weight = weight * 2.0 - 1.0;
-      color.y += average * weight;
-      total.y += weight;
-    }
-  }
-  return vec4(color / total, 0.0, 1.0);
-}
-
-vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
-  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;
-
-  vec2 color = vec2(0.0);
-  vec2 total = vec2(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);
-
-  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 = texture(source, texCoord + relativeDelta * percent).xy;
-    color.x += sampleColor.x * weight;
-    total.x += weight;
-    if (abs(t) < 15.0) {
-      weight = weight * 2.0 - 1.0;
-      color.y += sampleColor.y * weight;
-      total.y += weight;
-    }
-  }
-  float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);
-  return vec4(c, c, c, 1.0);
-}
-`
-  );
-  var edgeWork = {
-    props: {},
-    uniforms: {},
-    name: "edgeWork",
-    dependencies: [random],
-    fs: fs16,
-    uniformPropTypes: {
-      radius: { value: 2, min: 1, softMax: 50 },
-      delta: { value: [1, 0], private: true }
-    },
-    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 hexagonalPixelateUniforms {
-  vec2 center;
-  float scale;
-} hexagonalPixelate;
-
-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;
-
-  vec2 a;
-  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {
-    a = vec2(floor(tex.x), floor(tex.y));
-  }
-  else a = vec2(ceil(tex.x), ceil(tex.y));
-  vec2 b = vec2(ceil(tex.x), floor(tex.y));
-  vec2 c = vec2(floor(tex.x), ceil(tex.y));
-
-  vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);
-  vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);
-  vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);
-  vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);
-
-  float alen = length(TEX - A);
-  float blen = length(TEX - B);
-  float clen = length(TEX - C);
-
-  vec2 choice;
-  if (alen < blen) {
-    if (alen < clen) choice = a;
-    else choice = c;
-  } else {
-    if (blen < clen) choice = b;
-    else choice = c;
-  }
-
-  choice.x += choice.y * 0.5;
-  choice.y *= 0.866025404;
-  choice *= hexagonalPixelate.scale / texSize;
-
-  return texture(source, choice + hexagonalPixelate.center);
-}
-`
-  );
-  var hexagonalPixelate = {
-    props: {},
-    uniforms: {},
-    name: "hexagonalPixelate",
-    uniformTypes: {
-      center: "vec2<f32>",
-      scale: "f32"
-    },
-    uniformPropTypes: {
-      center: { value: [0.5, 0.5], hint: "screenspace" },
-      scale: { value: 10, min: 1, softMin: 5, softMax: 50 }
-    },
-    fs: fs17,
-    passes: [{ sampler: true }]
-  };
-
-  // src/modules/postprocessing/image-fun-filters/ink.ts
-  var fs18 = (
-    /* glsl */
-    `uniform inkUniforms {
-  float strength;
-} ink;
-
-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 = 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 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;
-      bigAverage += offsetColor;
-      bigTotal += 1.0;
-      if (abs(x) + abs(y) < 2.0) {
-        smallAverage += offsetColor;
-        smallTotal += 1.0;
-      }
-    }
-  }
-  vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);
-  float power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;
-  return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);
-}
-`
-  );
-  var ink = {
-    props: {},
-    uniforms: {},
-    name: "ink",
-    fs: fs18,
-    uniformTypes: {
-      strength: "f32"
-    },
-    uniformPropTypes: {
-      strength: { value: 0.25, min: 0, softMax: 1 }
-    },
-    passes: [{ sampler: true }]
-  };
-
-  // src/modules/postprocessing/image-fun-filters/magnify.ts
-  var fs19 = (
-    /* glsl */
-    `uniform magnifyUniforms {
-  vec2 screenXY;
-  float radiusPixels;
-  float zoom;
-  float borderWidthPixels;
-  vec4 borderColor;
-} magnify;
-
-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 texture(source, (texCoord - pos) / magnify.zoom + pos);
-  }
-
-  if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {
-    return magnify.borderColor;
-  }
-  return texture(source, texCoord);
-}
-`
-  );
-  var magnify = {
-    name: "magnify",
-    uniformTypes: {
-      screenXY: "vec2<f32>",
-      radiusPixels: "f32",
-      zoom: "f32",
-      borderWidthPixels: "f32",
-      borderColor: "vec4<f32>"
-    },
-    uniformPropTypes: {
-      // range 0 to 1
-      screenXY: { value: [0, 0] },
-      radiusPixels: 200,
-      zoom: 2,
-      borderWidthPixels: 0,
-      borderColor: { value: [255, 255, 255, 255] }
-    },
-    fs: fs19,
-    passes: [{ sampler: true }]
-  };
-
-  // src/modules/postprocessing/image-warp-filters/warp.ts
-  var fs20 = (
-    /* glsl */
-    `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 */
-    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));
-  }
-
-  return color;
-}
-`
-  );
-  var warp = {
-    name: "warp",
-    passes: [],
-    fs: fs20
-  };
-
-  // src/modules/postprocessing/image-warp-filters/bulgepinch.ts
-  var fs21 = (
-    /* glsl */
-    `uniform bulgePinchUniforms {
-  float radius;
-  float strength;
-  vec2 center;
-} bulgePinch;
-
-vec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {
-  coord -= texCenter;
-  float distance = length(coord);
-  if (distance < bulgePinch.radius) {
-    float percent = distance / bulgePinch.radius;
-    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);
-    }
-  }
-  coord += texCenter;
-  return coord;
-}
-
-vec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
-  vec2 coord = texCoord * texSize;
-  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);
-
-  return warp_sampleColor(source, texSize, coord);
-}
-`
-  );
-  var bulgePinch = {
-    props: {},
-    uniforms: {},
-    name: "bulgePinch",
-    dependencies: [warp],
-    fs: fs21,
-    uniformTypes: {
-      center: "vec2<f32>",
-      radius: "f32",
-      strength: "f32"
-    },
-    uniformPropTypes: {
-      center: { value: [0.5, 0.5] },
-      radius: { value: 200, min: 1, softMax: 600 },
-      strength: { value: 0.5, min: -1, max: 1 }
-    },
-    passes: [{ sampler: true }]
-  };
-
-  // src/modules/postprocessing/image-warp-filters/swirl.ts
-  var fs22 = (
-    /* glsl */
-    `uniform swirlUniforms {
-  float radius;
-  float angle;
-  vec2 center;
-} swirl;
-
-vec2 swirl_warp(vec2 coord, vec2 texCenter) {
-  coord -= texCenter;
-  float distance = length(coord);
-  if (distance < swirl.radius) {
-    float percent = (swirl.radius - distance) / swirl.radius;
-    float theta = percent * percent * swirl.angle;
-    float s = sin(theta);
-    float c = cos(theta);
-    coord = vec2(
-      coord.x * c - coord.y * s,
-      coord.x * s + coord.y * c
-    );
-  }
-  coord += texCenter;
-  return coord;
-}
-
-vec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
-  vec2 coord = texCoord * texSize;
-  coord = swirl_warp(coord, swirl.center * texSize);
-
-  return warp_sampleColor(source, texSize, coord);
-}
-`
-  );
-  var swirl = {
-    props: {},
-    uniforms: {},
-    name: "swirl",
-    dependencies: [warp],
-    fs: fs22,
-    uniformTypes: {
-      center: "vec2<f32>",
-      radius: "f32",
-      angle: "f32"
-    },
-    uniformPropTypes: {
-      center: { value: [0.5, 0.5] },
-      radius: { value: 200, min: 1, softMax: 600 },
-      angle: { value: 3, softMin: -25, softMax: 25 }
-    },
-    passes: [{ sampler: true }]
-  };
-
-  // src/modules/postprocessing/fxaa/fxaa.ts
-  var fs23 = `
-#define FXAA_QUALITY_PRESET 29
-
-#if (FXAA_QUALITY_PRESET == 10)
-    #define FXAA_QUALITY_PS 3
-    #define FXAA_QUALITY_P0 1.5
-    #define FXAA_QUALITY_P1 3.0
-    #define FXAA_QUALITY_P2 12.0
-#endif
-#if (FXAA_QUALITY_PRESET == 11)
-    #define FXAA_QUALITY_PS 4
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 3.0
-    #define FXAA_QUALITY_P3 12.0
-#endif
-#if (FXAA_QUALITY_PRESET == 12)
-    #define FXAA_QUALITY_PS 5
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 2.0
-    #define FXAA_QUALITY_P3 4.0
-    #define FXAA_QUALITY_P4 12.0
-#endif
-#if (FXAA_QUALITY_PRESET == 13)
-    #define FXAA_QUALITY_PS 6
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 2.0
-    #define FXAA_QUALITY_P3 2.0
-    #define FXAA_QUALITY_P4 4.0
-    #define FXAA_QUALITY_P5 12.0
-#endif
-#if (FXAA_QUALITY_PRESET == 14)
-    #define FXAA_QUALITY_PS 7
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 2.0
-    #define FXAA_QUALITY_P3 2.0
-    #define FXAA_QUALITY_P4 2.0
-    #define FXAA_QUALITY_P5 4.0
-    #define FXAA_QUALITY_P6 12.0
-#endif
-#if (FXAA_QUALITY_PRESET == 15)
-    #define FXAA_QUALITY_PS 8
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 2.0
-    #define FXAA_QUALITY_P3 2.0
-    #define FXAA_QUALITY_P4 2.0
-    #define FXAA_QUALITY_P5 2.0
-    #define FXAA_QUALITY_P6 4.0
-    #define FXAA_QUALITY_P7 12.0
-#endif
-#if (FXAA_QUALITY_PRESET == 20)
-    #define FXAA_QUALITY_PS 3
-    #define FXAA_QUALITY_P0 1.5
-    #define FXAA_QUALITY_P1 2.0
-    #define FXAA_QUALITY_P2 8.0
-#endif
-#if (FXAA_QUALITY_PRESET == 21)
-    #define FXAA_QUALITY_PS 4
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 2.0
-    #define FXAA_QUALITY_P3 8.0
-#endif
-#if (FXAA_QUALITY_PRESET == 22)
-    #define FXAA_QUALITY_PS 5
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 2.0
-    #define FXAA_QUALITY_P3 2.0
-    #define FXAA_QUALITY_P4 8.0
-#endif
-#if (FXAA_QUALITY_PRESET == 23)
-    #define FXAA_QUALITY_PS 6
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 2.0
-    #define FXAA_QUALITY_P3 2.0
-    #define FXAA_QUALITY_P4 2.0
-    #define FXAA_QUALITY_P5 8.0
-#endif
-#if (FXAA_QUALITY_PRESET == 24)
-    #define FXAA_QUALITY_PS 7
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 2.0
-    #define FXAA_QUALITY_P3 2.0
-    #define FXAA_QUALITY_P4 2.0
-    #define FXAA_QUALITY_P5 3.0
-    #define FXAA_QUALITY_P6 8.0
-#endif
-#if (FXAA_QUALITY_PRESET == 25)
-    #define FXAA_QUALITY_PS 8
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 2.0
-    #define FXAA_QUALITY_P3 2.0
-    #define FXAA_QUALITY_P4 2.0
-    #define FXAA_QUALITY_P5 2.0
-    #define FXAA_QUALITY_P6 4.0
-    #define FXAA_QUALITY_P7 8.0
-#endif
-#if (FXAA_QUALITY_PRESET == 26)
-    #define FXAA_QUALITY_PS 9
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 2.0
-    #define FXAA_QUALITY_P3 2.0
-    #define FXAA_QUALITY_P4 2.0
-    #define FXAA_QUALITY_P5 2.0
-    #define FXAA_QUALITY_P6 2.0
-    #define FXAA_QUALITY_P7 4.0
-    #define FXAA_QUALITY_P8 8.0
-#endif
-#if (FXAA_QUALITY_PRESET == 27)
-    #define FXAA_QUALITY_PS 10
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 2.0
-    #define FXAA_QUALITY_P3 2.0
-    #define FXAA_QUALITY_P4 2.0
-    #define FXAA_QUALITY_P5 2.0
-    #define FXAA_QUALITY_P6 2.0
-    #define FXAA_QUALITY_P7 2.0
-    #define FXAA_QUALITY_P8 4.0
-    #define FXAA_QUALITY_P9 8.0
-#endif
-#if (FXAA_QUALITY_PRESET == 28)
-    #define FXAA_QUALITY_PS 11
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 2.0
-    #define FXAA_QUALITY_P3 2.0
-    #define FXAA_QUALITY_P4 2.0
-    #define FXAA_QUALITY_P5 2.0
-    #define FXAA_QUALITY_P6 2.0
-    #define FXAA_QUALITY_P7 2.0
-    #define FXAA_QUALITY_P8 2.0
-    #define FXAA_QUALITY_P9 4.0
-    #define FXAA_QUALITY_P10 8.0
-#endif
-#if (FXAA_QUALITY_PRESET == 29)
-    #define FXAA_QUALITY_PS 12
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.5
-    #define FXAA_QUALITY_P2 2.0
-    #define FXAA_QUALITY_P3 2.0
-    #define FXAA_QUALITY_P4 2.0
-    #define FXAA_QUALITY_P5 2.0
-    #define FXAA_QUALITY_P6 2.0
-    #define FXAA_QUALITY_P7 2.0
-    #define FXAA_QUALITY_P8 2.0
-    #define FXAA_QUALITY_P9 2.0
-    #define FXAA_QUALITY_P10 4.0
-    #define FXAA_QUALITY_P11 8.0
-#endif
-#if (FXAA_QUALITY_PRESET == 39)
-    #define FXAA_QUALITY_PS 12
-    #define FXAA_QUALITY_P0 1.0
-    #define FXAA_QUALITY_P1 1.0
-    #define FXAA_QUALITY_P2 1.0
-    #define FXAA_QUALITY_P3 1.0
-    #define FXAA_QUALITY_P4 1.0
-    #define FXAA_QUALITY_P5 1.5
-    #define FXAA_QUALITY_P6 2.0
-    #define FXAA_QUALITY_P7 2.0
-    #define FXAA_QUALITY_P8 2.0
-    #define FXAA_QUALITY_P9 2.0
-    #define FXAA_QUALITY_P10 4.0
-    #define FXAA_QUALITY_P11 8.0
-#endif
-
-#define FxaaBool bool
-#define FxaaFloat float
-#define FxaaFloat2 vec2
-#define FxaaFloat3 vec3
-#define FxaaFloat4 vec4
-#define FxaaHalf float
-#define FxaaHalf2 vec2
-#define FxaaHalf3 vec3
-#define FxaaHalf4 vec4
-#define FxaaInt2 vec2
-#define FxaaTex sampler2D
-
-#define FxaaSat(x) clamp(x, 0.0, 1.0)
-#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)); }
-
-FxaaFloat4 FxaaPixelShader_(
-    //
-    // Use noperspective interpolation here (turn off perspective interpolation).
-    // {xy} = center of pixel
-    FxaaFloat2 pos,
-    //
-    // Input color texture.
-    // {rgb_} = color in linear or perceptual color space
-    // if (FXAA_GREEN_AS_LUMA == 0)
-    //     {___a} = luma in perceptual color space (not linear)
-    FxaaTex tex,
-    //
-    // Only used on FXAA Quality.
-    // This must be from a constant/uniform.
-    // {x_} = 1.0/screenWidthInPixels
-    // {_y} = 1.0/screenHeightInPixels
-    FxaaFloat2 fxaaQualityRcpFrame,
-    //
-    // Only used on FXAA Quality.
-    // This used to be the FXAA_QUALITY_SUBPIX define.
-    // It is here now to allow easier tuning.
-    // Choose the amount of sub-pixel aliasing removal.
-    // This can effect sharpness.
-    //   1.00 - upper limit (softer)
-    //   0.75 - default amount of filtering
-    //   0.50 - lower limit (sharper, less sub-pixel aliasing removal)
-    //   0.25 - almost off
-    //   0.00 - completely off
-    FxaaFloat fxaaQualitySubpix,
-    //
-    // Only used on FXAA Quality.
-    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD define.
-    // It is here now to allow easier tuning.
-    // The minimum amount of local contrast required to apply algorithm.
-    //   0.333 - too little (faster)
-    //   0.250 - low quality
-    //   0.166 - default
-    //   0.125 - high quality
-    //   0.063 - overkill (slower)
-    FxaaFloat fxaaQualityEdgeThreshold,
-    //
-    // Only used on FXAA Quality.
-    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD_MIN define.
-    // It is here now to allow easier tuning.
-    // Trims the algorithm from processing darks.
-    //   0.0833 - upper limit (default, the start of visible unfiltered edges)
-    //   0.0625 - high quality (faster)
-    //   0.0312 - visible limit (slower)
-    // Special notes when using FXAA_GREEN_AS_LUMA,
-    //   Likely want to set this to zero.
-    //   As colors that are mostly not-green
-    //   will appear very dark in the green channel!
-    //   Tune by looking at mostly non-green content,
-    //   then start at zero and increase until aliasing is a problem.
-    FxaaFloat fxaaQualityEdgeThresholdMin
-) {
-/*--------------------------------------------------------------------------*/
-    FxaaFloat2 posM;
-    posM.x = pos.x;
-    posM.y = pos.y;
-    FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
-    #define lumaM rgbyM.y
-    FxaaFloat lumaS = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));
-    FxaaFloat lumaE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));
-    FxaaFloat lumaN = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));
-    FxaaFloat lumaW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));
-/*--------------------------------------------------------------------------*/
-    FxaaFloat maxSM = max(lumaS, lumaM);
-    FxaaFloat minSM = min(lumaS, lumaM);
-    FxaaFloat maxESM = max(lumaE, maxSM);
-    FxaaFloat minESM = min(lumaE, minSM);
-    FxaaFloat maxWN = max(lumaN, lumaW);
-    FxaaFloat minWN = min(lumaN, lumaW);
-    FxaaFloat rangeMax = max(maxWN, maxESM);
-    FxaaFloat rangeMin = min(minWN, minESM);
-    FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;
-    FxaaFloat range = rangeMax - rangeMin;
-    FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);
-    FxaaBool earlyExit = range < rangeMaxClamped;
-/*--------------------------------------------------------------------------*/
-    if(earlyExit)
-        return rgbyM;
-/*--------------------------------------------------------------------------*/
-    FxaaFloat lumaNW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));
-    FxaaFloat lumaSE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));
-    FxaaFloat lumaNE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));
-    FxaaFloat lumaSW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
-/*--------------------------------------------------------------------------*/
-    FxaaFloat lumaNS = lumaN + lumaS;
-    FxaaFloat lumaWE = lumaW + lumaE;
-    FxaaFloat subpixRcpRange = 1.0/range;
-    FxaaFloat subpixNSWE = lumaNS + lumaWE;
-    FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;
-    FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;
-/*--------------------------------------------------------------------------*/
-    FxaaFloat lumaNESE = lumaNE + lumaSE;
-    FxaaFloat lumaNWNE = lumaNW + lumaNE;
-    FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;
-    FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;
-/*--------------------------------------------------------------------------*/
-    FxaaFloat lumaNWSW = lumaNW + lumaSW;
-    FxaaFloat lumaSWSE = lumaSW + lumaSE;
-    FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);
-    FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);
-    FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;
-    FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;
-    FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;
-    FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;
-/*--------------------------------------------------------------------------*/
-    FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;
-    FxaaFloat lengthSign = fxaaQualityRcpFrame.x;
-    FxaaBool horzSpan = edgeHorz >= edgeVert;
-    FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;
-/*--------------------------------------------------------------------------*/
-    if(!horzSpan) lumaN = lumaW;
-    if(!horzSpan) lumaS = lumaE;
-    if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;
-    FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;
-/*--------------------------------------------------------------------------*/
-    FxaaFloat gradientN = lumaN - lumaM;
-    FxaaFloat gradientS = lumaS - lumaM;
-    FxaaFloat lumaNN = lumaN + lumaM;
-    FxaaFloat lumaSS = lumaS + lumaM;
-    FxaaBool pairN = abs(gradientN) >= abs(gradientS);
-    FxaaFloat gradient = max(abs(gradientN), abs(gradientS));
-    if(pairN) lengthSign = -lengthSign;
-    FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);
-/*--------------------------------------------------------------------------*/
-    FxaaFloat2 posB;
-    posB.x = posM.x;
-    posB.y = posM.y;
-    FxaaFloat2 offNP;
-    offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;
-    offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;
-    if(!horzSpan) posB.x += lengthSign * 0.5;
-    if( horzSpan) posB.y += lengthSign * 0.5;
-/*--------------------------------------------------------------------------*/
-    FxaaFloat2 posN;
-    posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;
-    posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;
-    FxaaFloat2 posP;
-    posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;
-    posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;
-    FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;
-    FxaaFloat lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN));
-    FxaaFloat subpixE = subpixC * subpixC;
-    FxaaFloat lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP));
-/*--------------------------------------------------------------------------*/
-    if(!pairN) lumaNN = lumaSS;
-    FxaaFloat gradientScaled = gradient * 1.0/4.0;
-    FxaaFloat lumaMM = lumaM - lumaNN * 0.5;
-    FxaaFloat subpixF = subpixD * subpixE;
-    FxaaBool lumaMLTZero = lumaMM < 0.0;
-/*--------------------------------------------------------------------------*/
-    lumaEndN -= lumaNN * 0.5;
-    lumaEndP -= lumaNN * 0.5;
-    FxaaBool doneN = abs(lumaEndN) >= gradientScaled;
-    FxaaBool doneP = abs(lumaEndP) >= gradientScaled;
-    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;
-    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;
-    FxaaBool doneNP = (!doneN) || (!doneP);
-    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;
-    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;
-/*--------------------------------------------------------------------------*/
-    if(doneNP) {
-        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
-        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
-        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-        doneN = abs(lumaEndN) >= gradientScaled;
-        doneP = abs(lumaEndP) >= gradientScaled;
-        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;
-        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;
-        doneNP = (!doneN) || (!doneP);
-        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;
-        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;
-/*--------------------------------------------------------------------------*/
-        #if (FXAA_QUALITY_PS > 3)
-        if(doneNP) {
-            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
-            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
-            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-            doneN = abs(lumaEndN) >= gradientScaled;
-            doneP = abs(lumaEndP) >= gradientScaled;
-            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;
-            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;
-            doneNP = (!doneN) || (!doneP);
-            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;
-            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;
-/*--------------------------------------------------------------------------*/
-            #if (FXAA_QUALITY_PS > 4)
-            if(doneNP) {
-                if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
-                if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
-                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                doneN = abs(lumaEndN) >= gradientScaled;
-                doneP = abs(lumaEndP) >= gradientScaled;
-                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;
-                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;
-                doneNP = (!doneN) || (!doneP);
-                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;
-                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;
-/*--------------------------------------------------------------------------*/
-                #if (FXAA_QUALITY_PS > 5)
-                if(doneNP) {
-                    if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
-                    if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
-                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                    doneN = abs(lumaEndN) >= gradientScaled;
-                    doneP = abs(lumaEndP) >= gradientScaled;
-                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;
-                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;
-                    doneNP = (!doneN) || (!doneP);
-                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;
-                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;
-/*--------------------------------------------------------------------------*/
-                    #if (FXAA_QUALITY_PS > 6)
-                    if(doneNP) {
-                        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
-                        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
-                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                        doneN = abs(lumaEndN) >= gradientScaled;
-                        doneP = abs(lumaEndP) >= gradientScaled;
-                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;
-                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;
-                        doneNP = (!doneN) || (!doneP);
-                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;
-                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;
-/*--------------------------------------------------------------------------*/
-                        #if (FXAA_QUALITY_PS > 7)
-                        if(doneNP) {
-                            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
-                            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
-                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                            doneN = abs(lumaEndN) >= gradientScaled;
-                            doneP = abs(lumaEndP) >= gradientScaled;
-                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;
-                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;
-                            doneNP = (!doneN) || (!doneP);
-                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;
-                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;
-/*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PS > 8)
-    if(doneNP) {
-        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
-        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
-        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-        doneN = abs(lumaEndN) >= gradientScaled;
-        doneP = abs(lumaEndP) >= gradientScaled;
-        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;
-        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;
-        doneNP = (!doneN) || (!doneP);
-        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;
-        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;
-/*--------------------------------------------------------------------------*/
-        #if (FXAA_QUALITY_PS > 9)
-        if(doneNP) {
-            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
-            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
-            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-            doneN = abs(lumaEndN) >= gradientScaled;
-            doneP = abs(lumaEndP) >= gradientScaled;
-            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;
-            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;
-            doneNP = (!doneN) || (!doneP);
-            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;
-            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;
-/*--------------------------------------------------------------------------*/
-            #if (FXAA_QUALITY_PS > 10)
-            if(doneNP) {
-                if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
-                if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
-                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                doneN = abs(lumaEndN) >= gradientScaled;
-                doneP = abs(lumaEndP) >= gradientScaled;
-                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;
-                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;
-                doneNP = (!doneN) || (!doneP);
-                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;
-                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;
-/*--------------------------------------------------------------------------*/
-                #if (FXAA_QUALITY_PS > 11)
-                if(doneNP) {
-                    if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
-                    if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
-                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                    doneN = abs(lumaEndN) >= gradientScaled;
-                    doneP = abs(lumaEndP) >= gradientScaled;
-                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;
-                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;
-                    doneNP = (!doneN) || (!doneP);
-                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;
-                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;
-/*--------------------------------------------------------------------------*/
-                    #if (FXAA_QUALITY_PS > 12)
-                    if(doneNP) {
-                        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
-                        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
-                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                        doneN = abs(lumaEndN) >= gradientScaled;
-                        doneP = abs(lumaEndP) >= gradientScaled;
-                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;
-                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;
-                        doneNP = (!doneN) || (!doneP);
-                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;
-                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;
-/*--------------------------------------------------------------------------*/
-                    }
-                    #endif
-/*--------------------------------------------------------------------------*/
-                }
-                #endif
-/*--------------------------------------------------------------------------*/
-            }
-            #endif
-/*--------------------------------------------------------------------------*/
-        }
-        #endif
-/*--------------------------------------------------------------------------*/
-    }
-    #endif
-/*--------------------------------------------------------------------------*/
-                        }
-                        #endif
-/*--------------------------------------------------------------------------*/
-                    }
-                    #endif
-/*--------------------------------------------------------------------------*/
-                }
-                #endif
-/*--------------------------------------------------------------------------*/
-            }
-            #endif
-/*--------------------------------------------------------------------------*/
-        }
-        #endif
-/*--------------------------------------------------------------------------*/
-    }
-/*--------------------------------------------------------------------------*/
-    FxaaFloat dstN = posM.x - posN.x;
-    FxaaFloat dstP = posP.x - posM.x;
-    if(!horzSpan) dstN = posM.y - posN.y;
-    if(!horzSpan) dstP = posP.y - posM.y;
-/*--------------------------------------------------------------------------*/
-    FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;
-    FxaaFloat spanLength = (dstP + dstN);
-    FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;
-    FxaaFloat spanLengthRcp = 1.0/spanLength;
-/*--------------------------------------------------------------------------*/
-    FxaaBool directionN = dstN < dstP;
-    FxaaFloat dst = min(dstN, dstP);
-    FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;
-    FxaaFloat subpixG = subpixF * subpixF;
-    FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;
-    FxaaFloat subpixH = subpixG * fxaaQualitySubpix;
-/*--------------------------------------------------------------------------*/
-    FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;
-    FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);
-    if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;
-    if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;
-    return FxaaTexTop(tex, posM);
-}
-
-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,
-        source,
-        vec2(1.0) / texSize,
-        fxaa_QualitySubpix,
-        fxaa_QualityEdgeThreshold,
-        fxaa_QualityEdgeThresholdMin
-    );
-}
-`;
-  var fxaa = {
-    name: "fxaa",
-    uniformPropTypes: {},
-    fs: fs23,
-    passes: [{ sampler: true }],
-    getUniforms: (props) => props
-  };
-
-  // src/modules-webgl1/math/fp64/fp64-arithmetic-glsl.ts
-  var fp64arithmeticShader = (
-    /* glsl */
-    `uniform float ONE;
+    `uniform float ONE;
 
 /*
 About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
@@ -10263,7 +8837,7 @@ void geometry_setPosition(vec3 position) {
 }
 `
   );
-  var fs24 = (
+  var fs4 = (
     /* glsl */
     `varying vec4 geometry_vPosition;
 varying vec3 geometry_vNormal;
@@ -10280,7 +8854,7 @@ vec3 geometry_getNormal() {
   var geometry = {
     name: "geometry",
     vs: vs3,
-    fs: fs24
+    fs: fs4
   };
 
   // src/modules-webgl1/project/project.ts
@@ -10380,13 +8954,13 @@ vec4 project_to_clipspace(vec3 position) {
   return viewProjectionMatrix * vec4(position, 1.);
 }
 `;
-  var fs25 = `
+  var fs5 = `
 ${common}`;
   var project = {
     name: "project",
     getUniforms: getUniforms5,
     vs: vs4,
-    fs: fs25
+    fs: fs5
   };
 
   // src/modules-webgl1/lighting/lights/lights-glsl.ts
@@ -10521,7 +9095,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     }
     return uniforms;
   }
-  var fs26 = (
+  var fs6 = (
     /* glsl */
     `uniform vec3 dirlight_uLightDirection;
 
@@ -10538,7 +9112,7 @@ vec4 dirlight_filterColor(vec4 color) {
   var dirlight2 = {
     name: "dirlight",
     // vs // TODO - reuse normal from geometry module
-    fs: fs26,
+    fs: fs6,
     getUniforms: getUniforms7,
     dependencies: [project]
   };
@@ -10706,7 +9280,7 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
   );
 
   // src/modules-webgl1/lighting/pbr/pbr-fragment-glsl.ts
-  var fs27 = (
+  var fs7 = (
     /* glsl */
     `precision highp float;
 
@@ -11096,7 +9670,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
   var pbr = {
     name: "pbr",
     vs: vs5,
-    fs: fs27,
+    fs: fs7,
     defines: {
       LIGHTING_FRAGMENT: 1
     },
@@ -11105,34 +9679,5 @@ vec4 pbr_filterColor(vec4 colorUnused)
   };
   return __toCommonJS(bundle_exports);
 })();
-/**
- * ORIGINAL LICENCE
- * @license
- * Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *  * Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *  * Neither the name of NVIDIA CORPORATION nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
       return __exports__;
       });