@remotion/effects 4.0.539 → 4.0.540

package/dist/value-noise-webgpu-shader.d.ts

@@ -0,0 +1 @@
+export declare const VALUE_NOISE_WEBGPU_SHADER = "\nfn lattice(point: vec3i, seed: u32) -> f32 {\n  let p = bitcast<vec3u>(point) & vec3u(65535u);\n  var h = (p.x*0x27d4eb2du) ^ (p.y*0x165667b1u) ^ (p.z*0x9e3779b9u) ^ (seed*0x85ebca6bu);\n  h ^= h >> 15u; h *= 0x2c1b3c6du; h ^= h >> 12u; h *= 0x297a2d39u; h ^= h >> 15u;\n  return f32(h & 65535u)/65535.0;\n}\nfn catmull(p: vec4f, t: f32) -> f32 {\n  return 0.5*(2.0*p.y+(p.z-p.x)*t+(2.0*p.x-5.0*p.y+4.0*p.z-p.w)*t*t+(3.0*p.y-p.x-3.0*p.z+p.w)*t*t*t);\n}\nfn bspline(t: f32) -> vec3f { return vec3f(0.5*(1.0-t)*(1.0-t),0.5+t*(1.0-t),0.5*t*t); }\nfn sliceNoise(p: vec3i,t: vec2f,seed: u32) -> f32 {\n  if(noiseType()==0) { return lattice(p,seed); }\n  if(noiseType()==1) { return mix(mix(lattice(p,seed),lattice(p+vec3i(1,0,0),seed),t.x),mix(lattice(p+vec3i(0,1,0),seed),lattice(p+vec3i(1,1,0),seed),t.x),t.y); }\n  if(noiseType()==2) {\n    let wx=bspline(t.x); let wy=bspline(t.y); var result=0.0;\n    for(var y=0;y<3;y++) { for(var x=0;x<3;x++) { result += wx[x]*wy[y]*lattice(p+vec3i(x-1,y-1,0),seed); } }\n    return result;\n  }\n  var rows: vec4f;\n  for(var y=0;y<4;y++) {\n    var row: vec4f;\n    for(var x=0;x<4;x++) { row[x]=lattice(p+vec3i(x-1,y-1,0),seed); }\n    rows[y]=catmull(row,t.x);\n  }\n  return catmull(rows,t.y);\n}\nfn valueNoise(point: vec3f,seed: u32) -> f32 {\n  let offset=select(0.0,0.5,noiseType()==2);\n  let shifted=point+vec3f(offset,offset,0.0);\n  let p=shifted-floor(shifted/65536.0)*65536.0;\n  let cell=vec3i(floor(p)); let t=fract(p);\n  let fz=t.z*t.z*t.z*(t.z*(t.z*6.0-15.0)+10.0);\n  let n=mix(sliceNoise(cell,t.xy,seed),sliceNoise(cell+vec3i(0,0,1),t.xy,seed),fz);\n  return select(n,0.5+(n-0.5)*(181.0/231.0)/0.55,noiseType()==2);\n}\n";

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

@@ -0,0 +1 @@
+export declare const VIGNETTE_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 { shape: vec4f, color: vec4f, center: vec2f, mode: f32, padding: 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\n@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {\n  let color = textureSampleLevel(source, sourceSampler, input.uv, 0.0);\n  let centered = abs(input.uv - params.center) * 2.0;\n  let distanceFromCenter = mix(max(centered.x, centered.y), length(centered), params.shape.w);\n  var mask: f32;\n  if (params.shape.z <= 0.0001) {\n    mask = select(0.0, params.shape.x, distanceFromCenter >= params.shape.y);\n  } else {\n    mask = smoothstep(params.shape.y, params.shape.y + params.shape.z, distanceFromCenter) * params.shape.x;\n  }\n  if (params.mode == 1.0) { return color * (1.0 - mask); }\n  let overlayAlpha = mask * params.color.a;\n  return vec4f(params.color.rgb * overlayAlpha + color.rgb * (1.0 - overlayAlpha), overlayAlpha + color.a * (1.0 - overlayAlpha));\n}\n";

package/dist/wave/wave-runtime.d.ts

@@ -20,10 +20,11 @@ type ApplyWaveParams = {
     readonly source: CanvasImageSource;
     readonly width: number;
     readonly height: number;
+    readonly flipSourceY: boolean;
     readonly amplitude: number;
     readonly wavelength: number;
     readonly phase: number;
     readonly direction: 'horizontal' | 'vertical';
 };
-export declare const applyWave: ({ state, source, width, height, amplitude, wavelength, phase, direction, }: ApplyWaveParams) => void;
+export declare const applyWave: ({ state, source, width, height, flipSourceY, amplitude, wavelength, phase, direction, }: ApplyWaveParams) => void;
 export {};

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

@@ -0,0 +1 @@
+export declare const WAVE_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 { resolutionAndWave: vec4f, phaseAndDirection: vec4f, }\n@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {\n  let resolution = params.resolutionAndWave.xy;\n  let amplitude = params.resolutionAndWave.z;\n  let wavelength = max(params.resolutionAndWave.w, 0.001);\n  let phase = params.phaseAndDirection.x;\n  var uv = input.uv;\n  if (params.phaseAndDirection.y == 0.0) {\n    let coord = input.uv.x * resolution.x;\n    let offset = sin((coord / wavelength) * 6.28318530718 + phase) * amplitude;\n    uv.y += offset / resolution.y;\n  } else {\n    let coord = (1.0 - input.uv.y) * resolution.y;\n    let offset = sin((coord / wavelength) * 6.28318530718 + phase) * amplitude;\n    uv.x -= offset / resolution.x;\n  }\n  return textureSampleLevel(source, sourceSampler, uv, 0);\n}\n";

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

@@ -0,0 +1 @@
+export declare const WAVES_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 sourceTexture: 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 palette: texture_2d<f32>;\nstruct Params {\n geometry: vec4f,\n stripe: vec4f,\n flags: vec4f,\n wave: vec4f,\n}\nfn sampleSource(uv: vec2f) -> vec4f {\n return textureSampleLevel(sourceTexture, sourceSampler, vec2f(uv.x, 1.0 - uv.y), 0);\n}\nfn glslModulo(value: f32, divisor: f32) -> f32 { return value - divisor * floor(value / divisor); }\nfn paletteColor(index: f32) -> vec4f { return textureLoad(palette, vec2i(i32(index), 0), 0); }\n\n@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {\n let vUv = vec2f(input.uv.x, 1.0 - input.uv.y);\n\n let texColor = sampleSource(vUv);\n let thickness = max(params.stripe.x, 0.001);\n let spacing = max(params.stripe.y, 0.001);\n let cycle = spacing * params.geometry.z;\n let centered = vec2f(input.position.x, params.geometry.y - input.position.y) - params.geometry.xy * 0.5;\n let s = sin(params.stripe.z);\n let c = cos(params.stripe.z);\n let rotated = vec2f(centered.x * c - centered.y * s, centered.x * s + centered.y * c);\n var axis = select(rotated.x, rotated.y, params.geometry.w == 0.0);\n let waveAxis = select(rotated.y, rotated.x, params.geometry.w == 0.0);\naxis += sin((waveAxis / max(params.wave.y, 0.001)) * 6.283185307179586 + params.wave.z) * params.wave.x;\n\n var position = glslModulo(axis + params.stripe.w, cycle);\n if (position < 0.0) { position += cycle; }\n let colorIndex = floor(position / spacing);\n let inStripe = glslModulo(position, spacing);\n if (inStripe > thickness) { return texColor; }\n\n let overlay = paletteColor(colorIndex);\n let premultiplied = overlay.rgb * overlay.a;\n if (params.flags.x != 0.0) {\n  return vec4f(premultiplied * texColor.a + texColor.rgb * (1.0 - overlay.a), texColor.a);\n }\n return vec4f(premultiplied + texColor.rgb * (1.0 - overlay.a), overlay.a + texColor.a * (1.0 - overlay.a));\n\n}\n";

package/dist/weather/params.d.ts

@@ -0,0 +1,149 @@
+export type WeatherCommonParams = {
+    /** Elapsed time in seconds. Must be nonnegative. Defaults to `0`. */
+    readonly time?: number;
+    /** Particle size, from `0` to `50`. Defaults to `1` for rain and `3` for snow. */
+    readonly size?: number;
+    /** Depth of the particle field, from `0` to `20000`. Defaults to `5000`. */
+    readonly sceneDepth?: number;
+    /** Fall speed. Defaults to `4000` for rain and `100` for snow. */
+    readonly speed?: number;
+    /** Horizontal wind strength. Positive values move right. Defaults to `0` for rain and `25` for snow. */
+    readonly wind?: number;
+    /** Per-particle wind variation, from `0` to `1`. Defaults to `0` for rain and `0.5` for snow. */
+    readonly windVariation?: number;
+    /** Random horizontal velocity spread, from `0` to `1000`. Defaults to `0`. */
+    readonly spread?: number;
+    /** Particle color. Its alpha multiplies opacity. Defaults to `#cccccc` for rain and `#ffffff` for snow. */
+    readonly color?: string;
+    /** Particle opacity, from `0` to `1`. Defaults to `0.25` for rain and `1` for snow. */
+    readonly opacity?: number;
+    /** Blend with the source. Defaults to `lighten` for rain and `composite` for snow. */
+    readonly transferMode?: 'composite' | 'lighten';
+    /** Include the source behind the particles. Defaults to `true`. */
+    readonly compositeWithOriginal?: boolean;
+    /** Normalized pattern position. `[0.5, 0.5]` leaves it centered, the default. */
+    readonly offset?: readonly [number, number];
+    /** Unsigned 32-bit integer for a repeatable particle field. Defaults to `0`. */
+    readonly seed?: number;
+};
+export type WeatherCommonResolved = Required<WeatherCommonParams>;
+export declare const COMMON_WEATHER_DEFAULTS: {
+    readonly time: 0;
+    readonly sceneDepth: 5000;
+    readonly spread: 0;
+    readonly compositeWithOriginal: true;
+    readonly offset: readonly [0.5, 0.5];
+    readonly seed: 0;
+};
+export declare const createWeatherSchema: (defaults: WeatherCommonResolved, maxSpeed: number, maxWind: number) => {
+    readonly time: {
+        readonly type: 'number';
+        readonly min: 0;
+        readonly max: 10;
+        readonly step: 0.01;
+        readonly default: number;
+        readonly description: 'Time';
+        readonly hiddenFromList: false;
+    };
+    readonly size: {
+        readonly type: 'number';
+        readonly min: 0;
+        readonly max: 50;
+        readonly step: 0.01;
+        readonly default: number;
+        readonly description: 'Size';
+        readonly hiddenFromList: false;
+    };
+    readonly sceneDepth: {
+        readonly type: 'number';
+        readonly min: 0;
+        readonly max: 20000;
+        readonly step: 1;
+        readonly default: number;
+        readonly description: 'Scene depth';
+        readonly hiddenFromList: false;
+    };
+    readonly speed: {
+        readonly type: 'number';
+        readonly min: 0;
+        readonly max: number;
+        readonly step: 1;
+        readonly default: number;
+        readonly description: 'Speed';
+        readonly hiddenFromList: false;
+    };
+    readonly wind: {
+        readonly type: 'number';
+        readonly min: number;
+        readonly max: number;
+        readonly step: 1;
+        readonly default: number;
+        readonly description: 'Wind';
+        readonly hiddenFromList: false;
+    };
+    readonly windVariation: {
+        readonly type: 'number';
+        readonly min: 0;
+        readonly max: 1;
+        readonly step: 0.01;
+        readonly default: number;
+        readonly description: 'Wind variation';
+        readonly hiddenFromList: false;
+    };
+    readonly spread: {
+        readonly type: 'number';
+        readonly min: 0;
+        readonly max: 1000;
+        readonly step: 1;
+        readonly default: number;
+        readonly description: 'Spread';
+        readonly hiddenFromList: false;
+    };
+    readonly opacity: {
+        readonly type: 'number';
+        readonly min: 0;
+        readonly max: 1;
+        readonly step: 0.01;
+        readonly default: number;
+        readonly description: 'Opacity';
+        readonly hiddenFromList: false;
+    };
+    readonly color: {
+        readonly type: 'color';
+        readonly default: string;
+        readonly description: 'Color';
+    };
+    readonly transferMode: {
+        readonly type: 'enum';
+        readonly variants: {
+            readonly composite: {};
+            readonly lighten: {};
+        };
+        readonly default: "composite" | "lighten";
+        readonly description: 'Transfer mode';
+    };
+    readonly compositeWithOriginal: {
+        readonly type: 'boolean';
+        readonly default: boolean;
+        readonly description: 'Composite with original';
+    };
+    readonly offset: {
+        readonly type: 'uv-coordinate';
+        readonly step: 0.01;
+        readonly default: readonly [number, number];
+        readonly description: 'Offset';
+    };
+    readonly seed: {
+        readonly type: 'number';
+        readonly min: 0;
+        readonly max: 4294967295;
+        readonly step: 1;
+        readonly integer: true;
+        readonly default: number;
+        readonly description: 'Seed';
+        readonly hiddenFromList: false;
+    };
+};
+export declare const resolveWeatherParams: (params: WeatherCommonParams, defaults: WeatherCommonResolved) => WeatherCommonResolved;
+export declare const validateWeatherRange: (value: number | undefined, name: string, min: number, max: number | null) => void;
+export declare const validateWeatherParams: (params: WeatherCommonParams, label: string, maxSpeed: number, maxWind: number) => void;

package/dist/weather/runtime.d.ts

@@ -0,0 +1,52 @@
+import { type ParsedColorRgba } from '../color-utils.js';
+export type WeatherRenderParams = {
+    readonly time: number;
+    readonly count: number;
+    readonly size: number;
+    readonly sizeVariation: number;
+    readonly sceneDepth: number;
+    readonly speed: number;
+    readonly speedVariation: number;
+    readonly wind: number;
+    readonly windVariation: number;
+    readonly spread: number;
+    readonly wiggleAmount: number;
+    readonly wiggleAmountVariation: number;
+    readonly wiggleFrequency: number;
+    readonly wiggleFrequencyVariation: number;
+    readonly color: string;
+    readonly opacity: number;
+    readonly transferMode: 'composite' | 'lighten';
+    readonly compositeWithOriginal: boolean;
+    readonly appearance: 'refracting' | 'soft-solid';
+    readonly offset: readonly [number, number];
+    readonly seed: number;
+};
+export type WeatherState = {
+    readonly gl: WebGL2RenderingContext;
+    readonly program: WebGLProgram;
+    readonly compositeProgram: WebGLProgram;
+    readonly vao: WebGLVertexArrayObject;
+    readonly sourceTexture: WebGLTexture;
+    readonly weatherTexture: WebGLTexture;
+    readonly framebuffer: WebGLFramebuffer;
+    readonly uniforms: Record<string, WebGLUniformLocation | null>;
+    readonly compositeUniforms: Record<string, WebGLUniformLocation | null>;
+    readonly colorCtx: CanvasRenderingContext2D;
+    readonly floatingPoint: boolean;
+    cachedColor: string | null;
+    cachedColorRgba: ParsedColorRgba;
+    width: number;
+    height: number;
+};
+export declare const setupWeather: (target: HTMLCanvasElement, effectName: string) => WeatherState;
+export declare const drawWeather: ({ state, source, width, height, flipSourceY, params, type, }: {
+    state: WeatherState;
+    source: TexImageSource;
+    width: number;
+    height: number;
+    flipSourceY: boolean;
+    params: WeatherRenderParams;
+    type: 'rain' | 'snow';
+}) => void;
+export declare const cleanupWeather: (state: WeatherState) => void;

package/dist/weather/shaders.d.ts

@@ -0,0 +1,4 @@
+export declare const WEATHER_VERTEX_SHADER = "#version 300 es\nprecision highp float;\nprecision highp int;\n\nuniform sampler2D uSource;\nuniform vec2 uResolution;\nuniform int uSnow;\nuniform float uTime;\nuniform uint uSeed;\nuniform vec2 uOffset;\nuniform float uSize;\nuniform float uSizeVariation;\nuniform float uSceneDepth;\nuniform float uSpeed;\nuniform float uSpeedVariation;\nuniform float uWind;\nuniform float uWindVariation;\nuniform float uSpread;\nuniform float uWiggleAmount;\nuniform float uWiggleAmountVariation;\nuniform float uWiggleFrequency;\nuniform float uWiggleFrequencyVariation;\nuniform vec4 uColor;\nuniform float uOpacity;\nuniform int uRefract;\n\nflat out vec2 vPosition;\nflat out vec2 vLine;\nflat out float vRadius;\nflat out vec4 vColor;\n\nfloat noise(uint i, uint key) {\n\tuint h = i * 0x8da6b343u ^ key * 0xd8163841u ^ uSeed * 0xcb1ab31fu;\n\th ^= h >> 13;\n\th *= 0x5bd1e995u;\n\th ^= h >> 15;\n\treturn float(h & 0x00ffffffu) / 16777216.0;\n}\n\nfloat signedNoise(uint i, uint key) {\n\treturn noise(i, key) * 2.0 - 1.0;\n}\n\nfloat wrap(float value, float margin, float size) {\n\treturn -margin + mod(value + margin, size + 2.0 * margin);\n}\n\nvec4 sourcePixel(ivec2 p) {\n\tivec2 size = textureSize(uSource, 0);\n\tif (p.x < 0 || p.y < 0 || p.x >= size.x || p.y >= size.y) {\n\t\treturn vec4(0.0);\n\t}\n\treturn texelFetch(uSource, ivec2(p.x, size.y - 1 - p.y), 0);\n}\n\n// Bilinear sampling with transparent borders, at pixel centers of +0.5.\nvec4 sourceAt(vec2 position) {\n\tvec2 p = position - 0.5;\n\tivec2 base = ivec2(floor(p));\n\tvec2 f = fract(p);\n\treturn mix(\n\t\tmix(sourcePixel(base), sourcePixel(base + ivec2(1, 0)), f.x),\n\t\tmix(sourcePixel(base + ivec2(0, 1)), sourcePixel(base + ivec2(1, 1)), f.x),\n\t\tf.y\n\t);\n}\n\nvoid main() {\n\tuint i = uint(gl_InstanceID);\n\tfloat depth = 1.0 / (1.0 + noise(i, 1u) * uSceneDepth / 2500.0);\n\tvec2 offset = (uOffset - 0.5) * uResolution;\n\tvec2 position;\n\tvec2 line = vec2(0.0);\n\tfloat radius;\n\tfloat alpha;\n\tif (uSnow == 1) {\n\t\tradius = max(uSize * 0.5 * depth * (1.0 + uSizeVariation * signedNoise(i, 2u)), 0.05);\n\t\tfloat speed = uSpeed * (uResolution.y / 600.0) * depth * (1.0 + uSpeedVariation * signedNoise(i, 3u));\n\t\tfloat wind = uWind * (uResolution.y / 1200.0) * depth * (1.0 + uWindVariation * signedNoise(i, 4u))\n\t\t\t+ uSpread * signedNoise(i, 8u) * depth;\n\t\tfloat amplitude = uWiggleAmount * 2.0 * depth * (1.0 + uWiggleAmountVariation * signedNoise(i, 5u));\n\t\tfloat frequency = uWiggleFrequency * (1.0 + uWiggleFrequencyVariation * signedNoise(i, 6u));\n\t\tfloat phase = noise(i, 9u) * 6.283185307179586;\n\t\tfloat margin = radius + abs(amplitude) + 2.0;\n\t\tposition.y = wrap(noise(i, 10u) * (uResolution.y + 2.0 * margin) + speed * uTime + offset.y, margin, uResolution.y);\n\t\tposition.x = wrap(noise(i, 11u) * (uResolution.x + 2.0 * margin) + wind * uTime + offset.x, margin, uResolution.x)\n\t\t\t+ amplitude * sin(frequency * uTime * 6.283185307179586 + phase);\n\t\talpha = uOpacity * (0.4 + 0.6 * depth);\n\t} else {\n\t\tfloat speed = uSpeed / 4000.0 * uResolution.y * 2.2 * depth;\n\t\tfloat wind = uWind / 1000.0 * uResolution.y * (1.0 + uWindVariation * signedNoise(i, 2u)) * depth\n\t\t\t+ uSpread * signedNoise(i, 7u) * depth;\n\t\tfloat length = max(speed * 0.04 * max(uSize, 0.2), 1.0);\n\t\tfloat horizontalLength = wind * 0.04 * max(uSize, 0.2);\n\t\tfloat margin = length + abs(horizontalLength) + 4.0;\n\t\tposition.y = wrap(noise(i, 3u) * (uResolution.y + 2.0 * margin) + speed * uTime + offset.y, margin, uResolution.y);\n\t\tposition.x = wrap(noise(i, 4u) * (uResolution.x + 2.0 * margin) + wind * uTime + offset.x, margin, uResolution.x);\n\t\tline = vec2(-horizontalLength, -length);\n\t\tradius = max(uSize * 0.6 * depth, 0.25);\n\t\talpha = uOpacity * (0.35 + 0.65 * depth);\n\t}\n\n\tvec3 color = uColor.rgb;\n\tif (uSnow == 0 && uRefract == 1) {\n\t\tvec4 sampleColor = sourceAt(position + vec2(2.0, 0.0));\n\t\tif (sampleColor.a > 0.0) {\n\t\t\tvec3 straight = sampleColor.a > 0.000001 ? sampleColor.rgb / sampleColor.a : vec3(0.0);\n\t\t\tcolor *= straight * 0.6 + 0.5;\n\t\t}\n\t}\n\n\tvPosition = position;\n\tvLine = line;\n\tvRadius = radius;\n\tvColor = vec4(color, alpha * uColor.a);\n\tfloat padding = max(radius, 0.5) + 1.0;\n\tvec2 minimum = min(position, position + line) - padding;\n\tvec2 maximum = max(position, position + line) + padding;\n\tvec2 corner = vec2(float(gl_VertexID & 1), float(gl_VertexID >> 1));\n\tvec2 pixel = mix(minimum, maximum, corner);\n\tgl_Position = vec4(pixel.x / uResolution.x * 2.0 - 1.0, 1.0 - pixel.y / uResolution.y * 2.0, 0.0, 1.0);\n}\n";
+export declare const WEATHER_FRAGMENT_SHADER = "#version 300 es\nprecision highp float;\nprecision highp int;\n\nuniform vec2 uResolution;\nuniform int uSnow;\n\nflat in vec2 vPosition;\nflat in vec2 vLine;\nflat in float vRadius;\nflat in vec4 vColor;\nout vec4 fragColor;\n\nvoid main() {\n\tif (vColor.a <= 0.00001) discard;\n\tvec2 delta = vec2(gl_FragCoord.x, uResolution.y - gl_FragCoord.y) - vPosition;\n\tfloat radius = max(vRadius, 0.5);\n\tfloat fade = min(vRadius / 0.5, 1.0);\n\tfloat coverage;\n\tif (uSnow == 1) {\n\t\tfloat distanceSquared = dot(delta, delta) / (radius * radius);\n\t\tif (distanceSquared >= 1.0) discard;\n\t\tfloat q = 1.0 - distanceSquared;\n\t\tcoverage = q * q;\n\t} else {\n\t\tfloat lengthSquared = dot(vLine, vLine);\n\t\tfloat along = lengthSquared > 0.0 ? clamp(dot(delta, vLine) / lengthSquared, 0.0, 1.0) : 0.0;\n\t\tcoverage = clamp(radius - length(delta - vLine * along) + 0.5, 0.0, 1.0);\n\t}\n\tfloat alpha = coverage * vColor.a * fade;\n\tif (alpha <= 0.000001) discard;\n\tfragColor = vec4(vColor.rgb * alpha, alpha);\n}\n";
+export declare const WEATHER_COMPOSITE_VERTEX_SHADER = "#version 300 es\nout vec2 vUv;\n\nvoid main() {\n\tvUv = vec2(float(gl_VertexID & 1), float(gl_VertexID >> 1));\n\tgl_Position = vec4(vUv * 2.0 - 1.0, 0.0, 1.0);\n}\n";
+export declare const WEATHER_COMPOSITE_FRAGMENT_SHADER = "#version 300 es\nprecision highp float;\n\nuniform sampler2D uSource;\nuniform sampler2D uWeather;\nuniform int uCompositeWithOriginal;\nuniform int uLighten;\n\nin vec2 vUv;\nout vec4 fragColor;\n\nvoid main() {\n\tvec4 weather = texture(uWeather, vUv);\n\tif (uCompositeWithOriginal == 0) {\n\t\tfragColor = weather;\n\t\treturn;\n\t}\n\tvec4 source = texture(uSource, vUv);\n\tif (uLighten == 1) {\n\t\tfragColor = vec4(max(source.rgb, weather.rgb), source.a + weather.a - source.a * weather.a);\n\t} else {\n\t\tfragColor = weather + source * (1.0 - weather.a);\n\t}\n}\n";

package/dist/weather/webgpu-runtime.d.ts

@@ -0,0 +1,36 @@
+import { type ParsedColorRgba } from '../color-utils.js';
+import type { WeatherRenderParams } from './runtime.js';
+export type WeatherWebGpuState = {
+    readonly context: GPUCanvasContext;
+    readonly colorCtx: CanvasRenderingContext2D;
+    cachedColor: string | null;
+    cachedColorRgba: ParsedColorRgba;
+    resources: {
+        readonly device: GPUDevice;
+        readonly particles: GPURenderPipeline;
+        readonly composite: GPURenderPipeline;
+        readonly uniforms: GPUBuffer;
+        readonly sampler: GPUSampler;
+        textures: {
+            readonly source: GPUTexture;
+            readonly weather: GPUTexture;
+            readonly particleGroup: GPUBindGroup;
+            readonly compositeGroup: GPUBindGroup;
+            readonly width: number;
+            readonly height: number;
+            readonly sourceWidth: number;
+            readonly sourceHeight: number;
+        } | null;
+    } | null;
+};
+export declare const setupWeatherWebGpu: (target: HTMLCanvasElement) => WeatherWebGpuState;
+export declare const cleanupWeatherWebGpu: (state: WeatherWebGpuState) => void;
+export declare const drawWeatherWebGpu: ({ state, source, width, height, device, params, type, }: {
+    state: WeatherWebGpuState;
+    source: CanvasImageSource;
+    width: number;
+    height: number;
+    device: GPUDevice;
+    params: WeatherRenderParams;
+    type: 'rain' | 'snow';
+}) => void;

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

@@ -0,0 +1 @@
+export declare const WEATHER_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 {\n resolution: vec2f, offset: vec2f, color: vec4f,\n snow: f32, time: f32, seed: u32, size: f32,\n sizeVariation: f32, sceneDepth: f32, speed: f32, speedVariation: f32,\n wind: f32, windVariation: f32, spread: f32, wiggleAmount: f32,\n wiggleAmountVariation: f32, wiggleFrequency: f32, wiggleFrequencyVariation: f32, opacity: f32,\n refract: f32, composite: f32, lighten: f32, padding: f32,\n}\nstruct ParticleOutput {\n @builtin(position) position: vec4f,\n @location(0) @interpolate(flat) particlePosition: vec2f,\n @location(1) @interpolate(flat) line: vec2f,\n @location(2) @interpolate(flat) radius: f32,\n @location(3) @interpolate(flat) color: vec4f,\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;\n@group(0) @binding(3) var weather: texture_2d<f32>;\nfn noise(i: u32, key: u32) -> f32 {\n\tvar h: u32 = (i * 0x8da6b343u) ^ (key * 0xd8163841u) ^ (params.seed * 0xcb1ab31fu);\n\th ^= h >> 13u;\n\th *= 0x5bd1e995u;\n\th ^= h >> 15u;\n\treturn f32(h & 0x00ffffffu) / 16777216.0;\n}\n\nfn signedNoise(i: u32, key: u32) -> f32 {\n\treturn noise(i, key) * 2.0 - 1.0;\n}\n\nfn wrap(value: f32, margin: f32, size: f32) -> f32 {\n\treturn -margin + (value + margin - floor((value + margin)/(size + 2.0*margin))*(size+2.0*margin));\n}\n\nfn sourcePixel(p: vec2i) -> vec4f {\n\tvar size: vec2i = vec2i(textureDimensions(source));\n\tif (p.x < 0 || p.y < 0 || p.x >= size.x || p.y >= size.y) {\n\t\treturn vec4f(0.0);\n\t}\n\treturn textureLoad(source,p,0);\n}\n\n// Bilinear sampling with transparent borders, at pixel centers of +0.5.\nfn sourceAt(position: vec2f) -> vec4f {\n\tvar p: vec2f = position - vec2f(0.5);\n\tvar base: vec2i = vec2i(floor(p));\n\tvar f: vec2f = fract(p);\n\treturn mix(\n\t\tmix(sourcePixel(base), sourcePixel(base + vec2i(1, 0)), f.x),\n\t\tmix(sourcePixel(base + vec2i(0, 1)), sourcePixel(base + vec2i(1, 1)), f.x),\n\t\tf.y\n\t);\n}\n\n@vertex fn particleVertex(@builtin(vertex_index) vertexIndex: u32, @builtin(instance_index) instanceIndex: u32) -> ParticleOutput {\n var output: ParticleOutput;\n\tvar i: u32 = instanceIndex;\n\tvar depth: f32 = 1.0 / (1.0 + noise(i, 1u) * params.sceneDepth / 2500.0);\n\tvar offset: vec2f = (params.offset - vec2f(0.5)) * params.resolution;\n\tvar position: vec2f ;\n\tvar line: vec2f = vec2f(0.0);\n\tvar radius: f32 ;\n\tvar alpha: f32 ;\n\tif (params.snow == 1) {\n\t\tradius = max(params.size * 0.5 * depth * (1.0 + params.sizeVariation * signedNoise(i, 2u)), 0.05);\n\t\tvar speed: f32 = params.speed * (params.resolution.y / 600.0) * depth * (1.0 + params.speedVariation * signedNoise(i, 3u));\n\t\tvar wind: f32 = params.wind * (params.resolution.y / 1200.0) * depth * (1.0 + params.windVariation * signedNoise(i, 4u))\n\t\t\t+ params.spread * signedNoise(i, 8u) * depth;\n\t\tvar amplitude: f32 = params.wiggleAmount * 2.0 * depth * (1.0 + params.wiggleAmountVariation * signedNoise(i, 5u));\n\t\tvar frequency: f32 = params.wiggleFrequency * (1.0 + params.wiggleFrequencyVariation * signedNoise(i, 6u));\n\t\tvar phase: f32 = noise(i, 9u) * 6.283185307179586;\n\t\tvar margin: f32 = radius + abs(amplitude) + 2.0;\n\t\tposition.y = wrap(noise(i, 10u) * (params.resolution.y + 2.0 * margin) + speed * params.time + offset.y, margin, params.resolution.y);\n\t\tposition.x = wrap(noise(i, 11u) * (params.resolution.x + 2.0 * margin) + wind * params.time + offset.x, margin, params.resolution.x)\n\t\t\t+ amplitude * sin(frequency * params.time * 6.283185307179586 + phase);\n\t\talpha = params.opacity * (0.4 + 0.6 * depth);\n\t} else {\n\t\tvar speed: f32 = params.speed / 4000.0 * params.resolution.y * 2.2 * depth;\n\t\tvar wind: f32 = params.wind / 1000.0 * params.resolution.y * (1.0 + params.windVariation * signedNoise(i, 2u)) * depth\n\t\t\t+ params.spread * signedNoise(i, 7u) * depth;\n\t\tvar length: f32 = max(speed * 0.04 * max(params.size, 0.2), 1.0);\n\t\tvar horizontalLength: f32 = wind * 0.04 * max(params.size, 0.2);\n\t\tvar margin: f32 = length + abs(horizontalLength) + 4.0;\n\t\tposition.y = wrap(noise(i, 3u) * (params.resolution.y + 2.0 * margin) + speed * params.time + offset.y, margin, params.resolution.y);\n\t\tposition.x = wrap(noise(i, 4u) * (params.resolution.x + 2.0 * margin) + wind * params.time + offset.x, margin, params.resolution.x);\n\t\tline = vec2f(-horizontalLength, -length);\n\t\tradius = max(params.size * 0.6 * depth, 0.25);\n\t\talpha = params.opacity * (0.35 + 0.65 * depth);\n\t}\n\n\tvar color: vec3f = params.color.rgb;\n\tif (params.snow == 0 && params.refract == 1) {\n\t\tvar sampleColor: vec4f = sourceAt(position + vec2f(2.0, 0.0));\n\t\tif (sampleColor.a > 0.0) {\n\t\t\tvar straight: vec3f = select(vec3f(0),sampleColor.rgb/max(sampleColor.a,0.000001),sampleColor.a>0.000001);\n\t\t\tcolor *= straight * 0.6 + vec3f(0.5);\n\t\t}\n\t}\n\n\toutput.particlePosition = position;\n\toutput.line = line;\n\toutput.radius = radius;\n\toutput.color = vec4f(color, alpha * params.color.a);\n\tvar padding: f32 = max(radius, 0.5) + 1.0;\n\tvar minimum: vec2f = min(position, position + line) - vec2f(padding);\n\tvar maximum: vec2f = max(position, position + line) + vec2f(padding);\n\tvar corner: vec2f = vec2f(f32(vertexIndex & 1u), f32(vertexIndex >> 1u));\n\tvar pixel: vec2f = mix(minimum, maximum, corner);\n\toutput.position = vec4f(pixel.x / params.resolution.x * 2.0 - 1.0, 1.0 - pixel.y / params.resolution.y * 2.0, 0.0, 1.0);\nreturn output;\n}\n@fragment fn particleFragment(input: ParticleOutput) -> @location(0) vec4f {\n\tif (input.color.a <= 0.00001) { discard; }\n\tvar delta: vec2f = input.position.xy - input.particlePosition;\n\tvar radius: f32 = max(input.radius, 0.5);\n\tvar fade: f32 = min(input.radius / 0.5, 1.0);\n\tvar coverage: f32 ;\n\tif (params.snow == 1) {\n\t\tvar distanceSquared: f32 = dot(delta, delta) / (radius * radius);\n\t\tif (distanceSquared >= 1.0) { discard; }\n\t\tvar q: f32 = 1.0 - distanceSquared;\n\t\tcoverage = q * q;\n\t} else {\n\t\tvar lengthSquared: f32 = dot(input.line, input.line);\n\t\tvar along: f32 = select(0.0,clamp(dot(delta, input.line)/max(lengthSquared,0.00000001),0.0,1.0),lengthSquared>0.0);\n\t\tcoverage = clamp(radius - length(delta - input.line * along) + 0.5, 0.0, 1.0);\n\t}\n\tvar alpha: f32 = coverage * input.color.a * fade;\n\tif (alpha <= 0.000001) { discard; }\n\treturn vec4f(input.color.rgb * alpha, alpha);\n}\n\n@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {\n let result=textureSampleLevel(weather,sourceSampler,input.uv,0);\n if(params.composite==0.0) { return result; }\n let original=textureSampleLevel(source,sourceSampler,input.uv,0);\n if(params.lighten==1.0) { return vec4f(max(original.rgb,result.rgb),original.a+result.a-original.a*result.a); }\n return result+original*(1.0-result.a);\n}\n";

package/dist/webgl-projection-runtime.d.ts

@@ -0,0 +1,18 @@
+export type WebGlProjectionState = {
+    gl: WebGL2RenderingContext;
+    program: WebGLProgram;
+    texture: WebGLTexture;
+    vao: WebGLVertexArrayObject;
+    uniforms: WebGLUniformLocation | null;
+    source: WebGLUniformLocation | null;
+};
+export declare const setupWebGlProjection: (target: HTMLCanvasElement, shader: string) => WebGlProjectionState;
+export declare const applyWebGlProjection: ({ state, source, width, height, flipSourceY, uniformData, }: {
+    state: WebGlProjectionState;
+    source: CanvasImageSource;
+    width: number;
+    height: number;
+    flipSourceY: boolean;
+    uniformData: Float32Array<ArrayBuffer>;
+}) => void;
+export declare const cleanupWebGlProjection: ({ gl, program, texture, vao, }: WebGlProjectionState) => void;

package/dist/webgpu-color-state.d.ts

@@ -0,0 +1,10 @@
+import { type WebGpuSinglePassState } from './webgpu-single-pass-runtime.js';
+export type WebGpuColorState = WebGpuSinglePassState & {
+    readonly colorContext: CanvasRenderingContext2D;
+    colors: {
+        key: string;
+        data: Uint8Array<ArrayBuffer>;
+    } | null;
+};
+export declare const setupWebGpuColors: (target: HTMLCanvasElement, label: string) => WebGpuColorState;
+export declare const getWebGpuColors: (state: WebGpuColorState, colors: readonly string[]) => Uint8Array<ArrayBuffer>;

package/dist/webgpu-mesh-runtime.d.ts

@@ -0,0 +1,46 @@
+export type WebGpuMeshState = {
+    readonly context: GPUCanvasContext;
+    readonly label: string;
+    resources: {
+        readonly device: GPUDevice;
+        readonly shader: string;
+        readonly uniformSize: number;
+        readonly topology: GPUPrimitiveTopology;
+        readonly blend: boolean;
+        readonly pipeline: GPURenderPipeline;
+        readonly flipPipeline: GPURenderPipeline;
+        readonly sampler: GPUSampler;
+        readonly uniforms: GPUBuffer;
+        multisample: {
+            readonly resolved: GPUTexture;
+            readonly texture: GPUTexture;
+            readonly width: number;
+            readonly height: number;
+        } | null;
+        vertices: {
+            readonly buffer: GPUBuffer;
+            readonly size: number;
+        } | null;
+        source: {
+            readonly texture: GPUTexture;
+            readonly width: number;
+            readonly height: number;
+        } | null;
+    } | null;
+};
+export declare const setupWebGpuMesh: (target: HTMLCanvasElement, label: string) => WebGpuMeshState;
+export declare const cleanupWebGpuMesh: (state: WebGpuMeshState) => void;
+export declare const applyWebGpuMesh: ({ state, source, width, height, vertices, device, shader, uniformData, topology, blend, vertexCount, instanceCount, }: {
+    state: WebGpuMeshState;
+    source: CanvasImageSource;
+    width: number;
+    height: number;
+    vertices: Float32Array | null;
+    shader: string;
+    uniformData: Float32Array<ArrayBuffer>;
+    topology: GPUPrimitiveTopology;
+    blend: boolean;
+    vertexCount: number;
+    instanceCount: number;
+    device: GPUDevice;
+}) => void;

package/dist/webgpu-multipass-runtime.d.ts

@@ -0,0 +1,50 @@
+export declare const WEBGPU_MULTIPASS_BINDINGS = "\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;\n@group(0) @binding(3) var secondary: texture_2d<f32>;\n";
+export type WebGpuPass = {
+    readonly shader: string;
+    readonly uniforms: Float32Array<ArrayBuffer>;
+    readonly source: number;
+    readonly secondary: number;
+};
+type PassResources = {
+    readonly shader: string;
+    readonly size: number;
+    readonly format: GPUTextureFormat;
+    readonly pipeline: GPURenderPipeline;
+    readonly uniforms: GPUBuffer;
+};
+export type WebGpuMultipassState = {
+    readonly context: GPUCanvasContext;
+    readonly label: string;
+    resources: {
+        readonly device: GPUDevice;
+        readonly layout: GPUBindGroupLayout;
+        readonly sampler: GPUSampler;
+        readonly format: GPUTextureFormat;
+        readonly passes: PassResources[];
+        readonly textures: GPUTexture[];
+        auxiliary: {
+            readonly texture: GPUTexture;
+            readonly width: number;
+            readonly height: number;
+        } | null;
+        width: number;
+        height: number;
+        source: {
+            readonly texture: GPUTexture;
+            readonly width: number;
+            readonly height: number;
+        } | null;
+    } | null;
+};
+export declare const setupWebGpuMultipass: (target: HTMLCanvasElement, label: string) => WebGpuMultipassState;
+export declare const cleanupWebGpuMultipass: (state: WebGpuMultipassState) => void;
+export declare const applyWebGpuMultipass: ({ state, source, width, height, device, passes, auxiliarySource, }: {
+    state: WebGpuMultipassState;
+    source: CanvasImageSource;
+    width: number;
+    height: number;
+    device: GPUDevice;
+    passes: readonly WebGpuPass[];
+    auxiliarySource: HTMLCanvasElement | null;
+}) => void;
+export {};

package/dist/webgpu-projection-runtime.d.ts

@@ -2,18 +2,22 @@ export type WebGpuProjectionState = {
     context: GPUCanvasContext;
     resources: {
         device: GPUDevice;
+        shader: string;
+        format: GPUTextureFormat;
         pipeline: GPURenderPipeline;
         uniforms: GPUBuffer;
         sampler: GPUSampler;
-        texture: GPUTexture;
-        bindGroup: GPUBindGroup;
-        width: number;
-        height: number;
+        source: {
+            texture: GPUTexture;
+            bindGroup: GPUBindGroup;
+            width: number;
+            height: number;
+        } | null;
     } | null;
 };
 export declare const cleanupWebGpuProjection: (state: WebGpuProjectionState) => void;
 export declare const setupWebGpuProjection: (target: HTMLCanvasElement, label: string) => WebGpuProjectionState;
-export declare const applyWebGpuProjection: ({ state, source, width, height, device, shader, uniformData, }: {
+export declare const applyWebGpuProjection: ({ state, source, device, shader, uniformData, }: {
     state: WebGpuProjectionState;
     source: CanvasImageSource;
     width: number;

package/dist/webgpu-single-pass-runtime.d.ts

@@ -0,0 +1,47 @@
+export type WebGpuSinglePassState = {
+    readonly context: GPUCanvasContext;
+    readonly label: string;
+    resources: {
+        readonly device: GPUDevice;
+        readonly shader: string;
+        readonly uniformBufferSize: number;
+        readonly sourceFilter: GPUFilterMode;
+        readonly auxiliary: {
+            readonly texture: GPUTexture;
+            readonly width: number;
+            readonly height: number;
+            readonly format: 'rgba8unorm' | 'rgba32float';
+            uploadedData: Uint8Array<ArrayBuffer> | Float32Array<ArrayBuffer> | null;
+        } | null;
+        readonly pipeline: GPURenderPipeline;
+        readonly uniforms: GPUBuffer;
+        readonly sampler: GPUSampler;
+        readonly bindGroupLayout: GPUBindGroupLayout;
+        source: {
+            readonly texture: GPUTexture;
+            readonly bindGroup: GPUBindGroup;
+            readonly width: number;
+            readonly height: number;
+        } | null;
+    } | null;
+};
+export declare const WEBGPU_SINGLE_PASS_VERTEX = "\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";
+export declare const setupWebGpuSinglePass: (target: HTMLCanvasElement, label: string) => WebGpuSinglePassState;
+export declare const cleanupWebGpuSinglePass: (state: WebGpuSinglePassState) => void;
+export declare const applyWebGpuSinglePass: ({ state, source, device, shader, uniformData, }: {
+    state: WebGpuSinglePassState;
+    source: CanvasImageSource;
+    width: number;
+    height: number;
+    device: GPUDevice;
+    shader: string;
+    uniformData: Float32Array<ArrayBuffer>;
+}, options?: {
+    sourceFilter: GPUFilterMode | null;
+    auxiliaryTexture: {
+        data: Uint8Array<ArrayBuffer> | Float32Array<ArrayBuffer>;
+        width: number;
+        height: number;
+        format: 'rgba8unorm' | 'rgba32float';
+    } | null;
+} | null) => void;

package/dist/white-noise-webgpu-shader.d.ts

@@ -0,0 +1 @@
+export declare const WHITE_NOISE_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;\n\nstruct Params { size: vec2f, amount: f32, seed: f32, }\nfn random(co: vec2f) -> f32 {\n  return fract(sin(dot(co, vec2f(12.9898, 78.233)) + params.seed * 37.719) * 43758.5453);\n}\n@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {\n  let color = textureSampleLevel(source, sourceSampler, input.uv, 0);\n  let noise = random(vec2f(input.position.x, params.size.y - input.position.y));\n  var rgb = vec3f(0);\n  if (color.a != 0.0) { rgb = color.rgb / color.a; }\n  return vec4f(mix(rgb, vec3f(noise), params.amount) * color.a, color.a);\n}\n\n";

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

@@ -0,0 +1 @@
+export declare const ZIGZAG_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 sourceTexture: 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 palette: texture_2d<f32>;\nstruct Params {\n geometry: vec4f,\n stripe: vec4f,\n flags: vec4f,\n wave: vec4f,\n}\nfn sampleSource(uv: vec2f) -> vec4f {\n return textureSampleLevel(sourceTexture, sourceSampler, vec2f(uv.x, 1.0 - uv.y), 0);\n}\nfn glslModulo(value: f32, divisor: f32) -> f32 { return value - divisor * floor(value / divisor); }\nfn paletteColor(index: f32) -> vec4f { return textureLoad(palette, vec2i(i32(index), 0), 0); }\n\n@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {\n let vUv = vec2f(input.uv.x, 1.0 - input.uv.y);\n\n let texColor = sampleSource(vUv);\n let thickness = max(params.stripe.x, 0.001);\n let spacing = max(params.stripe.y, 0.001);\n let cycle = spacing * params.geometry.z;\n let centered = vec2f(input.position.x, params.geometry.y - input.position.y) - params.geometry.xy * 0.5;\n let s = sin(params.stripe.z);\n let c = cos(params.stripe.z);\n let rotated = vec2f(centered.x * c - centered.y * s, centered.x * s + centered.y * c);\n var axis = select(rotated.x, rotated.y, params.geometry.w == 0.0);\n let waveAxis = select(rotated.y, rotated.x, params.geometry.w == 0.0);\nlet phase = fract(waveAxis / max(params.wave.y, 0.001));\n axis += (1.0 - abs(phase * 2.0 - 1.0) * 2.0) * params.wave.x;\n\n var position = glslModulo(axis + params.stripe.w, cycle);\n if (position < 0.0) { position += cycle; }\n // Snap rounding noise at exact band boundaries before choosing the palette entry.\n var stripeIndex = position / spacing;\n let nearestIndex = floor(stripeIndex + 0.5);\n if (abs(stripeIndex - nearestIndex) < 0.00001) { stripeIndex = nearestIndex; }\n let colorIndex = glslModulo(floor(stripeIndex), params.geometry.z);\n let inStripe = glslModulo(position, spacing);\n if (inStripe > thickness) { return texColor; }\n\n let overlay = paletteColor(colorIndex);\n let premultiplied = overlay.rgb * overlay.a;\n if (params.flags.x != 0.0) {\n  return vec4f(premultiplied * texColor.a + texColor.rgb * (1.0 - overlay.a), texColor.a);\n }\n return vec4f(premultiplied + texColor.rgb * (1.0 - overlay.a), overlay.a + texColor.a * (1.0 - overlay.a));\n\n}\n";

package/dist/zoom-blur/webgpu-shader.d.ts

@@ -0,0 +1 @@
+export declare const ZOOM_BLUR_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 { resolutionAndCenter: vec4f, amountAndSamples: vec4f, }\n@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {\n  let resolution = params.resolutionAndCenter.xy;\n  let center = vec2f(params.resolutionAndCenter.z, 1.0 - params.resolutionAndCenter.w);\n  let direction = input.uv - center;\n  let amount = params.amountAndSamples.x / min(resolution.x, resolution.y);\n  let samples = i32(params.amountAndSamples.y);\n  var color = vec4f(0);\n  var total = 0.0;\n  for (var i = 0; i < 64; i++) {\n    if (i >= samples) { break; }\n    let denominator = max(f32(samples - 1), 1.0);\n    let progress = f32(i) / denominator;\n    let uv = clamp(input.uv - direction * amount * progress, vec2f(0), vec2f(1));\n    color += textureSampleLevel(source, sourceSampler, uv, 0);\n    total += 1.0;\n  }\n  return color / total;\n}\n";