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

package/dist/dist.dev.js

@@ -5435,14 +5435,14 @@ vec4 pbr_filterColor(vec4 colorUnused)
   // src/modules/postprocessing/image-adjust-filters/brightnesscontrast.ts
   var fs4 = glsl`\
 
-uniform BrightnessContrast{
+uniform brightnessContrastUniforms {
   float brightness;
   float contrast;
 } brightnessContrast;
 
 vec4 brightnessContrast_filterColor(vec4 color) {
   color.rgb += brightnessContrast.brightness;
-  if (contrast > 0.0) {
+  if (brightnessContrast.contrast > 0.0) {
     color.rgb = (color.rgb - 0.5) / (1.0 - brightnessContrast.contrast) + 0.5;
   } else {
     color.rgb = (color.rgb - 0.5) * (1.0 + brightnessContrast.contrast) + 0.5;
@@ -5482,22 +5482,22 @@ vec4 brightnessContrast_filterColor(vec4 color, vec2 texSize, vec2 texCoords) {
 
   // src/modules/postprocessing/image-adjust-filters/denoise.ts
   var fs5 = glsl`\
-uniform Noise {
+uniform denoiseUniforms {
   float strength;
 } noise;
 
-vec4 denoise_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 denoise_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   float adjustedExponent = 3. + 200. * pow(1. - noise.strength, 4.);
 
-  vec4 center = texture2D(texture, texCoord);
+  vec4 center = texture(source, texCoord);
   vec4 color = vec4(0.0);
   float total = 0.0;
   for (float x = -4.0; x <= 4.0; x += 1.0) {
     for (float y = -4.0; y <= 4.0; y += 1.0) {
-      vec4 sample = texture2D(texture, texCoord + vec2(x, y) / texSize);
-      float weight = 1.0 - abs(dot(sample.rgb - center.rgb, vec3(0.25)));
+      vec4 offsetColor = texture(source, texCoord + vec2(x, y) / texSize);
+      float weight = 1.0 - abs(dot(offsetColor.rgb - center.rgb, vec3(0.25)));
       weight = pow(weight, adjustedExponent);
-      color += sample * weight;
+      color += offsetColor * weight;
       total += weight;
     }
   }
@@ -5515,7 +5515,7 @@ vec4 denoise_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
         format: "f32",
         value: 0.5,
         min: 0,
-        max: 0.1
+        max: 1
       }
     },
     fs: fs5,
@@ -5528,14 +5528,14 @@ vec4 denoise_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-adjust-filters/huesaturation.ts
   var fs6 = glsl`\
-uniform HueSaturation {
+uniform hueSaturationUniforms {
   float hue;
   float saturation;
 } hueSaturation;
 
 vec4 hueSaturation_filterColor(vec4 color) {
   // hue adjustment, wolfram alpha: RotationTransform[angle, {1, 1, 1}][{x, y, z}]
-  float angle = hue * 3.14159265;
+  float angle = hueSaturation.hue * 3.14159265;
   float s = sin(angle), c = cos(angle);
   vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;
   float len = length(color.rgb);
@@ -5547,10 +5547,10 @@ vec4 hueSaturation_filterColor(vec4 color) {
 
   // saturation adjustment
   float average = (color.r + color.g + color.b) / 3.0;
-  if (saturation > 0.0) {
-    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - saturation));
+  if (hueSaturation.saturation > 0.0) {
+    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));
   } else {
-    color.rgb += (average - color.rgb) * (-saturation);
+    color.rgb += (average - color.rgb) * (-hueSaturation.saturation);
   }
 
   return color;
@@ -5586,7 +5586,7 @@ vec4 hueSaturation_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-adjust-filters/noise.ts
   var fs7 = glsl`\
-uniform Noise {
+uniform noiseUniforms {
   float amount;
 } noise;
 
@@ -5626,7 +5626,7 @@ vec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-adjust-filters/sepia.ts
   var fs8 = glsl`\
-uniform Sepia {
+uniform sepiaUniforms {
   float amount;
 } sepia;
 
@@ -5667,7 +5667,7 @@ vec4 sepia_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-adjust-filters/vibrance.ts
   var fs9 = glsl`\
-uniform Vibrance {
+uniform vibranceUniforms {
   float amount;
 } vibrance;
 
@@ -5700,7 +5700,7 @@ vec4 vibrance_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-adjust-filters/vignette.ts
   var fs10 = glsl`\
-uniform Vignette {
+uniform vignetteUniforms {
   float radius;
   float amount;
 } vignette;
@@ -5741,7 +5741,7 @@ vec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-blur-filters/tiltshift.ts
   var fs11 = glsl`\
-uniform TiltShift {
+uniform tiltShiftUniforms {
   float blurRadius;
   float gradientRadius;
   vec2 start;
@@ -5754,26 +5754,26 @@ vec2 tiltShift_getDelta(vec2 texSize) {
   return tiltShift.invert ? vec2(-vector.y, vector.x) : vector;
 }
 
-vec4 tiltShift_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec4 color = vec4(0.0);
   float total = 0.0;
 
   /* randomize the lookup values to hide the fixed number of samples */
   float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
 
-  vec2 normal = normalize(vec2((start.y - end.y) * texSize.y, (end.x - start.x) * texSize.x));
+  vec2 normal = normalize(vec2((tiltShift.start.y - tiltShift.end.y) * texSize.y, (tiltShift.end.x - tiltShift.start.x) * texSize.x));
   float radius = smoothstep(0.0, 1.0,
-    abs(dot(texCoord * texSize - start * texSize, normal)) / tiltShift.gradientRadius) * tiltShift.blurRadius;
+    abs(dot(texCoord * texSize - tiltShift.start * texSize, normal)) / tiltShift.gradientRadius) * tiltShift.blurRadius;
 
   for (float t = -30.0; t <= 30.0; t++) {
     float percent = (t + offset - 0.5) / 30.0;
     float weight = 1.0 - abs(percent);
-    vec4 sample = texture2D(texture, texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius);
+    vec4 offsetColor = texture(source, texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius);
 
     /* switch to pre-multiplied alpha to correctly blur transparent images */
-    sample.rgb *= sample.a;
+    offsetColor.rgb *= offsetColor.a;
 
-    color += sample * weight;
+    color += offsetColor * weight;
     total += weight;
   }
 
@@ -5833,11 +5833,13 @@ vec4 tiltShift_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-blur-filters/triangleblur.ts
   var fs12 = glsl`\
-uniform float radius;
-uniform vec2 delta;
+uniform triangleBlurUniforms {
+  float radius;
+  vec2 delta;
+} triangleBlur;
 
-vec4 triangleBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
-  vec2 adjustedDelta = delta * radius / texSize;
+vec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec2 adjustedDelta = triangleBlur.delta * triangleBlur.radius / texSize;
 
   vec4 color = vec4(0.0);
   float total = 0.0;
@@ -5848,12 +5850,12 @@ vec4 triangleBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   for (float t = -30.0; t <= 30.0; t++) {
     float percent = (t + offset - 0.5) / 30.0;
     float weight = 1.0 - abs(percent);
-    vec4 sample = texture2D(texture, texCoord + adjustedDelta * percent);
+    vec4 offsetColor = texture(source, texCoord + adjustedDelta * percent);
 
     /* switch to pre-multiplied alpha to correctly blur transparent images */
-    sample.rgb *= sample.a;
+    offsetColor.rgb *= offsetColor.a;
 
-    color += sample * weight;
+    color += offsetColor * weight;
     total += weight;
   }
 
@@ -5899,13 +5901,15 @@ vec4 triangleBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-blur-filters/zoomblur.ts
   var fs13 = `
-uniform vec2 center;
-uniform float strength;
+uniform zoomBlurUniforms {
+  vec2 center;
+  float strength;
+} zoomBlur;
 
-vec4 zoomBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec4 color = vec4(0.0);
   float total = 0.0;
-  vec2 toCenter = center * texSize - texCoord * texSize;
+  vec2 toCenter = zoomBlur.center * texSize - texCoord * texSize;
 
   /* randomize the lookup values to hide the fixed number of samples */
   float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
@@ -5913,12 +5917,12 @@ vec4 zoomBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
   for (float t = 0.0; t <= 40.0; t++) {
     float percent = (t + offset) / 40.0;
     float weight = 4.0 * (percent - percent * percent);
-    vec4 sample = texture2D(texture, texCoord + toCenter * percent * strength / texSize);
+    vec4 offsetColor = texture(source, texCoord + toCenter * percent * zoomBlur.strength / texSize);
 
     /* switch to pre-multiplied alpha to correctly blur transparent images */
-    sample.rgb *= sample.a;
+    offsetColor.rgb *= offsetColor.a;
 
-    color += sample * weight;
+    color += offsetColor * weight;
     total += weight;
   }
 
@@ -5955,16 +5959,14 @@ vec4 zoomBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-fun-filters/colorhalftone.ts
   var fs14 = glsl`\
-uniform ColorHalftone {
+uniform colorHalftoneUniforms {
   vec2 center;
   float angle;
   float size;
 } colorHalftone;
 
-float scale = 3.1514 / colorHalftone.size;
-
-float pattern(float angle, vec2 texSize, vec2 texCoord) {
-  float s = sin(colorHalftone.angle), c = cos(colorHalftone.angle);
+float pattern(float angle, float scale, vec2 texSize, vec2 texCoord) {
+  float s = sin(angle), c = cos(angle);
   vec2 tex = texCoord * texSize - colorHalftone.center * texSize;
   vec2 point = vec2(
 	c * tex.x - s * tex.y,
@@ -5974,19 +5976,21 @@ float pattern(float angle, vec2 texSize, vec2 texCoord) {
 }
 
 vec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
+  float scale = 3.1514 / colorHalftone.size;
   vec3 cmy = 1.0 - color.rgb;
   float k = min(cmy.x, min(cmy.y, cmy.z));
+
   cmy = (cmy - k) / (1.0 - k);
   cmy = clamp(
-	cmy * 10.0 - 3.0 + vec3(
-    pattern(angle + 0.26179, texSize, texCoord),
-	  pattern(angle + 1.30899, texSize, texCoord),
-    pattern(angle, texSize, texCoord)
-  ),
-	0.0,
-	1.0
+	  cmy * 10.0 - 3.0 + vec3(
+      pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),
+	    pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),
+      pattern(colorHalftone.angle, scale, texSize, texCoord)
+    ),
+	  0.0,
+	  1.0
   );
-  k = clamp(k * 10.0 - 5.0 + pattern(angle + 0.78539, texSize, texCoord), 0.0, 1.0);
+  k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);
   return vec4(1.0 - cmy - k, color.a);
 }
 `;
@@ -6021,7 +6025,7 @@ vec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-fun-filters/dotscreen.ts
   var fs15 = glsl`\
-uniform DotScreen {
+uniform dotScreenUniforms {
   vec2 center;
   float angle;
   float size;
@@ -6075,7 +6079,7 @@ vec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-fun-filters/edgework.ts
   var fs16 = glsl`\
-uniform EdgeWork {
+uniform edgeWorkUniforms {
   float radius;
   vec2 delta;
 } edgeWork;
@@ -6092,7 +6096,7 @@ vec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {
   for (float t = -30.0; t <= 30.0; t++) {
     float percent = (t + offset - 0.5) / 30.0;
     float weight = 1.0 - abs(percent);
-    vec3 sampleColor = texture2D(source, texCoord + relativeDelta * percent).rgb;
+    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;
     float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;
     color.x += average * weight;
     total.x += weight;
@@ -6117,7 +6121,7 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
   for (float t = -30.0; t <= 30.0; t++) {
     float percent = (t + offset - 0.5) / 30.0;
     float weight = 1.0 - abs(percent);
-    vec2 sampleColor = texture2D(source, texCoord + relativeDelta * percent).xy;
+    vec2 sampleColor = texture(source, texCoord + relativeDelta * percent).xy;
     color.x += sampleColor.x * weight;
     total.x += weight;
     if (abs(t) < 15.0) {
@@ -6160,12 +6164,12 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-fun-filters/hexagonalpixelate.ts
   var fs17 = glsl`\
-uniform HexagonalPixelate {
+uniform hexagonalPixelateUniforms {
   vec2 center;
   float scale;
 } hexagonalPixelate;
 
-vec4 hexagonalPixelate_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;
   tex.y /= 0.866025404;
   tex.x -= tex.y * 0.5;
@@ -6200,7 +6204,7 @@ vec4 hexagonalPixelate_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoor
   choice.y *= 0.866025404;
   choice *= hexagonalPixelate.scale / texSize;
 
-  return texture2D(texture, choice + hexagonalPixelate.center);
+  return texture(source, choice + hexagonalPixelate.center);
 }
 `;
   var hexagonalPixelate = {
@@ -6229,25 +6233,25 @@ vec4 hexagonalPixelate_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoor
 
   // src/modules/postprocessing/image-fun-filters/ink.ts
   var fs18 = glsl`\
-uniform Ink {
+uniform inkUniforms {
   float strength;
 } ink;
 
-vec4 ink_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec2 dx = vec2(1.0 / texSize.x, 0.0);
   vec2 dy = vec2(0.0, 1.0 / texSize.y);
-  vec4 color = texture2D(texture, texCoord);
+  vec4 color = texture(source, texCoord);
   float bigTotal = 0.0;
   float smallTotal = 0.0;
   vec3 bigAverage = vec3(0.0);
   vec3 smallAverage = vec3(0.0);
   for (float x = -2.0; x <= 2.0; x += 1.0) {
     for (float y = -2.0; y <= 2.0; y += 1.0) {
-      vec3 sample = texture2D(texture, texCoord + dx * x + dy * y).rgb;
-      bigAverage += sample;
+      vec3 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;
+      bigAverage += offsetColor;
       bigTotal += 1.0;
       if (abs(x) + abs(y) < 2.0) {
-        smallAverage += sample;
+        smallAverage += offsetColor;
         smallTotal += 1.0;
       }
     }
@@ -6277,7 +6281,7 @@ vec4 ink_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-fun-filters/magnify.ts
   var fs19 = glsl`\
-uniform Magnify {
+uniform magnifyUniforms {
   vec2 screenXY;
   float radiusPixels;
   float zoom;
@@ -6285,17 +6289,17 @@ uniform Magnify {
   vec4 borderColor;
 } magnify;
 
-vec4 magnify_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec2 pos = vec2(magnify.screenXY.x, 1.0 - magnify.screenXY.y);
   float dist = distance(texCoord * texSize, pos * texSize);
   if (dist < magnify.radiusPixels) {
-    return texture2D(texture, (texCoord - pos) / magnify.zoom + pos);
+    return texture(source, (texCoord - pos) / magnify.zoom + pos);
   }
 
   if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {
     return magnify.borderColor;
   }
-  return texture2D(texture, texCoord);
+  return texture(source, texCoord);
 }
 `;
   var magnify = {
@@ -6326,8 +6330,8 @@ vec4 magnify_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-warp-filters/warp.ts
   var fs20 = glsl`\
-vec4 warp_sampleColor(sampler2D texture, vec2 texSize, vec2 coord) {
-  vec4 color = texture2D(texture, coord / texSize);
+vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {
+  vec4 color = texture(source, coord / texSize);
   vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);
   if (coord != clampedCoord) {
     /* fade to transparent if we are outside the image */
@@ -6339,12 +6343,13 @@ vec4 warp_sampleColor(sampler2D texture, vec2 texSize, vec2 coord) {
 `;
   var warp = {
     name: "warp",
+    passes: [],
     fs: fs20
   };
 
   // src/modules/postprocessing/image-warp-filters/bulgepinch.ts
   var fs21 = glsl`\
-uniform BulgePinch {
+uniform bulgePinchUniforms {
   float radius;
   float strength;
   vec2 center;
@@ -6355,7 +6360,7 @@ vec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {
   float distance = length(coord);
   if (distance < bulgePinch.radius) {
     float percent = distance / bulgePinch.radius;
-    if (strength > 0.0) {
+    if (bulgePinch.strength > 0.0) {
       coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);
     } else {
       coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);
@@ -6365,11 +6370,11 @@ vec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {
   return coord;
 }
 
-vec4 bulgePinch_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec2 coord = texCoord * texSize;
   coord = bulgePinch_warp(coord, bulgePinch.center * texSize);
 
-  return warp_sampleColor(texture, texSize, coord);
+  return warp_sampleColor(source, texSize, coord);
 }
 `;
   var bulgePinch = {
@@ -6403,7 +6408,7 @@ vec4 bulgePinch_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
 
   // src/modules/postprocessing/image-warp-filters/swirl.ts
   var fs22 = glsl`\
-uniform Swirl {
+uniform swirlUniforms {
   float radius;
   float angle;
   vec2 center;
@@ -6426,11 +6431,11 @@ vec2 swirl_warp(vec2 coord, vec2 texCenter) {
   return coord;
 }
 
-vec4 swirl_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   vec2 coord = texCoord * texSize;
   coord = swirl_warp(coord, swirl.center * texSize);
 
-  return warp_sampleColor(texture, texSize, coord);
+  return warp_sampleColor(source, texSize, coord);
 }
 `;
   var swirl = {
@@ -6651,8 +6656,8 @@ vec4 swirl_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
 #define FxaaTex sampler2D
 
 #define FxaaSat(x) clamp(x, 0.0, 1.0)
-#define FxaaTexTop(t, p) texture2D(t, p)
-#define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r))
+#define FxaaTexTop(t, p) texture(t, p)
+#define FxaaTexOff(t, p, o, r) texture(t, p + (o * r))
 
 FxaaFloat FxaaLuma_(FxaaFloat4 rgba) { return dot(rgba.rgb, vec3(0.2126, 0.7152, 0.0722)); }
 
@@ -7029,14 +7034,14 @@ FxaaFloat4 FxaaPixelShader_(
     return FxaaTexTop(tex, posM);
 }
 
-vec4 fxaa_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+vec4 fxaa_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
     const float fxaa_QualitySubpix = 0.5;
     const float fxaa_QualityEdgeThreshold = 0.125;
     const float fxaa_QualityEdgeThresholdMin = 0.0833;
 
     return FxaaPixelShader_(
         texCoord,
-        texture,
+        source,
         vec2(1.0) / texSize,
         fxaa_QualitySubpix,
         fxaa_QualityEdgeThreshold,