@remotion/effects 4.0.541 → 4.0.542

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

@@ -0,0 +1,389 @@
+import {
+  assertOptionalFiniteNumber,
+  validateUnitInterval,
+  validateNonNegative
+} from "./index-wxhvgv2s.mjs";
+import {
+  WEBGPU_SINGLE_PASS_VERTEX,
+  setupWebGpuSinglePass,
+  cleanupWebGpuSinglePass,
+  applyWebGpuSinglePass
+} from "./index-tvfexb7s.mjs";
+import {
+  assertEffectParamsObject
+} from "./index-4fvp93ps.mjs";
+
+// src/zoom-blur/index.ts
+import { Internals as Internals2 } from "remotion";
+
+// src/zoom-blur/webgpu-shader.ts
+var ZOOM_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;
+struct Params { resolutionAndCenter: vec4f, amountAndSamples: vec4f, }
+@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {
+  let resolution = params.resolutionAndCenter.xy;
+  let center = vec2f(params.resolutionAndCenter.z, 1.0 - params.resolutionAndCenter.w);
+  let direction = input.uv - center;
+  let amount = params.amountAndSamples.x / min(resolution.x, resolution.y);
+  let samples = i32(params.amountAndSamples.y);
+  var color = vec4f(0);
+  var total = 0.0;
+  for (var i = 0; i < 64; i++) {
+    if (i >= samples) { break; }
+    let denominator = max(f32(samples - 1), 1.0);
+    let progress = f32(i) / denominator;
+    let uv = clamp(input.uv - direction * amount * progress, vec2f(0), vec2f(1));
+    color += textureSampleLevel(source, sourceSampler, uv, 0);
+    total += 1.0;
+  }
+  return color / total;
+}
+`;
+
+// src/zoom-blur/zoom-blur-runtime.ts
+import { Internals } from "remotion";
+
+// src/zoom-blur/zoom-blur-shaders.ts
+var ZOOM_BLUR_VS = `#version 300 es
+layout(location = 0) in vec2 aPos;
+layout(location = 1) in vec2 aUv;
+out vec2 vUv;
+void main() {
+	vUv = aUv;
+	gl_Position = vec4(aPos, 0.0, 1.0);
+}
+`;
+var ZOOM_BLUR_FS = `#version 300 es
+precision highp float;
+in vec2 vUv;
+out vec4 fragColor;
+
+uniform sampler2D uSource;
+uniform vec2 uResolution;
+uniform vec2 uCenter;
+uniform float uAmount;
+uniform int uSamples;
+
+const int MAX_SAMPLES = 64;
+
+void main() {
+	vec2 direction = vUv - uCenter;
+	float normalizedAmount = uAmount / min(uResolution.x, uResolution.y);
+	vec4 color = vec4(0.0);
+	float total = 0.0;
+
+	for (int i = 0; i < MAX_SAMPLES; i++) {
+		if (i >= uSamples) {
+			break;
+		}
+
+		float denominator = max(float(uSamples - 1), 1.0);
+		float progress = float(i) / denominator;
+		vec2 sampleUv = clamp(vUv - direction * normalizedAmount * progress, 0.0, 1.0);
+		color += texture(uSource, sampleUv);
+		total += 1.0;
+	}
+
+	fragColor = color / total;
+}
+`;
+
+// src/zoom-blur/zoom-blur-runtime.ts
+var { createWebGL2ContextError } = Internals;
+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(`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(`Program link failed: ${log ?? "(no log)"}`);
+  }
+  return program;
+};
+var createProgram = (gl, vertexSource, fragmentSource) => {
+  const vs = compileShader(gl, gl.VERTEX_SHADER, vertexSource);
+  const fs = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSource);
+  const program = linkProgram(gl, vs, fs);
+  gl.deleteShader(vs);
+  gl.deleteShader(fs);
+  return program;
+};
+var createRgbaTexture = (gl) => {
+  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 texture;
+};
+var setupZoomBlur = (target) => {
+  const gl = target.getContext("webgl2", {
+    premultipliedAlpha: true,
+    alpha: true,
+    preserveDrawingBuffer: true
+  });
+  if (!gl) {
+    throw createWebGL2ContextError("zoom blur effect");
+  }
+  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+  const program = createProgram(gl, ZOOM_BLUR_VS, ZOOM_BLUR_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);
+  gl.enableVertexAttribArray(0);
+  gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 16, 0);
+  gl.enableVertexAttribArray(1);
+  gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 16, 8);
+  gl.bindVertexArray(null);
+  const textureSource = createRgbaTexture(gl);
+  return {
+    gl,
+    program,
+    vao,
+    vbo,
+    textureSource,
+    uniforms: {
+      uSource: gl.getUniformLocation(program, "uSource"),
+      uResolution: gl.getUniformLocation(program, "uResolution"),
+      uCenter: gl.getUniformLocation(program, "uCenter"),
+      uAmount: gl.getUniformLocation(program, "uAmount"),
+      uSamples: gl.getUniformLocation(program, "uSamples")
+    }
+  };
+};
+var cleanupZoomBlur = (state) => {
+  const { gl, program, vao, vbo, textureSource } = state;
+  gl.deleteTexture(textureSource);
+  gl.deleteBuffer(vbo);
+  gl.deleteProgram(program);
+  gl.deleteVertexArray(vao);
+};
+var drawFullscreenQuad = (state) => {
+  const { gl, vao } = state;
+  gl.bindVertexArray(vao);
+  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+  gl.bindVertexArray(null);
+};
+var applyZoomBlur = ({
+  state,
+  source,
+  width,
+  height,
+  amount,
+  center,
+  samples,
+  flipSourceY
+}) => {
+  const { gl, program, textureSource, uniforms } = state;
+  gl.viewport(0, 0, width, height);
+  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipSourceY);
+  gl.bindTexture(gl.TEXTURE_2D, textureSource);
+  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
+  gl.bindTexture(gl.TEXTURE_2D, null);
+  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+  gl.clearColor(0, 0, 0, 0);
+  gl.clear(gl.COLOR_BUFFER_BIT);
+  gl.useProgram(program);
+  if (uniforms.uSource)
+    gl.uniform1i(uniforms.uSource, 0);
+  if (uniforms.uResolution)
+    gl.uniform2f(uniforms.uResolution, width, height);
+  if (uniforms.uCenter)
+    gl.uniform2f(uniforms.uCenter, center[0], center[1]);
+  if (uniforms.uAmount)
+    gl.uniform1f(uniforms.uAmount, amount);
+  if (uniforms.uSamples)
+    gl.uniform1i(uniforms.uSamples, samples);
+  gl.activeTexture(gl.TEXTURE0);
+  gl.bindTexture(gl.TEXTURE_2D, textureSource);
+  drawFullscreenQuad(state);
+  gl.bindTexture(gl.TEXTURE_2D, null);
+  gl.useProgram(null);
+};
+
+// src/zoom-blur/index.ts
+var { createEffect } = Internals2;
+var DEFAULT_AMOUNT = 40;
+var DEFAULT_CENTER = [0.5, 0.5];
+var DEFAULT_SAMPLES = 24;
+var MAX_SAMPLES = 64;
+var zoomBlurSchema = {
+  amount: {
+    type: "number",
+    min: 0,
+    max: 200,
+    step: 1,
+    default: DEFAULT_AMOUNT,
+    description: "Amount",
+    hiddenFromList: false
+  },
+  center: {
+    type: "uv-coordinate",
+    step: 0.01,
+    default: DEFAULT_CENTER,
+    description: "Center"
+  },
+  samples: {
+    type: "number",
+    min: 1,
+    max: MAX_SAMPLES,
+    step: 1,
+    integer: true,
+    default: DEFAULT_SAMPLES,
+    description: "Samples",
+    hiddenFromList: false
+  }
+};
+var resolve = (params) => ({
+  amount: params.amount ?? DEFAULT_AMOUNT,
+  center: [...params.center ?? DEFAULT_CENTER],
+  samples: params.samples ?? DEFAULT_SAMPLES
+});
+var assertOptionalUvCoordinate = (value, name) => {
+  if (value === undefined) {
+    return;
+  }
+  if (!Array.isArray(value) || value.length !== 2 || value.some((item) => typeof item !== "number" || !Number.isFinite(item))) {
+    throw new TypeError(`"${name}" must be a [number, number] tuple`);
+  }
+};
+var assertOptionalInteger = (value, name) => {
+  if (value === undefined) {
+    return;
+  }
+  if (!Number.isInteger(value)) {
+    throw new TypeError(`"${name}" must be an integer, but got ${JSON.stringify(value)}`);
+  }
+};
+var validateZoomBlurParams = (params) => {
+  assertEffectParamsObject(params, "Zoom Blur");
+  assertOptionalFiniteNumber(params.amount, "amount");
+  assertOptionalUvCoordinate(params.center, "center");
+  assertOptionalFiniteNumber(params.samples, "samples");
+  assertOptionalInteger(params.samples, "samples");
+  const r = resolve(params);
+  validateNonNegative(r.amount, "amount");
+  validateUnitInterval(r.center[0], "center[0]");
+  validateUnitInterval(r.center[1], "center[1]");
+  if (r.samples < 1) {
+    throw new TypeError(`"samples" must be >= 1, but got ${JSON.stringify(r.samples)}`);
+  }
+  if (r.samples > MAX_SAMPLES) {
+    throw new TypeError(`"samples" must be <= ${MAX_SAMPLES}, but got ${JSON.stringify(r.samples)}`);
+  }
+};
+var zoomBlur = createEffect({
+  type: "remotion/zoom-blur",
+  label: "zoomBlur()",
+  documentationLink: "https://www.remotion.dev/docs/effects/zoom-blur",
+  calculateKey: (params) => {
+    const r = resolve(params);
+    return `zoom-blur-${r.amount}-${r.center[0]}-${r.center[1]}-${r.samples}`;
+  },
+  implementations: {
+    webgpu: Internals2.createEffectImplementation({
+      setup: (target) => setupWebGpuSinglePass(target, "zoom-blur"),
+      apply: ({ source, width, height, params, state, gpuDevice }) => {
+        if (!gpuDevice) {
+          throw new Error("A WebGPU device is required for the zoom-blur effect");
+        }
+        const r = resolve(params);
+        const uniformData = new Float32Array([
+          width,
+          height,
+          r.center[0],
+          r.center[1],
+          r.amount,
+          r.samples,
+          0,
+          0
+        ]);
+        applyWebGpuSinglePass({
+          state,
+          source,
+          width,
+          height,
+          device: gpuDevice,
+          shader: ZOOM_BLUR_WEBGPU_SHADER,
+          uniformData
+        });
+      },
+      cleanup: cleanupWebGpuSinglePass
+    }),
+    webgl2: Internals2.createEffectImplementation({
+      setup: (target) => setupZoomBlur(target),
+      apply: ({ source, width, height, params, state, flipSourceY }) => {
+        const r = resolve(params);
+        applyZoomBlur({
+          state,
+          source,
+          width,
+          height,
+          amount: r.amount,
+          center: r.center,
+          samples: r.samples,
+          flipSourceY
+        });
+      },
+      cleanup: (state) => cleanupZoomBlur(state)
+    })
+  },
+  schema: zoomBlurSchema,
+  validateParams: validateZoomBlurParams
+});
+export {
+  zoomBlur
+};

package/dist/lightning/geometry.d.ts

@@ -0,0 +1,10 @@
+import type { LightningParams } from './params.js';
+type Point = readonly [number, number];
+type Segment = {
+    start: Point;
+    end: Point;
+    intensity: number;
+    main: boolean;
+};
+export declare const lightningSegments: (p: Required<LightningParams>, width: number, height: number, alpha: ImageData | null) => Segment[];
+export {};

package/dist/lightning/index.d.ts

@@ -0,0 +1,4 @@
+import { type LightningParams } from './params.js';
+export declare const lightning: (params?: (LightningParams & {
+    readonly disabled?: boolean;
+}) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/lightning/mask.d.ts

@@ -0,0 +1,2 @@
+import type { LightningParams } from './params.js';
+export declare const makeLightningMask: (p: Required<LightningParams>, width: number, height: number, alpha: ImageData | null) => Uint8Array<ArrayBuffer>;

package/dist/lightning/params.d.ts

@@ -0,0 +1,259 @@
+import type { UvCoordinate } from '../uv-coordinate.js';
+export type LightningType = 'direction' | 'strike' | 'breaking' | 'bouncy' | 'omni' | 'anywhere' | 'vertical' | 'two-way-strike';
+export type LightningFractalType = 'linear' | 'semi-linear' | 'spline';
+export type LightningParams = {
+    readonly lightningType?: LightningType;
+    /** Starting UV coordinate measured from the top-left. Defaults to [0.5, 0]. */
+    readonly origin?: UvCoordinate;
+    /** Destination or direction in UV coordinates. Defaults to [0.5, 1]. */
+    readonly direction?: UvCoordinate;
+    /** Each integer selects a repeatable bolt shape. Defaults to 10. */
+    readonly conductivityState?: number;
+    /** Radius of the bright center in pixels. Defaults to 3. */
+    readonly coreRadius?: number;
+    readonly coreOpacity?: number;
+    readonly coreColor?: string;
+    /** Radius of the surrounding glow in pixels. Defaults to 50. */
+    readonly glowRadius?: number;
+    readonly glowOpacity?: number;
+    readonly glowColor?: string;
+    readonly turbulence?: number;
+    readonly forking?: number;
+    readonly decay?: number;
+    readonly decayMainCore?: boolean;
+    /** Positive values repel the bolt from opaque pixels, negative values attract it. Ranges from -10 to 10. */
+    readonly alphaObstacle?: number;
+    /** Include the source behind the lightning. Defaults to true. */
+    readonly compositeOnOriginal?: boolean;
+    /** Number of subdivisions, from 1 to 12. Defaults to 6. */
+    readonly complexity?: number;
+    readonly minForkDistance?: number;
+    readonly terminationThreshold?: number;
+    readonly mainCoreCollisionOnly?: boolean;
+    readonly fractalType?: LightningFractalType;
+    readonly coreDrain?: number;
+    readonly forkStrength?: number;
+    readonly forkVariation?: number;
+    /** Unsigned 32-bit seed for the bolt pattern. Defaults to 0. */
+    readonly seed?: number;
+};
+export declare const lightningSchema: {
+    readonly lightningType: {
+        readonly type: 'enum';
+        readonly description: 'Lightning type';
+        readonly variants: {
+            readonly direction: {};
+            readonly strike: {};
+            readonly breaking: {};
+            readonly bouncy: {};
+            readonly omni: {};
+            readonly anywhere: {};
+            readonly vertical: {};
+            readonly 'two-way-strike': {};
+        };
+        readonly default: 'strike';
+    };
+    readonly origin: {
+        readonly type: 'uv-coordinate';
+        readonly description: string;
+        readonly default: UvCoordinate;
+        readonly min: 0;
+        readonly max: 1;
+        readonly step: 0.01;
+        readonly visual: {
+            readonly type: 'line';
+            readonly to: 'direction';
+        };
+    };
+    readonly direction: {
+        readonly type: 'uv-coordinate';
+        readonly description: string;
+        readonly default: UvCoordinate;
+        readonly min: 0;
+        readonly max: 1;
+        readonly step: 0.01;
+    };
+    readonly conductivityState: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly coreRadius: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly coreOpacity: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly coreColor: {
+        readonly type: 'color';
+        readonly description: 'Core color';
+        readonly default: '#ffffff';
+    };
+    readonly glowRadius: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly glowOpacity: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly glowColor: {
+        readonly type: 'color';
+        readonly description: 'Glow color';
+        readonly default: '#4059ff';
+    };
+    readonly turbulence: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly forking: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly decay: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly decayMainCore: {
+        readonly type: 'boolean';
+        readonly description: 'Decay main core';
+        readonly default: false;
+    };
+    readonly alphaObstacle: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly compositeOnOriginal: {
+        readonly type: 'boolean';
+        readonly description: 'Composite on original';
+        readonly default: true;
+    };
+    readonly complexity: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+        readonly integer: true;
+    };
+    readonly minForkDistance: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly terminationThreshold: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly mainCoreCollisionOnly: {
+        readonly type: 'boolean';
+        readonly description: 'Main core collision only';
+        readonly default: false;
+    };
+    readonly fractalType: {
+        readonly type: 'enum';
+        readonly description: 'Fractal type';
+        readonly variants: {
+            readonly linear: {};
+            readonly 'semi-linear': {};
+            readonly spline: {};
+        };
+        readonly default: 'linear';
+    };
+    readonly coreDrain: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly forkStrength: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly forkVariation: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+    };
+    readonly seed: {
+        readonly type: 'number';
+        readonly description: string;
+        readonly default: number;
+        readonly min: number;
+        readonly max: number;
+        readonly step: number;
+        readonly hiddenFromList: false;
+        readonly integer: true;
+    };
+};
+export declare const resolve: (params: LightningParams) => Required<LightningParams>;
+export declare const validateLightningParams: (params: LightningParams) => void;

package/dist/lightning/shaders.d.ts

@@ -0,0 +1,2 @@
+export declare const LIGHTNING_FRAGMENT_SHADER = "#version 300 es\nprecision highp float;\nuniform sampler2D uSource;\nuniform sampler2D uMask;\nuniform vec4 uCore;\nuniform vec4 uGlow;\nuniform float uComposite;\nin vec2 vUv;\nout vec4 fragColor;\n\nvoid main() {\n\tvec4 source = texture(uSource, vUv) * uComposite;\n\tvec2 mask = texture(uMask, vec2(vUv.x, 1.0 - vUv.y)).rg;\n\tfloat core = mask.r * uCore.a;\n\tfloat glow = mask.g * uGlow.a;\n\tfloat alpha = source.a + max(core, glow) * (1.0 - source.a);\n\tvec3 color = source.rgb + uCore.rgb * core + uGlow.rgb * glow;\n\tfragColor = vec4(min(color, vec3(alpha)), alpha);\n}\n";
+export declare const LIGHTNING_WEBGPU_SHADER = "\n\nstruct VertexOutput {\n\t@builtin(position) position: vec4f,\n\t@location(0) uv: vec2f,\n}\n\n@vertex fn vertex(@builtin(vertex_index) index: u32) -> VertexOutput {\n\tlet positions = array<vec2f, 3>(vec2f(-1, -1), vec2f(3, -1), vec2f(-1, 3));\n\tlet position = positions[index];\n\tvar output: VertexOutput;\n\toutput.position = vec4f(position, 0, 1);\n\toutput.uv = vec2f(position.x * 0.5 + 0.5, 0.5 - position.y * 0.5);\n\treturn output;\n}\n\nstruct Params { core: vec4f, glow: vec4f, composite: f32 }\n@group(0) @binding(0) var source: texture_2d<f32>;\n@group(0) @binding(1) var sourceSampler: sampler;\n@group(0) @binding(2) var<uniform> params: Params;\n@group(0) @binding(3) var mask: texture_2d<f32>;\n\n@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {\n\tlet src = textureSampleLevel(source, sourceSampler, input.uv, 0) * params.composite;\n\tlet coverage = textureLoad(mask, vec2i(input.position.xy), 0).rg;\n\tlet core = coverage.r * params.core.a;\n\tlet glow = coverage.g * params.glow.a;\n\tlet alpha = src.a + max(core, glow) * (1.0 - src.a);\n\tlet color = src.rgb + params.core.rgb * core + params.glow.rgb * glow;\n\treturn vec4f(min(color, vec3f(alpha)), alpha);\n}\n";

package/dist/lightning.d.ts

@@ -0,0 +1,2 @@
+export { lightning } from './lightning/index.js';
+export type { LightningParams, LightningType, LightningFractalType, } from './lightning/params.js';

package/dist/magnify/shader.d.ts

@@ -0,0 +1 @@
+export declare const MAGNIFY_FRAGMENT_SHADER = "#version 300 es\nprecision highp float;\nprecision highp int;\n\nin vec2 vUv;\nout vec4 fragColor;\nuniform sampler2D uSource;\nuniform vec2 uResolution;\nuniform vec2 uCenter;\nuniform float uMagnification;\nuniform float uSize;\nuniform float uFeather;\nuniform float uOpacity;\nuniform bool uSquare;\nuniform int uScaling;\nuniform bool uIsolated;\n\nvec4 pixelAt(ivec2 p) {\n\tif (any(lessThan(p, ivec2(0))) || any(greaterThanEqual(p, textureSize(uSource, 0)))) {\n\t\treturn vec4(0.0);\n\t}\n\treturn texelFetch(uSource, p, 0);\n}\n\nvec4 cubicWeights(float t) {\n\tfloat t2 = t * t;\n\tfloat t3 = t2 * t;\n\treturn vec4(-0.5 * t3 + t2 - 0.5 * t,\n\t\t1.5 * t3 - 2.5 * t2 + 1.0,\n\t\t-1.5 * t3 + 2.0 * t2 + 0.5 * t,\n\t\t0.5 * t3 - 0.5 * t2);\n}\n\nvec4 sampleMagnified(vec2 uv, vec2 position) {\n\tvec2 dimensions = vec2(textureSize(uSource, 0));\n\tvec2 p = uv * dimensions;\n\tif (uScaling == 0) return pixelAt(ivec2(floor(p)));\n\tif (uScaling == 2) {\n\t\tuvec2 xy = uvec2(floor(position));\n\t\tuvec2 h = (xy.x ^ (xy.y + uvec2(1048576u, 2097152u))) * 1664525u + 1013904223u;\n\t\th = (h ^ (h >> 16u)) * 2246822519u;\n\t\tvec2 jitter = (vec2(h ^ (h >> 13u)) / 4294967295.0 - 0.5) * max(1.0 - 1.0 / uMagnification, 0.0);\n\t\tjitter.y = -jitter.y;\n\t\tvec2 q = floor(p) + jitter;\n\t\tivec2 base = ivec2(floor(q));\n\t\tvec2 f = fract(q);\n\t\treturn mix(mix(pixelAt(base), pixelAt(base + ivec2(1, 0)), f.x),\n\t\t\tmix(pixelAt(base + ivec2(0, 1)), pixelAt(base + ivec2(1, 1)), f.x), f.y);\n\t}\n\tvec2 q = p - 0.5;\n\tivec2 base = ivec2(floor(q));\n\tvec4 wx = cubicWeights(fract(q.x));\n\tvec4 wy = cubicWeights(fract(q.y));\n\tvec4 color = vec4(0.0);\n\tfor (int y = 0; y < 4; y++) {\n\t\tfor (int x = 0; x < 4; x++) {\n\t\t\tcolor += pixelAt(base + ivec2(x - 1, y - 1)) * wx[x] * wy[y];\n\t\t}\n\t}\n\tfloat alpha = clamp(color.a, 0.0, 1.0);\n\treturn vec4(clamp(color.rgb, vec3(0.0), vec3(alpha)), alpha);\n}\n\nvoid main() {\n\tvec4 original = texture(uSource, vUv);\n\tvec2 uv = vec2(vUv.x, 1.0 - vUv.y);\n\tvec2 offset = (uv - uCenter) * uResolution;\n\tfloat distance = uSquare ? max(abs(offset.x), abs(offset.y)) : length(offset);\n\tfloat weight = 0.0;\n\tif (uSize > 0.0) {\n\t\tweight = uFeather > 0.0\n\t\t\t? 1.0 - smoothstep(uSize - uFeather, uSize, distance)\n\t\t\t: clamp(uSize - distance + 0.5, 0.0, 1.0);\n\t}\n\tweight *= uOpacity;\n\tif (weight <= 0.0) {\n\t\tfragColor = uIsolated ? vec4(0.0) : original;\n\t\treturn;\n\t}\n\tvec2 sourceUv = uCenter + offset / (uResolution * uMagnification);\n\tvec4 magnified = uMagnification == 1.0 ? original\n\t\t: sampleMagnified(vec2(sourceUv.x, 1.0 - sourceUv.y), uv * uResolution);\n\tfragColor = uIsolated ? magnified * weight : mix(original, magnified, weight);\n}\n";

package/dist/magnify/webgpu-shader.d.ts

@@ -0,0 +1 @@
+export declare const MAGNIFY_WEBGPU_SHADER = "\n\nstruct VertexOutput {\n\t@builtin(position) position: vec4f,\n\t@location(0) uv: vec2f,\n}\n\n@vertex fn vertex(@builtin(vertex_index) index: u32) -> VertexOutput {\n\tlet positions = array<vec2f, 3>(vec2f(-1, -1), vec2f(3, -1), vec2f(-1, 3));\n\tlet position = positions[index];\n\tvar output: VertexOutput;\n\toutput.position = vec4f(position, 0, 1);\n\toutput.uv = vec2f(position.x * 0.5 + 0.5, 0.5 - position.y * 0.5);\n\treturn output;\n}\n\n@group(0) @binding(0) var source: texture_2d<f32>;\n@group(0) @binding(1) var sourceSampler: sampler;\n@group(0) @binding(2) var<uniform> params: Params;\nstruct Params {\n\tresolutionAndCenter: vec4f,\n\tlens: vec4f,\n\tmodes: vec4f,\n}\n\nfn pixelAt(p: vec2i) -> vec4f {\n\tif (any(p < vec2i(0)) || any(p >= vec2i(textureDimensions(source)))) {\n\t\treturn vec4f(0);\n\t}\n\treturn textureLoad(source, p, 0);\n}\n\nfn cubicWeights(t: f32) -> vec4f {\n\tlet t2 = t * t;\n\tlet t3 = t2 * t;\n\treturn vec4f(-0.5 * t3 + t2 - 0.5 * t,\n\t\t1.5 * t3 - 2.5 * t2 + 1.0,\n\t\t-1.5 * t3 + 2.0 * t2 + 0.5 * t,\n\t\t0.5 * t3 - 0.5 * t2);\n}\n\nfn sampleMagnified(uv: vec2f, position: vec2f) -> vec4f {\n\tlet p = uv * vec2f(textureDimensions(source));\n\tif (params.modes.y == 0) { return pixelAt(vec2i(floor(p))); }\n\tif (params.modes.y == 2) {\n\t\tlet xy = vec2u(floor(position));\n\t\tvar h = (vec2u(xy.x) ^ (vec2u(xy.y) + vec2u(1048576u, 2097152u))) * 1664525u + 1013904223u;\n\t\th = (h ^ (h >> vec2u(16u))) * 2246822519u;\n\t\tlet jitter = (vec2f(h ^ (h >> vec2u(13u))) / 4294967295.0 - 0.5) * max(1.0 - 1.0 / params.lens.x, 0.0);\n\t\tlet q = floor(p) + jitter;\n\t\tlet base = vec2i(floor(q));\n\t\tlet f = fract(q);\n\t\treturn mix(mix(pixelAt(base), pixelAt(base + vec2i(1, 0)), f.x),\n\t\t\tmix(pixelAt(base + vec2i(0, 1)), pixelAt(base + vec2i(1, 1)), f.x), f.y);\n\t}\n\tlet q = p - 0.5;\n\tlet base = vec2i(floor(q));\n\tlet wx = cubicWeights(fract(q.x));\n\tlet wy = cubicWeights(fract(q.y));\n\tvar color = vec4f(0);\n\tfor (var y = 0; y < 4; y++) {\n\t\tfor (var x = 0; x < 4; x++) {\n\t\t\tcolor += pixelAt(base + vec2i(x - 1, y - 1)) * wx[x] * wy[y];\n\t\t}\n\t}\n\tlet alpha = clamp(color.a, 0.0, 1.0);\n\treturn vec4f(clamp(color.rgb, vec3f(0), vec3f(alpha)), alpha);\n}\n\n@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {\n\tlet original = textureSampleLevel(source, sourceSampler, input.uv, 0);\n\tlet resolution = params.resolutionAndCenter.xy;\n\tlet center = params.resolutionAndCenter.zw;\n\tlet offset = (input.uv - center) * resolution;\n\tlet distance = select(length(offset), max(abs(offset.x), abs(offset.y)), params.modes.x == 1);\n\tlet size = params.lens.y;\n\tlet feather = params.lens.z;\n\tvar weight = 0.0;\n\tif (size > 0) {\n\t\tif (feather > 0) {\n\t\t\tweight = 1.0 - smoothstep(size - feather, size, distance);\n\t\t} else {\n\t\t\tweight = clamp(size - distance + 0.5, 0.0, 1.0);\n\t\t}\n\t}\n\tweight *= params.lens.w;\n\tif (weight <= 0) {\n\t\treturn select(original, vec4f(0), params.modes.z == 1);\n\t}\n\tvar magnified = original;\n\tif (params.lens.x != 1) {\n\t\tmagnified = sampleMagnified(center + offset / (resolution * params.lens.x), input.uv * resolution);\n\t}\n\treturn select(mix(original, magnified, weight), magnified * weight, params.modes.z == 1);\n}\n";