@luma.gl/shadertools 9.0.0-alpha.20 → 9.0.0-alpha.23

package/dist/dist.dev.js

@@ -27,11 +27,15 @@ var __exports__ = (() => {
   // src/index.ts
   var src_exports = {};
   __export(src_exports, {
+    _ShaderModuleInstance: () => ShaderModuleInstance,
+    _getDependencyGraph: () => getDependencyGraph,
+    _resolveModules: () => resolveModules,
     _transform: () => transform,
     _warp: () => warp,
     assembleShaders: () => assembleShaders,
     brightnessContrast: () => brightnessContrast,
     bulgePinch: () => bulgePinch,
+    capitalize: () => capitalize,
     colorHalftone: () => colorHalftone,
     combineInjects: () => combineInjects,
     convertToVec4: () => convertToVec4,
@@ -43,6 +47,7 @@ var __exports__ = (() => {
     fp64: () => fp64,
     fp64arithmetic: () => fp64arithmetic,
     fxaa: () => fxaa,
+    generateShaderForModule: () => generateShaderForModule,
     getPassthroughFS: () => getPassthroughFS,
     getQualifierDetails: () => getQualifierDetails,
     getShaderInfo: () => getShaderInfo,
@@ -165,11 +170,24 @@ var __exports__ = (() => {
   // src/lib/shader-module/shader-module-instance.ts
   var ShaderModuleInstance = class {
     uniforms = {};
+    uniformFormats = {};
+    static instantiateModules(modules) {
+      return modules.map((module) => {
+        if (module instanceof ShaderModuleInstance) {
+          return module;
+        }
+        assert(typeof module !== "string", `Shader module use by name is deprecated. Import shader module '${module}' and use it directly.`);
+        assert(module.name, "shader module has no name");
+        const moduleObject = new ShaderModuleInstance(module);
+        moduleObject.dependencies = ShaderModuleInstance.instantiateModules(module.dependencies || []);
+        return moduleObject;
+      });
+    }
     constructor(props) {
       const {
         name,
-        vs: vs4,
-        fs: fs25,
+        vs: vs5,
+        fs: fs26,
         dependencies = [],
         uniforms: uniforms18 = {},
         getUniforms: getUniforms7,
@@ -179,10 +197,10 @@ var __exports__ = (() => {
       } = props;
       assert(typeof name === "string");
       this.name = name;
-      this.vs = vs4;
-      this.fs = fs25;
+      this.vs = vs5;
+      this.fs = fs26;
       this.getModuleUniforms = getUniforms7;
-      this.dependencies = dependencies;
+      this.dependencies = ShaderModuleInstance.instantiateModules(dependencies);
       this.deprecations = this._parseDeprecationDefinitions(deprecations);
       this.defines = defines;
       this.injections = normalizeInjections(inject);
@@ -282,19 +300,8 @@ ${moduleSource}// END MODULE_${this.name}
 
   // src/lib/shader-assembler/resolve-modules.ts
   function resolveModules(modules) {
-    return getShaderDependencies(instantiateModules(modules));
-  }
-  function instantiateModules(modules) {
-    return modules.map((module) => {
-      if (module instanceof ShaderModuleInstance) {
-        return module;
-      }
-      assert(typeof module !== "string", `Shader module use by name is deprecated. Import shader module '${module}' and use it directly.`);
-      assert(module.name, "shader module has no name");
-      const moduleObject = new ShaderModuleInstance(module);
-      moduleObject.dependencies = instantiateModules(module.dependencies || []);
-      return moduleObject;
-    });
+    const instances = ShaderModuleInstance.instantiateModules(modules);
+    return getShaderDependencies(instances);
   }
   function getShaderDependencies(modules) {
     const moduleMap = {};
@@ -639,20 +646,20 @@ precision highp float;
 `;
   function assembleShaders(platformInfo, options) {
     const {
-      vs: vs4,
-      fs: fs25
+      vs: vs5,
+      fs: fs26
     } = options;
     const modules = resolveModules(options.modules || []);
     return {
       vs: assembleShader(platformInfo, {
         ...options,
-        source: vs4,
+        source: vs5,
         type: "vs",
         modules
       }),
       fs: assembleShader(platformInfo, {
         ...options,
-        source: fs25,
+        source: fs26,
         type: "fs",
         modules
       }),
@@ -991,6 +998,103 @@ void main() {
     }
   }
 
+  // src/lib/shader-generator/utils/capitalize.ts
+  function capitalize(str) {
+    return typeof str === "string" ? str.charAt(0).toUpperCase() + str.slice(1) : str;
+  }
+
+  // src/lib/shader-generator/glsl/generate-glsl.ts
+  function generateGLSLForModule(module, options) {
+    return generateGLSLUniformDeclarations(module, options);
+  }
+  function generateGLSLUniformDeclarations(module, options) {
+    const glsl2 = [];
+    switch (options.uniforms) {
+      case "scoped-interface-blocks":
+      case "unscoped-interface-blocks":
+        glsl2.push(`uniform ${capitalize(module.name)} {`);
+        break;
+      case "uniforms":
+    }
+    for (const [uniformName, uniformFormat] of Object.entries(module.uniformFormats || module.uniforms || {})) {
+      const glslUniformType = getGLSLUniformType(uniformFormat.format);
+      switch (options.uniforms) {
+        case "scoped-interface-blocks":
+          glsl2.push(`  ${glslUniformType} ${uniformName};`);
+          break;
+        case "unscoped-interface-blocks":
+          glsl2.push(`  ${glslUniformType} ${module.name}_${uniformName};`);
+          break;
+        case "uniforms":
+          glsl2.push(`uniform ${glslUniformType} ${module.name}_${uniformName};`);
+      }
+    }
+    switch (options.uniforms) {
+      case "scoped-interface-blocks":
+        glsl2.push(`} ${module.name};`);
+        break;
+      case "unscoped-interface-blocks":
+        glsl2.push("};");
+        break;
+      case "uniforms":
+    }
+    glsl2.push("");
+    return glsl2.join("\n");
+  }
+  function getGLSLUniformType(uniformFormat) {
+    const UNIFORM_TYPE_TO_GLSL = {
+      "f32": "float",
+      "i32": "int",
+      "u32": "uint",
+      "vec2<f32>": "vec2",
+      "vec3<f32>": "vec3",
+      "vec4<f32>": "vec4",
+      "vec2<i32>": "ivec2",
+      "vec3<i32>": "ivec3",
+      "vec4<i32>": "ivec4",
+      "vec2<u32>": "uvec2",
+      "vec3<u32>": "uvec3",
+      "vec4<u32>": "uvec4",
+      "mat2x2<f32>": "mat2",
+      "mat2x3<f32>": "mat2x3",
+      "mat2x4<f32>": "mat2x4",
+      "mat3x2<f32>": "mat3x2",
+      "mat3x3<f32>": "mat3",
+      "mat3x4<f32>": "mat3x4",
+      "mat4x2<f32>": "mat4x2",
+      "mat4x3<f32>": "mat4x3",
+      "mat4x4<f32>": "mat4"
+    };
+    const glsl2 = UNIFORM_TYPE_TO_GLSL[uniformFormat];
+    return glsl2;
+  }
+
+  // src/lib/shader-generator/wgsl/generate-wgsl.ts
+  function generateWGSLForModule(module, options) {
+    return generateWGSLUniformDeclarations(module, options);
+  }
+  function generateWGSLUniformDeclarations(module, options) {
+    const wgsl = [];
+    wgsl.push(`struct ${capitalize(module.name)} {`);
+    for (const [uniformName, uniformFormat] of Object.entries(module?.uniformFormats || {})) {
+      const wgslUniformType = uniformFormat;
+      wgsl.push(`  ${uniformName} : ${wgslUniformType};`);
+    }
+    wgsl.push("};");
+    wgsl.push(`var<uniform> ${module.name} : ${capitalize(module.name)};`);
+    return wgsl.join("\n");
+  }
+
+  // src/lib/shader-generator/generate-shader.ts
+  function generateShaderForModule(module, options) {
+    switch (options.shaderLanguage) {
+      case "glsl":
+        return generateGLSLForModule(module, options);
+      case "wgsl":
+        return generateWGSLForModule(module, options);
+    }
+  }
+
   // src/modules/utils/random.ts
   var fs = glsl`\
 float random(vec3 scale, float seed) {
@@ -3702,7 +3806,7 @@ ${common}`;
   };
 
   // src/modules/lights/lights.glsl.ts
-  var lights_glsl_default = glsl`\
+  var lightingShader = glsl`\
 #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
 
 struct AmbientLight {
@@ -3822,8 +3926,8 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
   }
   var lights = {
     name: "lights",
-    vs: lights_glsl_default,
-    fs: lights_glsl_default,
+    vs: lightingShader,
+    fs: lightingShader,
     getUniforms: getUniforms3,
     defines: {
       MAX_LIGHTS: 3
@@ -4007,7 +4111,7 @@ vec4 picking_filterColor(vec4 color) {
   };
 
   // src/modules/phong-lighting/phong-lighting.glsl.ts
-  var phong_lighting_glsl_default = glsl`\
+  var lightingShader2 = glsl`\
 
 uniform float lighting_uAmbient;
 uniform float lighting_uDiffuse;
@@ -4116,7 +4220,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   var gouraudLighting = {
     name: "gouraud-lighting",
     dependencies: [lights],
-    vs: phong_lighting_glsl_default,
+    vs: lightingShader2,
     defines: {
       LIGHTING_VERTEX: 1
     },
@@ -4125,7 +4229,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   var phongLighting = {
     name: "phong-lighting",
     dependencies: [lights],
-    fs: phong_lighting_glsl_default,
+    fs: lightingShader2,
     defines: {
       LIGHTING_FRAGMENT: 1
     },
@@ -4133,7 +4237,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   };
 
   // src/modules/pbr/pbr-vertex.glsl.ts
-  var pbr_vertex_glsl_default = glsl`\
+  var vs3 = glsl`\
 uniform mat4 u_MVPMatrix;
 uniform mat4 u_ModelMatrix;
 uniform mat4 u_NormalMatrix;
@@ -4174,7 +4278,7 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 `;
 
   // src/modules/pbr/pbr-fragment.glsl.ts
-  var pbr_fragment_glsl_default = glsl`\
+  var fs5 = glsl`\
 #if defined(USE_TEX_LOD) && !defined(FEATURE_GLSL_TEXTURE_LOD)
 # error PBR fragment shader: Texture LOD is not available
 #endif
@@ -4578,8 +4682,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
   // src/modules/pbr/pbr.ts
   var pbr = {
     name: "pbr",
-    vs: pbr_vertex_glsl_default,
-    fs: pbr_fragment_glsl_default,
+    vs: vs3,
+    fs: fs5,
     defines: {
       LIGHTING_FRAGMENT: 1
     },
@@ -4587,7 +4691,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
   };
 
   // src/modules/image-blur-filters/tiltshift.ts
-  var fs5 = `uniform float blurRadius;
+  var fs6 = `uniform float blurRadius;
 uniform float gradientRadius;
 uniform vec2 start;
 uniform vec2 end;
@@ -4650,7 +4754,7 @@ vec4 tiltShift_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   var tiltShift = {
     name: "tiltShift",
     uniforms,
-    fs: fs5,
+    fs: fs6,
     dependencies: [random],
     passes: [{
       sampler: true,
@@ -4666,7 +4770,7 @@ vec4 tiltShift_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/image-blur-filters/triangleblur.ts
-  var fs6 = glsl`\
+  var fs7 = glsl`\
 uniform float radius;
 uniform vec2 delta;
 
@@ -4713,7 +4817,7 @@ vec4 triangleBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   var triangleBlur = {
     name: "triangleBlur",
     uniforms: uniforms2,
-    fs: fs6,
+    fs: fs7,
     dependencies: [random],
     passes: [{
       sampler: true,
@@ -4729,7 +4833,7 @@ vec4 triangleBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/image-blur-filters/zoomblur.ts
-  var fs7 = `
+  var fs8 = `
 uniform vec2 center;
 uniform float strength;
 
@@ -4772,7 +4876,7 @@ vec4 zoomBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   var zoomBlur = {
     name: "zoomBlur",
     uniforms: uniforms3,
-    fs: fs7,
+    fs: fs8,
     dependencies: [random],
     passes: [{
       sampler: true
@@ -4792,7 +4896,7 @@ vec4 zoomBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
       max: 1
     }
   };
-  var fs8 = glsl`\
+  var fs9 = glsl`\
 uniform float brightness;
 uniform float contrast;
 
@@ -4813,14 +4917,14 @@ vec4 brightnessContrast_filterColor(vec4 color, vec2 texSize, vec2 texCoords) {
   var brightnessContrast = {
     name: "brightnessContrast",
     uniforms: uniforms4,
-    fs: fs8,
+    fs: fs9,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/image-adjust-filters/denoise.ts
-  var fs9 = glsl`\
+  var fs10 = glsl`\
 uniform float strength;
 
 vec4 denoise_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
@@ -4854,7 +4958,7 @@ vec4 denoise_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   var denoise = {
     name: "denoise",
     uniforms: uniforms5,
-    fs: fs9,
+    fs: fs10,
     passes: [{
       sampler: true
     }, {
@@ -4863,7 +4967,7 @@ vec4 denoise_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/image-adjust-filters/huesaturation.ts
-  var fs10 = glsl`\
+  var fs11 = glsl`\
 uniform float hue;
 uniform float saturation;
 
@@ -4909,14 +5013,14 @@ vec4 hueSaturation_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   var hueSaturation = {
     name: "hueSaturation",
     uniforms: uniforms6,
-    fs: fs10,
+    fs: fs11,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/image-adjust-filters/noise.ts
-  var fs11 = glsl`\
+  var fs12 = glsl`\
 uniform float amount;
 
 float rand(vec2 co) {
@@ -4944,14 +5048,14 @@ vec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
         max: 1
       }
     },
-    fs: fs11,
+    fs: fs12,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/image-adjust-filters/sepia.ts
-  var fs12 = glsl`\
+  var fs13 = glsl`\
 uniform float amount;
 
 vec4 sepia_filterColor(vec4 color) {
@@ -4981,14 +5085,14 @@ vec4 sepia_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   var sepia = {
     name: "sepia",
     uniforms: uniforms7,
-    fs: fs12,
+    fs: fs13,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/image-adjust-filters/vibrance.ts
-  var fs13 = glsl`\
+  var fs14 = glsl`\
 uniform float amount;
 
 vec4 vibrance_filterColor(vec4 color) {
@@ -5013,14 +5117,14 @@ vec4 vibrance_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   var vibrance = {
     name: "vibrance",
     uniforms: uniforms8,
-    fs: fs13,
+    fs: fs14,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/image-adjust-filters/vignette.ts
-  var fs14 = glsl`\
+  var fs15 = glsl`\
 uniform float radius;
 uniform float amount;
 
@@ -5048,7 +5152,7 @@ vec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   };
   var vignette = {
     name: "vignette",
-    fs: fs14,
+    fs: fs15,
     uniforms: uniforms9,
     passes: [{
       filter: true
@@ -5056,7 +5160,7 @@ vec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/image-fun-filters/colorhalftone.ts
-  var fs15 = glsl`\
+  var fs16 = glsl`\
 uniform vec2 center;
 uniform float angle;
 uniform float size;
@@ -5107,14 +5211,14 @@ vec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   var colorHalftone = {
     name: "colorHalftone",
     uniforms: uniforms10,
-    fs: fs15,
+    fs: fs16,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/image-fun-filters/dotscreen.ts
-  var fs16 = glsl`\
+  var fs17 = glsl`\
 uniform vec2 center;
 uniform float angle;
 uniform float size;
@@ -5153,14 +5257,14 @@ vec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   var dotScreen = {
     name: "dotScreen",
     uniforms: uniforms11,
-    fs: fs16,
+    fs: fs17,
     passes: [{
       filter: true
     }]
   };
 
   // src/modules/image-fun-filters/edgework.ts
-  var fs17 = glsl`\
+  var fs18 = glsl`\
 uniform float radius;
 uniform vec2 delta;
 
@@ -5228,7 +5332,7 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
   var edgeWork = {
     name: "edgeWork",
     uniforms: uniforms12,
-    fs: fs17,
+    fs: fs18,
     dependencies: [random],
     passes: [{
       sampler: "edgeWork_sampleColor1",
@@ -5244,7 +5348,7 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/image-fun-filters/hexagonalpixelate.ts
-  var fs18 = glsl`\
+  var fs19 = glsl`\
 uniform vec2 center;
 uniform float scale;
 
@@ -5301,14 +5405,14 @@ vec4 hexagonalPixelate_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoor
   var hexagonalPixelate = {
     name: "hexagonalPixelate",
     uniforms: uniforms13,
-    fs: fs18,
+    fs: fs19,
     passes: [{
       sampler: true
     }]
   };
 
   // src/modules/image-fun-filters/ink.ts
-  var fs19 = glsl`\
+  var fs20 = glsl`\
 uniform float strength;
 
 vec4 ink_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
@@ -5345,14 +5449,14 @@ vec4 ink_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   var ink = {
     name: "ink",
     uniforms: uniforms14,
-    fs: fs19,
+    fs: fs20,
     passes: [{
       sampler: true
     }]
   };
 
   // src/modules/image-fun-filters/magnify.ts
-  var fs20 = `uniform vec2 screenXY;
+  var fs21 = `uniform vec2 screenXY;
 uniform float radiusPixels;
 uniform float zoom;
 uniform float borderWidthPixels;
@@ -5382,14 +5486,14 @@ vec4 magnify_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   var magnify = {
     name: "magnify",
     uniforms: uniforms15,
-    fs: fs20,
+    fs: fs21,
     passes: [{
       sampler: true
     }]
   };
 
   // src/modules/image-warp-filters/warp.ts
-  var fs21 = glsl`\
+  var fs22 = glsl`\
 vec4 warp_sampleColor(sampler2D texture, vec2 texSize, vec2 coord) {
   vec4 color = texture2D(texture, coord / texSize);
   vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);
@@ -5403,11 +5507,11 @@ vec4 warp_sampleColor(sampler2D texture, vec2 texSize, vec2 coord) {
 `;
   var warp = {
     name: "warp",
-    fs: fs21
+    fs: fs22
   };
 
   // src/modules/image-warp-filters/bulgepinch.ts
-  var fs22 = glsl`\
+  var fs23 = glsl`\
 uniform float radius;
 uniform float strength;
 uniform vec2 center;
@@ -5449,7 +5553,7 @@ vec4 bulgePinch_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   };
   var bulgePinch = {
     name: "bulgePinch",
-    fs: fs22,
+    fs: fs23,
     uniforms: uniforms16,
     dependencies: [warp],
     passes: [{
@@ -5458,7 +5562,7 @@ vec4 bulgePinch_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/image-warp-filters/swirl.ts
-  var fs23 = glsl`\
+  var fs24 = glsl`\
 uniform float radius;
 uniform float angle;
 uniform vec2 center;
@@ -5502,7 +5606,7 @@ vec4 swirl_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   };
   var swirl = {
     name: "swirl",
-    fs: fs23,
+    fs: fs24,
     uniforms: uniforms17,
     dependencies: [warp],
     passes: [{
@@ -5511,7 +5615,7 @@ vec4 swirl_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/fxaa/fxaa.ts
-  var fs24 = `
+  var fs25 = `
 #define FXAA_QUALITY_PRESET 29
 
 #if (FXAA_QUALITY_PRESET == 10)
@@ -6095,14 +6199,14 @@ vec4 fxaa_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   var fxaa = {
     name: "fxaa",
     uniforms: {},
-    fs: fs24,
+    fs: fs25,
     passes: [{
       sampler: true
     }]
   };
 
   // src/modules/transform/transform.ts
-  var vs3 = glsl`\
+  var vs4 = glsl`\
 attribute float transform_elementID;
 
 // returns half of pixel size, used to move the pixel position to center of the pixel.
@@ -6144,7 +6248,7 @@ vec4 transform_getInput(sampler2D texSampler, vec2 size) {
 `;
   var transform = {
     name: "transform",
-    vs: vs3
+    vs: vs4
   };
   return __toCommonJS(src_exports);
 })();