@luma.gl/shadertools 9.1.0-alpha.16 → 9.1.0-alpha.18

package/dist/modules/lighting/phong-material/phong-shaders-glsl.d.ts

@@ -1,42 +1,3 @@
 export declare const PHONG_VS = "uniform phongMaterialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n";
-export declare const PHONG_FS = "uniform phongMaterialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n  vec3 halfway_direction = normalize(light_direction + view_direction);\n  float lambertian = dot(light_direction, normal_worldspace);\n  float specular = 0.0;\n  if (lambertian > 0.0) {\n    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n    specular = pow(specular_angle, material.shininess);\n  }\n  lambertian = max(lambertian, 0.0);\n  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = surfaceColor;\n\n  if (lighting.enabled == 0) {\n    return lightColor;\n  }\n\n  vec3 view_direction = normalize(cameraPosition - position_worldspace);\n  lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n  if (lighting.lightType == 0) {\n    PointLight pointLight = lighting_getPointLight(0);\n    vec3 light_position_worldspace = pointLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n  } else if (lighting.lightType == 1) {\n    DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  \n  /*\n  for (int i = 0; i < MAX_LIGHTS; i++) {\n    if (i >= lighting.pointLightCount) {\n      break;\n    }\n    PointLight pointLight = lighting.pointLight[i];\n    vec3 light_position_worldspace = pointLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n  }\n\n  for (int i = 0; i < MAX_LIGHTS; i++) {\n    if (i >= lighting.directionalLightCount) {\n      break;\n    }\n    DirectionalLight directionalLight = lighting.directionalLight[i];\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  */\n  return lightColor;\n}\n\nvec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = vec3(0, 0, 0);\n  vec3 surfaceColor = vec3(0, 0, 0);\n\n  if (lighting.enabled == 0) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n\n    switch (lighting.lightType) {\n      case 0:\n        PointLight pointLight = lighting_getPointLight(0);\n        vec3 light_position_worldspace = pointLight.position;\n        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n        break;\n\n      case 1:\n        DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n        break;\n    }\n  }\n  return lightColor;\n}\n";
-/**
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.pointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getPointLight(i);
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.directionalLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getDirectionalLight(i);
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-  }
-    /**
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.pointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getPointLight(i);
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.directionalLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getDirectionalLight(i);
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-  }
-  */
+export declare const PHONG_FS = "uniform phongMaterialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n  vec3 halfway_direction = normalize(light_direction + view_direction);\n  float lambertian = dot(light_direction, normal_worldspace);\n  float specular = 0.0;\n  if (lambertian > 0.0) {\n    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n    specular = pow(specular_angle, material.shininess);\n  }\n  lambertian = max(lambertian, 0.0);\n  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = surfaceColor;\n\n  if (lighting.enabled == 0) {\n    return lightColor;\n  }\n\n  vec3 view_direction = normalize(cameraPosition - position_worldspace);\n  lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n  for (int i = 0; i < lighting.pointLightCount; i++) {\n    PointLight pointLight = lighting_getPointLight(i);\n    vec3 light_position_worldspace = pointLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);\n  }\n\n  int totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);\n  for (int i = lighting.pointLightCount; i < totalLights; i++) {\n    DirectionalLight directionalLight = lighting_getDirectionalLight(i);\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  \n  return lightColor;\n}\n";
 //# sourceMappingURL=phong-shaders-glsl.d.ts.map

package/dist/modules/lighting/phong-material/phong-shaders-glsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"phong-shaders-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-shaders-glsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ,mKAOpB,CAAC;AAEF,eAAO,MAAM,QAAQ,ogHAqFpB,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsCI"}
+{"version":3,"file":"phong-shaders-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-shaders-glsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ,mKAOpB,CAAC;AAEF,eAAO,MAAM,QAAQ,gjEA8CpB,CAAC"}

package/dist/modules/lighting/phong-material/phong-shaders-glsl.js

@@ -39,99 +39,20 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positio
   vec3 view_direction = normalize(cameraPosition - position_worldspace);
   lightColor = material.ambient * surfaceColor * lighting.ambientColor;
 
-  if (lighting.lightType == 0) {
-    PointLight pointLight = lighting_getPointLight(0);
+  for (int i = 0; i < lighting.pointLightCount; i++) {
+    PointLight pointLight = lighting_getPointLight(i);
     vec3 light_position_worldspace = pointLight.position;
     vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-  } else if (lighting.lightType == 1) {
-    DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-  }
-  
-  /*
-  for (int i = 0; i < MAX_LIGHTS; i++) {
-    if (i >= lighting.pointLightCount) {
-      break;
-    }
-    PointLight pointLight = lighting.pointLight[i];
-    vec3 light_position_worldspace = pointLight.position;
-    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);
   }
 
-  for (int i = 0; i < MAX_LIGHTS; i++) {
-    if (i >= lighting.directionalLightCount) {
-      break;
-    }
-    DirectionalLight directionalLight = lighting.directionalLight[i];
+  int totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
+  for (int i = lighting.pointLightCount; i < totalLights; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
     lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
   }
-  */
-  return lightColor;
-}
-
-vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-  vec3 lightColor = vec3(0, 0, 0);
-  vec3 surfaceColor = vec3(0, 0, 0);
-
-  if (lighting.enabled == 0) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
-
-    switch (lighting.lightType) {
-      case 0:
-        PointLight pointLight = lighting_getPointLight(0);
-        vec3 light_position_worldspace = pointLight.position;
-        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-        break;
-
-      case 1:
-        DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-        break;
-    }
-  }
+  
   return lightColor;
 }
 `;
-// TODO - handle multiple lights
-/**
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.pointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getPointLight(i);
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.directionalLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getDirectionalLight(i);
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-  }
-    /**
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.pointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getPointLight(i);
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.directionalLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getDirectionalLight(i);
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-  }
-  */

package/dist/modules-webgl1/project/project.d.ts

@@ -1,8 +1,10 @@
+import { Vector3, Matrix4 } from '@math.gl/core';
+import type { NumberArray3, NumberArray16 } from '@math.gl/core';
 type ProjectionProps = {
-    modelMatrix?: readonly number[];
-    viewMatrix?: readonly number[];
-    projectionMatrix?: readonly number[];
-    cameraPositionWorld?: readonly number[];
+    modelMatrix?: Readonly<Matrix4 | NumberArray16>;
+    viewMatrix?: Readonly<Matrix4 | NumberArray16>;
+    projectionMatrix?: Readonly<Matrix4 | NumberArray16>;
+    cameraPositionWorld?: Readonly<Vector3 | NumberArray3>;
 };
 declare function getUniforms(opts?: ProjectionProps, prevUniforms?: {}): Record<string, any>;
 /**

package/dist/modules-webgl1/project/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../src/modules-webgl1/project/project.ts"],"names":[],"mappings":"AAOA,KAAK,eAAe,GAAG;IACrB,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC,CAAC;AAWF,iBAAS,WAAW,CAAC,IAAI,GAAE,eAAwC,EAAE,YAAY,KAAK,uBA2BrF;AA2ED;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;CAK+C,CAAC"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../src/modules-webgl1/project/project.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,OAAO,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,EAAC,YAAY,EAAE,aAAa,EAAC,MAAM,eAAe,CAAC;AAE/D,KAAK,eAAe,GAAG;IACrB,WAAW,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,aAAa,CAAC,CAAC;IAChD,UAAU,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,aAAa,CAAC,CAAC;IAC/C,gBAAgB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,aAAa,CAAC,CAAC;IACrD,mBAAmB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,YAAY,CAAC,CAAC;CACxD,CAAC;AAWF,iBAAS,WAAW,CAAC,IAAI,GAAE,eAAwC,EAAE,YAAY,KAAK,uBA2BrF;AA2ED;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;CAK+C,CAAC"}

package/dist/passes/postprocessing/fxaa/fxaa.d.ts

@@ -10,6 +10,6 @@ export declare const fxaa: {
     readonly passes: [{
         readonly sampler: true;
     }];
-    readonly getUniforms: (props: any) => any;
+    readonly getUniforms: (props: Partial<FXAAProps>) => Partial<FXAAProps>;
 };
 //# sourceMappingURL=fxaa.d.ts.map

package/dist/passes/postprocessing/fxaa/fxaa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fxaa.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/fxaa/fxaa.ts"],"names":[],"mappings":"AAyqBA,MAAM,MAAM,SAAS,GAAG,EAAE,CAAC;AAC3B,MAAM,MAAM,YAAY,GAAG,EAAE,CAAC;AAE9B;;GAEG;AACH,eAAO,MAAM,IAAI;;;;;;;;CAMuC,CAAC"}
+{"version":3,"file":"fxaa.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/fxaa/fxaa.ts"],"names":[],"mappings":"AAyqBA,MAAM,MAAM,SAAS,GAAG,EAAE,CAAC;AAC3B,MAAM,MAAM,YAAY,GAAG,EAAE,CAAC;AAE9B;;GAEG;AACH,eAAO,MAAM,IAAI;;;;;;;;CAM2C,CAAC"}

package/dist/passes/postprocessing/fxaa/fxaa.js

@@ -91,7 +91,7 @@
 //  _ = the lowest digit is directly related to performance
 // _  = the highest digit is directly related to style
 //
-const fs = `
+const fs = /* glsl */ `
 #define FXAA_QUALITY_PRESET 29
 
 #if (FXAA_QUALITY_PRESET == 10)

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

@@ -11,7 +11,6 @@ export type BrightnessContrastUniforms = BrightnessContrastProps;
  */
 export declare const brightnessContrast: {
     readonly props: BrightnessContrastProps;
-    readonly uniforms: BrightnessContrastUniforms;
     readonly name: "brightnessContrast";
     readonly uniformTypes: {
         readonly brightness: "f32";

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

@@ -1 +1 @@
-{"version":3,"file":"brightnesscontrast.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/brightnesscontrast.ts"],"names":[],"mappings":"AA+CA,MAAM,MAAM,uBAAuB,GAAG;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,uBAAuB,CAAC;AAEjE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;oBAChB,uBAAuB;uBACpB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBY,CAAC"}
+{"version":3,"file":"brightnesscontrast.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/brightnesscontrast.ts"],"names":[],"mappings":"AA+CA,MAAM,MAAM,uBAAuB,GAAG;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,uBAAuB,CAAC;AAEjE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;oBAChB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBkB,CAAC"}

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

@@ -48,7 +48,6 @@ vec4 brightnessContrast_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord)
  */
 export const brightnessContrast = {
     props: {},
-    uniforms: {},
     name: 'brightnessContrast',
     uniformTypes: {
         brightness: 'f32',

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

@@ -20,7 +20,6 @@ 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_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  return hueSaturation_filterColor(color);\n}\n";
     readonly uniformTypes: {

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

@@ -45,7 +45,6 @@ vec4 hueSaturation_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
  */
 export const hueSaturation = {
     props: {},
-    uniforms: {},
     name: 'hueSaturation',
     fs,
     uniformTypes: {

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

@@ -11,6 +11,9 @@ export declare const vibrance: {
     readonly props: VibranceProps;
     readonly uniforms: VibranceUniforms;
     readonly name: "vibrance";
+    readonly uniformTypes: {
+        readonly amount: "f32";
+    };
     readonly propTypes: {
         readonly amount: {
             readonly value: 0;

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

@@ -23,6 +23,9 @@ export const vibrance = {
     props: {},
     uniforms: {},
     name: 'vibrance',
+    uniformTypes: {
+        amount: 'f32'
+    },
     propTypes: {
         amount: { value: 0, min: -1, 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. */

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/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;
 /**

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/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;
 };

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-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. */

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/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. */

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/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 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 propTypes: {
-            readonly delta: readonly [1, 0];
+        readonly sampler: true;
+        readonly uniforms: {
+            readonly mode: 0;
         };
     }, {
-        readonly sampler: "edgeWork_sampleColor2";
-        readonly propTypes: {
-            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,
+    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',
-            propTypes: { delta: [1, 0] }
+            sampler: true,
+            uniforms: { mode: 0 }
         },
         {
-            // @ts-expect-error
-            sampler: 'edgeWork_sampleColor2',
-            propTypes: { delta: [0, 1] }
+            sampler: true,
+            uniforms: { mode: 1 }
         }
     ]
 };

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

@@ -5,7 +5,7 @@
  */
 export type HexagonalPixelateProps = {
     /** The [x, y] coordinates of the pattern center. */
-    center?: number[];
+    center?: [number, number];
     /** The width of an individual tile, in pixels. */
     scale?: number;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"hexagonalpixelate.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/hexagonalpixelate.ts"],"names":[],"mappings":"AAmDA;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,oDAAoD;IACpD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,sBAAsB,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;oBACf,sBAAsB;uBACnB,yBAAyB;;;;;;;;;;;;;;;;;;;;;;CAaoC,CAAC"}
+{"version":3,"file":"hexagonalpixelate.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/hexagonalpixelate.ts"],"names":[],"mappings":"AAmDA;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,oDAAoD;IACpD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,sBAAsB,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;oBACf,sBAAsB;uBACnB,yBAAyB;;;;;;;;;;;;;;;;;;;;;;CAaoC,CAAC"}

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

@@ -3,7 +3,7 @@
  */
 export type MagnifyProps = {
     /** x, y position in screen coords, both x and y is normalized and in range `[0, 1]`. `[0, 0]` is the up left corner, `[1, 1]` is the bottom right corner. Default value is `[0, 0]`. */
-    screenXY?: number[];
+    screenXY?: [number, number];
     /** effect radius in pixels. Default value is `100`. */
     radiusPixels?: number;
     /** magnify level. Default value is `2`. */
@@ -11,7 +11,7 @@ export type MagnifyProps = {
     /** border width of the effect circle, will not show border if value <= 0.0. Default value is `0`. */
     borderWidthPixels?: number;
     /** border color of the effect circle. Default value is `[255, 255, 255, 255]`. */
-    borderColor?: number[];
+    borderColor?: [number, number, number, number];
 };
 export type MagnifyUniforms = MagnifyProps;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"magnify.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/magnify.ts"],"names":[],"mappings":"AA6BA;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,wLAAwL;IACxL,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,uDAAuD;IACvD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qGAAqG;IACrG,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC;AAE3C;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;CAmBuC,CAAC"}
+{"version":3,"file":"magnify.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/magnify.ts"],"names":[],"mappings":"AA6BA;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,wLAAwL;IACxL,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,uDAAuD;IACvD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qGAAqG;IACrG,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAChD,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC;AAE3C;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;CAmBuC,CAAC"}

package/dist/passes/postprocessing/image-warp-filters/bulgepinch.d.ts

@@ -1,7 +1,7 @@
 /** Bulges or pinches the image in a circle. */
 export type BulgePinchProps = {
     /** The [x, y] coordinates of the center of the circle of effect. */
-    center?: number[];
+    center?: [number, number];
     /** The radius of the circle of effect. */
     radius?: number;
     /** strength -1 to 1 (-1 is strong pinch, 0 is no effect, 1 is strong bulge) */

package/dist/passes/postprocessing/image-warp-filters/bulgepinch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bulgepinch.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/bulgepinch.ts"],"names":[],"mappings":"AAqCA,+CAA+C;AAC/C,MAAM,MAAM,eAAe,GAAG;IAC5B,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,UAAU;oBACR,eAAe;uBACZ,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgB6B,CAAC"}
+{"version":3,"file":"bulgepinch.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/bulgepinch.ts"],"names":[],"mappings":"AAqCA,+CAA+C;AAC/C,MAAM,MAAM,eAAe,GAAG;IAC5B,oEAAoE;IACpE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,UAAU;oBACR,eAAe;uBACZ,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgB6B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/shadertools",
-  "version": "9.1.0-alpha.16",
+  "version": "9.1.0-alpha.18",
   "description": "Shader module system for luma.gl",
   "type": "module",
   "license": "MIT",
@@ -46,12 +46,12 @@
     "prepublishOnly": "npm run build-minified-bundle && npm run build-dev-bundle"
   },
   "peerDependencies": {
-    "@luma.gl/core": "9.1.0-alpha.14"
+    "@luma.gl/core": "9.1.0-alpha.17"
   },
   "dependencies": {
     "@math.gl/core": "4.1.0-alpha.3",
     "@math.gl/types": "4.1.0-alpha.3",
     "wgsl_reflect": "^1.0.1"
   },
-  "gitHead": "39eec40d12c826548b636c057fdb8572adfe611f"
+  "gitHead": "61c927cfdc3b96eb71aa014cbeac2bfe9375c0f6"
 }