fabric 5.3.0 → 6.0.0-beta3

package/src/filters/shaders/convolute.ts

@@ -0,0 +1,154 @@
+export const fragmentSource = {
+  Convolute_3_1: `
+    precision highp float;
+    uniform sampler2D uTexture;
+    uniform float uMatrix[9];
+    uniform float uStepW;
+    uniform float uStepH;
+    varying vec2 vTexCoord;
+    void main() {
+      vec4 color = vec4(0, 0, 0, 0);
+      for (float h = 0.0; h < 3.0; h+=1.0) {
+        for (float w = 0.0; w < 3.0; w+=1.0) {
+          vec2 matrixPos = vec2(uStepW * (w - 1), uStepH * (h - 1));
+          color += texture2D(uTexture, vTexCoord + matrixPos) * uMatrix[int(h * 3.0 + w)];
+        }
+      }
+      gl_FragColor = color;
+    }
+    `,
+  Convolute_3_0: `
+    precision highp float;
+    uniform sampler2D uTexture;
+    uniform float uMatrix[9];
+    uniform float uStepW;
+    uniform float uStepH;
+    varying vec2 vTexCoord;
+    void main() {
+      vec4 color = vec4(0, 0, 0, 1);
+      for (float h = 0.0; h < 3.0; h+=1.0) {
+        for (float w = 0.0; w < 3.0; w+=1.0) {
+          vec2 matrixPos = vec2(uStepW * (w - 1.0), uStepH * (h - 1.0));
+          color.rgb += texture2D(uTexture, vTexCoord + matrixPos).rgb * uMatrix[int(h * 3.0 + w)];
+        }
+      }
+      float alpha = texture2D(uTexture, vTexCoord).a;
+      gl_FragColor = color;
+      gl_FragColor.a = alpha;
+    }
+    `,
+  Convolute_5_1: `
+    precision highp float;
+    uniform sampler2D uTexture;
+    uniform float uMatrix[25];
+    uniform float uStepW;
+    uniform float uStepH;
+    varying vec2 vTexCoord;
+    void main() {
+      vec4 color = vec4(0, 0, 0, 0);
+      for (float h = 0.0; h < 5.0; h+=1.0) {
+        for (float w = 0.0; w < 5.0; w+=1.0) {
+          vec2 matrixPos = vec2(uStepW * (w - 2.0), uStepH * (h - 2.0));
+          color += texture2D(uTexture, vTexCoord + matrixPos) * uMatrix[int(h * 5.0 + w)];
+        }
+      }
+      gl_FragColor = color;
+    }
+    `,
+  Convolute_5_0: `
+    precision highp float;
+    uniform sampler2D uTexture;
+    uniform float uMatrix[25];
+    uniform float uStepW;
+    uniform float uStepH;
+    varying vec2 vTexCoord;
+    void main() {
+      vec4 color = vec4(0, 0, 0, 1);
+      for (float h = 0.0; h < 5.0; h+=1.0) {
+        for (float w = 0.0; w < 5.0; w+=1.0) {
+          vec2 matrixPos = vec2(uStepW * (w - 2.0), uStepH * (h - 2.0));
+          color.rgb += texture2D(uTexture, vTexCoord + matrixPos).rgb * uMatrix[int(h * 5.0 + w)];
+        }
+      }
+      float alpha = texture2D(uTexture, vTexCoord).a;
+      gl_FragColor = color;
+      gl_FragColor.a = alpha;
+    }
+    `,
+  Convolute_7_1: `
+    precision highp float;
+    uniform sampler2D uTexture;
+    uniform float uMatrix[49];
+    uniform float uStepW;
+    uniform float uStepH;
+    varying vec2 vTexCoord;
+    void main() {
+      vec4 color = vec4(0, 0, 0, 0);
+      for (float h = 0.0; h < 7.0; h+=1.0) {
+        for (float w = 0.0; w < 7.0; w+=1.0) {
+          vec2 matrixPos = vec2(uStepW * (w - 3.0), uStepH * (h - 3.0));
+          color += texture2D(uTexture, vTexCoord + matrixPos) * uMatrix[int(h * 7.0 + w)];
+        }
+      }
+      gl_FragColor = color;
+    }
+    `,
+  Convolute_7_0: `
+    precision highp float;
+    uniform sampler2D uTexture;
+    uniform float uMatrix[49];
+    uniform float uStepW;
+    uniform float uStepH;
+    varying vec2 vTexCoord;
+    void main() {
+      vec4 color = vec4(0, 0, 0, 1);
+      for (float h = 0.0; h < 7.0; h+=1.0) {
+        for (float w = 0.0; w < 7.0; w+=1.0) {
+          vec2 matrixPos = vec2(uStepW * (w - 3.0), uStepH * (h - 3.0));
+          color.rgb += texture2D(uTexture, vTexCoord + matrixPos).rgb * uMatrix[int(h * 7.0 + w)];
+        }
+      }
+      float alpha = texture2D(uTexture, vTexCoord).a;
+      gl_FragColor = color;
+      gl_FragColor.a = alpha;
+    }
+    `,
+  Convolute_9_1: `
+    precision highp float;
+    uniform sampler2D uTexture;
+    uniform float uMatrix[81];
+    uniform float uStepW;
+    uniform float uStepH;
+    varying vec2 vTexCoord;
+    void main() {
+      vec4 color = vec4(0, 0, 0, 0);
+      for (float h = 0.0; h < 9.0; h+=1.0) {
+        for (float w = 0.0; w < 9.0; w+=1.0) {
+          vec2 matrixPos = vec2(uStepW * (w - 4.0), uStepH * (h - 4.0));
+          color += texture2D(uTexture, vTexCoord + matrixPos) * uMatrix[int(h * 9.0 + w)];
+        }
+      }
+      gl_FragColor = color;
+    }
+    `,
+  Convolute_9_0: `
+    precision highp float;
+    uniform sampler2D uTexture;
+    uniform float uMatrix[81];
+    uniform float uStepW;
+    uniform float uStepH;
+    varying vec2 vTexCoord;
+    void main() {
+      vec4 color = vec4(0, 0, 0, 1);
+      for (float h = 0.0; h < 9.0; h+=1.0) {
+        for (float w = 0.0; w < 9.0; w+=1.0) {
+          vec2 matrixPos = vec2(uStepW * (w - 4.0), uStepH * (h - 4.0));
+          color.rgb += texture2D(uTexture, vTexCoord + matrixPos).rgb * uMatrix[int(h * 9.0 + w)];
+        }
+      }
+      float alpha = texture2D(uTexture, vTexCoord).a;
+      gl_FragColor = color;
+      gl_FragColor.a = alpha;
+    }
+    `,
+};

package/src/filters/shaders/gamma.ts

@@ -0,0 +1,15 @@
+export const fragmentSource = `
+  precision highp float;
+  uniform sampler2D uTexture;
+  uniform vec3 uGamma;
+  varying vec2 vTexCoord;
+  void main() {
+    vec4 color = texture2D(uTexture, vTexCoord);
+    vec3 correction = (1.0 / uGamma);
+    color.r = pow(color.r, correction.r);
+    color.g = pow(color.g, correction.g);
+    color.b = pow(color.b, correction.b);
+    gl_FragColor = color;
+    gl_FragColor.rgb *= color.a;
+  }
+`;

package/src/filters/shaders/grayscale.ts

@@ -0,0 +1,36 @@
+import { TGrayscaleMode } from '../Grayscale';
+
+export const fragmentSource: Record<TGrayscaleMode, string> = {
+  average: `
+    precision highp float;
+    uniform sampler2D uTexture;
+    varying vec2 vTexCoord;
+    void main() {
+      vec4 color = texture2D(uTexture, vTexCoord);
+      float average = (color.r + color.b + color.g) / 3.0;
+      gl_FragColor = vec4(average, average, average, color.a);
+    }
+    `,
+  lightness: `
+    precision highp float;
+    uniform sampler2D uTexture;
+    uniform int uMode;
+    varying vec2 vTexCoord;
+    void main() {
+      vec4 col = texture2D(uTexture, vTexCoord);
+      float average = (max(max(col.r, col.g),col.b) + min(min(col.r, col.g),col.b)) / 2.0;
+      gl_FragColor = vec4(average, average, average, col.a);
+    }
+    `,
+  luminosity: `
+    precision highp float;
+    uniform sampler2D uTexture;
+    uniform int uMode;
+    varying vec2 vTexCoord;
+    void main() {
+      vec4 col = texture2D(uTexture, vTexCoord);
+      float average = 0.21 * col.r + 0.72 * col.g + 0.07 * col.b;
+      gl_FragColor = vec4(average, average, average, col.a);
+    }
+    `,
+};

package/src/filters/shaders/invert.ts

@@ -0,0 +1,19 @@
+export const fragmentSource = `
+  precision highp float;
+  uniform sampler2D uTexture;
+  uniform int uInvert;
+  uniform int uAlpha;
+  varying vec2 vTexCoord;
+  void main() {
+    vec4 color = texture2D(uTexture, vTexCoord);
+    if (uInvert == 1) {
+      if (uAlpha == 1) {
+        gl_FragColor = vec4(1.0 - color.r,1.0 -color.g,1.0 -color.b,1.0 -color.a);
+      } else {
+        gl_FragColor = vec4(1.0 - color.r,1.0 -color.g,1.0 -color.b,color.a);
+      }
+    } else {
+      gl_FragColor = color;
+    }
+  }
+`;

package/src/filters/shaders/noise.ts

@@ -0,0 +1,16 @@
+export const fragmentSource = `
+  precision highp float;
+  uniform sampler2D uTexture;
+  uniform float uStepH;
+  uniform float uNoise;
+  uniform float uSeed;
+  varying vec2 vTexCoord;
+  float rand(vec2 co, float seed, float vScale) {
+    return fract(sin(dot(co.xy * vScale ,vec2(12.9898 , 78.233))) * 43758.5453 * (seed + 0.01) / 2.0);
+  }
+  void main() {
+    vec4 color = texture2D(uTexture, vTexCoord);
+    color.rgb += (0.5 - rand(vTexCoord, uSeed, 0.1 / uStepH)) * uNoise;
+    gl_FragColor = color;
+  }
+`;

package/src/filters/shaders/pixelate.ts

@@ -0,0 +1,19 @@
+export const fragmentSource = `
+  precision highp float;
+  uniform sampler2D uTexture;
+  uniform float uBlocksize;
+  uniform float uStepW;
+  uniform float uStepH;
+  varying vec2 vTexCoord;
+  void main() {
+    float blockW = uBlocksize * uStepW;
+    float blockH = uBlocksize * uStepW;
+    int posX = int(vTexCoord.x / blockW);
+    int posY = int(vTexCoord.y / blockH);
+    float fposX = float(posX);
+    float fposY = float(posY);
+    vec2 squareCoords = vec2(fposX * blockW, fposY * blockH);
+    vec4 color = texture2D(uTexture, squareCoords);
+    gl_FragColor = color;
+  }
+`;

package/src/filters/shaders/removeColor.ts

@@ -0,0 +1,13 @@
+export const fragmentShader = `
+precision highp float;
+uniform sampler2D uTexture;
+uniform vec4 uLow;
+uniform vec4 uHigh;
+varying vec2 vTexCoord;
+void main() {
+  gl_FragColor = texture2D(uTexture, vTexCoord);
+  if(all(greaterThan(gl_FragColor.rgb,uLow.rgb)) && all(greaterThan(uHigh.rgb,gl_FragColor.rgb))) {
+    gl_FragColor.a = 0.0;
+  }
+}
+`;

package/src/filters/shaders/saturation.ts

@@ -0,0 +1,15 @@
+export const fragmentSource = `
+  precision highp float;
+  uniform sampler2D uTexture;
+  uniform float uSaturation;
+  varying vec2 vTexCoord;
+  void main() {
+    vec4 color = texture2D(uTexture, vTexCoord);
+    float rgMax = max(color.r, color.g);
+    float rgbMax = max(rgMax, color.b);
+    color.r += rgbMax != color.r ? (rgbMax - color.r) * uSaturation : 0.00;
+    color.g += rgbMax != color.g ? (rgbMax - color.g) * uSaturation : 0.00;
+    color.b += rgbMax != color.b ? (rgbMax - color.b) * uSaturation : 0.00;
+    gl_FragColor = color;
+  }
+`;

package/src/filters/shaders/vibrance.ts

@@ -0,0 +1,16 @@
+export const fragmentSource = `
+  precision highp float;
+  uniform sampler2D uTexture;
+  uniform float uVibrance;
+  varying vec2 vTexCoord;
+  void main() {
+    vec4 color = texture2D(uTexture, vTexCoord);
+    float max = max(color.r, max(color.g, color.b));
+    float avg = (color.r + color.g + color.b) / 3.0;
+    float amt = (abs(max - avg) * 2.0) * uVibrance;
+    color.r += max != color.r ? (max - color.r) * amt : 0.00;
+    color.g += max != color.g ? (max - color.g) * amt : 0.00;
+    color.b += max != color.b ? (max - color.b) * amt : 0.00;
+    gl_FragColor = color;
+  }
+`;

package/src/filters/typedefs.ts

@@ -0,0 +1,65 @@
+import type { WebGLFilterBackend } from './WebGLFilterBackend';
+import type { Canvas2dFilterBackend } from './Canvas2dFilterBackend';
+
+export type TProgramCache = any;
+
+export type TTextureCache = any;
+
+export type TPipelineResources = {
+  blendImage?: HTMLCanvasElement;
+  blurLayer1?: HTMLCanvasElement;
+  blurLayer2?: HTMLCanvasElement;
+} & Record<string, unknown>;
+
+export type TWebGLPipelineState = {
+  filterBackend: WebGLFilterBackend;
+  originalWidth: number;
+  originalHeight: number;
+  sourceWidth: number;
+  sourceHeight: number;
+  destinationWidth: number;
+  destinationHeight: number;
+  context: WebGLRenderingContext;
+  sourceTexture: WebGLTexture | null;
+  targetTexture: WebGLTexture | null;
+  originalTexture: WebGLTexture;
+  passes: number;
+  webgl: boolean;
+  aPosition: Float32Array;
+  programCache: TProgramCache;
+  pass: number;
+  targetCanvas: HTMLCanvasElement;
+};
+
+export type T2DPipelineState = {
+  sourceWidth: number;
+  sourceHeight: number;
+  filterBackend: Canvas2dFilterBackend;
+  canvasEl: HTMLCanvasElement;
+  imageData: ImageData;
+  originalEl: CanvasImageSource;
+  originalImageData?: ImageData;
+  ctx: CanvasRenderingContext2D;
+  helpLayer?: HTMLCanvasElement;
+};
+
+export type TWebGLUniformLocationMap = Record<
+  string,
+  WebGLUniformLocation | null
+>;
+
+export type TWebGLAttributeLocationMap = Record<string, number>;
+
+export type TWebGLProgramCacheItem = {
+  program: WebGLProgram;
+  attributeLocations: TWebGLAttributeLocationMap;
+  uniformLocations: TWebGLUniformLocationMap;
+};
+
+export type TApplyFilterArgs = {};
+
+export const isWebGLPipelineState = (
+  options: TWebGLPipelineState | T2DPipelineState
+): options is TWebGLPipelineState => {
+  return (options as TWebGLPipelineState).webgl !== undefined;
+};