@remotion/effects 4.0.540 → 4.0.542

package/dist/esm/preview/index.mjs

@@ -0,0 +1,51 @@
+import {
+  checkerboard2
+} from "./index-1m1b1ad7.mjs";
+import {
+  pattern2
+} from "./index-cb77qg3g.mjs";
+import"./index-8p04sssx.mjs";
+import {
+  tile2
+} from "./index-ysnwfc4t.mjs";
+import {
+  rings2
+} from "./index-34fxm3ax.mjs";
+import {
+  starburstEffectSchema2,
+  starburst2
+} from "./index-18y0zcy2.mjs";
+import {
+  lightLeakEffectSchema2,
+  lightLeak2
+} from "./index-wy95a41r.mjs";
+import {
+  gridlines2
+} from "./index-8agtsbw4.mjs";
+import {
+  zigzag2
+} from "./index-afdtmrh2.mjs";
+import {
+  linearGradient2
+} from "./index-0w4eqht8.mjs";
+import {
+  linearGradientTint2
+} from "./index-6agxdrvr.mjs";
+import {
+  cornerPin2
+} from "./index-r0v18b2n.mjs";
+export {
+  checkerboard2 as checkerboard,
+  cornerPin2 as cornerPin,
+  gridlines2 as gridlines,
+  lightLeak2 as lightLeak,
+  lightLeakEffectSchema2 as lightLeakEffectSchema,
+  linearGradient2 as linearGradient,
+  linearGradientTint2 as linearGradientTint,
+  pattern2 as pattern,
+  rings2 as rings,
+  starburst2 as starburst,
+  starburstEffectSchema2 as starburstEffectSchema,
+  tile2 as tile,
+  zigzag2 as zigzag
+};

package/dist/esm/preview/invert.mjs

@@ -0,0 +1,84 @@
+import"./index-8p04sssx.mjs";
+import {
+  createColorMatrixImplementations
+} from "./index-cdp7tr8x.mjs";
+import {
+  DEFAULT_AMOUNT,
+  colorAmountSchema,
+  assertOptionalFiniteNumber,
+  validateUnitInterval
+} from "./index-wxhvgv2s.mjs";
+import {
+  assertEffectParamsObject
+} from "./index-4fvp93ps.mjs";
+
+// src/invert.ts
+import { Internals } from "remotion";
+var { createEffect } = Internals;
+var invertSchema = {
+  amount: colorAmountSchema
+};
+var resolve = (p) => ({
+  amount: p.amount ?? DEFAULT_AMOUNT
+});
+var validateInvertParams = (params) => {
+  assertEffectParamsObject(params, "Invert");
+  assertOptionalFiniteNumber(params.amount, "amount");
+  const { amount } = resolve(params);
+  validateUnitInterval(amount, "amount");
+};
+var invert = createEffect({
+  type: "dev.remotion.effects.invert",
+  label: "invert()",
+  documentationLink: "https://www.remotion.dev/docs/effects/invert",
+  calculateKey: (params) => {
+    const r = resolve(params);
+    return `invert-${r.amount}`;
+  },
+  implementations: {
+    ...createColorMatrixImplementations("invert", (params) => {
+      const { amount } = resolve(params);
+      const factor = 1 - 2 * amount;
+      return new Float32Array([
+        factor,
+        0,
+        0,
+        amount,
+        0,
+        factor,
+        0,
+        amount,
+        0,
+        0,
+        factor,
+        amount,
+        0,
+        0,
+        amount === 0 ? 1 : 0,
+        0
+      ]);
+    }),
+    "2d": Internals.createEffectImplementation({
+      setup: () => null,
+      apply: ({ source, target, width, height, params }) => {
+        const ctx = target.getContext("2d");
+        if (!ctx) {
+          throw new Error("Failed to acquire 2D context for invert effect. The canvas may have been assigned a different context type.");
+        }
+        const r = resolve(params);
+        ctx.clearRect(0, 0, width, height);
+        ctx.filter = `invert(${r.amount * 100}%)`;
+        ctx.drawImage(source, 0, 0, width, height);
+        ctx.filter = "none";
+      },
+      cleanup: () => {
+        return;
+      }
+    })
+  },
+  schema: invertSchema,
+  validateParams: validateInvertParams
+});
+export {
+  invert
+};

package/dist/esm/preview/iris-wipe.mjs

@@ -0,0 +1,315 @@
+import {
+  setupSinglePass,
+  prepareSinglePassSource,
+  drawSinglePass,
+  cleanupSinglePass
+} from "./index-8p04sssx.mjs";
+import {
+  assertOptionalFiniteNumber,
+  validateUnitInterval,
+  validateNonNegative
+} from "./index-wxhvgv2s.mjs";
+import {
+  WEBGPU_SINGLE_PASS_VERTEX,
+  setupWebGpuSinglePass,
+  cleanupWebGpuSinglePass,
+  applyWebGpuSinglePass
+} from "./index-tvfexb7s.mjs";
+import {
+  assertEffectParamsObject,
+  assertRequiredFiniteNumber,
+  assertOptionalBoolean
+} from "./index-4fvp93ps.mjs";
+
+// src/iris-wipe.ts
+import { Internals } from "remotion";
+var { createEffect } = Internals;
+var DEFAULT_CENTER = [0.5, 0.5];
+var DEFAULT_POINTS = 6;
+var DEFAULT_OUTER_RADIUS = 0;
+var DEFAULT_USE_INNER_RADIUS = false;
+var DEFAULT_INNER_RADIUS = 0;
+var DEFAULT_ROTATION = 0;
+var DEFAULT_FEATHER = 0;
+var irisWipeSchema = {
+  center: {
+    type: "uv-coordinate",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: DEFAULT_CENTER,
+    description: "Center"
+  },
+  points: {
+    type: "number",
+    min: 3,
+    max: 64,
+    step: 1,
+    integer: true,
+    default: DEFAULT_POINTS,
+    description: "Points",
+    hiddenFromList: false
+  },
+  outerRadius: {
+    type: "number",
+    min: 0,
+    max: 2000,
+    step: 1,
+    default: DEFAULT_OUTER_RADIUS,
+    description: "Outer radius",
+    hiddenFromList: false
+  },
+  useInnerRadius: {
+    type: "boolean",
+    default: DEFAULT_USE_INNER_RADIUS,
+    description: "Use inner radius"
+  },
+  innerRadius: {
+    type: "number",
+    min: 0,
+    max: 2000,
+    step: 1,
+    default: DEFAULT_INNER_RADIUS,
+    description: "Inner radius",
+    hiddenFromList: false
+  },
+  rotation: {
+    type: "rotation-degrees",
+    step: 1,
+    default: DEFAULT_ROTATION,
+    description: "Rotation"
+  },
+  feather: {
+    type: "number",
+    min: 0,
+    max: 500,
+    step: 1,
+    default: DEFAULT_FEATHER,
+    description: "Feather",
+    hiddenFromList: false
+  }
+};
+var resolve = (params) => ({
+  center: params.center ?? DEFAULT_CENTER,
+  points: params.points ?? DEFAULT_POINTS,
+  outerRadius: params.outerRadius ?? DEFAULT_OUTER_RADIUS,
+  useInnerRadius: params.useInnerRadius ?? DEFAULT_USE_INNER_RADIUS,
+  innerRadius: params.innerRadius ?? DEFAULT_INNER_RADIUS,
+  rotation: params.rotation ?? DEFAULT_ROTATION,
+  feather: params.feather ?? DEFAULT_FEATHER
+});
+var validateIrisWipeParams = (params) => {
+  assertEffectParamsObject(params, "Iris wipe");
+  assertOptionalFiniteNumber(params.points, "points");
+  assertOptionalFiniteNumber(params.outerRadius, "outerRadius");
+  assertOptionalBoolean(params.useInnerRadius, "useInnerRadius");
+  assertOptionalFiniteNumber(params.innerRadius, "innerRadius");
+  assertOptionalFiniteNumber(params.rotation, "rotation");
+  assertOptionalFiniteNumber(params.feather, "feather");
+  if (params.center !== undefined) {
+    if (!Array.isArray(params.center) || params.center.length !== 2) {
+      throw new TypeError('"center" must be a [number, number] tuple');
+    }
+    assertRequiredFiniteNumber(params.center[0], "center[0]");
+    assertRequiredFiniteNumber(params.center[1], "center[1]");
+    validateUnitInterval(params.center[0], "center[0]");
+    validateUnitInterval(params.center[1], "center[1]");
+  }
+  const r = resolve(params);
+  if (!Number.isInteger(r.points) || r.points < 3 || r.points > 64) {
+    throw new TypeError(`"points" must be an integer between 3 and 64, but got ${JSON.stringify(r.points)}`);
+  }
+  validateNonNegative(r.outerRadius, "outerRadius");
+  validateNonNegative(r.innerRadius, "innerRadius");
+  validateNonNegative(r.feather, "feather");
+};
+var FRAGMENT_SHADER = `#version 300 es
+precision highp float;
+
+in vec2 vUv;
+out vec4 fragColor;
+
+uniform sampler2D uSource;
+uniform vec2 uResolution;
+uniform vec2 uCenter;
+uniform int uPoints;
+uniform float uOuterRadius;
+uniform bool uUseInnerRadius;
+uniform float uInnerRadius;
+uniform float uRotation;
+uniform float uFeather;
+
+const float TAU = 6.283185307179586;
+
+float cross2d(vec2 a, vec2 b) {
+	return a.x * b.y - a.y * b.x;
+}
+
+void main() {
+	vec4 source = texture(uSource, vUv);
+	if (uOuterRadius <= 0.0) {
+		fragColor = source;
+		return;
+	}
+
+	vec2 position = (vec2(vUv.x, 1.0 - vUv.y) - uCenter) * uResolution;
+	float radius = length(position);
+	float innerRadius = uUseInnerRadius ? uInnerRadius : uOuterRadius;
+	float boundary = min(uOuterRadius, innerRadius);
+	if (radius > 0.000001) {
+		float vertexCount = float(uPoints) * (uUseInnerRadius ? 2.0 : 1.0);
+		float angleStep = TAU / vertexCount;
+		float angle = mod(atan(position.x, -position.y) - uRotation, TAU);
+		float index = min(floor(angle / angleStep), vertexCount - 1.0);
+		float firstRadius = uUseInnerRadius && mod(index, 2.0) == 1.0
+			? innerRadius : uOuterRadius;
+		float secondRadius = uUseInnerRadius && mod(index + 1.0, 2.0) == 1.0
+			? innerRadius : uOuterRadius;
+		float firstAngle = uRotation + index * angleStep;
+		float secondAngle = firstAngle + angleStep;
+		vec2 first = firstRadius * vec2(sin(firstAngle), -cos(firstAngle));
+		vec2 second = secondRadius * vec2(sin(secondAngle), -cos(secondAngle));
+		vec2 edge = second - first;
+		float denominator = cross2d(position / radius, edge);
+		boundary = abs(denominator) < 0.000001
+			? uOuterRadius : cross2d(first, edge) / denominator;
+	}
+
+	float mask = uFeather > 0.0
+		? clamp((radius - boundary) / uFeather + 0.5, 0.0, 1.0)
+		: step(boundary, radius);
+	fragColor = source * mask;
+}
+`;
+var WEBGPU_SHADER = `
+${WEBGPU_SINGLE_PASS_VERTEX}
+// Polygon and star geometry adapted from EffectCraft; see THIRD_PARTY_LICENSES.md.
+struct Params { resolutionCenter: vec4f, radii: vec4f, controls: vec4f, }
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var sourceSampler: sampler;
+@group(0) @binding(2) var<uniform> params: Params;
+fn cross2d(a: vec2f, b: vec2f) -> f32 { return a.x * b.y - a.y * b.x; }
+@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {
+	let color = textureSampleLevel(source, sourceSampler, input.uv, 0);
+	let outerRadius = params.radii.y;
+	if (outerRadius <= 0.0) { return color; }
+	let position = (input.uv - params.resolutionCenter.zw) * params.resolutionCenter.xy;
+	let radius = length(position);
+	let useInnerRadius = params.radii.z != 0.0;
+	let innerRadius = select(outerRadius, params.radii.w, useInnerRadius);
+	var boundary = min(outerRadius, innerRadius);
+	if (radius > 0.000001) {
+		let vertexCount = params.radii.x * select(1.0, 2.0, useInnerRadius);
+		let angleStep = 6.283185307179586 / vertexCount;
+		// Avoid the implementation-dependent atan2 result at a signed-zero X argument.
+		var polarAngle = atan2(position.x, -position.y);
+		if (position.y == 0.0) { polarAngle = select(-1.5707963267948966, 1.5707963267948966, position.x >= 0.0); }
+		let rawAngle = polarAngle - params.controls.x;
+		let angle = rawAngle - 6.283185307179586 * floor(rawAngle / 6.283185307179586);
+		let index = min(floor(angle / angleStep), vertexCount - 1.0);
+		let firstRadius = select(outerRadius, innerRadius, useInnerRadius && index % 2.0 == 1.0);
+		let secondRadius = select(outerRadius, innerRadius, useInnerRadius && (index + 1.0) % 2.0 == 1.0);
+		let firstAngle = params.controls.x + index * angleStep;
+		let secondAngle = firstAngle + angleStep;
+		let first = firstRadius * vec2f(sin(firstAngle), -cos(firstAngle));
+		let second = secondRadius * vec2f(sin(secondAngle), -cos(secondAngle));
+		let edge = second - first;
+		let denominator = cross2d(position / radius, edge);
+		boundary = outerRadius;
+		if (abs(denominator) >= 0.000001) { boundary = cross2d(first, edge) / denominator; }
+	}
+	var mask = step(boundary, radius);
+	if (params.controls.y > 0.0) { mask = clamp((radius - boundary) / params.controls.y + 0.5, 0.0, 1.0); }
+	return color * mask;
+}
+`;
+var irisWipe = createEffect({
+  type: "remotion/iris-wipe",
+  label: "irisWipe()",
+  documentationLink: "https://www.remotion.dev/docs/effects/iris-wipe",
+  calculateKey: (params) => {
+    const r = resolve(params);
+    return `iris-wipe-${r.center.join(":")}-${r.points}-${r.outerRadius}-${r.useInnerRadius}-${r.innerRadius}-${r.rotation}-${r.feather}`;
+  },
+  implementations: {
+    webgpu: Internals.createEffectImplementation({
+      setup: (target) => setupWebGpuSinglePass(target, "iris-wipe"),
+      apply: ({ source, width, height, params, state, gpuDevice }) => {
+        if (!gpuDevice) {
+          throw new Error("A WebGPU device is required for the iris-wipe effect");
+        }
+        const r = resolve(params);
+        applyWebGpuSinglePass({
+          source,
+          width,
+          height,
+          state,
+          device: gpuDevice,
+          shader: WEBGPU_SHADER,
+          uniformData: new Float32Array([
+            width,
+            height,
+            r.center[0],
+            r.center[1],
+            r.points,
+            r.outerRadius,
+            r.useInnerRadius ? 1 : 0,
+            r.innerRadius,
+            r.rotation % 360 * Math.PI / 180,
+            r.feather,
+            0,
+            0
+          ])
+        });
+      },
+      cleanup: cleanupWebGpuSinglePass
+    }),
+    webgl2: Internals.createEffectImplementation({
+      setup: (target) => setupSinglePass(target, FRAGMENT_SHADER, "iris wipe", [
+        "uResolution",
+        "uCenter",
+        "uPoints",
+        "uOuterRadius",
+        "uUseInnerRadius",
+        "uInnerRadius",
+        "uRotation",
+        "uFeather"
+      ]),
+      apply: ({ source, width, height, params, state, flipSourceY }) => {
+        const r = resolve(params);
+        const { gl, uniforms } = state;
+        prepareSinglePassSource({
+          state,
+          source,
+          width,
+          height,
+          flipSourceY
+        });
+        if (uniforms.uResolution)
+          gl.uniform2f(uniforms.uResolution, width, height);
+        if (uniforms.uCenter)
+          gl.uniform2f(uniforms.uCenter, r.center[0], r.center[1]);
+        if (uniforms.uPoints)
+          gl.uniform1i(uniforms.uPoints, r.points);
+        if (uniforms.uOuterRadius)
+          gl.uniform1f(uniforms.uOuterRadius, r.outerRadius);
+        if (uniforms.uUseInnerRadius)
+          gl.uniform1i(uniforms.uUseInnerRadius, r.useInnerRadius ? 1 : 0);
+        if (uniforms.uInnerRadius)
+          gl.uniform1f(uniforms.uInnerRadius, r.innerRadius);
+        if (uniforms.uRotation)
+          gl.uniform1f(uniforms.uRotation, r.rotation % 360 * Math.PI / 180);
+        if (uniforms.uFeather)
+          gl.uniform1f(uniforms.uFeather, r.feather);
+        drawSinglePass(state);
+      },
+      cleanup: cleanupSinglePass
+    })
+  },
+  schema: irisWipeSchema,
+  validateParams: validateIrisWipeParams
+});
+export {
+  irisWipe,
+  irisWipeSchema
+};