@remotion/effects 4.0.541 → 4.0.543

package/dist/esm/preview/lightning.mjs

@@ -0,0 +1,603 @@
+import {
+  setupSinglePass,
+  prepareSinglePassSource,
+  drawSinglePass,
+  cleanupSinglePass
+} from "./index-8p04sssx.mjs";
+import {
+  validateUnitInterval,
+  parseColorRgba
+} from "./index-wxhvgv2s.mjs";
+import {
+  WEBGPU_SINGLE_PASS_VERTEX,
+  setupWebGpuSinglePass,
+  cleanupWebGpuSinglePass,
+  applyWebGpuSinglePass
+} from "./index-tvfexb7s.mjs";
+import {
+  assertEffectParamsObject,
+  assertRequiredFiniteNumber,
+  assertOptionalColor,
+  assertOptionalBoolean
+} from "./index-4fvp93ps.mjs";
+
+// src/lightning/index.ts
+import { Internals } from "remotion";
+
+// src/lightning/geometry.ts
+var lightningSegments = (p, width, height, alpha) => {
+  const seed = BigInt(Math.floor(p.conductivityState)) ^ BigInt(p.seed) << 32n;
+  let state = BigInt.asUintN(64, seed * 0x9e3779b97f4a7c15n) ^ 0xd1b54a32d192ed03n | 1n;
+  const random = () => {
+    state ^= state >> 12n;
+    state ^= BigInt.asUintN(64, state << 25n);
+    state ^= state >> 27n;
+    return Number(BigInt.asUintN(64, state * 0x2545f4914f6cdd1dn) >> 11n) / 2 ** 53;
+  };
+  const alphaAt = (x, y) => {
+    if (!alpha)
+      return 0;
+    const px = Math.max(0, Math.min(width - 1, x - 0.5));
+    const py = Math.max(0, Math.min(height - 1, y - 0.5));
+    const x0 = Math.floor(px);
+    const y0 = Math.floor(py);
+    const x1 = Math.min(width - 1, x0 + 1);
+    const y1 = Math.min(height - 1, y0 + 1);
+    const tx = px - x0;
+    const ty = py - y0;
+    const { data } = alpha;
+    return ((data[(y0 * width + x0) * 4 + 3] * (1 - tx) + data[(y0 * width + x1) * 4 + 3] * tx) * (1 - ty) + (data[(y1 * width + x0) * 4 + 3] * (1 - tx) + data[(y1 * width + x1) * 4 + 3] * tx) * ty) / 255;
+  };
+  const origin = [p.origin[0] * width, p.origin[1] * height];
+  const direction = [p.direction[0] * width, p.direction[1] * height];
+  const dx = direction[0] - origin[0];
+  const dy = direction[1] - origin[1];
+  const distance = Math.hypot(dx, dy);
+  const depth = p.complexity + Number(p.fractalType === "spline");
+  const shape = { linear: 1, "semi-linear": 0.7, spline: 0.45 }[p.fractalType];
+  const turbulence = p.turbulence * (p.lightningType === "bouncy" ? 1.6 : 1);
+  const forking = p.lightningType === "breaking" ? Math.min(1, p.forking * (0.5 + distance / Math.max(width, height, 1))) : p.forking;
+  const segments = [];
+  const grow = (segment, remaining) => {
+    const { start, end, intensity, main } = segment;
+    if (segments.length > 20000)
+      return;
+    const vx = end[0] - start[0];
+    const vy = end[1] - start[1];
+    const length = Math.hypot(vx, vy);
+    if (remaining === 0 || length < 1) {
+      segments.push(segment);
+      return;
+    }
+    const nx = -vy / length;
+    const ny = vx / length;
+    let offset = (random() * 2 - 1) * length * 0.22 * turbulence * shape;
+    const mx = (start[0] + end[0]) / 2;
+    const my = (start[1] + end[1]) / 2;
+    if (alpha && (main || !p.mainCoreCollisionOnly)) {
+      const delta = alphaAt(mx + nx * offset, my + ny * offset) - alphaAt(mx - nx * offset, my - ny * offset);
+      if (delta * p.alphaObstacle > 0 && random() < Math.abs(p.alphaObstacle) / 10)
+        offset = -offset;
+    }
+    const mid = [mx + nx * offset, my + ny * offset];
+    if (!main && p.alphaObstacle > 0 && alphaAt(...mid) > 0.5 && random() < p.alphaObstacle / 10)
+      return;
+    grow({ start, end: mid, intensity, main }, remaining - 1);
+    grow({ start: mid, end, intensity, main }, remaining - 1);
+    if (random() < forking && intensity > p.terminationThreshold && length >= p.minForkDistance) {
+      const angle = (random() * 2 - 1) * 0.7;
+      const fx = mid[0] - start[0];
+      const fy = mid[1] - start[1];
+      const forkEnd = [
+        mid[0] + 1.2 * (fx * Math.cos(angle) - fy * Math.sin(angle)),
+        mid[1] + 1.2 * (fx * Math.sin(angle) + fy * Math.cos(angle))
+      ];
+      const variation = p.forkVariation > 0 ? 1 - p.forkVariation * random() : 1;
+      grow({
+        start: mid,
+        end: forkEnd,
+        intensity: Math.min(1, intensity * (1 - p.decay) * p.forkStrength * 2 * variation),
+        main: false
+      }, remaining - 1);
+    }
+  };
+  const growMain = (start, end, subdivisions) => grow({ start, end, intensity: 1, main: true }, subdivisions);
+  switch (p.lightningType) {
+    case "direction":
+      growMain(origin, [origin[0] + dx * 3, origin[1] + dy * 3], depth);
+      break;
+    case "vertical":
+      growMain(origin, [origin[0], height], depth);
+      break;
+    case "two-way-strike": {
+      const mid = [origin[0] + dx / 2, origin[1] + dy / 2];
+      const halfDepth = Math.max(1, depth - 1);
+      growMain(origin, mid, halfDepth);
+      growMain(direction, mid, halfDepth);
+      break;
+    }
+    case "omni":
+    case "anywhere": {
+      const radius = Math.max(distance, Math.min(width, height) * 0.25);
+      for (let i = 0;i < 4; i++) {
+        const angle = random() * 2 * Math.PI;
+        const length = p.lightningType === "anywhere" ? radius * (0.3 + 0.7 * random()) : radius;
+        growMain(origin, [
+          origin[0] + Math.cos(angle) * length,
+          origin[1] + Math.sin(angle) * length
+        ], depth);
+      }
+      break;
+    }
+    default:
+      growMain(origin, direction, depth);
+  }
+  if (p.decayMainCore || p.coreDrain > 0) {
+    const distanceFromOrigin = (point) => Math.hypot(point[0] - origin[0], point[1] - origin[1]);
+    const farthest = segments.reduce((max, segment) => Math.max(max, distanceFromOrigin(segment.end)), 0.000000001);
+    for (const segment of segments) {
+      const fraction = distanceFromOrigin(segment.start) / farthest;
+      if (p.decayMainCore)
+        segment.intensity *= Math.max(0, 1 - p.decay * fraction);
+      if (segment.main)
+        segment.intensity *= Math.max(0, 1 - p.coreDrain * fraction);
+    }
+  }
+  return segments;
+};
+
+// src/lightning/mask.ts
+var blurRows = (input, output, width, radius) => {
+  const height = input.length / width;
+  const weight = 1 / (2 * radius + 1);
+  for (let y = 0;y < height; y++) {
+    const row = y * width;
+    let sum = input[row] * (radius + 1);
+    for (let x = 1;x <= radius; x++)
+      sum += input[row + Math.min(width - 1, x)];
+    for (let x = 0;x < width; x++) {
+      output[row + x] = sum * weight;
+      sum += input[row + Math.min(width - 1, x + radius + 1)] - input[row + Math.max(0, x - radius)];
+    }
+  }
+};
+var transpose = (input, output, width, height) => {
+  for (let x = 0;x < width; x++) {
+    for (let y = 0;y < height; y++)
+      output[x * height + y] = input[y * width + x];
+  }
+};
+var makeLightningMask = (p, width, height, alpha) => {
+  const segments = lightningSegments(p, width, height, alpha);
+  const data = new Uint8Array(width * height * 4);
+  const coreRadius = Math.max(0.3, p.coreRadius);
+  const sigma = p.glowRadius / 3;
+  const idealWidth = Math.sqrt(4 * sigma * sigma + 1);
+  const lowerWidth = 2 * Math.floor((idealWidth - 1) / 2) + 1;
+  const lowerPasses = Math.round((12 * sigma * sigma - 3 * lowerWidth ** 2 - 12 * lowerWidth - 9) / (-4 * lowerWidth - 4));
+  const radii = p.glowRadius > 0.5 ? [0, 1, 2].map((pass) => (lowerWidth - 1) / 2 + Number(pass >= lowerPasses)) : [];
+  const margin = coreRadius + 1 + radii.reduce((total, r) => total + r, 0);
+  let left = width;
+  let top = height;
+  let right = 0;
+  let bottom = 0;
+  for (const { start, end } of segments) {
+    left = Math.min(left, Math.floor(Math.min(start[0], end[0]) - margin));
+    right = Math.max(right, Math.ceil(Math.max(start[0], end[0]) + margin));
+    top = Math.min(top, Math.floor(Math.min(start[1], end[1]) - margin));
+    bottom = Math.max(bottom, Math.ceil(Math.max(start[1], end[1]) + margin));
+  }
+  left = Math.max(0, left);
+  top = Math.max(0, top);
+  right = Math.min(width, right);
+  bottom = Math.min(height, bottom);
+  const w = right - left;
+  const h = bottom - top;
+  if (w <= 0 || h <= 0)
+    return data;
+  let core = new Float32Array(w * h);
+  for (const { start, end, intensity } of segments) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const lengthSq = Math.max(0.000000000001, dx * dx + dy * dy);
+    const x0 = Math.max(left, Math.floor(Math.min(start[0], end[0]) - coreRadius - 1));
+    const y0 = Math.max(top, Math.floor(Math.min(start[1], end[1]) - coreRadius - 1));
+    const x1 = Math.min(right, Math.ceil(Math.max(start[0], end[0]) + coreRadius + 1));
+    const y1 = Math.min(bottom, Math.ceil(Math.max(start[1], end[1]) + coreRadius + 1));
+    for (let y = y0;y < y1; y++) {
+      const py = y + 0.5 - start[1];
+      for (let x = x0;x < x1; x++) {
+        const px = x + 0.5 - start[0];
+        const t = Math.max(0, Math.min(1, (px * dx + py * dy) / lengthSq));
+        const distance = Math.sqrt((px - dx * t) ** 2 + (py - dy * t) ** 2);
+        const coverage = Math.min(1, coreRadius + 0.5 - distance) * intensity;
+        const index = (y - top) * w + x - left;
+        if (coverage > core[index])
+          core[index] = coverage;
+      }
+    }
+  }
+  for (let y = 0;y < h; y++) {
+    for (let x = 0;x < w; x++)
+      data[((y + top) * width + x + left) * 4] = Math.round(core[y * w + x] * 255);
+  }
+  if (radii.length === 0)
+    return data;
+  let scratch = new Float32Array(w * h);
+  for (const radius of radii) {
+    if (radius === 0)
+      continue;
+    blurRows(core, scratch, w, radius);
+    [core, scratch] = [scratch, core];
+  }
+  transpose(core, scratch, w, h);
+  [core, scratch] = [scratch, core];
+  for (const radius of radii) {
+    if (radius === 0)
+      continue;
+    blurRows(core, scratch, h, radius);
+    [core, scratch] = [scratch, core];
+  }
+  for (let x = 0;x < w; x++) {
+    for (let y = 0;y < h; y++)
+      data[((y + top) * width + x + left) * 4 + 1] = Math.round(Math.min(1, core[x * h + y] * 3) * 255);
+  }
+  return data;
+};
+
+// src/lightning/params.ts
+var numberField = (description, defaultValue, [min, max], step) => ({
+  type: "number",
+  description,
+  default: defaultValue,
+  min,
+  max,
+  step,
+  hiddenFromList: false
+});
+var uvCoordinateField = (description, defaultValue) => ({
+  type: "uv-coordinate",
+  description,
+  default: defaultValue,
+  min: 0,
+  max: 1,
+  step: 0.01
+});
+var lightningSchema = {
+  lightningType: {
+    type: "enum",
+    description: "Lightning type",
+    variants: {
+      direction: {},
+      strike: {},
+      breaking: {},
+      bouncy: {},
+      omni: {},
+      anywhere: {},
+      vertical: {},
+      "two-way-strike": {}
+    },
+    default: "strike"
+  },
+  origin: {
+    ...uvCoordinateField("Origin", [0.5, 0]),
+    visual: { type: "line", to: "direction" }
+  },
+  direction: uvCoordinateField("Direction", [0.5, 1]),
+  conductivityState: numberField("Conductivity state", 10, [0, 1e5], 1),
+  coreRadius: numberField("Core radius", 3, [0, 100], 0.1),
+  coreOpacity: numberField("Core opacity", 0.75, [0, 1], 0.01),
+  coreColor: { type: "color", description: "Core color", default: "#ffffff" },
+  glowRadius: numberField("Glow radius", 50, [0, 1000], 0.1),
+  glowOpacity: numberField("Glow opacity", 0.5, [0, 1], 0.01),
+  glowColor: { type: "color", description: "Glow color", default: "#4059ff" },
+  turbulence: numberField("Turbulence", 1, [0, 10], 0.01),
+  forking: numberField("Forking", 0.25, [0, 1], 0.01),
+  decay: numberField("Decay", 0.3, [0, 1], 0.01),
+  decayMainCore: {
+    type: "boolean",
+    description: "Decay main core",
+    default: false
+  },
+  alphaObstacle: numberField("Alpha obstacle", 0, [-10, 10], 0.1),
+  compositeOnOriginal: {
+    type: "boolean",
+    description: "Composite on original",
+    default: true
+  },
+  complexity: { ...numberField("Complexity", 6, [1, 12], 1), integer: true },
+  minForkDistance: numberField("Min fork distance", 0, [0, 1000], 1),
+  terminationThreshold: numberField("Termination threshold", 0.05, [0, 1], 0.01),
+  mainCoreCollisionOnly: {
+    type: "boolean",
+    description: "Main core collision only",
+    default: false
+  },
+  fractalType: {
+    type: "enum",
+    description: "Fractal type",
+    variants: { linear: {}, "semi-linear": {}, spline: {} },
+    default: "linear"
+  },
+  coreDrain: numberField("Core drain", 0, [0, 1], 0.01),
+  forkStrength: numberField("Fork strength", 0.5, [0, 1], 0.01),
+  forkVariation: numberField("Fork variation", 0, [0, 1], 0.01),
+  seed: { ...numberField("Seed", 0, [0, 4294967295], 1), integer: true }
+};
+var resolve = (params) => ({
+  lightningType: params.lightningType ?? lightningSchema.lightningType.default,
+  origin: params.origin ?? lightningSchema.origin.default,
+  direction: params.direction ?? lightningSchema.direction.default,
+  conductivityState: params.conductivityState ?? lightningSchema.conductivityState.default,
+  coreRadius: params.coreRadius ?? lightningSchema.coreRadius.default,
+  coreOpacity: params.coreOpacity ?? lightningSchema.coreOpacity.default,
+  coreColor: params.coreColor ?? lightningSchema.coreColor.default,
+  glowRadius: params.glowRadius ?? lightningSchema.glowRadius.default,
+  glowOpacity: params.glowOpacity ?? lightningSchema.glowOpacity.default,
+  glowColor: params.glowColor ?? lightningSchema.glowColor.default,
+  turbulence: params.turbulence ?? lightningSchema.turbulence.default,
+  forking: params.forking ?? lightningSchema.forking.default,
+  decay: params.decay ?? lightningSchema.decay.default,
+  decayMainCore: params.decayMainCore ?? lightningSchema.decayMainCore.default,
+  alphaObstacle: params.alphaObstacle ?? lightningSchema.alphaObstacle.default,
+  compositeOnOriginal: params.compositeOnOriginal ?? lightningSchema.compositeOnOriginal.default,
+  complexity: params.complexity ?? lightningSchema.complexity.default,
+  minForkDistance: params.minForkDistance ?? lightningSchema.minForkDistance.default,
+  terminationThreshold: params.terminationThreshold ?? lightningSchema.terminationThreshold.default,
+  mainCoreCollisionOnly: params.mainCoreCollisionOnly ?? lightningSchema.mainCoreCollisionOnly.default,
+  fractalType: params.fractalType ?? lightningSchema.fractalType.default,
+  coreDrain: params.coreDrain ?? lightningSchema.coreDrain.default,
+  forkStrength: params.forkStrength ?? lightningSchema.forkStrength.default,
+  forkVariation: params.forkVariation ?? lightningSchema.forkVariation.default,
+  seed: params.seed ?? lightningSchema.seed.default
+});
+var validateLightningParams = (params) => {
+  assertEffectParamsObject(params, "Lightning");
+  for (const [name, field] of Object.entries(lightningSchema)) {
+    const value = params[name];
+    if (value === undefined)
+      continue;
+    switch (field.type) {
+      case "number":
+        assertRequiredFiniteNumber(value, name);
+        if (typeof value !== "number" || value < field.min || value > field.max) {
+          throw new TypeError(`"${name}" must be between ${field.min} and ${field.max}`);
+        }
+        if ("integer" in field && !Number.isInteger(value)) {
+          throw new TypeError(`"${name}" must be an integer`);
+        }
+        break;
+      case "uv-coordinate":
+        if (!Array.isArray(value) || value.length !== 2)
+          throw new TypeError(`"${name}" must be a [number, number] tuple`);
+        for (const coordinate of value) {
+          assertRequiredFiniteNumber(coordinate, name);
+          validateUnitInterval(coordinate, name);
+        }
+        break;
+      case "boolean":
+        assertOptionalBoolean(value, name);
+        break;
+      case "color":
+        assertOptionalColor(value, name);
+        break;
+      case "enum":
+        if (typeof value !== "string" || !Object.hasOwn(field.variants, value))
+          throw new TypeError(`Invalid "${name}": ${JSON.stringify(value)}`);
+        break;
+      default:
+        throw new TypeError(`Unknown lightning field "${name}"`);
+    }
+  }
+};
+
+// src/lightning/shaders.ts
+var LIGHTNING_FRAGMENT_SHADER = `#version 300 es
+precision highp float;
+uniform sampler2D uSource;
+uniform sampler2D uMask;
+uniform vec4 uCore;
+uniform vec4 uGlow;
+uniform float uComposite;
+in vec2 vUv;
+out vec4 fragColor;
+
+void main() {
+	vec4 source = texture(uSource, vUv) * uComposite;
+	vec2 mask = texture(uMask, vec2(vUv.x, 1.0 - vUv.y)).rg;
+	float core = mask.r * uCore.a;
+	float glow = mask.g * uGlow.a;
+	float alpha = source.a + max(core, glow) * (1.0 - source.a);
+	vec3 color = source.rgb + uCore.rgb * core + uGlow.rgb * glow;
+	fragColor = vec4(min(color, vec3(alpha)), alpha);
+}
+`;
+var LIGHTNING_WEBGPU_SHADER = `
+${WEBGPU_SINGLE_PASS_VERTEX}
+struct Params { core: vec4f, glow: vec4f, composite: f32 }
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var sourceSampler: sampler;
+@group(0) @binding(2) var<uniform> params: Params;
+@group(0) @binding(3) var mask: texture_2d<f32>;
+
+@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {
+	let src = textureSampleLevel(source, sourceSampler, input.uv, 0) * params.composite;
+	let coverage = textureLoad(mask, vec2i(input.position.xy), 0).rg;
+	let core = coverage.r * params.core.a;
+	let glow = coverage.g * params.glow.a;
+	let alpha = src.a + max(core, glow) * (1.0 - src.a);
+	let color = src.rgb + params.core.rgb * core + params.glow.rgb * glow;
+	return vec4f(min(color, vec3f(alpha)), alpha);
+}
+`;
+
+// src/lightning/index.ts
+var setupLightning = () => {
+  const canvas = document.createElement("canvas");
+  canvas.width = 1;
+  canvas.height = 1;
+  const ctx = canvas.getContext("2d", { willReadFrequently: true });
+  if (!ctx)
+    throw new Error("Could not acquire a 2D context for lightning");
+  return { ctx, mask: null };
+};
+var prepareLightning = ({
+  state,
+  params,
+  source,
+  width,
+  height,
+  sourceIsFlipped
+}) => {
+  const p = resolve(params);
+  const {
+    coreColor,
+    coreOpacity,
+    glowColor,
+    glowOpacity,
+    compositeOnOriginal,
+    ...shape
+  } = p;
+  const key = JSON.stringify([width, height, shape]);
+  const { ctx } = state;
+  if (state.mask?.key !== key || p.alphaObstacle !== 0) {
+    let alpha = null;
+    if (p.alphaObstacle !== 0) {
+      if (ctx.canvas.width !== width)
+        ctx.canvas.width = width;
+      if (ctx.canvas.height !== height)
+        ctx.canvas.height = height;
+      ctx.clearRect(0, 0, width, height);
+      ctx.save();
+      try {
+        if (sourceIsFlipped) {
+          ctx.translate(0, height);
+          ctx.scale(1, -1);
+        }
+        ctx.drawImage(source, 0, 0, width, height);
+      } finally {
+        ctx.restore();
+      }
+      alpha = ctx.getImageData(0, 0, width, height);
+    }
+    state.mask = { key, data: makeLightningMask(p, width, height, alpha) };
+  }
+  const core = parseColorRgba(ctx, coreColor);
+  const glow = parseColorRgba(ctx, glowColor);
+  return {
+    data: state.mask.data,
+    uniforms: new Float32Array([
+      core[0] / 255,
+      core[1] / 255,
+      core[2] / 255,
+      core[3] / 255 * coreOpacity,
+      glow[0] / 255,
+      glow[1] / 255,
+      glow[2] / 255,
+      glow[3] / 255 * glowOpacity,
+      Number(compositeOnOriginal),
+      0,
+      0,
+      0
+    ])
+  };
+};
+var lightning = Internals.createEffect({
+  type: "remotion/lightning",
+  label: "lightning()",
+  documentationLink: "https://www.remotion.dev/docs/effects/lightning",
+  calculateKey: (params) => `lightning-${JSON.stringify(resolve(params))}`,
+  schema: lightningSchema,
+  validateParams: validateLightningParams,
+  implementations: {
+    webgl2: Internals.createEffectImplementation({
+      setup: (target) => {
+        const shared = setupLightning();
+        const pass = setupSinglePass(target, LIGHTNING_FRAGMENT_SHADER, "lightning", ["uMask", "uCore", "uGlow", "uComposite"]);
+        const { gl } = pass;
+        const maskTexture = gl.createTexture();
+        if (!maskTexture) {
+          cleanupSinglePass(pass);
+          throw new Error("Could not allocate lightning mask texture");
+        }
+        gl.bindTexture(gl.TEXTURE_2D, maskTexture);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        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);
+        return { ...shared, ...pass, maskTexture };
+      },
+      apply: ({ source, width, height, params, state, flipSourceY }) => {
+        const previous = state.mask?.data;
+        const { data, uniforms } = prepareLightning({
+          state,
+          params,
+          source,
+          width,
+          height,
+          sourceIsFlipped: !flipSourceY
+        });
+        const { gl } = state;
+        prepareSinglePassSource({
+          state,
+          source,
+          width,
+          height,
+          flipSourceY
+        });
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, state.maskTexture);
+        if (previous !== data) {
+          gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+          gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+          gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
+          gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+        }
+        gl.uniform1i(state.uniforms.uMask, 1);
+        gl.uniform4fv(state.uniforms.uCore, uniforms, 0, 4);
+        gl.uniform4fv(state.uniforms.uGlow, uniforms, 4, 4);
+        gl.uniform1f(state.uniforms.uComposite, uniforms[8]);
+        drawSinglePass(state);
+        gl.activeTexture(gl.TEXTURE0);
+      },
+      cleanup: (state) => {
+        state.gl.deleteTexture(state.maskTexture);
+        cleanupSinglePass(state);
+      }
+    }),
+    webgpu: Internals.createEffectImplementation({
+      setup: (target) => ({
+        ...setupLightning(),
+        ...setupWebGpuSinglePass(target, "lightning")
+      }),
+      apply: ({ source, width, height, params, state, gpuDevice }) => {
+        if (!gpuDevice)
+          throw new Error("A WebGPU device is required for lightning");
+        const { data, uniforms } = prepareLightning({
+          state,
+          params,
+          source,
+          width,
+          height,
+          sourceIsFlipped: false
+        });
+        applyWebGpuSinglePass({
+          state,
+          source,
+          width,
+          height,
+          device: gpuDevice,
+          shader: LIGHTNING_WEBGPU_SHADER,
+          uniformData: uniforms
+        }, {
+          sourceFilter: null,
+          auxiliaryTexture: { data, width, height, format: "rgba8unorm" }
+        });
+      },
+      cleanup: cleanupWebGpuSinglePass
+    })
+  }
+});
+export {
+  lightning
+};

package/dist/esm/preview/linear-gradient-tint.mjs

@@ -0,0 +1,6 @@
+import {
+  linearGradientTint2
+} from "./index-6agxdrvr.mjs";
+export {
+  linearGradientTint2 as linearGradientTint
+};

package/dist/esm/preview/linear-gradient.mjs

@@ -0,0 +1,6 @@
+import {
+  linearGradient2
+} from "./index-0w4eqht8.mjs";
+export {
+  linearGradient2 as linearGradient
+};