@remotion/effects 4.0.541 → 4.0.543

package/dist/esm/preview/lens-blur.mjs

@@ -0,0 +1,563 @@
+import {
+  assertOptionalFiniteNumber,
+  validateUnitInterval,
+  validateNonNegative
+} from "./index-wxhvgv2s.mjs";
+import {
+  WEBGPU_SINGLE_PASS_VERTEX,
+  setupWebGpuSinglePass,
+  cleanupWebGpuSinglePass,
+  applyWebGpuSinglePass
+} from "./index-tvfexb7s.mjs";
+import {
+  assertEffectParamsObject,
+  assertOptionalBoolean
+} from "./index-4fvp93ps.mjs";
+
+// src/lens-blur/index.ts
+import { Internals } from "remotion";
+
+// src/lens-blur/shader.ts
+var LENS_BLUR_FRAGMENT_SHADER = `#version 300 es
+precision highp float;
+
+in vec2 vUv;
+out vec4 fragColor;
+
+uniform sampler2D uSource;
+uniform vec2 uResolution;
+uniform float uRadius;
+uniform int uIrisShape;
+uniform float uIrisRoundness;
+uniform float uIrisRotation;
+uniform float uIrisAspectRatio;
+uniform float uHighlightGain;
+uniform float uHighlightThreshold;
+uniform float uHighlightSaturation;
+uniform bool uRepeatEdgePixels;
+uniform int uSamples;
+uniform bool uLinearLight;
+
+const float PI = 3.141592653589793;
+const float GOLDEN_ANGLE = 2.399963229728653;
+
+vec3 toLinear(vec3 color) {
+	return mix(color / 12.92, pow((color + 0.055) / 1.055, vec3(2.4)), step(vec3(0.04045), color));
+}
+
+vec3 toSrgb(vec3 color) {
+	return mix(color * 12.92, 1.055 * pow(max(color, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055, step(vec3(0.0031308), color));
+}
+
+vec4 readSource(vec2 uv) {
+	vec4 sampleColor = texture(uSource, uv);
+	if (sampleColor.a <= 0.0) return vec4(0.0);
+	vec3 color = sampleColor.rgb / sampleColor.a;
+	float luminance = dot(color, vec3(0.2126, 0.7152, 0.0722));
+	if (uLinearLight) color = toLinear(color);
+	if (luminance >= uHighlightThreshold) {
+		float brightest = max(color.r, max(color.g, color.b));
+		vec3 highlight = mix(vec3(brightest), color, uHighlightSaturation);
+		color += highlight * (4.0 * uHighlightGain);
+	}
+
+	float coverage = 1.0;
+	if (!uRepeatEdgePixels) {
+		// The texture clamps to its edge texels. Fade their bilinear footprint
+		// against transparent texels beyond the canvas instead of cutting it off.
+		vec2 pixel = uv * uResolution;
+		vec2 nearEdge = clamp(pixel + 0.5, 0.0, 1.0);
+		vec2 farEdge = clamp(uResolution + 0.5 - pixel, 0.0, 1.0);
+		coverage = nearEdge.x * nearEdge.y * farEdge.x * farEdge.y;
+	}
+	return vec4(color * sampleColor.a, sampleColor.a) * coverage;
+}
+
+void main() {
+	// A zero radius must be an exact identity, including with highlight gain.
+	if (uRadius == 0.0) {
+		fragColor = texture(uSource, vUv);
+		return;
+	}
+
+	vec4 sum = vec4(0.0);
+	float totalWeight = 0.0;
+	for (int i = 0; i < 2048; i++) {
+		if (i >= uSamples) break;
+		float angle = float(i) * GOLDEN_ANGLE;
+		float boundary = 1.0;
+		if (uIrisShape < 11) {
+			float halfSector = PI / float(uIrisShape);
+			float localAngle = mod(angle + PI / 2.0, 2.0 * halfSector) - halfSector;
+			float polygon = cos(halfSector) / cos(localAngle);
+			boundary = mix(polygon, 1.0, uIrisRoundness);
+		}
+		float distance = sqrt((float(i) + 0.5) / float(uSamples)) * boundary;
+		float rotatedAngle = angle + uIrisRotation;
+		vec2 offset = vec2(cos(rotatedAngle) * uIrisAspectRatio, -sin(rotatedAngle)) * distance * uRadius;
+		// Radially mapping a disc onto a polygon changes area by boundary^2.
+		// Weight by that Jacobian to keep the aperture uniformly illuminated.
+		float weight = boundary * boundary;
+		sum += readSource(vUv - offset / uResolution) * weight;
+		totalWeight += weight;
+	}
+
+	vec4 color = sum / totalWeight;
+	if (uLinearLight && color.a > 0.0) {
+		color.rgb = toSrgb(color.rgb / color.a) * color.a;
+	}
+	// Keep the result premultiplied even when highlights exceed display white.
+	fragColor = vec4(clamp(color.rgb, vec3(0.0), vec3(color.a)), color.a);
+}
+`;
+
+// src/lens-blur/webgpu-shader.ts
+var LENS_BLUR_WEBGPU_SHADER = `
+${WEBGPU_SINGLE_PASS_VERTEX}
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var sourceSampler: sampler;
+@group(0) @binding(2) var<uniform> params: Params;
+// Aperture geometry and highlight controls adapted from EffectCraft's blur2.rs (MIT).
+// See ../../THIRD_PARTY_LICENSES.md.
+struct Params {resolution: vec2f, radius: f32, shape: f32, iris: vec4f, highlights: vec4f, options: vec4f,}
+const PI=3.141592653589793;
+const GOLDEN_ANGLE=2.399963229728653;
+fn toLinear(color: vec3f) -> vec3f {
+ return mix(color/12.92,pow((color+0.055)/1.055,vec3f(2.4)),step(vec3f(0.04045),color));
+}
+fn toSrgb(color: vec3f) -> vec3f {
+ return mix(color*12.92,1.055*pow(max(color,vec3f(0)),vec3f(1.0/2.4))-0.055,step(vec3f(0.0031308),color));
+}
+fn readSource(uv: vec2f) -> vec4f {
+ let sampled=textureSampleLevel(source,sourceSampler,uv,0);
+ if (sampled.a<=0.0) {return vec4f(0);}
+ var color=sampled.rgb/sampled.a;
+ let luminance=dot(color,vec3f(0.2126,0.7152,0.0722));
+ if (params.options.y!=0.0) {color=toLinear(color);}
+ if (luminance>=params.highlights.y) {
+  let brightest=max(color.r,max(color.g,color.b));
+  let highlight=mix(vec3f(brightest),color,params.highlights.z);
+  color+=highlight*(4.0*params.highlights.x);
+ }
+ var coverage=1.0;
+ if (params.highlights.w==0.0) {
+  let pixel=uv*params.resolution;
+  let nearEdge=clamp(pixel+0.5,vec2f(0),vec2f(1));
+  let farEdge=clamp(params.resolution+0.5-pixel,vec2f(0),vec2f(1));
+  coverage=nearEdge.x*nearEdge.y*farEdge.x*farEdge.y;
+ }
+ return vec4f(color*sampled.a,sampled.a)*coverage;
+}
+@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {
+ if (params.radius==0.0) {return textureSampleLevel(source,sourceSampler,input.uv,0);}
+ var sum=vec4f(0);var total=0.0;
+ for (var i=0;i<2048;i++) {
+  if (f32(i)>=params.options.x) {break;}
+  let angle=f32(i)*GOLDEN_ANGLE;
+  var boundary=1.0;
+  if (params.shape<11.0) {
+   let halfSector=PI/params.shape;
+   let value=angle+PI/2.0;
+   let localAngle=value-floor(value/(2.0*halfSector))*(2.0*halfSector)-halfSector;
+   let polygon=cos(halfSector)/cos(localAngle);
+   boundary=mix(polygon,1.0,params.iris.x);
+  }
+  let distance=sqrt((f32(i)+0.5)/params.options.x)*boundary;
+  let rotatedAngle=angle+params.iris.y;
+  let offset=vec2f(cos(rotatedAngle)*params.iris.z,sin(rotatedAngle))*distance*params.radius;
+  let weight=boundary*boundary;
+  sum+=readSource(input.uv-offset/params.resolution)*weight;
+  total+=weight;
+ }
+ var color=sum/total;
+ if (params.options.y!=0.0 && color.a>0.0) {color=vec4f(toSrgb(color.rgb/color.a)*color.a,color.a);}
+ return vec4f(clamp(color.rgb,vec3f(0),vec3f(color.a)),color.a);
+}
+`;
+
+// src/lens-blur/index.ts
+var { createEffect, createWebGL2ContextError } = Internals;
+var DEFAULT_RADIUS = 10;
+var DEFAULT_IRIS_SHAPE = "hexagon";
+var DEFAULT_IRIS_ROUNDNESS = 0;
+var DEFAULT_IRIS_ROTATION = 0;
+var DEFAULT_IRIS_ASPECT_RATIO = 1;
+var DEFAULT_HIGHLIGHT_GAIN = 0;
+var DEFAULT_HIGHLIGHT_THRESHOLD = 1;
+var DEFAULT_HIGHLIGHT_SATURATION = 1;
+var DEFAULT_REPEAT_EDGE_PIXELS = false;
+var DEFAULT_SAMPLES = 256;
+var DEFAULT_LINEAR_LIGHT = false;
+var IRIS_SHAPES = [
+  "triangle",
+  "square",
+  "pentagon",
+  "hexagon",
+  "heptagon",
+  "octagon",
+  "nonagon",
+  "decagon",
+  "circle"
+];
+var lensBlurSchema = {
+  radius: {
+    type: "number",
+    default: DEFAULT_RADIUS,
+    description: "Blur radius in pixels",
+    min: 0,
+    max: 200,
+    step: 1,
+    hiddenFromList: false
+  },
+  irisShape: {
+    type: "enum",
+    default: DEFAULT_IRIS_SHAPE,
+    description: "Iris shape",
+    variants: {
+      triangle: {},
+      square: {},
+      pentagon: {},
+      hexagon: {},
+      heptagon: {},
+      octagon: {},
+      nonagon: {},
+      decagon: {},
+      circle: {}
+    }
+  },
+  irisRoundness: {
+    type: "number",
+    default: DEFAULT_IRIS_ROUNDNESS,
+    description: "Roundness of the iris, from 0 (polygon) to 1 (circle)",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    hiddenFromList: false
+  },
+  irisRotation: {
+    type: "rotation-degrees",
+    default: DEFAULT_IRIS_ROTATION,
+    description: "Clockwise iris rotation in degrees",
+    step: 1
+  },
+  irisAspectRatio: {
+    type: "number",
+    default: DEFAULT_IRIS_ASPECT_RATIO,
+    description: "Horizontal stretch of the iris",
+    min: 0.01,
+    max: 4,
+    step: 0.01,
+    hiddenFromList: false
+  },
+  highlightGain: {
+    type: "number",
+    default: DEFAULT_HIGHLIGHT_GAIN,
+    description: "Additional brightness of highlights, from 0 to 1",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    hiddenFromList: false
+  },
+  highlightThreshold: {
+    type: "number",
+    default: DEFAULT_HIGHLIGHT_THRESHOLD,
+    description: "Minimum luminance for highlight gain, from 0 to 1",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    hiddenFromList: false
+  },
+  highlightSaturation: {
+    type: "number",
+    default: DEFAULT_HIGHLIGHT_SATURATION,
+    description: "Saturation of added highlight brightness, from 0 to 1",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    hiddenFromList: false
+  },
+  repeatEdgePixels: {
+    type: "boolean",
+    default: DEFAULT_REPEAT_EDGE_PIXELS,
+    description: "Repeat edge pixels outside the source instead of sampling transparency"
+  },
+  samples: {
+    type: "number",
+    default: DEFAULT_SAMPLES,
+    description: "Number of aperture samples, from 16 to 2048",
+    min: 16,
+    max: 2048,
+    step: 1,
+    hiddenFromList: false,
+    integer: true
+  },
+  linearLight: {
+    type: "boolean",
+    default: DEFAULT_LINEAR_LIGHT,
+    description: "Average colors in linear light"
+  }
+};
+var resolve = (p) => ({
+  radius: p.radius ?? DEFAULT_RADIUS,
+  irisShape: p.irisShape ?? DEFAULT_IRIS_SHAPE,
+  irisRoundness: p.irisRoundness ?? DEFAULT_IRIS_ROUNDNESS,
+  irisRotation: p.irisRotation ?? DEFAULT_IRIS_ROTATION,
+  irisAspectRatio: p.irisAspectRatio ?? DEFAULT_IRIS_ASPECT_RATIO,
+  highlightGain: p.highlightGain ?? DEFAULT_HIGHLIGHT_GAIN,
+  highlightThreshold: p.highlightThreshold ?? DEFAULT_HIGHLIGHT_THRESHOLD,
+  highlightSaturation: p.highlightSaturation ?? DEFAULT_HIGHLIGHT_SATURATION,
+  repeatEdgePixels: p.repeatEdgePixels ?? DEFAULT_REPEAT_EDGE_PIXELS,
+  samples: p.samples ?? DEFAULT_SAMPLES,
+  linearLight: p.linearLight ?? DEFAULT_LINEAR_LIGHT
+});
+var validateLensBlurParams = (params) => {
+  assertEffectParamsObject(params, "Lens blur");
+  assertOptionalFiniteNumber(params.radius, "radius");
+  assertOptionalFiniteNumber(params.irisRoundness, "irisRoundness");
+  assertOptionalFiniteNumber(params.irisRotation, "irisRotation");
+  assertOptionalFiniteNumber(params.irisAspectRatio, "irisAspectRatio");
+  assertOptionalFiniteNumber(params.highlightGain, "highlightGain");
+  assertOptionalFiniteNumber(params.highlightThreshold, "highlightThreshold");
+  assertOptionalFiniteNumber(params.highlightSaturation, "highlightSaturation");
+  assertOptionalBoolean(params.repeatEdgePixels, "repeatEdgePixels");
+  assertOptionalFiniteNumber(params.samples, "samples");
+  assertOptionalBoolean(params.linearLight, "linearLight");
+  if (params.irisShape !== undefined && !IRIS_SHAPES.includes(params.irisShape)) {
+    throw new TypeError("Invalid irisShape: " + JSON.stringify(params.irisShape));
+  }
+  const r = resolve(params);
+  validateNonNegative(r.radius, "radius");
+  validateUnitInterval(r.irisRoundness, "irisRoundness");
+  validateUnitInterval(r.highlightGain, "highlightGain");
+  validateUnitInterval(r.highlightThreshold, "highlightThreshold");
+  validateUnitInterval(r.highlightSaturation, "highlightSaturation");
+  if (r.irisAspectRatio <= 0)
+    throw new TypeError('"irisAspectRatio" must be greater than zero');
+  if (!Number.isInteger(r.samples) || r.samples < 16 || r.samples > 2048)
+    throw new TypeError('"samples" must be an integer between 16 and 2048');
+};
+var VERTEX_SHADER = `#version 300 es
+in vec2 aPos;
+in vec2 aUv;
+out vec2 vUv;
+
+void main() {
+	vUv = aUv;
+	gl_Position = vec4(aPos, 0.0, 1.0);
+}
+`;
+var compileShader = (gl, type, source) => {
+  const shader = gl.createShader(type);
+  if (!shader) {
+    throw new Error("Failed to create WebGL shader");
+  }
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    const log = gl.getShaderInfoLog(shader);
+    gl.deleteShader(shader);
+    throw new Error(`LensBlur shader compile failed: ${log ?? "(no log)"}`);
+  }
+  return shader;
+};
+var linkProgram = (gl, vs, fs) => {
+  const program = gl.createProgram();
+  if (!program) {
+    throw new Error("Failed to create WebGL program");
+  }
+  gl.attachShader(program, vs);
+  gl.attachShader(program, fs);
+  gl.linkProgram(program);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    const log = gl.getProgramInfoLog(program);
+    gl.deleteProgram(program);
+    throw new Error(`LensBlur program link failed: ${log ?? "(no log)"}`);
+  }
+  return program;
+};
+var setupLensBlur = (target) => {
+  const gl = target.getContext("webgl2", {
+    premultipliedAlpha: true,
+    alpha: true,
+    preserveDrawingBuffer: true
+  });
+  if (!gl) {
+    throw createWebGL2ContextError("lens blur effect");
+  }
+  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+  const vs = compileShader(gl, gl.VERTEX_SHADER, VERTEX_SHADER);
+  const fs = compileShader(gl, gl.FRAGMENT_SHADER, LENS_BLUR_FRAGMENT_SHADER);
+  const program = linkProgram(gl, vs, fs);
+  gl.deleteShader(vs);
+  gl.deleteShader(fs);
+  const vao = gl.createVertexArray();
+  if (!vao) {
+    throw new Error("Failed to create WebGL vertex array");
+  }
+  gl.bindVertexArray(vao);
+  const data = new Float32Array([
+    -1,
+    -1,
+    0,
+    0,
+    1,
+    -1,
+    1,
+    0,
+    -1,
+    1,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1
+  ]);
+  const vbo = gl.createBuffer();
+  if (!vbo) {
+    throw new Error("Failed to create WebGL buffer");
+  }
+  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+  gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
+  const aPos = gl.getAttribLocation(program, "aPos");
+  const aUv = gl.getAttribLocation(program, "aUv");
+  gl.enableVertexAttribArray(aPos);
+  gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
+  gl.enableVertexAttribArray(aUv);
+  gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
+  gl.bindVertexArray(null);
+  const texture = gl.createTexture();
+  if (!texture) {
+    throw new Error("Failed to create WebGL texture");
+  }
+  gl.bindTexture(gl.TEXTURE_2D, texture);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+  gl.bindTexture(gl.TEXTURE_2D, null);
+  return {
+    gl,
+    program,
+    vao,
+    vbo,
+    texture,
+    uSource: gl.getUniformLocation(program, "uSource"),
+    uResolution: gl.getUniformLocation(program, "uResolution"),
+    uRadius: gl.getUniformLocation(program, "uRadius"),
+    uIrisShape: gl.getUniformLocation(program, "uIrisShape"),
+    uIrisRoundness: gl.getUniformLocation(program, "uIrisRoundness"),
+    uIrisRotation: gl.getUniformLocation(program, "uIrisRotation"),
+    uIrisAspectRatio: gl.getUniformLocation(program, "uIrisAspectRatio"),
+    uHighlightGain: gl.getUniformLocation(program, "uHighlightGain"),
+    uHighlightThreshold: gl.getUniformLocation(program, "uHighlightThreshold"),
+    uHighlightSaturation: gl.getUniformLocation(program, "uHighlightSaturation"),
+    uRepeatEdgePixels: gl.getUniformLocation(program, "uRepeatEdgePixels"),
+    uSamples: gl.getUniformLocation(program, "uSamples"),
+    uLinearLight: gl.getUniformLocation(program, "uLinearLight")
+  };
+};
+var lensBlur = createEffect({
+  type: "remotion/lens-blur",
+  label: "lensBlur()",
+  documentationLink: "https://www.remotion.dev/docs/effects/lens-blur",
+  calculateKey: (params) => {
+    const r = resolve(params);
+    return `lens-blur-${JSON.stringify(r)}`;
+  },
+  implementations: {
+    webgpu: Internals.createEffectImplementation({
+      setup: (target) => setupWebGpuSinglePass(target, "lens-blur"),
+      apply: ({ source, width, height, params, state, gpuDevice }) => {
+        if (!gpuDevice)
+          throw new Error("A WebGPU device is required for this effect");
+        const r = resolve(params);
+        applyWebGpuSinglePass({
+          state,
+          source,
+          width,
+          height,
+          device: gpuDevice,
+          shader: LENS_BLUR_WEBGPU_SHADER,
+          uniformData: new Float32Array([
+            width,
+            height,
+            r.radius,
+            IRIS_SHAPES.indexOf(r.irisShape) + 3,
+            r.irisRoundness,
+            r.irisRotation % 360 * Math.PI / 180,
+            r.irisAspectRatio,
+            0,
+            r.highlightGain,
+            r.highlightThreshold,
+            r.highlightSaturation,
+            r.repeatEdgePixels ? 1 : 0,
+            r.samples,
+            r.linearLight ? 1 : 0,
+            0,
+            0
+          ])
+        });
+      },
+      cleanup: cleanupWebGpuSinglePass
+    }),
+    webgl2: Internals.createEffectImplementation({
+      setup: (target) => setupLensBlur(target),
+      apply: ({ source, width, height, params, state, flipSourceY }) => {
+        const r = resolve(params);
+        const { gl, program, texture, vao } = state;
+        gl.viewport(0, 0, width, height);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        gl.clearColor(0, 0, 0, 0);
+        gl.clear(gl.COLOR_BUFFER_BIT);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipSourceY);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
+        gl.useProgram(program);
+        if (state.uSource)
+          gl.uniform1i(state.uSource, 0);
+        if (state.uResolution)
+          gl.uniform2f(state.uResolution, width, height);
+        if (state.uRadius)
+          gl.uniform1f(state.uRadius, r.radius);
+        if (state.uIrisShape)
+          gl.uniform1i(state.uIrisShape, IRIS_SHAPES.indexOf(r.irisShape) + 3);
+        if (state.uIrisRoundness)
+          gl.uniform1f(state.uIrisRoundness, r.irisRoundness);
+        if (state.uIrisRotation)
+          gl.uniform1f(state.uIrisRotation, r.irisRotation % 360 * Math.PI / 180);
+        if (state.uIrisAspectRatio)
+          gl.uniform1f(state.uIrisAspectRatio, r.irisAspectRatio);
+        if (state.uHighlightGain)
+          gl.uniform1f(state.uHighlightGain, r.highlightGain);
+        if (state.uHighlightThreshold)
+          gl.uniform1f(state.uHighlightThreshold, r.highlightThreshold);
+        if (state.uHighlightSaturation)
+          gl.uniform1f(state.uHighlightSaturation, r.highlightSaturation);
+        if (state.uRepeatEdgePixels)
+          gl.uniform1i(state.uRepeatEdgePixels, r.repeatEdgePixels ? 1 : 0);
+        if (state.uSamples)
+          gl.uniform1i(state.uSamples, r.samples);
+        if (state.uLinearLight)
+          gl.uniform1i(state.uLinearLight, r.linearLight ? 1 : 0);
+        gl.bindVertexArray(vao);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+        gl.bindVertexArray(null);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.useProgram(null);
+      },
+      cleanup: ({ gl, program, vao, vbo, texture }) => {
+        gl.deleteTexture(texture);
+        gl.deleteBuffer(vbo);
+        gl.deleteProgram(program);
+        gl.deleteVertexArray(vao);
+      }
+    })
+  },
+  schema: lensBlurSchema,
+  validateParams: validateLensBlurParams
+});
+export {
+  lensBlur
+};