@luma.gl/shadertools 9.1.0-alpha.15 → 9.1.0-alpha.17

package/dist/passes/postprocessing/image-adjust-filters/denoise.d.ts

@@ -24,7 +24,7 @@ export declare const denoise: {
     readonly uniformTypes: {
         readonly strength: "f32";
     };
-    readonly uniformPropTypes: {
+    readonly propTypes: {
         readonly strength: {
             readonly format: "f32";
             readonly value: 0.5;

package/dist/passes/postprocessing/image-adjust-filters/denoise.js

@@ -38,7 +38,7 @@ export const denoise = {
     uniformTypes: {
         strength: 'f32'
     },
-    uniformPropTypes: {
+    propTypes: {
         strength: { format: 'f32', value: 0.5, min: 0, max: 1 }
         // strength: {..., adjust: (strength: number): number => 0.53 + 200 * Math.pow(1 - strength, 4) // TODO - JS preprocessing
     },

package/dist/passes/postprocessing/image-adjust-filters/huesaturation.d.ts

@@ -20,14 +20,13 @@ export type HueSaturationUniforms = HueSaturationProps;
  */
 export declare const hueSaturation: {
     readonly props: HueSaturationProps;
-    readonly uniforms: HueSaturationUniforms;
     readonly name: "hueSaturation";
-    readonly fs: "uniform hueSaturationUniforms {\n  float hue;\n  float saturation;\n} hueSaturation;\n\nvec4 hueSaturation_filterColor(vec4 color) {\n  // hue adjustment, wolfram alpha: RotationTransform[angle, {1, 1, 1}][{x, y, z}]\n  float angle = hueSaturation.hue * 3.14159265;\n  float s = sin(angle), c = cos(angle);\n  vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;\n  float len = length(color.rgb);\n  color.rgb = vec3(\n    dot(color.rgb, weights.xyz),\n    dot(color.rgb, weights.zxy),\n    dot(color.rgb, weights.yzx)\n  );\n\n  // saturation adjustment\n  float average = (color.r + color.g + color.b) / 3.0;\n  if (hueSaturation.saturation > 0.0) {\n    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));\n  } else {\n    color.rgb += (average - color.rgb) * (-hueSaturation.saturation);\n  }\n\n  return color;\n}\n\nvec4 hueSaturation_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return hueSaturation_filterColor(color);\n}\n";
+    readonly fs: "uniform hueSaturationUniforms {\n  float hue;\n  float saturation;\n} hueSaturation;\n\nvec4 hueSaturation_filterColor(vec4 color) {\n  // hue adjustment, wolfram alpha: RotationTransform[angle, {1, 1, 1}][{x, y, z}]\n  float angle = hueSaturation.hue * 3.14159265;\n  float s = sin(angle), c = cos(angle);\n  vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;\n  float len = length(color.rgb);\n  color.rgb = vec3(\n    dot(color.rgb, weights.xyz),\n    dot(color.rgb, weights.zxy),\n    dot(color.rgb, weights.yzx)\n  );\n\n  // saturation adjustment\n  float average = (color.r + color.g + color.b) / 3.0;\n  if (hueSaturation.saturation > 0.0) {\n    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));\n  } else {\n    color.rgb += (average - color.rgb) * (-hueSaturation.saturation);\n  }\n\n  return color;\n}\n\nvec4 hueSaturation_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  return hueSaturation_filterColor(color);\n}\n";
     readonly uniformTypes: {
         readonly hue: "f32";
         readonly saturation: "f32";
     };
-    readonly uniformPropTypes: {
+    readonly propTypes: {
         readonly hue: {
             readonly value: 0;
             readonly min: -1;

package/dist/passes/postprocessing/image-adjust-filters/huesaturation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"huesaturation.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/huesaturation.ts"],"names":[],"mappings":"AAwCA;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B;iEAC6D;IAC7D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;AAEvD;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;oBACX,kBAAkB;uBACf,qBAAqB;;;;;;;;;;;;;;;;;;;;;;CAcY,CAAC"}
+{"version":3,"file":"huesaturation.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/huesaturation.ts"],"names":[],"mappings":"AAwCA;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B;iEAC6D;IAC7D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;AAEvD;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;oBACX,kBAAkB;;;;;;;;;;;;;;;;;;;;;;CAckB,CAAC"}

package/dist/passes/postprocessing/image-adjust-filters/huesaturation.js

@@ -30,7 +30,7 @@ vec4 hueSaturation_filterColor(vec4 color) {
   return color;
 }
 
-vec4 hueSaturation_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
+vec4 hueSaturation_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
   return hueSaturation_filterColor(color);
 }
 `;
@@ -45,14 +45,13 @@ vec4 hueSaturation_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
  */
 export const hueSaturation = {
     props: {},
-    uniforms: {},
     name: 'hueSaturation',
     fs,
     uniformTypes: {
         hue: 'f32',
         saturation: 'f32'
     },
-    uniformPropTypes: {
+    propTypes: {
         hue: { value: 0, min: -1, max: 1 },
         saturation: { value: 0, min: -1, max: 1 }
     },

package/dist/passes/postprocessing/image-adjust-filters/noise.d.ts

@@ -17,14 +17,14 @@ export declare const noise: {
     readonly uniformTypes: {
         readonly amount: "f32";
     };
-    readonly uniformPropTypes: {
+    readonly propTypes: {
         readonly amount: {
             readonly value: 0.5;
             readonly min: 0;
             readonly max: 1;
         };
     };
-    readonly fs: "uniform noiseUniforms {\n  float amount;\n} noise;\n\nfloat rand(vec2 co) {\n  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n\nvec4 noise_filterColor(vec4 color, vec2 texCoord) {\n  float diff = (rand(texCoord) - 0.5) * noise.amount;\n  color.r += diff;\n  color.g += diff;\n  color.b += diff;\n  return color;\n}\n\nvec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return noise_filterColor(color, texCoord);\n}\n";
+    readonly fs: "uniform noiseUniforms {\n  float amount;\n} noise;\n\nfloat rand(vec2 co) {\n  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n\nvec4 noise_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float diff = (rand(texCoord) - 0.5) * noise.amount;\n  color.r += diff;\n  color.g += diff;\n  color.b += diff;\n  return color;\n}\n";
     readonly passes: [{
         readonly filter: true;
     }];

package/dist/passes/postprocessing/image-adjust-filters/noise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"noise.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/noise.ts"],"names":[],"mappings":"AA4BA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC;AAEvC;;;GAGG;AACH,eAAO,MAAM,KAAK;oBACH,UAAU;uBACP,aAAa;;;;;;;;;;;;;;;;CAWwB,CAAC"}
+{"version":3,"file":"noise.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/noise.ts"],"names":[],"mappings":"AAwBA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC;AAEvC;;;GAGG;AACH,eAAO,MAAM,KAAK;oBACH,UAAU;uBACP,aAAa;;;;;;;;;;;;;;;;CAWwB,CAAC"}

package/dist/passes/postprocessing/image-adjust-filters/noise.js

@@ -10,17 +10,13 @@ float rand(vec2 co) {
   return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
 }
 
-vec4 noise_filterColor(vec4 color, vec2 texCoord) {
+vec4 noise_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
   float diff = (rand(texCoord) - 0.5) * noise.amount;
   color.r += diff;
   color.g += diff;
   color.b += diff;
   return color;
 }
-
-vec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
-  return noise_filterColor(color, texCoord);
-}
 `;
 /**
  * Noise
@@ -33,7 +29,7 @@ export const noise = {
     uniformTypes: {
         amount: 'f32'
     },
-    uniformPropTypes: {
+    propTypes: {
         amount: { value: 0.5, min: 0, max: 1 }
     },
     fs,

package/dist/passes/postprocessing/image-adjust-filters/sepia.d.ts

@@ -14,14 +14,14 @@ export declare const sepia: {
     readonly uniformTypes: {
         readonly amount: "f32";
     };
-    readonly uniformPropTypes: {
+    readonly propTypes: {
         readonly amount: {
             readonly value: 0.5;
             readonly min: 0;
             readonly max: 1;
         };
     };
-    readonly fs: "uniform sepiaUniforms {\n  float amount;\n} sepia;\n\nvec4 sepia_filterColor(vec4 color) {\n  float r = color.r;\n  float g = color.g;\n  float b = color.b;\n\n  color.r =\n    min(1.0, (r * (1.0 - (0.607 * sepia.amount))) + (g * (0.769 * sepia.amount)) + (b * (0.189 * sepia.amount)));\n  color.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));\n  color.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));\n\n  return color;\n}\n\nvec4 sepia_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return sepia_filterColor(color);\n}\n";
+    readonly fs: "uniform sepiaUniforms {\n  float amount;\n} sepia;\n\nvec4 sepia_filterColor(vec4 color) {\n  float r = color.r;\n  float g = color.g;\n  float b = color.b;\n\n  color.r =\n    min(1.0, (r * (1.0 - (0.607 * sepia.amount))) + (g * (0.769 * sepia.amount)) + (b * (0.189 * sepia.amount)));\n  color.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));\n  color.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));\n\n  return color;\n}\n\nvec4 sepia_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  return sepia_filterColor(color);\n}\n";
     readonly passes: [{
         readonly filter: true;
     }];

package/dist/passes/postprocessing/image-adjust-filters/sepia.js

@@ -19,7 +19,7 @@ vec4 sepia_filterColor(vec4 color) {
   return color;
 }
 
-vec4 sepia_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
+vec4 sepia_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
   return sepia_filterColor(color);
 }
 `;
@@ -35,7 +35,7 @@ export const sepia = {
     uniformTypes: {
         amount: 'f32'
     },
-    uniformPropTypes: {
+    propTypes: {
         amount: { value: 0.5, min: 0, max: 1 }
     },
     fs,

package/dist/passes/postprocessing/image-adjust-filters/vibrance.d.ts

@@ -11,14 +11,17 @@ export declare const vibrance: {
     readonly props: VibranceProps;
     readonly uniforms: VibranceUniforms;
     readonly name: "vibrance";
-    readonly uniformPropTypes: {
+    readonly uniformTypes: {
+        readonly amount: "f32";
+    };
+    readonly propTypes: {
         readonly amount: {
             readonly value: 0;
             readonly min: -1;
             readonly max: 1;
         };
     };
-    readonly fs: "uniform vibranceUniforms {\n  float amount;\n} vibrance;\n\nvec4 vibrance_filterColor(vec4 color) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  float mx = max(color.r, max(color.g, color.b));\n  float amt = (mx - average) * (-vibrance.amount * 3.0);\n  color.rgb = mix(color.rgb, vec3(mx), amt);\n  return color;\n}\n\nvec4 vibrance_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vibrance_filterColor(color);\n}\n";
+    readonly fs: "uniform vibranceUniforms {\n  float amount;\n} vibrance;\n\nvec4 vibrance_filterColor(vec4 color) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  float mx = max(color.r, max(color.g, color.b));\n  float amt = (mx - average) * (-vibrance.amount * 3.0);\n  color.rgb = mix(color.rgb, vec3(mx), amt);\n  return color;\n}\n\nvec4 vibrance_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vibrance_filterColor(color);\n}\n";
     readonly passes: [{
         readonly filter: true;
     }];

package/dist/passes/postprocessing/image-adjust-filters/vibrance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vibrance.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/vibrance.ts"],"names":[],"mappings":"AAwBA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C,qGAAqG;AACrG,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;CAO2B,CAAC"}
+{"version":3,"file":"vibrance.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/vibrance.ts"],"names":[],"mappings":"AAwBA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C,qGAAqG;AACrG,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;;;;CAU2B,CAAC"}

package/dist/passes/postprocessing/image-adjust-filters/vibrance.js

@@ -14,7 +14,7 @@ vec4 vibrance_filterColor(vec4 color) {
   return color;
 }
 
-vec4 vibrance_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
+vec4 vibrance_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
   return vibrance_filterColor(color);
 }
 `;
@@ -23,7 +23,10 @@ export const vibrance = {
     props: {},
     uniforms: {},
     name: 'vibrance',
-    uniformPropTypes: {
+    uniformTypes: {
+        amount: 'f32'
+    },
+    propTypes: {
         amount: { value: 0, min: -1, max: 1 }
     },
     fs,

package/dist/passes/postprocessing/image-adjust-filters/vignette.d.ts

@@ -20,7 +20,11 @@ export declare const vignette: {
         readonly radius: "f32";
         readonly amount: "f32";
     };
-    readonly uniformPropTypes: {
+    readonly defaultUniforms: {
+        readonly radius: 0.5;
+        readonly amount: 0.5;
+    };
+    readonly propTypes: {
         readonly radius: {
             readonly value: 0.5;
             readonly min: 0;
@@ -35,6 +39,6 @@ export declare const vignette: {
     readonly passes: [{
         readonly filter: true;
     }];
-    readonly fs: "uniform vignetteUniforms {\n  float radius;\n  float amount;\n} vignette;\n\nvec4 vignette_filterColor(vec4 color, vec2 texCoord) {\n  float dist = distance(texCoord, vec2(0.5, 0.5));\n  float ratio = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));\n  return color.rgba * ratio + (1.0 - ratio)*vec4(0.0, 0.0, 0.0, 1.0);\n}\n\nvec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vignette_filterColor(color, texCoord);\n}\n";
+    readonly fs: "uniform vignetteUniforms {\n  float radius;\n  float amount;\n} vignette;\n\nvec4 vignette_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float dist = distance(texCoord, vec2(0.5, 0.5));\n  float ratio = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));\n  return color.rgba * ratio + (1.0 - ratio)*vec4(0.0, 0.0, 0.0, 1.0);\n}\n";
 };
 //# sourceMappingURL=vignette.d.ts.map

package/dist/passes/postprocessing/image-adjust-filters/vignette.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vignette.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/vignette.ts"],"names":[],"mappings":"AAuBA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;;;;;;;;;;CAgB2B,CAAC"}
+{"version":3,"file":"vignette.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/vignette.ts"],"names":[],"mappings":"AAmBA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;CAoB2B,CAAC"}

package/dist/passes/postprocessing/image-adjust-filters/vignette.js

@@ -7,15 +7,11 @@ uniform vignetteUniforms {
   float amount;
 } vignette;
 
-vec4 vignette_filterColor(vec4 color, vec2 texCoord) {
+vec4 vignette_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
   float dist = distance(texCoord, vec2(0.5, 0.5));
   float ratio = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));
   return color.rgba * ratio + (1.0 - ratio)*vec4(0.0, 0.0, 0.0, 1.0);
 }
-
-vec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
-  return vignette_filterColor(color, texCoord);
-}
 `;
 /**
  * Vignette -
@@ -29,7 +25,11 @@ export const vignette = {
         radius: 'f32',
         amount: 'f32'
     },
-    uniformPropTypes: {
+    defaultUniforms: {
+        radius: 0.5,
+        amount: 0.5
+    },
+    propTypes: {
         radius: { value: 0.5, min: 0, max: 1 },
         amount: { value: 0.5, min: 0, max: 1 }
     },

package/dist/passes/postprocessing/image-blur-filters/tiltshift.d.ts

@@ -4,9 +4,9 @@
  */
 export type TiltShiftProps = {
     /** The x,y coordinate of the start of the line segment. */
-    start?: number[];
+    start?: [number, number];
     /** The xm y coordinate of the end of the line segment. */
-    end?: number[];
+    end?: [number, number];
     /** The maximum radius of the pyramid blur. */
     blurRadius?: number;
     /** The distance from the line at which the maximum blur radius is reached. */
@@ -41,7 +41,7 @@ export declare const tiltShift: {
         readonly end: "vec2<f32>";
         readonly invert: "i32";
     };
-    readonly uniformPropTypes: {
+    readonly propTypes: {
         readonly blurRadius: {
             readonly value: 15;
             readonly min: 0;

package/dist/passes/postprocessing/image-blur-filters/tiltshift.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tiltshift.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/tiltshift.ts"],"names":[],"mappings":"AAqDA;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,0DAA0D;IAC1D,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,8CAA8C;IAC9C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8EAA8E;IAC9E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS;oBACP,cAAc;uBACX,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuB4B,CAAC"}
+{"version":3,"file":"tiltshift.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/tiltshift.ts"],"names":[],"mappings":"AAqDA;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,2DAA2D;IAC3D,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzB,0DAA0D;IAC1D,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvB,8CAA8C;IAC9C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8EAA8E;IAC9E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS;oBACP,cAAc;uBACX,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuB4B,CAAC"}

package/dist/passes/postprocessing/image-blur-filters/tiltshift.js

@@ -70,7 +70,7 @@ export const tiltShift = {
         end: 'vec2<f32>',
         invert: 'i32'
     },
-    uniformPropTypes: {
+    propTypes: {
         blurRadius: { value: 15, min: 0, max: 50 },
         gradientRadius: { value: 200, min: 0, max: 400 },
         start: { value: [0, 0] },

package/dist/passes/postprocessing/image-blur-filters/triangleblur.d.ts

@@ -8,7 +8,7 @@ export type TriangleBlurProps = {
     /** The radius of the pyramid convolved with the image. */
     radius?: number;
     /** @deprecated internal property */
-    delta?: number[];
+    delta?: [number, number];
 };
 export type TriangleBlurUniforms = TriangleBlurProps;
 /**
@@ -25,7 +25,7 @@ export declare const triangleBlur: {
         readonly radius: "f32";
         readonly delta: "vec2<f32>";
     };
-    readonly uniformPropTypes: {
+    readonly propTypes: {
         readonly radius: {
             readonly value: 20;
             readonly min: 0;

package/dist/passes/postprocessing/image-blur-filters/triangleblur.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangleblur.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/triangleblur.ts"],"names":[],"mappings":"AA2CA;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,YAAY;oBACV,iBAAiB;uBACd,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiB+B,CAAC"}
+{"version":3,"file":"triangleblur.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/triangleblur.ts"],"names":[],"mappings":"AA2CA;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,YAAY;oBACV,iBAAiB;uBACd,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiB+B,CAAC"}

package/dist/passes/postprocessing/image-blur-filters/triangleblur.js

@@ -51,7 +51,7 @@ export const triangleBlur = {
         radius: 'f32',
         delta: 'vec2<f32>'
     },
-    uniformPropTypes: {
+    propTypes: {
         radius: { value: 20, min: 0, softMax: 100 },
         delta: { value: [1, 0], private: true }
     },

package/dist/passes/postprocessing/image-blur-filters/zoomblur.d.ts

@@ -3,7 +3,7 @@
  */
 export type ZoomBlurProps = {
     /** - The x, y coordinate of the blur origin. */
-    center?: number[];
+    center?: [number, number];
     /** - The strength of the blur. Values in the range 0 to 1 are usually sufficient, where 0 doesn't change the image and 1 creates a highly blurred image. */
     strength?: number;
 };
@@ -20,7 +20,7 @@ export declare const zoomBlur: {
         readonly center: "vec2<f32>";
         readonly strength: "f32";
     };
-    readonly uniformPropTypes: {
+    readonly propTypes: {
         readonly center: {
             readonly value: readonly [0.5, 0.5];
         };

package/dist/passes/postprocessing/image-blur-filters/zoomblur.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zoomblur.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/zoomblur.ts"],"names":[],"mappings":"AA0CA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,4JAA4J;IAC5J,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;CAc2B,CAAC"}
+{"version":3,"file":"zoomblur.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/zoomblur.ts"],"names":[],"mappings":"AA0CA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,gDAAgD;IAChD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,4JAA4J;IAC5J,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;CAc2B,CAAC"}

package/dist/passes/postprocessing/image-blur-filters/zoomblur.js

@@ -48,7 +48,7 @@ export const zoomBlur = {
         center: 'vec2<f32>',
         strength: 'f32'
     },
-    uniformPropTypes: {
+    propTypes: {
         center: { value: [0.5, 0.5] },
         strength: { value: 0.3, min: 0, softMax: 1 }
     },

package/dist/passes/postprocessing/image-fun-filters/colorhalftone.d.ts

@@ -6,7 +6,7 @@
  */
 export type ColorHalftoneProps = {
     /** The x,y coordinate of the pattern origin. */
-    center?: number[];
+    center?: [number, number];
     /** The rotation of the pattern in radians. */
     angle?: number;
     /** The diameter of a dot in pixels. */
@@ -28,7 +28,7 @@ export declare const colorHalftone: {
         readonly angle: "f32";
         readonly size: "f32";
     };
-    readonly uniformPropTypes: {
+    readonly propTypes: {
         readonly center: {
             readonly value: readonly [0.5, 0.5];
         };
@@ -44,7 +44,7 @@ export declare const colorHalftone: {
             readonly softMax: 20;
         };
     };
-    readonly fs: "uniform colorHalftoneUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} colorHalftone;\n\nfloat pattern(float angle, float scale, vec2 texSize, vec2 texCoord) {\n  float s = sin(angle), c = cos(angle);\n  vec2 tex = texCoord * texSize - colorHalftone.center * texSize;\n  vec2 point = vec2(\n\tc * tex.x - s * tex.y,\n\ts * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  float scale = 3.1514 / colorHalftone.size;\n  vec3 cmy = 1.0 - color.rgb;\n  float k = min(cmy.x, min(cmy.y, cmy.z));\n\n  cmy = (cmy - k) / (1.0 - k);\n  cmy = clamp(\n\t  cmy * 10.0 - 3.0 + vec3(\n      pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),\n\t    pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),\n      pattern(colorHalftone.angle, scale, texSize, texCoord)\n    ),\n\t  0.0,\n\t  1.0\n  );\n  k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);\n  return vec4(1.0 - cmy - k, color.a);\n}\n";
+    readonly fs: "uniform colorHalftoneUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} colorHalftone;\n\nfloat pattern(float angle, float scale, vec2 texSize, vec2 texCoord) {\n  float s = sin(angle), c = cos(angle);\n  vec2 tex = texCoord * texSize - colorHalftone.center * texSize;\n  vec2 point = vec2(\n\tc * tex.x - s * tex.y,\n\ts * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 colorHalftone_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float scale = 3.1514 / colorHalftone.size;\n  vec3 cmy = 1.0 - color.rgb;\n  float k = min(cmy.x, min(cmy.y, cmy.z));\n\n  cmy = (cmy - k) / (1.0 - k);\n  cmy = clamp(\n\t  cmy * 10.0 - 3.0 + vec3(\n      pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),\n\t    pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),\n      pattern(colorHalftone.angle, scale, texSize, texCoord)\n    ),\n\t  0.0,\n\t  1.0\n  );\n  k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);\n  return vec4(1.0 - cmy - k, color.a);\n}\n";
     readonly passes: [{
         readonly filter: true;
     }];

package/dist/passes/postprocessing/image-fun-filters/colorhalftone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"colorhalftone.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/colorhalftone.ts"],"names":[],"mappings":"AA4CA;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,aAAa;oBACX,kBAAkB;uBACf,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAegC,CAAC"}
+{"version":3,"file":"colorhalftone.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/colorhalftone.ts"],"names":[],"mappings":"AA4CA;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gDAAgD;IAChD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,aAAa;oBACX,kBAAkB;uBACf,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAegC,CAAC"}

package/dist/passes/postprocessing/image-fun-filters/colorhalftone.js

@@ -19,7 +19,7 @@ float pattern(float angle, float scale, vec2 texSize, vec2 texCoord) {
   return (sin(point.x) * sin(point.y)) * 4.0;
 }
 
-vec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
+vec4 colorHalftone_filterColor_ext(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));
@@ -53,7 +53,7 @@ export const colorHalftone = {
         angle: 'f32',
         size: 'f32'
     },
-    uniformPropTypes: {
+    propTypes: {
         center: { value: [0.5, 0.5] },
         angle: { value: 1.1, softMin: 0, softMax: Math.PI / 2 },
         size: { value: 4, min: 1, softMin: 3, softMax: 20 }

package/dist/passes/postprocessing/image-fun-filters/dotscreen.d.ts

@@ -5,7 +5,7 @@
  */
 export type DotScreenProps = {
     /** The x, y coordinate of the pattern origin. */
-    center?: number[];
+    center?: [number, number];
     /** The rotation of the pattern in radians. */
     angle?: number;
     /** The diameter of a dot in pixels. */
@@ -26,7 +26,7 @@ export declare const dotScreen: {
         readonly angle: "f32";
         readonly size: "f32";
     };
-    readonly uniformPropTypes: {
+    readonly propTypes: {
         readonly center: {
             readonly value: readonly [0.5, 0.5];
         };
@@ -42,7 +42,7 @@ export declare const dotScreen: {
             readonly softMax: 20;
         };
     };
-    readonly fs: "uniform dotScreenUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} dotScreen;\n\nfloat pattern(vec2 texSize, vec2 texCoord) {\n  float scale = 3.1415 / dotScreen.size;\n\n  float s = sin(dotScreen.angle), c = cos(dotScreen.angle);\n  vec2 tex = texCoord * texSize - dotScreen.center * texSize;\n  vec2 point = vec2(\n    c * tex.x - s * tex.y,\n    s * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);\n}\n";
+    readonly fs: "uniform dotScreenUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} dotScreen;\n\nfloat pattern(vec2 texSize, vec2 texCoord) {\n  float scale = 3.1415 / dotScreen.size;\n\n  float s = sin(dotScreen.angle), c = cos(dotScreen.angle);\n  vec2 tex = texCoord * texSize - dotScreen.center * texSize;\n  vec2 point = vec2(\n    c * tex.x - s * tex.y,\n    s * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 dotScreen_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);\n}\n";
     readonly passes: [{
         readonly filter: true;
     }];

package/dist/passes/postprocessing/image-fun-filters/dotscreen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dotscreen.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/dotscreen.ts"],"names":[],"mappings":"AA+BA;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,SAAS;oBACP,cAAc;uBACX,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe4B,CAAC"}
+{"version":3,"file":"dotscreen.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/dotscreen.ts"],"names":[],"mappings":"AA+BA;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,iDAAiD;IACjD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,SAAS;oBACP,cAAc;uBACX,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe4B,CAAC"}

package/dist/passes/postprocessing/image-fun-filters/dotscreen.js

@@ -20,7 +20,7 @@ float pattern(vec2 texSize, vec2 texCoord) {
   return (sin(point.x) * sin(point.y)) * 4.0;
 }
 
-vec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
+vec4 dotScreen_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
   float average = (color.r + color.g + color.b) / 3.0;
   return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);
 }
@@ -39,7 +39,7 @@ export const dotScreen = {
         angle: 'f32',
         size: 'f32'
     },
-    uniformPropTypes: {
+    propTypes: {
         center: { value: [0.5, 0.5] },
         angle: { value: 1.1, softMin: 0, softMax: Math.PI / 2 },
         size: { value: 3, min: 1, softMin: 3, softMax: 20 }

package/dist/passes/postprocessing/image-fun-filters/edgework.d.ts

@@ -6,8 +6,8 @@
 export type EdgeWorkProps = {
     /** radius The radius of the effect in pixels. */
     radius?: number;
-    /** @deprecated internal */
-    delta?: number;
+    /** @deprecated xy or RGB */
+    mode?: 0 | 1;
 };
 export type EdgeWorkUniforms = EdgeWorkProps;
 /**
@@ -23,27 +23,31 @@ export declare const edgeWork: {
         readonly name: "random";
         readonly fs: "float random(vec3 scale, float seed) {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n";
     }];
-    readonly fs: "uniform edgeWorkUniforms {\n  float radius;\n  vec2 delta;\n} edgeWork;\n\nvec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;\n    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;\n    color.x += average * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += average * weight;\n      total.y += weight;\n    }\n  }\n  return vec4(color / total, 0.0, 1.0);\n}\n\nvec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec2 sampleColor = texture(source, texCoord + relativeDelta * percent).xy;\n    color.x += sampleColor.x * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += sampleColor.y * weight;\n      total.y += weight;\n    }\n  }\n  float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);\n  return vec4(c, c, c, 1.0);\n}\n";
-    readonly uniformPropTypes: {
+    readonly fs: "uniform edgeWorkUniforms {\n  float radius;\n  int mode;\n} edgeWork;\n\nvec4 edgeWork_sampleColorRGB(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {\n  vec2 relativeDelta = edgeWork.radius * delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;\n    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;\n    color.x += average * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += average * weight;\n      total.y += weight;\n    }\n  }\n  return vec4(color / total, 0.0, 1.0);\n}\n\nvec4 edgeWork_sampleColorXY(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {\n  vec2 relativeDelta = edgeWork.radius * delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec2 sampleColor = texture(source, texCoord + relativeDelta * percent).xy;\n    color.x += sampleColor.x * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += sampleColor.y * weight;\n      total.y += weight;\n    }\n  }\n  float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);\n  return vec4(c, c, c, 1.0);\n}\n\nvec4 edgeWork_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  switch (edgeWork.mode) {\n    case 0: \n    return edgeWork_sampleColorRGB(source, texSize, texCoord, vec2(1., 0.));\n    case 1: \n    default:\n      return edgeWork_sampleColorXY(source, texSize, texCoord, vec2(0., 1.));\n  }\n}\n";
+    readonly uniformTypes: {
+        readonly radius: "f32";
+        readonly mode: "i32";
+    };
+    readonly propTypes: {
         readonly radius: {
             readonly value: 2;
             readonly min: 1;
             readonly softMax: 50;
         };
-        readonly delta: {
-            readonly value: readonly [1, 0];
+        readonly mode: {
+            readonly value: 0;
             readonly private: true;
         };
     };
     readonly passes: [{
-        readonly sampler: "edgeWork_sampleColor1";
-        readonly uniformPropTypes: {
-            readonly delta: readonly [1, 0];
+        readonly sampler: true;
+        readonly uniforms: {
+            readonly mode: 0;
         };
     }, {
-        readonly sampler: "edgeWork_sampleColor2";
-        readonly uniformPropTypes: {
-            readonly delta: readonly [0, 1];
+        readonly sampler: true;
+        readonly uniforms: {
+            readonly mode: 1;
         };
     }];
 };

package/dist/passes/postprocessing/image-fun-filters/edgework.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edgework.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/edgework.ts"],"names":[],"mappings":"AAgEA;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;;GAIG;AACH,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuB8B,CAAC"}
+{"version":3,"file":"edgework.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/edgework.ts"],"names":[],"mappings":"AA0EA;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4BAA4B;IAC5B,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;;GAIG;AACH,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwB8B,CAAC"}

package/dist/passes/postprocessing/image-fun-filters/edgework.js

@@ -5,11 +5,11 @@ import { random } from "../../../modules/math/random/random.js";
 const fs = /* glsl */ `\
 uniform edgeWorkUniforms {
   float radius;
-  vec2 delta;
+  int mode;
 } edgeWork;
 
-vec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {
-  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;
+vec4 edgeWork_sampleColorRGB(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {
+  vec2 relativeDelta = edgeWork.radius * delta / texSize;
 
   vec2 color = vec2(0.0);
   vec2 total = vec2(0.0);
@@ -33,8 +33,8 @@ vec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {
   return vec4(color / total, 0.0, 1.0);
 }
 
-vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
-  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;
+vec4 edgeWork_sampleColorXY(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {
+  vec2 relativeDelta = edgeWork.radius * delta / texSize;
 
   vec2 color = vec2(0.0);
   vec2 total = vec2(0.0);
@@ -57,6 +57,16 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
   float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);
   return vec4(c, c, c, 1.0);
 }
+
+vec4 edgeWork_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  switch (edgeWork.mode) {
+    case 0: 
+    return edgeWork_sampleColorRGB(source, texSize, texCoord, vec2(1., 0.));
+    case 1: 
+    default:
+      return edgeWork_sampleColorXY(source, texSize, texCoord, vec2(0., 1.));
+  }
+}
 `;
 /**
  * Edge Work -
@@ -69,20 +79,22 @@ export const edgeWork = {
     name: 'edgeWork',
     dependencies: [random],
     fs,
-    uniformPropTypes: {
+    uniformTypes: {
+        radius: 'f32',
+        mode: 'i32'
+    },
+    propTypes: {
         radius: { value: 2, min: 1, softMax: 50 },
-        delta: { value: [1, 0], private: true }
+        mode: { value: 0, private: true }
     },
     passes: [
         {
-            // @ts-expect-error
-            sampler: 'edgeWork_sampleColor1',
-            uniformPropTypes: { delta: [1, 0] }
+            sampler: true,
+            uniforms: { mode: 0 }
         },
         {
-            // @ts-expect-error
-            sampler: 'edgeWork_sampleColor2',
-            uniformPropTypes: { delta: [0, 1] }
+            sampler: true,
+            uniforms: { mode: 1 }
         }
     ]
 };