@luma.gl/shadertools 9.1.9 → 9.2.0-alpha.2

package/dist/index.cjs

@@ -34,7 +34,6 @@ __export(dist_exports, {
   combineInjects: () => combineInjects,
   convertToVec4: () => convertToVec4,
   dirlight: () => dirlight,
-  dirlight1: () => dirlight2,
   fp32: () => fp32,
   fp64: () => fp64,
   fp64LowPart: () => fp64LowPart,
@@ -43,7 +42,6 @@ __export(dist_exports, {
   fp64ifyMatrix4: () => fp64ifyMatrix4,
   fromHalfFloat: () => fromHalfFloat,
   generateShaderForModule: () => generateShaderForModule,
-  geometry1: () => geometry,
   getPassthroughFS: () => getPassthroughFS,
   getQualifierDetails: () => getQualifierDetails,
   getShaderInfo: () => getShaderInfo,
@@ -51,19 +49,14 @@ __export(dist_exports, {
   getShaderModuleDependencies: () => getShaderModuleDependencies,
   getShaderModuleSource: () => getShaderModuleSource,
   getShaderModuleUniforms: () => getShaderModuleUniforms,
-  gouraudLighting: () => gouraudLighting,
   gouraudMaterial: () => gouraudMaterial,
   initializeShaderModule: () => initializeShaderModule,
   initializeShaderModules: () => initializeShaderModules,
   lighting: () => lighting,
-  lights1: () => lights,
-  pbr: () => pbr,
   pbrMaterial: () => pbrMaterial,
-  phongLighting: () => phongLighting,
   phongMaterial: () => phongMaterial,
   picking: () => picking,
   preprocess: () => preprocess,
-  project1: () => project,
   random: () => random,
   toHalfFloat: () => toHalfFloat,
   typeToChannelCount: () => typeToChannelCount,
@@ -209,7 +202,7 @@ function getHookStage(hook) {
       throw new Error(type);
   }
 }
-function injectShader(source, stage, inject, injectStandardStubs = false) {
+function injectShader(source3, stage, inject, injectStandardStubs = false) {
   const isVertex = stage === "vertex";
   for (const key in inject) {
     const fragmentData = inject[key];
@@ -223,43 +216,43 @@ function injectShader(source, stage, inject, injectStandardStubs = false) {
     switch (key) {
       case "vs:#decl":
         if (isVertex) {
-          source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);
+          source3 = source3.replace(DECLARATION_INJECT_MARKER, fragmentString);
         }
         break;
       case "vs:#main-start":
         if (isVertex) {
-          source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
+          source3 = source3.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
         }
         break;
       case "vs:#main-end":
         if (isVertex) {
-          source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
+          source3 = source3.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
         }
         break;
       case "fs:#decl":
         if (!isVertex) {
-          source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);
+          source3 = source3.replace(DECLARATION_INJECT_MARKER, fragmentString);
         }
         break;
       case "fs:#main-start":
         if (!isVertex) {
-          source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
+          source3 = source3.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
         }
         break;
       case "fs:#main-end":
         if (!isVertex) {
-          source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
+          source3 = source3.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
         }
         break;
       default:
-        source = source.replace(key, (match) => match + fragmentString);
+        source3 = source3.replace(key, (match) => match + fragmentString);
     }
   }
-  source = source.replace(DECLARATION_INJECT_MARKER, "");
+  source3 = source3.replace(DECLARATION_INJECT_MARKER, "");
   if (injectStandardStubs) {
-    source = source.replace(/\}\s*$/, (match) => match + MODULE_INJECTORS[stage]);
+    source3 = source3.replace(/\}\s*$/, (match) => match + MODULE_INJECTORS[stage]);
   }
-  return source;
+  return source3;
 }
 function combineInjects(injects) {
   const result = {};
@@ -439,19 +432,19 @@ function getPlatformShaderDefines(platformInfo) {
 }
 
 // dist/lib/shader-transpiler/transpile-glsl-shader.js
-function transpileGLSLShader(source, stage) {
+function transpileGLSLShader(source3, stage) {
   var _a;
-  const sourceGLSLVersion = Number(((_a = source.match(/^#version[ \t]+(\d+)/m)) == null ? void 0 : _a[1]) || 100);
+  const sourceGLSLVersion = Number(((_a = source3.match(/^#version[ \t]+(\d+)/m)) == null ? void 0 : _a[1]) || 100);
   if (sourceGLSLVersion !== 300) {
     throw new Error("luma.gl v9 only supports GLSL 3.00 shader sources");
   }
   switch (stage) {
     case "vertex":
-      source = convertShader(source, ES300_VERTEX_REPLACEMENTS);
-      return source;
+      source3 = convertShader(source3, ES300_VERTEX_REPLACEMENTS);
+      return source3;
     case "fragment":
-      source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);
-      return source;
+      source3 = convertShader(source3, ES300_FRAGMENT_REPLACEMENTS);
+      return source3;
     default:
       throw new Error(stage);
   }
@@ -475,11 +468,11 @@ var ES300_FRAGMENT_REPLACEMENTS = [
   // `varying` keyword replaced with `in`
   [makeVariableTextRegExp("varying"), "in $1"]
 ];
-function convertShader(source, replacements) {
+function convertShader(source3, replacements) {
   for (const [pattern, replacement] of replacements) {
-    source = source.replace(pattern, replacement);
+    source3 = source3.replace(pattern, replacement);
   }
-  return source;
+  return source3;
 }
 function makeVariableTextRegExp(qualifier) {
   return new RegExp(`\\b${qualifier}[ \\t]+(\\w+[ \\t]+\\w+(\\[\\w+\\])?;)`, "g");
@@ -541,11 +534,11 @@ function normalizeShaderHooks(hookFunctions) {
 }
 
 // dist/lib/glsl-utils/get-shader-info.js
-function getShaderInfo(source, defaultName) {
+function getShaderInfo(source3, defaultName) {
   return {
-    name: getShaderName(source, defaultName),
+    name: getShaderName(source3, defaultName),
     language: "glsl",
-    version: getShaderVersion(source)
+    version: getShaderVersion(source3)
   };
 }
 function getShaderName(shader, defaultName = "unnamed") {
@@ -553,9 +546,9 @@ function getShaderName(shader, defaultName = "unnamed") {
   const match = SHADER_NAME_REGEXP.exec(shader);
   return match ? match[1] : defaultName;
 }
-function getShaderVersion(source) {
+function getShaderVersion(source3) {
   let version = 100;
-  const words = source.match(/[^\s]+/g);
+  const words = source3.match(/[^\s]+/g);
   if (words && words.length >= 2 && words[0] === "#version") {
     const parsedVersion = parseInt(words[1], 10);
     if (Number.isFinite(parsedVersion)) {
@@ -591,19 +584,19 @@ function assembleWGSLShader(options) {
   };
 }
 function assembleGLSLShaderPair(options) {
-  const { vs: vs6, fs: fs8 } = options;
+  const { vs: vs3, fs: fs4 } = options;
   const modules = getShaderModuleDependencies(options.modules || []);
   return {
     vs: assembleShaderGLSL(options.platformInfo, {
       ...options,
-      source: vs6,
+      source: vs3,
       stage: "vertex",
       modules
     }),
     fs: assembleShaderGLSL(options.platformInfo, {
       ...options,
       // @ts-expect-error
-      source: fs8,
+      source: fs4,
       stage: "fragment",
       modules
     }),
@@ -614,7 +607,7 @@ function assembleShaderWGSL(platformInfo, options) {
   var _a;
   const {
     // id,
-    source,
+    source: source3,
     stage,
     modules,
     // defines = {},
@@ -622,8 +615,8 @@ function assembleShaderWGSL(platformInfo, options) {
     inject = {},
     log: log3
   } = options;
-  assert(typeof source === "string", "shader source must be a string");
-  const coreSource = source;
+  assert(typeof source3 === "string", "shader source must be a string");
+  const coreSource = source3;
   let assembledSource = "";
   const hookFunctionMap = normalizeShaderHooks(hookFunctions);
   const hookInjections = {};
@@ -678,12 +671,12 @@ function assembleShaderWGSL(platformInfo, options) {
 }
 function assembleShaderGLSL(platformInfo, options) {
   var _a;
-  const { id, source, stage, language = "glsl", modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log: log3 } = options;
-  assert(typeof source === "string", "shader source must be a string");
-  const sourceVersion = language === "glsl" ? getShaderInfo(source).version : -1;
+  const { source: source3, stage, language = "glsl", modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log: log3 } = options;
+  assert(typeof source3 === "string", "shader source must be a string");
+  const sourceVersion = language === "glsl" ? getShaderInfo(source3).version : -1;
   const targetVersion = platformInfo.shaderLanguageVersion;
   const sourceVersionDirective = sourceVersion === 100 ? "#version 100" : "#version 300 es";
-  const sourceLines = source.split("\n");
+  const sourceLines = source3.split("\n");
   const coreSource = sourceLines.slice(1).join("\n");
   const allDefines = {};
   modules.forEach((module2) => {
@@ -698,7 +691,6 @@ function assembleShaderGLSL(platformInfo, options) {
       assembledSource = prologue ? `${sourceVersionDirective}
 
 // ----- PROLOGUE -------------------------
-${getShaderNameDefine({ id, source, stage })}
 ${`#define SHADER_TYPE_${stage.toUpperCase()}`}
 
 ${getPlatformShaderDefines(platformInfo)}
@@ -767,7 +759,7 @@ ${getApplicationDefines(allDefines)}
   return assembledSource.trim();
 }
 function assembleGetUniforms(modules) {
-  return function getUniforms8(opts) {
+  return function getUniforms4(opts) {
     var _a;
     const uniforms = {};
     for (const module2 of modules) {
@@ -777,12 +769,6 @@ function assembleGetUniforms(modules) {
     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) {
@@ -813,24 +799,24 @@ function getShaderModuleSource(module2, stage) {
     throw new Error("Shader module must have a name");
   }
   const moduleName = module2.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
-  let source = `// ----- MODULE ${module2.name} ---------------
+  let source3 = `// ----- MODULE ${module2.name} ---------------
 
 `;
   if (stage !== "wgsl") {
-    source += `#define MODULE_${moduleName}
+    source3 += `#define MODULE_${moduleName}
 `;
   }
-  source += `${moduleSource}
+  source3 += `${moduleSource}
 `;
-  return source;
+  return source3;
 }
 
 // dist/lib/preprocessor/preprocessor.js
 var IFDEF_REGEXP = /^\s*\#\s*ifdef\s*([a-zA-Z_]+)\s*$/;
 var ENDIF_REGEXP = /^\s*\#\s*endif\s*$/;
-function preprocess(source, options) {
+function preprocess(source3, options) {
   var _a;
-  const lines = source.split("\n");
+  const lines = source3.split("\n");
   const output = [];
   let conditional = true;
   let currentDefine = null;
@@ -898,15 +884,15 @@ var _ShaderAssembler = class {
   assembleWGSLShader(props) {
     const modules = this._getModuleList(props.modules);
     const hookFunctions = this._hookFunctions;
-    const { source, getUniforms: getUniforms8 } = assembleWGSLShader({
+    const { source: source3, getUniforms: getUniforms4 } = assembleWGSLShader({
       ...props,
       // @ts-expect-error
       source: props.source,
       modules,
       hookFunctions
     });
-    const preprocessedSource = props.platformInfo.shaderLanguage === "wgsl" ? preprocess(source) : source;
-    return { source: preprocessedSource, getUniforms: getUniforms8, modules };
+    const preprocessedSource = props.platformInfo.shaderLanguage === "wgsl" ? preprocess(source3) : source3;
+    return { source: preprocessedSource, getUniforms: getUniforms4, modules };
   }
   /**
    * Assemble a pair of shaders into a single shader program
@@ -1152,12 +1138,12 @@ function generateShaderForModule(module2, options) {
 // dist/lib/wgsl/get-shader-layout-wgsl.js
 var import_core = require("@luma.gl/core");
 var import_wgsl_reflect = require("wgsl_reflect");
-function getShaderLayoutFromWGSL(source) {
+function getShaderLayoutFromWGSL(source3) {
   var _a;
   const shaderLayout = { attributes: [], bindings: [] };
   let parsedWGSL;
   try {
-    parsedWGSL = parseWGSL(source);
+    parsedWGSL = parseWGSL(source3);
   } catch (error) {
     import_core.log.error(error.message)();
     return shaderLayout;
@@ -1211,11 +1197,11 @@ function getShaderLayoutFromWGSL(source) {
   return shaderLayout;
 }
 function getType(type) {
-  return type.format ? `${type.name}<${type.format.name}>` : type.name;
+  return (type == null ? void 0 : type.format) ? `${type.name}<${type.format.name}>` : type.name;
 }
-function parseWGSL(source) {
+function parseWGSL(source3) {
   try {
-    return new import_wgsl_reflect.WgslReflect(source);
+    return new import_wgsl_reflect.WgslReflect(source3);
   } catch (error) {
     if (error instanceof Error) {
       throw error;
@@ -1340,6 +1326,14 @@ function fp64ifyMatrix4(matrix) {
 }
 
 // dist/modules/math/random/random.js
+var source = (
+  /* wgsl */
+  `fn random(scale: vec3f, seed: float) -> f32 {
+  /* use the fragment position for a different seed per-pixel */
+  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
+}
+`
+);
 var fs = (
   /* glsl */
   `float random(vec3 scale, float seed) {
@@ -1350,6 +1344,7 @@ var fs = (
 );
 var random = {
   name: "random",
+  source,
   fs
 };
 
@@ -2578,7 +2573,7 @@ function getUniforms(opts = {}, prevUniforms) {
 // dist/modules/lighting/lights/lighting.js
 var import_core3 = require("@luma.gl/core");
 
-// dist/modules/lighting/lights/lighting-uniforms-glsl.js
+// dist/modules/lighting/lights/lighting-glsl.js
 var lightingUniformsGLSL = (
   /* glsl */
   `precision highp int;
@@ -2658,7 +2653,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
 `
 );
 
-// dist/modules/lighting/lights/lighting-uniforms-wgsl.js
+// dist/modules/lighting/lights/lighting-wgsl.js
 var lightingUniformsWGSL = (
   /* wgsl */
   `// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
@@ -2716,7 +2711,7 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
 );
 
 // dist/modules/lighting/lights/lighting.js
-var MAX_LIGHTS = 3;
+var MAX_LIGHTS = 5;
 var COLOR_FACTOR = 255;
 var LIGHT_TYPE;
 (function(LIGHT_TYPE2) {
@@ -2728,7 +2723,7 @@ var lighting = {
   uniforms: {},
   name: "lighting",
   defines: {
-    MAX_LIGHTS
+    // MAX_LIGHTS
   },
   uniformTypes: {
     enabled: "i32",
@@ -2825,10 +2820,10 @@ function getLightSourceUniforms({ ambientLight, pointLights = [], directionalLig
   lightSourceUniforms.pointLightCount = pointLights.length;
   return lightSourceUniforms;
 }
-function extractLightTypes(lights2) {
+function extractLightTypes(lights) {
   var _a, _b;
   const lightSources = { pointLights: [], directionalLights: [] };
-  for (const light of lights2 || []) {
+  for (const light of lights || []) {
     switch (light.type) {
       case "ambient":
         lightSources.ambientLight = light;
@@ -2929,7 +2924,7 @@ var dirlight = {
 function getUniforms3(opts = dirlight.defaultUniforms) {
   const uniforms = {};
   if (opts.lightDirection) {
-    uniforms.dirlight_uLightDirection = opts.lightDirection;
+    uniforms.lightDirection = opts.lightDirection;
   }
   return uniforms;
 }
@@ -2947,7 +2942,9 @@ var PHONG_VS = (
 );
 var PHONG_FS = (
   /* glsl */
-  `uniform phongMaterialUniforms {
+  `#define MAX_LIGHTS 1
+
+uniform phongMaterialUniforms {
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -3095,7 +3092,7 @@ var gouraudMaterial = {
   fs: PHONG_VS.replace("phongMaterial", "gouraudMaterial"),
   source: PHONG_WGSL.replaceAll("phongMaterial", "gouraudMaterial"),
   defines: {
-    LIGHTING_VERTEX: 1
+    LIGHTING_VERTEX: true
   },
   dependencies: [lighting],
   uniformTypes: {
@@ -3128,7 +3125,7 @@ var phongMaterial = {
   vs: PHONG_VS,
   fs: PHONG_FS,
   defines: {
-    LIGHTING_FRAGMENT: 1
+    LIGHTING_FRAGMENT: true
   },
   uniformTypes: {
     ambient: "f32",
@@ -3151,7 +3148,7 @@ var phongMaterial = {
   }
 };
 
-// dist/modules/lighting/pbr-material/pbr-vertex-glsl.js
+// dist/modules/lighting/pbr-material/pbr-material-glsl.js
 var vs2 = (
   /* glsl */
   `out vec3 pbr_vPosition;
@@ -3189,8 +3186,6 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 }
 `
 );
-
-// dist/modules/lighting/pbr-material/pbr-fragment-glsl.js
 var fs3 = (
   /* glsl */
   `precision highp float;
@@ -3597,524 +3592,31 @@ vec4 pbr_filterColor(vec4 colorUnused)
 `
 );
 
-// dist/modules/lighting/pbr-material/pbr-projection.js
-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>"
-  }
-};
-
-// dist/modules/lighting/pbr-material/pbr-material.js
-var pbrMaterial = {
-  props: {},
-  uniforms: {},
-  name: "pbrMaterial",
-  dependencies: [lighting, pbrProjection],
-  vs: vs2,
-  fs: fs3,
-  defines: {
-    LIGHTING_FRAGMENT: 1
-    // TODO defining these as 0 breaks shader
-    // HAS_NORMALMAP: 0
-    // HAS_EMISSIVEMAP: 0,
-    // HAS_OCCLUSIONMAP: 0,
-    // HAS_BASECOLORMAP: 0,
-    // HAS_METALROUGHNESSMAP: 0,
-    // ALPHA_CUTOFF: 0
-    // USE_IBL: 0
-    // PBR_DEBUG: 0
-  },
-  getUniforms: (props) => props,
-  uniformTypes: {
-    // Material is unlit
-    unlit: "i32",
-    // Base color map
-    baseColorMapEnabled: "i32",
-    baseColorFactor: "vec4<f32>",
-    normalMapEnabled: "i32",
-    normalScale: "f32",
-    // #ifdef HAS_NORMALMAP
-    emissiveMapEnabled: "i32",
-    emissiveFactor: "vec3<f32>",
-    // #ifdef HAS_EMISSIVEMAP
-    metallicRoughnessValues: "vec2<f32>",
-    metallicRoughnessMapEnabled: "i32",
-    occlusionMapEnabled: "i32",
-    occlusionStrength: "f32",
-    // #ifdef HAS_OCCLUSIONMAP
-    alphaCutoffEnabled: "i32",
-    alphaCutoff: "f32",
-    // #ifdef ALPHA_CUTOFF
-    // IBL
-    IBLenabled: "i32",
-    scaleIBLAmbient: "vec2<f32>",
-    // #ifdef USE_IBL
-    // debugging flags used for shader output of intermediate PBR variables
-    // #ifdef PBR_DEBUG
-    scaleDiffBaseMR: "vec4<f32>",
-    scaleFGDSpec: "vec4<f32>"
-  }
-};
-
-// dist/modules-webgl1/geometry/geometry.js
-var vs3 = (
-  /* glsl */
-  `varying vec4 geometry_vPosition;
-varying vec3 geometry_vNormal;
-
-void geometry_setNormal(vec3 normal) {
-  geometry_vNormal = normal;
-}
-
-void geometry_setPosition(vec4 position) {
-  geometry_vPosition = position;
-}
-
-void geometry_setPosition(vec3 position) {
-  geometry_vPosition = vec4(position, 1.);
-}
-`
-);
-var fs4 = (
-  /* glsl */
-  `varying vec4 geometry_vPosition;
-varying vec3 geometry_vNormal;
-
-vec4 geometry_getPosition() {
-  return geometry_vPosition;
-}
-
-vec3 geometry_getNormal() {
-  return geometry_vNormal;
-}
-`
-);
-var geometry = {
-  name: "geometry",
-  vs: vs3,
-  fs: fs4
-};
-
-// dist/modules-webgl1/project/project.js
-var import_core4 = require("@math.gl/core");
-var IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
-var DEFAULT_MODULE_OPTIONS = {
-  modelMatrix: IDENTITY_MATRIX,
-  viewMatrix: IDENTITY_MATRIX,
-  projectionMatrix: IDENTITY_MATRIX,
-  cameraPositionWorld: [0, 0, 0]
-};
-function getUniforms4(opts = DEFAULT_MODULE_OPTIONS, prevUniforms = {}) {
-  const uniforms = {};
-  if (opts.modelMatrix !== void 0) {
-    uniforms.modelMatrix = opts.modelMatrix;
-  }
-  if (opts.viewMatrix !== void 0) {
-    uniforms.viewMatrix = opts.viewMatrix;
-  }
-  if (opts.projectionMatrix !== void 0) {
-    uniforms.projectionMatrix = opts.projectionMatrix;
-  }
-  if (opts.cameraPositionWorld !== void 0) {
-    uniforms.cameraPositionWorld = opts.cameraPositionWorld;
-  }
-  if (opts.projectionMatrix !== void 0 && opts.viewMatrix !== void 0) {
-    uniforms.viewProjectionMatrix = new import_core4.Matrix4(opts.projectionMatrix).multiplyRight(opts.viewMatrix);
-  }
-  return uniforms;
-}
-var common = (
-  /* glsl */
-  `varying vec4 project_vPositionWorld;
-varying vec3 project_vNormalWorld;
-
-vec4 project_getPosition_World() {
-  return project_vPositionWorld;
-}
-
-vec3 project_getNormal_World() {
-  return project_vNormalWorld;
-}
-`
-);
-var vs4 = `${common}
-
-// Unprefixed uniforms
-uniform mat4 modelMatrix;
-uniform mat4 viewMatrix;
-uniform mat4 projectionMatrix;
-uniform mat4 viewProjectionMatrix;
-uniform vec3 cameraPositionWorld;
-
-struct World {
-  vec3 position;
-  vec3 normal;
-};
-
-World world;
-
-void project_setPosition(vec4 position) {
-  project_vPositionWorld = position;
-}
-
-void project_setNormal(vec3 normal) {
-  project_vNormalWorld = normal;
-}
-
-void project_setPositionAndNormal_World(vec3 position, vec3 normal) {
-  world.position = position;
-  world.normal = normal;
-}
-
-void project_setPositionAndNormal_Model(vec3 position, vec3 normal) {
-  world.position = (modelMatrix * vec4(position, 1.)).xyz;
-  world.normal = mat3(modelMatrix) * normal;
-}
-
-vec4 project_model_to_clipspace(vec4 position) {
-  return viewProjectionMatrix * modelMatrix * position;
-}
-
-vec4 project_model_to_clipspace(vec3 position) {
-  return viewProjectionMatrix * modelMatrix * vec4(position, 1.);
-}
-
-vec4 project_world_to_clipspace(vec3 position) {
-  return viewProjectionMatrix * vec4(position, 1.);
-}
-
-vec4 project_view_to_clipspace(vec3 position) {
-  return projectionMatrix * vec4(position, 1.);
-}
-
-vec4 project_to_clipspace(vec3 position) {
-  return viewProjectionMatrix * vec4(position, 1.);
-}
-`;
-var fs5 = `
-${common}`;
-var project = {
-  name: "project",
-  getUniforms: getUniforms4,
-  vs: vs4,
-  fs: fs5
-};
-
-// dist/modules-webgl1/lighting/lights/lights-glsl.js
-var lightingShader = (
-  /* glsl */
-  `#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
-
-struct AmbientLight {
- vec3 color;
-};
-
-struct PointLight {
- vec3 color;
- vec3 position;
-
- // Constant-Linear-Exponential
- vec3 attenuation;
-};
-
-struct DirectionalLight {
-  vec3 color;
-  vec3 direction;
-};
-
-uniform AmbientLight lighting_uAmbientLight;
-uniform PointLight lighting_uPointLight[MAX_LIGHTS];
-uniform DirectionalLight lighting_uDirectionalLight[MAX_LIGHTS];
-uniform int lighting_uPointLightCount;
-uniform int lighting_uDirectionalLightCount;
-
-uniform bool lighting_uEnabled;
-
-float getPointLightAttenuation(PointLight pointLight, float distance) {
-  return pointLight.attenuation.x
-       + pointLight.attenuation.y * distance
-       + pointLight.attenuation.z * distance * distance;
-}
-
-#endif
-`
-);
-
-// dist/modules-webgl1/lighting/lights/lights.js
-var INITIAL_MODULE_OPTIONS = {
-  lightSources: {}
-};
-function convertColor2(colorDef = {}) {
-  const { color = [0, 0, 0], intensity = 1 } = colorDef;
-  return color.map((component) => component * intensity / 255);
-}
-function getLightSourceUniforms2({ ambientLight, pointLights = [], directionalLights = [] }) {
-  const lightSourceUniforms = {};
-  if (ambientLight) {
-    lightSourceUniforms["lighting_uAmbientLight.color"] = convertColor2(ambientLight);
-  } else {
-    lightSourceUniforms["lighting_uAmbientLight.color"] = [0, 0, 0];
-  }
-  pointLights.forEach((pointLight, index) => {
-    lightSourceUniforms[`lighting_uPointLight[${index}].color`] = convertColor2(pointLight);
-    lightSourceUniforms[`lighting_uPointLight[${index}].position`] = pointLight.position;
-    lightSourceUniforms[`lighting_uPointLight[${index}].attenuation`] = pointLight.attenuation || [
-      1,
-      0,
-      0
-    ];
-  });
-  lightSourceUniforms.lighting_uPointLightCount = pointLights.length;
-  directionalLights.forEach((directionalLight, index) => {
-    lightSourceUniforms[`lighting_uDirectionalLight[${index}].color`] = convertColor2(directionalLight);
-    lightSourceUniforms[`lighting_uDirectionalLight[${index}].direction`] = directionalLight.direction;
-  });
-  lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length;
-  return lightSourceUniforms;
-}
-function getUniforms5(opts = INITIAL_MODULE_OPTIONS) {
-  var _a, _b;
-  if ("lightSources" in opts) {
-    const { ambientLight, pointLights, directionalLights } = opts.lightSources || {};
-    const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0;
-    if (!hasLights) {
-      return { lighting_uEnabled: false };
-    }
-    return Object.assign({}, getLightSourceUniforms2({ ambientLight, pointLights, directionalLights }), {
-      lighting_uEnabled: true
-    });
-  }
-  if ("lights" in opts) {
-    const lightSources = { pointLights: [], directionalLights: [] };
-    for (const light of opts.lights || []) {
-      switch (light.type) {
-        case "ambient":
-          lightSources.ambientLight = light;
-          break;
-        case "directional":
-          (_a = lightSources.directionalLights) == null ? void 0 : _a.push(light);
-          break;
-        case "point":
-          (_b = lightSources.pointLights) == null ? void 0 : _b.push(light);
-          break;
-        default:
-      }
-    }
-    return getUniforms5({ lightSources });
-  }
-  return {};
-}
-var lights = {
-  name: "lights",
-  vs: lightingShader,
-  fs: lightingShader,
-  getUniforms: getUniforms5,
-  defines: {
-    MAX_LIGHTS: 3
-  }
-};
-
-// dist/modules-webgl1/lighting/dirlight/dirlight.js
-var DEFAULT_MODULE_OPTIONS2 = {
-  lightDirection: new Float32Array([1, 1, 2])
-};
-function getUniforms6(opts = DEFAULT_MODULE_OPTIONS2) {
-  const uniforms = {};
-  if (opts.lightDirection) {
-    uniforms.dirlight_uLightDirection = opts.lightDirection;
-  }
-  return uniforms;
-}
-var fs6 = (
-  /* glsl */
-  `uniform vec3 dirlight_uLightDirection;
-
-/*
- * Returns color attenuated by angle from light source
- */
-vec4 dirlight_filterColor(vec4 color) {
-  vec3 normal = project_getNormal_World();
-  float d = abs(dot(normalize(normal), normalize(dirlight_uLightDirection)));
-  return vec4(color.rgb * d, color.a);
-}
-`
-);
-var dirlight2 = {
-  name: "dirlight",
-  // vs // TODO - reuse normal from geometry module
-  fs: fs6,
-  getUniforms: getUniforms6,
-  dependencies: [project]
-};
-
-// dist/modules-webgl1/lighting/phong-lighting/phong-lighting-glsl.js
-var lightingShader2 = (
-  /* glsl */
-  `
-uniform float lighting_uAmbient;
-uniform float lighting_uDiffuse;
-uniform float lighting_uShininess;
-uniform vec3  lighting_uSpecularColor;
-
-vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {
-    vec3 halfway_direction = normalize(light_direction + view_direction);
-    float lambertian = dot(light_direction, normal_worldspace);
-    float specular = 0.0;
-    if (lambertian > 0.0) {
-      float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
-      specular = pow(specular_angle, lighting_uShininess);
-    }
-    lambertian = max(lambertian, 0.0);
-    return (lambertian * lighting_uDiffuse * surfaceColor + specular * lighting_uSpecularColor) * color;
-}
-
-vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-  vec3 lightColor = surfaceColor;
-
-  if (lighting_uEnabled) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
-    lightColor = lighting_uAmbient * surfaceColor * lighting_uAmbientLight.color;
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting_uPointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_uPointLight[i];
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting_uDirectionalLightCount) {
-        break;
-      }
-      DirectionalLight directionalLight = lighting_uDirectionalLight[i];
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-  }
-  return lightColor;
-}
-
-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_uEnabled) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting_uPointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_uPointLight[i];
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting_uDirectionalLightCount) {
-        break;
-      }
-      DirectionalLight directionalLight = lighting_uDirectionalLight[i];
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-  }
-  return lightColor;
-}
-`
-);
-
-// dist/modules-webgl1/lighting/phong-lighting/phong-lighting.js
-var INITIAL_MODULE_OPTIONS2 = {};
-function getMaterialUniforms(material) {
-  const { ambient = 0.35, diffuse = 0.6, shininess = 32, specularColor = [30, 30, 30] } = material;
-  return {
-    lighting_uAmbient: ambient,
-    lighting_uDiffuse: diffuse,
-    lighting_uShininess: shininess,
-    lighting_uSpecularColor: specularColor.map((x) => x / 255)
-  };
-}
-function getUniforms7(opts = INITIAL_MODULE_OPTIONS2) {
-  if (!("material" in opts)) {
-    return {};
-  }
-  const { material } = opts;
-  if (!material) {
-    return { lighting_uEnabled: false };
-  }
-  return getMaterialUniforms(material);
-}
-var gouraudLighting = {
-  name: "gouraud-lighting",
-  dependencies: [lights],
-  vs: lightingShader2,
-  defines: {
-    LIGHTING_VERTEX: 1
-  },
-  getUniforms: getUniforms7
-};
-var phongLighting = {
-  name: "phong-lighting",
-  dependencies: [lights],
-  fs: lightingShader2,
-  defines: {
-    LIGHTING_FRAGMENT: 1
-  },
-  getUniforms: getUniforms7
+// dist/modules/lighting/pbr-material/pbr-material-wgsl.js
+var source2 = (
+  /* wgsl */
+  `struct PBRFragmentInputs {
+  pbr_vPosition: vec3f,
+  pbr_vUV: vec2f,
+  pbr_vTBN: mat3f,
+  pbr_vNormal: vec3f
 };
 
-// dist/modules-webgl1/lighting/pbr/pbr-vertex-glsl.js
-var vs5 = (
-  /* glsl */
-  `uniform mat4 u_MVPMatrix;
-uniform mat4 u_ModelMatrix;
-uniform mat4 u_NormalMatrix;
-
-out vec3 pbr_vPosition;
-out vec2 pbr_vUV;
-
-#ifdef HAS_NORMALS
-# ifdef HAS_TANGENTS
-out mat3 pbr_vTBN;
-# else
-out vec3 pbr_vNormal;
-# endif
-#endif
+var fragmentInputs: PBRFragmentInputs;
 
-void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
+fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f, uv: vec2f)
 {
-  vec4 pos = u_ModelMatrix * position;
+  var pos: vec4f = pbrProjection.modelMatrix * position;
   pbr_vPosition = vec3(pos.xyz) / pos.w;
 
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
-  vec3 normalW = normalize(vec3(u_NormalMatrix * vec4(normal.xyz, 0.0)));
-  vec3 tangentW = normalize(vec3(u_ModelMatrix * vec4(tangent.xyz, 0.0)));
-  vec3 bitangentW = cross(normalW, tangentW) * tangent.w;
-  pbr_vTBN = mat3(tangentW, bitangentW, normalW);
+  let normalW: vec3f = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
+  let tangentW: vec3f = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
+  let bitangentW: vec3f = cross(normalW, tangentW) * tangent.w;
+  fragmentInputs,pbr_vTBN = mat3(tangentW, bitangentW, normalW);
 #else // HAS_TANGENTS != 1
-  pbr_vNormal = normalize(vec3(u_ModelMatrix * vec4(normal.xyz, 0.0)));
+  fragmentInputs.pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
 #endif
 #endif
 
@@ -4124,103 +3626,98 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
   pbr_vUV = vec2(0.,0.);
 #endif
 }
-`
-);
 
-// dist/modules-webgl1/lighting/pbr/pbr-fragment-glsl.js
-var fs7 = (
-  /* glsl */
-  `precision highp float;
+struct pbrMaterialUniforms {
+  // Material is unlit
+  unlit: uint32,
 
-uniform bool pbr_uUnlit;
+  // Base color map
+  baseColorMapEnabled: uint32,
+  baseColorFactor: vec4f,
 
-#ifdef USE_IBL
-uniform samplerCube u_DiffuseEnvSampler;
-uniform samplerCube u_SpecularEnvSampler;
-uniform sampler2D u_brdfLUT;
-uniform vec2 u_ScaleIBLAmbient;
-#endif
+  normalMapEnabled : uint32,
+  normalScale: f32,  // #ifdef HAS_NORMALMAP
 
+  emissiveMapEnabled: uint32,
+  emissiveFactor: vec3f, // #ifdef HAS_EMISSIVEMAP
+
+  metallicRoughnessValues: vec2f,
+  metallicRoughnessMapEnabled: uint32,
+
+  occlusionMapEnabled: i32,
+  occlusionStrength: f32, // #ifdef HAS_OCCLUSIONMAP
+  
+  alphaCutoffEnabled: i32,
+  alphaCutoff: f32, // #ifdef ALPHA_CUTOFF
+  
+  // IBL
+  IBLenabled: i32,
+  scaleIBLAmbient: vec2f, // #ifdef USE_IBL
+  
+  // debugging flags used for shader output of intermediate PBR variables
+  // #ifdef PBR_DEBUG
+  scaleDiffBaseMR: vec4f,
+  scaleFGDSpec: vec4f
+  // #endif
+} 
+  
+@binding(2) @group(0) var<uniform> material : pbrMaterialUniforms;
+
+// Samplers
 #ifdef HAS_BASECOLORMAP
-uniform sampler2D u_BaseColorSampler;
+uniform sampler2D pbr_baseColorSampler;
 #endif
 #ifdef HAS_NORMALMAP
-uniform sampler2D u_NormalSampler;
-uniform float u_NormalScale;
+uniform sampler2D pbr_normalSampler;
 #endif
 #ifdef HAS_EMISSIVEMAP
-uniform sampler2D u_EmissiveSampler;
-uniform vec3 u_EmissiveFactor;
+uniform sampler2D pbr_emissiveSampler;
 #endif
 #ifdef HAS_METALROUGHNESSMAP
-uniform sampler2D u_MetallicRoughnessSampler;
+uniform sampler2D pbr_metallicRoughnessSampler;
 #endif
 #ifdef HAS_OCCLUSIONMAP
-uniform sampler2D u_OcclusionSampler;
-uniform float u_OcclusionStrength;
-#endif
-
-#ifdef ALPHA_CUTOFF
-uniform float u_AlphaCutoff;
-#endif
-
-uniform vec2 u_MetallicRoughnessValues;
-uniform vec4 u_BaseColorFactor;
-
-uniform vec3 u_Camera;
-
-// debugging flags used for shader output of intermediate PBR variables
-#ifdef PBR_DEBUG
-uniform vec4 u_ScaleDiffBaseMR;
-uniform vec4 u_ScaleFGDSpec;
-#endif
-
-in vec3 pbr_vPosition;
-
-in vec2 pbr_vUV;
-
-#ifdef HAS_NORMALS
-#ifdef HAS_TANGENTS
-in mat3 pbr_vTBN;
-#else
-in vec3 pbr_vNormal;
+uniform sampler2D pbr_occlusionSampler;
 #endif
+#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
 #endif
 
 // Encapsulate the various inputs used by the various functions in the shading equation
 // We store values in this struct to simplify the integration of alternative implementations
 // of the shading terms, outlined in the Readme.MD Appendix.
-struct PBRInfo
-{
-  float NdotL;                  // cos angle between normal and light direction
-  float NdotV;                  // cos angle between normal and view direction
-  float NdotH;                  // cos angle between normal and half vector
-  float LdotH;                  // cos angle between light direction and half vector
-  float VdotH;                  // cos angle between view direction and half vector
-  float perceptualRoughness;    // roughness value, as authored by the model creator (input to shader)
-  float metalness;              // metallic value at the surface
-  vec3 reflectance0;            // full reflectance color (normal incidence angle)
-  vec3 reflectance90;           // reflectance color at grazing angle
-  float alphaRoughness;         // roughness mapped to a more linear change in the roughness (proposed by [2])
-  vec3 diffuseColor;            // color contribution from diffuse lighting
-  vec3 specularColor;           // color contribution from specular lighting
-  vec3 n;                       // normal at surface point
-  vec3 v;                       // vector from surface point to camera
+struct PBRInfo {
+  NdotL: f32,                  // cos angle between normal and light direction
+  NdotV: f32,                  // cos angle between normal and view direction
+  NdotH: f32,                  // cos angle between normal and half vector
+  LdotH: f32,                  // cos angle between light direction and half vector
+  VdotH: f32,                  // cos angle between view direction and half vector
+  perceptualRoughness: f32,    // roughness value, as authored by the model creator (input to shader)
+  metalness: f32,              // metallic value at the surface
+  reflectance0: vec3f,            // full reflectance color (normal incidence angle)
+  reflectance90: vec3f,           // reflectance color at grazing angle
+  alphaRoughness: f32,         // roughness mapped to a more linear change in the roughness (proposed by [2])
+  diffuseColor: vec3f,            // color contribution from diffuse lighting
+  specularColor: vec3f,           // color contribution from specular lighting
+  n: vec3f,                       // normal at surface point
+  v: vec3f,                       // vector from surface point to camera
 };
 
-const float M_PI = 3.141592653589793;
-const float c_MinRoughness = 0.04;
+const M_PI = 3.141592653589793;
+const c_MinRoughness = 0.04;
 
-vec4 SRGBtoLINEAR(vec4 srgbIn)
+fn SRGBtoLINEAR(srgbIn: vec4f ) -> vec4f
 {
 #ifdef MANUAL_SRGB
 #ifdef SRGB_FAST_APPROXIMATION
-  vec3 linOut = pow(srgbIn.xyz,vec3(2.2));
-#else //SRGB_FAST_APPROXIMATION
-  vec3 bLess = step(vec3(0.04045),srgbIn.xyz);
-  vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
+  var linOut: vec3f = pow(srgbIn.xyz,vec3(2.2));
+#else // SRGB_FAST_APPROXIMATION
+  var bLess: vec3f = step(vec3(0.04045),srgbIn.xyz);
+  var linOut: vec3f = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
 #endif //SRGB_FAST_APPROXIMATION
-  return vec4(linOut,srgbIn.w);;
+  return vec4f(linOut,srgbIn.w);;
 #else //MANUAL_SRGB
   return srgbIn;
 #endif //MANUAL_SRGB
@@ -4228,32 +3725,32 @@ vec4 SRGBtoLINEAR(vec4 srgbIn)
 
 // Find the normal for this fragment, pulling either from a predefined normal map
 // or from the interpolated mesh normal and tangent attributes.
-vec3 getNormal()
+fn getNormal() -> vec3f
 {
   // Retrieve the tangent space matrix
 #ifndef HAS_TANGENTS
-  vec3 pos_dx = dFdx(pbr_vPosition);
-  vec3 pos_dy = dFdy(pbr_vPosition);
-  vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));
-  vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));
-  vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
+  var pos_dx: vec3f = dFdx(pbr_vPosition);
+  var pos_dy: vec3f = dFdy(pbr_vPosition);
+  var tex_dx: vec3f = dFdx(vec3(pbr_vUV, 0.0));
+  var tex_dy: vec3f = dFdy(vec3(pbr_vUV, 0.0));
+  var t: vec3f = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
 
 #ifdef HAS_NORMALS
-  vec3 ng = normalize(pbr_vNormal);
+  var ng: vec3f = normalize(pbr_vNormal);
 #else
-  vec3 ng = cross(pos_dx, pos_dy);
+  var ng: vec3f = cross(pos_dx, pos_dy);
 #endif
 
   t = normalize(t - ng * dot(ng, t));
-  vec3 b = normalize(cross(ng, t));
-  mat3 tbn = mat3(t, b, ng);
+  var b: vec3f = normalize(cross(ng, t));
+  var tbn: mat3f = mat3f(t, b, ng);
 #else // HAS_TANGENTS
-  mat3 tbn = pbr_vTBN;
+  var tbn: mat3f = pbr_vTBN;
 #endif
 
 #ifdef HAS_NORMALMAP
-  vec3 n = texture(u_NormalSampler, pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_NormalScale, u_NormalScale, 1.0)));
+  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);
@@ -4266,27 +3763,27 @@ vec3 getNormal()
 // Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
 // See our README.md on Environment Maps [3] for additional discussion.
 #ifdef USE_IBL
-vec3 getIBLContribution(PBRInfo pbrInputs, vec3 n, vec3 reflection)
+fn getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection) -> vec3f
 {
   float mipCount = 9.0; // resolution of 512x512
-  float lod = (pbrInputs.perceptualRoughness * mipCount);
+  float lod = (pbrInfo.perceptualRoughness * mipCount);
   // retrieve a scale and bias to F0. See [1], Figure 3
-  vec3 brdf = SRGBtoLINEAR(texture(u_brdfLUT,
-    vec2(pbrInputs.NdotV, 1.0 - pbrInputs.perceptualRoughness))).rgb;
-  vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;
+  vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
+    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
+  vec3 diffuseLight = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, n)).rgb;
 
 #ifdef USE_TEX_LOD
-  vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
 #else
-  vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
 #endif
 
-  vec3 diffuse = diffuseLight * pbrInputs.diffuseColor;
-  vec3 specular = specularLight * (pbrInputs.specularColor * brdf.x + brdf.y);
+  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
+  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
 
   // For presentation, this allows us to disable IBL terms
-  diffuse *= u_ScaleIBLAmbient.x;
-  specular *= u_ScaleIBLAmbient.y;
+  diffuse *= pbrMaterial.scaleIBLAmbient.x;
+  specular *= pbrMaterial.scaleIBLAmbient.y;
 
   return diffuse + specular;
 }
@@ -4295,32 +3792,29 @@ vec3 getIBLContribution(PBRInfo pbrInputs, vec3 n, vec3 reflection)
 // Basic Lambertian diffuse
 // Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog
 // See also [1], Equation 1
-vec3 diffuse(PBRInfo pbrInputs)
-{
-  return pbrInputs.diffuseColor / M_PI;
+fn diffuse(pbrInfo: PBRInfo) -> vec3<f32> {
+  return pbrInfo.diffuseColor / PI;
 }
 
 // The following equation models the Fresnel reflectance term of the spec equation (aka F())
 // Implementation of fresnel from [4], Equation 15
-vec3 specularReflection(PBRInfo pbrInputs)
-{
-  return pbrInputs.reflectance0 +
-    (pbrInputs.reflectance90 - pbrInputs.reflectance0) *
-    pow(clamp(1.0 - pbrInputs.VdotH, 0.0, 1.0), 5.0);
+fn specularReflection(pbrInfo: PBRInfo) -> vec3<f32> {
+  return pbrInfo.reflectance0 +
+    (pbrInfo.reflectance90 - pbrInfo.reflectance0) *
+    pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
 }
 
 // This calculates the specular geometric attenuation (aka G()),
 // where rougher material will reflect less light back to the viewer.
 // This implementation is based on [1] Equation 4, and we adopt their modifications to
 // alphaRoughness as input as originally proposed in [2].
-float geometricOcclusion(PBRInfo pbrInputs)
-{
-  float NdotL = pbrInputs.NdotL;
-  float NdotV = pbrInputs.NdotV;
-  float r = pbrInputs.alphaRoughness;
+fn geometricOcclusion(pbrInfo: PBRInfo) -> f32 {
+  let NdotL: f32 = pbrInfo.NdotL;
+  let NdotV: f32 = pbrInfo.NdotV;
+  let r: f32 = pbrInfo.alphaRoughness;
 
-  float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
-  float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
+  let attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
+  let attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
   return attenuationL * attenuationV;
 }
 
@@ -4330,112 +3824,110 @@ float geometricOcclusion(PBRInfo pbrInputs)
 // for Ray Reflection" by T. S. Trowbridge, and K. P. Reitz
 // Follows the distribution function recommended in the SIGGRAPH 2013 course notes
 // from EPIC Games [1], Equation 3.
-float microfacetDistribution(PBRInfo pbrInputs)
-{
-  float roughnessSq = pbrInputs.alphaRoughness * pbrInputs.alphaRoughness;
-  float f = (pbrInputs.NdotH * roughnessSq - pbrInputs.NdotH) * pbrInputs.NdotH + 1.0;
-  return roughnessSq / (M_PI * f * f);
+fn microfacetDistribution(pbrInfo: PBRInfo) -> f32 {
+  let roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
+  let f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
+  return roughnessSq / (PI * f * f);
 }
 
-void PBRInfo_setAmbientLight(inout PBRInfo pbrInputs) {
-  pbrInputs.NdotL = 1.0;
-  pbrInputs.NdotH = 0.0;
-  pbrInputs.LdotH = 0.0;
-  pbrInputs.VdotH = 1.0;
+fn PBRInfo_setAmbientLight(pbrInfo: ptr<function, PBRInfo>) {
+  (*pbrInfo).NdotL = 1.0;
+  (*pbrInfo).NdotH = 0.0;
+  (*pbrInfo).LdotH = 0.0;
+  (*pbrInfo).VdotH = 1.0;
 }
 
-void PBRInfo_setDirectionalLight(inout PBRInfo pbrInputs, vec3 lightDirection) {
-  vec3 n = pbrInputs.n;
-  vec3 v = pbrInputs.v;
-  vec3 l = normalize(lightDirection);             // Vector from surface point to light
-  vec3 h = normalize(l+v);                        // Half vector between both l and v
+fn PBRInfo_setDirectionalLight(pbrInfo: ptr<function, PBRInfo>, lightDirection: vec3<f32>) {
+  let n = (*pbrInfo).n;
+  let v = (*pbrInfo).v;
+  let l = normalize(lightDirection);             // Vector from surface point to light
+  let h = normalize(l + v);                      // Half vector between both l and v
 
-  pbrInputs.NdotL = clamp(dot(n, l), 0.001, 1.0);
-  pbrInputs.NdotH = clamp(dot(n, h), 0.0, 1.0);
-  pbrInputs.LdotH = clamp(dot(l, h), 0.0, 1.0);
-  pbrInputs.VdotH = clamp(dot(v, h), 0.0, 1.0);
+  (*pbrInfo).NdotL = clamp(dot(n, l), 0.001, 1.0);
+  (*pbrInfo).NdotH = clamp(dot(n, h), 0.0, 1.0);
+  (*pbrInfo).LdotH = clamp(dot(l, h), 0.0, 1.0);
+  (*pbrInfo).VdotH = clamp(dot(v, h), 0.0, 1.0);
 }
 
-void PBRInfo_setPointLight(inout PBRInfo pbrInputs, PointLight pointLight) {
-  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
-  PBRInfo_setDirectionalLight(pbrInputs, light_direction);
+fn PBRInfo_setPointLight(pbrInfo: ptr<function, PBRInfo>, pointLight: PointLight) {
+  let light_direction = normalize(pointLight.position - pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
 }
 
-vec3 calculateFinalColor(PBRInfo pbrInputs, vec3 lightColor) {
+fn calculateFinalColor(pbrInfo: PBRInfo, lightColor: vec3<f32>) -> vec3<f32> {
   // Calculate the shading terms for the microfacet specular shading model
-  vec3 F = specularReflection(pbrInputs);
-  float G = geometricOcclusion(pbrInputs);
-  float D = microfacetDistribution(pbrInputs);
+  let F = specularReflection(pbrInfo);
+  let G = geometricOcclusion(pbrInfo);
+  let D = microfacetDistribution(pbrInfo);
 
   // Calculation of analytical lighting contribution
-  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInputs);
-  vec3 specContrib = F * G * D / (4.0 * pbrInputs.NdotL * pbrInputs.NdotV);
+  let diffuseContrib = (1.0 - F) * diffuse(pbrInfo);
+  let specContrib = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);
   // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)
-  return pbrInputs.NdotL * lightColor * (diffuseContrib + specContrib);
+  return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);
 }
 
-vec4 pbr_filterColor(vec4 colorUnused)
-{
+fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   // The albedo may be defined from a base texture or a flat color
-#ifdef HAS_BASECOLORMAP
-  vec4 baseColor = SRGBtoLINEAR(texture(u_BaseColorSampler, pbr_vUV)) * u_BaseColorFactor;
-#else
-  vec4 baseColor = u_BaseColorFactor;
-#endif
-
-#ifdef ALPHA_CUTOFF
-  if (baseColor.a < u_AlphaCutoff) {
+  var baseColor: vec4<f32>;
+  #ifdef HAS_BASECOLORMAP
+  baseColor = SRGBtoLINEAR(textureSample(pbr_baseColorSampler, pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
+  #else
+  baseColor = pbrMaterial.baseColorFactor;
+  #endif
+
+  #ifdef ALPHA_CUTOFF
+  if (baseColor.a < pbrMaterial.alphaCutoff) {
     discard;
   }
-#endif
+  #endif
 
-  vec3 color = vec3(0, 0, 0);
+  var color = vec3<f32>(0.0, 0.0, 0.0);
 
-  if(pbr_uUnlit){
-    color.rgb = baseColor.rgb;
-  }
-  else{
+  if (pbrMaterial.unlit) {
+    color = baseColor.rgb;
+  } else {
     // Metallic and Roughness material properties are packed together
     // In glTF, these factors can be specified by fixed scalar values
     // or from a metallic-roughness map
-    float perceptualRoughness = u_MetallicRoughnessValues.y;
-    float metallic = u_MetallicRoughnessValues.x;
-#ifdef HAS_METALROUGHNESSMAP
+    var perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
+    var metallic = pbrMaterial.metallicRoughnessValues.x;
+    #ifdef HAS_METALROUGHNESSMAP
     // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
     // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
-    vec4 mrSample = texture(u_MetallicRoughnessSampler, pbr_vUV);
+    let mrSample = textureSample(pbr_metallicRoughnessSampler, pbr_metallicRoughnessSampler, pbr_vUV);
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
-#endif
+    #endif
     perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
     metallic = clamp(metallic, 0.0, 1.0);
     // Roughness is authored as perceptual roughness; as is convention,
     // convert to material roughness by squaring the perceptual roughness [2].
-    float alphaRoughness = perceptualRoughness * perceptualRoughness;
+    let alphaRoughness = perceptualRoughness * perceptualRoughness;
 
-    vec3 f0 = vec3(0.04);
-    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
+    let f0 = vec3<f32>(0.04);
+    var diffuseColor = baseColor.rgb * (vec3<f32>(1.0) - f0);
     diffuseColor *= 1.0 - metallic;
-    vec3 specularColor = mix(f0, baseColor.rgb, metallic);
+    let specularColor = mix(f0, baseColor.rgb, metallic);
 
     // Compute reflectance.
-    float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
+    let reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
 
     // For typical incident reflectance range (between 4% to 100%) set the grazing
     // reflectance to 100% for typical fresnel effect.
     // For very low reflectance range on highly diffuse objects (below 4%),
-    // incrementally reduce grazing reflecance to 0%.
-    float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
-    vec3 specularEnvironmentR0 = specularColor.rgb;
-    vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
+    // incrementally reduce grazing reflectance to 0%.
+    let reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
+    let specularEnvironmentR0 = specularColor;
+    let specularEnvironmentR90 = vec3<f32>(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
+    let n = getNormal();                          // normal at surface point
+    let 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));
+    let NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
+    let reflection = -normalize(reflect(v, n));
 
-    PBRInfo pbrInputs = PBRInfo(
+    var pbrInfo = PBRInfo(
       0.0, // NdotL
       NdotV,
       0.0, // NdotH
@@ -4452,77 +3944,147 @@ vec4 pbr_filterColor(vec4 colorUnused)
       v
     );
 
-#ifdef USE_LIGHTS
+    #ifdef USE_LIGHTS
     // Apply ambient light
-    PBRInfo_setAmbientLight(pbrInputs);
-    color += calculateFinalColor(pbrInputs, lighting_uAmbientLight.color);
+    PBRInfo_setAmbientLight(&pbrInfo);
+    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
 
     // Apply directional light
-    for(int i = 0; i < lighting_uDirectionalLightCount; i++) {
-      if (i < lighting_uDirectionalLightCount) {
-        PBRInfo_setDirectionalLight(pbrInputs, lighting_uDirectionalLight[i].direction);
-        color += calculateFinalColor(pbrInputs, lighting_uDirectionalLight[i].color);
+    for (var i = 0; i < lighting.directionalLightCount; i++) {
+      if (i < lighting.directionalLightCount) {
+        PBRInfo_setDirectionalLight(&pbrInfo, lighting_getDirectionalLight(i).direction);
+        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
       }
     }
 
     // Apply point light
-    for(int i = 0; i < lighting_uPointLightCount; i++) {
-      if (i < lighting_uPointLightCount) {
-        PBRInfo_setPointLight(pbrInputs, lighting_uPointLight[i]);
-        float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));
-        color += calculateFinalColor(pbrInputs, lighting_uPointLight[i].color / attenuation);
+    for (var i = 0; i < lighting.pointLightCount; i++) {
+      if (i < lighting.pointLightCount) {
+        PBRInfo_setPointLight(&pbrInfo, lighting_getPointLight(i));
+        let attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
       }
     }
-#endif
+    #endif
 
     // Calculate lighting contribution from image based lighting source (IBL)
-#ifdef USE_IBL
-    color += getIBLContribution(pbrInputs, n, reflection);
-#endif
+    #ifdef USE_IBL
+    if (pbrMaterial.IBLenabled) {
+      color += getIBLContribution(pbrInfo, n, reflection);
+    }
+    #endif
 
     // Apply optional PBR terms for additional (optional) shading
-#ifdef HAS_OCCLUSIONMAP
-    float ao = texture(u_OcclusionSampler, pbr_vUV).r;
-    color = mix(color, color * ao, u_OcclusionStrength);
-#endif
+    #ifdef HAS_OCCLUSIONMAP
+    if (pbrMaterial.occlusionMapEnabled) {
+      let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSampler, pbr_vUV).r;
+      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+    }
+    #endif
 
-#ifdef HAS_EMISSIVEMAP
-    vec3 emissive = SRGBtoLINEAR(texture(u_EmissiveSampler, pbr_vUV)).rgb * u_EmissiveFactor;
-    color += emissive;
-#endif
+    #ifdef HAS_EMISSIVEMAP
+    if (pbrMaterial.emissiveMapEnabled) {
+      let emissive = SRGBtoLINEAR(textureSample(pbr_emissiveSampler, pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
+      color += emissive;
+    }
+    #endif
 
     // This section uses mix to override final color for reference app visualization
     // of various parameters in the lighting equation.
-#ifdef PBR_DEBUG
+    #ifdef PBR_DEBUG
     // TODO: Figure out how to debug multiple lights
 
-    // color = mix(color, F, u_ScaleFGDSpec.x);
-    // color = mix(color, vec3(G), u_ScaleFGDSpec.y);
-    // color = mix(color, vec3(D), u_ScaleFGDSpec.z);
-    // color = mix(color, specContrib, u_ScaleFGDSpec.w);
-
-    // color = mix(color, diffuseContrib, u_ScaleDiffBaseMR.x);
-    color = mix(color, baseColor.rgb, u_ScaleDiffBaseMR.y);
-    color = mix(color, vec3(metallic), u_ScaleDiffBaseMR.z);
-    color = mix(color, vec3(perceptualRoughness), u_ScaleDiffBaseMR.w);
-#endif
+    // color = mix(color, F, pbr_scaleFGDSpec.x);
+    // color = mix(color, vec3(G), pbr_scaleFGDSpec.y);
+    // color = mix(color, vec3(D), pbr_scaleFGDSpec.z);
+    // color = mix(color, specContrib, pbr_scaleFGDSpec.w);
 
+    // color = mix(color, diffuseContrib, pbr_scaleDiffBaseMR.x);
+    color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+    color = mix(color, vec3<f32>(metallic), pbrMaterial.scaleDiffBaseMR.z);
+    color = mix(color, vec3<f32>(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+    #endif
   }
 
-  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
+  return vec4<f32>(pow(color, vec3<f32>(1.0 / 2.2)), baseColor.a);
 }
 `
 );
 
-// dist/modules-webgl1/lighting/pbr/pbr.js
-var pbr = {
-  name: "pbr",
-  vs: vs5,
-  fs: fs7,
+// dist/modules/lighting/pbr-material/pbr-projection.js
+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>"
+  }
+};
+
+// dist/modules/lighting/pbr-material/pbr-material.js
+var pbrMaterial = {
+  props: {},
+  uniforms: {},
+  name: "pbrMaterial",
+  dependencies: [lighting, pbrProjection],
+  source: source2,
+  vs: vs2,
+  fs: fs3,
   defines: {
-    LIGHTING_FRAGMENT: 1
+    LIGHTING_FRAGMENT: true,
+    HAS_NORMALMAP: false,
+    HAS_EMISSIVEMAP: false,
+    HAS_OCCLUSIONMAP: false,
+    HAS_BASECOLORMAP: false,
+    HAS_METALROUGHNESSMAP: false,
+    ALPHA_CUTOFF: false,
+    USE_IBL: false,
+    PBR_DEBUG: false
   },
-  dependencies: [lights],
-  getUniforms: (props) => props
+  getUniforms: (props) => props,
+  uniformTypes: {
+    // Material is unlit
+    unlit: "i32",
+    // Base color map
+    baseColorMapEnabled: "i32",
+    baseColorFactor: "vec4<f32>",
+    normalMapEnabled: "i32",
+    normalScale: "f32",
+    // #ifdef HAS_NORMALMAP
+    emissiveMapEnabled: "i32",
+    emissiveFactor: "vec3<f32>",
+    // #ifdef HAS_EMISSIVEMAP
+    metallicRoughnessValues: "vec2<f32>",
+    metallicRoughnessMapEnabled: "i32",
+    occlusionMapEnabled: "i32",
+    occlusionStrength: "f32",
+    // #ifdef HAS_OCCLUSIONMAP
+    alphaCutoffEnabled: "i32",
+    alphaCutoff: "f32",
+    // #ifdef ALPHA_CUTOFF
+    // IBL
+    IBLenabled: "i32",
+    scaleIBLAmbient: "vec2<f32>",
+    // #ifdef USE_IBL
+    // debugging flags used for shader output of intermediate PBR variables
+    // #ifdef PBR_DEBUG
+    scaleDiffBaseMR: "vec4<f32>",
+    scaleFGDSpec: "vec4<f32>"
+  }
 };
 //# sourceMappingURL=index.cjs.map