@luma.gl/shadertools 9.0.0-beta.1 → 9.0.0-beta.2

package/dist/dist.dev.js

@@ -329,8 +329,8 @@ ${inject[key]}` : inject[key];
     constructor(props) {
       const {
         name,
-        vs: vs7,
-        fs: fs29,
+        vs: vs6,
+        fs: fs28,
         dependencies = [],
         uniformPropTypes = {},
         getUniforms: getUniforms9,
@@ -340,8 +340,8 @@ ${inject[key]}` : inject[key];
       } = props;
       assert(typeof name === "string");
       this.name = name;
-      this.vs = vs7;
-      this.fs = fs29;
+      this.vs = vs6;
+      this.fs = fs28;
       this.getModuleUniforms = getUniforms9;
       this.dependencies = ShaderModuleInstance.instantiateModules(dependencies);
       this.deprecations = this._parseDeprecationDefinitions(deprecations);
@@ -725,8 +725,8 @@ precision highp float;
 `;
   function assembleShaders(options) {
     const {
-      vs: vs7,
-      fs: fs29
+      vs: vs6,
+      fs: fs28
     } = options;
     const modules = resolveModules(options.modules || []);
     switch (options.platformInfo.shaderLanguage) {
@@ -734,13 +734,13 @@ precision highp float;
         return {
           vs: assembleGLSLShader(options.platformInfo, {
             ...options,
-            source: vs7,
+            source: vs6,
             stage: "vertex",
             modules
           }),
           fs: assembleGLSLShader(options.platformInfo, {
             ...options,
-            source: fs29,
+            source: fs28,
             stage: "fragment",
             modules
           }),
@@ -750,13 +750,13 @@ precision highp float;
         return {
           vs: assembleWGSLShader(options.platformInfo, {
             ...options,
-            source: vs7,
+            source: vs6,
             stage: "vertex",
             modules
           }),
           fs: assembleWGSLShader(options.platformInfo, {
             ...options,
-            source: fs29,
+            source: fs28,
             stage: "fragment",
             modules
           }),
@@ -769,18 +769,12 @@ precision highp float;
       source,
       stage,
       modules,
-      defines = {},
       hookFunctions = [],
       inject = {},
       log
     } = options;
     assert(typeof source === "string", "shader source must be a string");
     const coreSource = source;
-    const allDefines = {};
-    modules.forEach((module) => {
-      Object.assign(allDefines, module.getDefines());
-    });
-    Object.assign(allDefines, defines);
     let assembledSource = "";
     const hookFunctionMap = normalizeShaderHooks(hookFunctions);
     const hookInjections = {};
@@ -808,7 +802,8 @@ precision highp float;
         mainInjections[key] = [injection];
       }
     }
-    for (const module of modules) {
+    const modulesToInject = platformInfo.type !== "webgpu" ? modules : [];
+    for (const module of modulesToInject) {
       if (log) {
         module.checkDeprecations(coreSource, log);
       }
@@ -981,15 +976,15 @@ ${getApplicationDefines(allDefines)}
     if (!props.vs) {
       throw new Error("no vertex shader");
     }
-    const vs7 = getShaderSource(props.platformInfo, props.vs);
-    let fs29;
+    const vs6 = getShaderSource(props.platformInfo, props.vs);
+    let fs28;
     if (props.fs) {
-      fs29 = getShaderSource(props.platformInfo, props.fs);
+      fs28 = getShaderSource(props.platformInfo, props.fs);
     }
     return {
       ...props,
-      vs: vs7,
-      fs: fs29
+      vs: vs6,
+      fs: fs28
     };
   }
   function getShaderSource(platformInfo, shader) {
@@ -4606,14 +4601,14 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
   }
 
   // src/modules/lighting/no-material/dirlight.ts
-  var vs2 = glsl`\
+  var VS_GLSL = glsl`\
 out vec3 dirlight_vNormal;
 
 void dirlight_setNormal(vec3 normal) {
   dirlight_vNormal = normalize(normal);
 }
 `;
-  var fs3 = glsl`\
+  var FS_GLSL = glsl`\
 uniform dirlightUniforms {
   vec3 lightDirection;
 } dirlight;
@@ -4629,8 +4624,8 @@ vec4 dirlight_filterColor(vec4 color) {
   var dirlight = {
     name: "dirlight",
     dependencies: [],
-    vs: vs2,
-    fs: fs3,
+    vs: VS_GLSL,
+    fs: FS_GLSL,
     uniformTypes: {
       lightDirection: "vec3<f32>"
     },
@@ -4895,7 +4890,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   };
 
   // src/modules/lighting/pbr-material/pbr-vertex.glsl.ts
-  var vs3 = glsl`\
+  var vs2 = glsl`\
 uniform projection {
   mat4 u_MVPMatrix;
   mat4 u_ModelMatrix;
@@ -4940,7 +4935,7 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 `;
 
   // src/modules/lighting/pbr-material/pbr-fragment.glsl.ts
-  var fs4 = glsl`\
+  var fs3 = glsl`\
 #if defined(USE_TEX_LOD) && !defined(FEATURE_GLSL_TEXTURE_LOD)
 # error PBR fragment shader: Texture LOD is not available
 #endif
@@ -5368,8 +5363,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
   // src/modules/lighting/pbr-material/pbr-material.ts
   var pbrMaterial = {
     name: "pbr",
-    vs: vs3,
-    fs: fs4,
+    vs: vs2,
+    fs: fs3,
     defines: {
       LIGHTING_FRAGMENT: 1,
       HAS_NORMALMAP: 0,
@@ -5438,7 +5433,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
   };
 
   // src/modules/postprocessing/image-adjust-filters/brightnesscontrast.ts
-  var fs5 = glsl`\
+  var fs4 = glsl`\
 
 uniform BrightnessContrast{
   float brightness;
@@ -5479,14 +5474,14 @@ vec4 brightnessContrast_filterColor(vec4 color, vec2 texSize, vec2 texCoords) {
         max: 1
       }
     },
-    fs: fs5,
+    fs: fs4,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/postprocessing/image-adjust-filters/denoise.ts
-  var fs6 = glsl`\
+  var fs5 = glsl`\
 uniform Noise {
   float strength;
 } noise;
@@ -5523,7 +5518,7 @@ vec4 denoise_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
         max: 0.1
       }
     },
-    fs: fs6,
+    fs: fs5,
     passes: [{
       sampler: true
     }, {
@@ -5532,7 +5527,7 @@ vec4 denoise_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-adjust-filters/huesaturation.ts
-  var fs7 = glsl`\
+  var fs6 = glsl`\
 uniform HueSaturation {
   float hue;
   float saturation;
@@ -5583,14 +5578,14 @@ vec4 hueSaturation_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
         max: 1
       }
     },
-    fs: fs7,
+    fs: fs6,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/postprocessing/image-adjust-filters/noise.ts
-  var fs8 = glsl`\
+  var fs7 = glsl`\
 uniform Noise {
   float amount;
 } noise;
@@ -5623,14 +5618,14 @@ vec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
         max: 1
       }
     },
-    fs: fs8,
+    fs: fs7,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/postprocessing/image-adjust-filters/sepia.ts
-  var fs9 = glsl`\
+  var fs8 = glsl`\
 uniform Sepia {
   float amount;
 } sepia;
@@ -5664,14 +5659,14 @@ vec4 sepia_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
         max: 1
       }
     },
-    fs: fs9,
+    fs: fs8,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/postprocessing/image-adjust-filters/vibrance.ts
-  var fs10 = glsl`\
+  var fs9 = glsl`\
 uniform Vibrance {
   float amount;
 } vibrance;
@@ -5697,14 +5692,14 @@ vec4 vibrance_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
         max: 1
       }
     },
-    fs: fs10,
+    fs: fs9,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/postprocessing/image-adjust-filters/vignette.ts
-  var fs11 = glsl`\
+  var fs10 = glsl`\
 uniform Vignette {
   float radius;
   float amount;
@@ -5722,7 +5717,7 @@ vec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
 `;
   var vignette = {
     name: "vignette",
-    fs: fs11,
+    fs: fs10,
     uniformTypes: {
       radius: "f32",
       amount: "f32"
@@ -5745,7 +5740,7 @@ vec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-blur-filters/tiltshift.ts
-  var fs12 = glsl`\
+  var fs11 = glsl`\
 uniform TiltShift {
   float blurRadius;
   float gradientRadius;
@@ -5833,11 +5828,11 @@ vec4 tiltShift_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
       }
     }],
     dependencies: [random],
-    fs: fs12
+    fs: fs11
   };
 
   // src/modules/postprocessing/image-blur-filters/triangleblur.ts
-  var fs13 = glsl`\
+  var fs12 = glsl`\
 uniform float radius;
 uniform vec2 delta;
 
@@ -5887,7 +5882,7 @@ vec4 triangleBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
         private: true
       }
     },
-    fs: fs13,
+    fs: fs12,
     dependencies: [random],
     passes: [{
       sampler: true,
@@ -5903,7 +5898,7 @@ vec4 triangleBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-blur-filters/zoomblur.ts
-  var fs14 = `
+  var fs13 = `
 uniform vec2 center;
 uniform float strength;
 
@@ -5951,7 +5946,7 @@ vec4 zoomBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
         softMax: 1
       }
     },
-    fs: fs14,
+    fs: fs13,
     dependencies: [random],
     passes: [{
       sampler: true
@@ -5959,7 +5954,7 @@ vec4 zoomBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-fun-filters/colorhalftone.ts
-  var fs15 = glsl`\
+  var fs14 = glsl`\
 uniform ColorHalftone {
   vec2 center;
   float angle;
@@ -6018,14 +6013,14 @@ vec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
         softMax: 20
       }
     },
-    fs: fs15,
+    fs: fs14,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/postprocessing/image-fun-filters/dotscreen.ts
-  var fs16 = glsl`\
+  var fs15 = glsl`\
 uniform DotScreen {
   vec2 center;
   float angle;
@@ -6072,14 +6067,14 @@ vec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
         softMax: 20
       }
     },
-    fs: fs16,
+    fs: fs15,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/postprocessing/image-fun-filters/edgework.ts
-  var fs17 = glsl`\
+  var fs16 = glsl`\
 uniform EdgeWork {
   float radius;
   vec2 delta;
@@ -6148,7 +6143,7 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
         private: true
       }
     },
-    fs: fs17,
+    fs: fs16,
     dependencies: [random],
     passes: [{
       sampler: "edgeWork_sampleColor1",
@@ -6164,7 +6159,7 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-fun-filters/hexagonalpixelate.ts
-  var fs18 = glsl`\
+  var fs17 = glsl`\
 uniform HexagonalPixelate {
   vec2 center;
   float scale;
@@ -6226,14 +6221,14 @@ vec4 hexagonalPixelate_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoor
         softMax: 50
       }
     },
-    fs: fs18,
+    fs: fs17,
     passes: [{
       sampler: true
     }]
   };
 
   // src/modules/postprocessing/image-fun-filters/ink.ts
-  var fs19 = glsl`\
+  var fs18 = glsl`\
 uniform Ink {
   float strength;
 } ink;
@@ -6274,14 +6269,14 @@ vec4 ink_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
         softMax: 1
       }
     },
-    fs: fs19,
+    fs: fs18,
     passes: [{
       sampler: true
     }]
   };
 
   // src/modules/postprocessing/image-fun-filters/magnify.ts
-  var fs20 = glsl`\
+  var fs19 = glsl`\
 uniform Magnify {
   vec2 screenXY;
   float radiusPixels;
@@ -6323,14 +6318,14 @@ vec4 magnify_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
         value: [255, 255, 255, 255]
       }
     },
-    fs: fs20,
+    fs: fs19,
     passes: [{
       sampler: true
     }]
   };
 
   // src/modules/postprocessing/image-warp-filters/warp.ts
-  var fs21 = glsl`\
+  var fs20 = glsl`\
 vec4 warp_sampleColor(sampler2D texture, vec2 texSize, vec2 coord) {
   vec4 color = texture2D(texture, coord / texSize);
   vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);
@@ -6344,11 +6339,11 @@ vec4 warp_sampleColor(sampler2D texture, vec2 texSize, vec2 coord) {
 `;
   var warp = {
     name: "warp",
-    fs: fs21
+    fs: fs20
   };
 
   // src/modules/postprocessing/image-warp-filters/bulgepinch.ts
-  var fs22 = glsl`\
+  var fs21 = glsl`\
 uniform BulgePinch {
   float radius;
   float strength;
@@ -6379,7 +6374,7 @@ vec4 bulgePinch_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
 `;
   var bulgePinch = {
     name: "bulgePinch",
-    fs: fs22,
+    fs: fs21,
     uniformTypes: {
       center: "vec2<f32>",
       radius: "f32",
@@ -6407,7 +6402,7 @@ vec4 bulgePinch_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-warp-filters/swirl.ts
-  var fs23 = glsl`\
+  var fs22 = glsl`\
 uniform Swirl {
   float radius;
   float angle;
@@ -6440,7 +6435,7 @@ vec4 swirl_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
 `;
   var swirl = {
     name: "swirl",
-    fs: fs23,
+    fs: fs22,
     uniformTypes: {
       center: "vec2<f32>",
       radius: "f32",
@@ -6468,7 +6463,7 @@ vec4 swirl_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/fxaa/fxaa.ts
-  var fs24 = `
+  var fs23 = `
 #define FXAA_QUALITY_PRESET 29
 
 #if (FXAA_QUALITY_PRESET == 10)
@@ -7052,7 +7047,7 @@ vec4 fxaa_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   var fxaa = {
     name: "fxaa",
     uniformPropTypes: {},
-    fs: fs24,
+    fs: fs23,
     passes: [{
       sampler: true
     }]
@@ -7947,7 +7942,7 @@ void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
   };
 
   // src/modules-webgl1/geometry/geometry.ts
-  var vs4 = glsl`\
+  var vs3 = glsl`\
 varying vec4 geometry_vPosition;
 varying vec3 geometry_vNormal;
 
@@ -7963,7 +7958,7 @@ void geometry_setPosition(vec3 position) {
   geometry_vPosition = vec4(position, 1.);
 }
 `;
-  var fs25 = glsl`\
+  var fs24 = glsl`\
 varying vec4 geometry_vPosition;
 varying vec3 geometry_vNormal;
 
@@ -7977,8 +7972,8 @@ vec3 geometry_getNormal() {
 `;
   var geometry = {
     name: "geometry",
-    vs: vs4,
-    fs: fs25
+    vs: vs3,
+    fs: fs24
   };
 
   // ../../node_modules/@math.gl/core/dist/lib/common.js
@@ -9569,7 +9564,7 @@ vec3 project_getNormal_World() {
   return project_vNormalWorld;
 }
 `;
-  var vs5 = `${common}
+  var vs4 = `${common}
 
 // Unprefixed uniforms
 uniform mat4 modelMatrix;
@@ -9623,13 +9618,13 @@ vec4 project_to_clipspace(vec3 position) {
   return viewProjectionMatrix * vec4(position, 1.);
 }
 `;
-  var fs26 = `
+  var fs25 = `
 ${common}`;
   var project = {
     name: "project",
     getUniforms: getUniforms5,
-    vs: vs5,
-    fs: fs26
+    vs: vs4,
+    fs: fs25
   };
 
   // src/modules-webgl1/lighting/lights/lights.glsl.ts
@@ -9772,7 +9767,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     }
     return uniforms;
   }
-  var fs27 = glsl`\
+  var fs26 = glsl`\
 uniform vec3 dirlight_uLightDirection;
 
 /*
@@ -9786,7 +9781,7 @@ vec4 dirlight_filterColor(vec4 color) {
 `;
   var dirlight2 = {
     name: "dirlight",
-    fs: fs27,
+    fs: fs26,
     getUniforms: getUniforms7,
     dependencies: [project]
   };
@@ -9918,7 +9913,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   };
 
   // src/modules-webgl1/lighting/pbr/pbr-vertex.glsl.ts
-  var vs6 = glsl`\
+  var vs5 = glsl`\
 uniform mat4 u_MVPMatrix;
 uniform mat4 u_ModelMatrix;
 uniform mat4 u_NormalMatrix;
@@ -9959,7 +9954,7 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 `;
 
   // src/modules-webgl1/lighting/pbr/pbr-fragment.glsl.ts
-  var fs28 = glsl`\
+  var fs27 = glsl`\
 #if defined(USE_TEX_LOD) && !defined(FEATURE_GLSL_TEXTURE_LOD)
 # error PBR fragment shader: Texture LOD is not available
 #endif
@@ -10363,8 +10358,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
   // src/modules-webgl1/lighting/pbr/pbr.ts
   var pbr = {
     name: "pbr",
-    vs: vs6,
-    fs: fs28,
+    vs: vs5,
+    fs: fs27,
     defines: {
       LIGHTING_FRAGMENT: 1
     },