@remotion/effects 4.0.541 → 4.0.543

package/dist/esm/preview/radial-progressive-pixelate.mjs

@@ -0,0 +1,220 @@
+import {
+  setupProgressivePixelate,
+  prepareProgressivePixelate,
+  drawProgressivePixelate,
+  cleanupProgressivePixelate,
+  PROGRESSIVE_PIXELATE_WEBGPU_SHADER
+} from "./index-00v3hr66.mjs";
+import {
+  assertOptionalFiniteNumber,
+  validateUnitInterval,
+  validateNonNegative
+} from "./index-wxhvgv2s.mjs";
+import {
+  setupWebGpuSinglePass,
+  cleanupWebGpuSinglePass,
+  applyWebGpuSinglePass
+} from "./index-tvfexb7s.mjs";
+import {
+  assertEffectParamsObject
+} from "./index-4fvp93ps.mjs";
+
+// src/radial-progressive-pixelate/index.ts
+import { Internals } from "remotion";
+var { createEffect } = Internals;
+var DEFAULT_CENTER = [0.5, 0.5];
+var DEFAULT_WIDTH = 1;
+var DEFAULT_HEIGHT = 1;
+var DEFAULT_ROTATION = 0;
+var DEFAULT_START = 0;
+var DEFAULT_START_BLOCK_SIZE = 1;
+var DEFAULT_END_BLOCK_SIZE = 40;
+var radialProgressivePixelateSchema = {
+  center: {
+    type: "uv-coordinate",
+    min: -1,
+    max: 2,
+    step: 0.01,
+    default: DEFAULT_CENTER,
+    description: "Center",
+    visual: {
+      type: "ellipse",
+      width: "width",
+      height: "height",
+      rotation: "rotation",
+      innerScale: "start"
+    }
+  },
+  width: {
+    type: "number",
+    min: 0,
+    step: 0.01,
+    default: DEFAULT_WIDTH,
+    description: "Width",
+    hiddenFromList: false
+  },
+  height: {
+    type: "number",
+    min: 0,
+    step: 0.01,
+    default: DEFAULT_HEIGHT,
+    description: "Height",
+    hiddenFromList: false
+  },
+  rotation: {
+    type: "rotation-degrees",
+    step: 1,
+    default: DEFAULT_ROTATION,
+    description: "Rotation"
+  },
+  start: {
+    type: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: DEFAULT_START,
+    description: "Start",
+    hiddenFromList: false
+  },
+  startBlockSize: {
+    type: "number",
+    min: 1,
+    max: 200,
+    step: 1,
+    default: DEFAULT_START_BLOCK_SIZE,
+    description: "Start block size",
+    hiddenFromList: false
+  },
+  endBlockSize: {
+    type: "number",
+    min: 1,
+    max: 200,
+    step: 1,
+    default: DEFAULT_END_BLOCK_SIZE,
+    description: "End block size",
+    hiddenFromList: false
+  }
+};
+var resolve = (params) => ({
+  center: [
+    ...params.center ?? DEFAULT_CENTER
+  ],
+  width: params.width ?? DEFAULT_WIDTH,
+  height: params.height ?? DEFAULT_HEIGHT,
+  rotation: params.rotation ?? DEFAULT_ROTATION,
+  start: params.start ?? DEFAULT_START,
+  startBlockSize: params.startBlockSize ?? DEFAULT_START_BLOCK_SIZE,
+  endBlockSize: params.endBlockSize ?? DEFAULT_END_BLOCK_SIZE
+});
+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 validateBlockSize = (value, name) => {
+  if (value < 1) {
+    throw new TypeError(`"${name}" must be >= 1`);
+  }
+};
+var validateParams = (params) => {
+  assertEffectParamsObject(params, "Radial progressive pixelate");
+  assertOptionalUvCoordinate(params.center, "center");
+  assertOptionalFiniteNumber(params.width, "width");
+  assertOptionalFiniteNumber(params.height, "height");
+  assertOptionalFiniteNumber(params.rotation, "rotation");
+  validateNonNegative(params.width ?? DEFAULT_WIDTH, "width");
+  validateNonNegative(params.height ?? DEFAULT_HEIGHT, "height");
+  assertOptionalFiniteNumber(params.start, "start");
+  validateUnitInterval(params.start ?? DEFAULT_START, "start");
+  assertOptionalFiniteNumber(params.startBlockSize, "startBlockSize");
+  assertOptionalFiniteNumber(params.endBlockSize, "endBlockSize");
+  validateBlockSize(params.startBlockSize ?? DEFAULT_START_BLOCK_SIZE, "startBlockSize");
+  validateBlockSize(params.endBlockSize ?? DEFAULT_END_BLOCK_SIZE, "endBlockSize");
+};
+var radialProgressivePixelate = createEffect({
+  type: "dev.remotion.effects.radialProgressivePixelate",
+  label: "radialProgressivePixelate()",
+  documentationLink: "https://www.remotion.dev/docs/effects/radial-progressive-pixelate",
+  calculateKey: (params) => {
+    const r = resolve(params);
+    return `radial-progressive-pixelate-${r.center.join(":")}-${r.width}-${r.height}-${r.rotation}-${r.start}-${r.startBlockSize}-${r.endBlockSize}`;
+  },
+  implementations: {
+    webgpu: Internals.createEffectImplementation({
+      setup: (target) => setupWebGpuSinglePass(target, "radial-progressive-pixelate"),
+      apply: ({ source, width, height, params, state, gpuDevice }) => {
+        if (!gpuDevice) {
+          throw new Error("A WebGPU device is required for the radial-progressive-pixelate effect");
+        }
+        const r = resolve(params);
+        applyWebGpuSinglePass({
+          source,
+          width,
+          height,
+          state,
+          device: gpuDevice,
+          shader: PROGRESSIVE_PIXELATE_WEBGPU_SHADER,
+          uniformData: new Float32Array([
+            width,
+            height,
+            1,
+            r.startBlockSize,
+            0,
+            0,
+            0,
+            0,
+            r.center[0],
+            r.center[1],
+            r.width,
+            r.height,
+            r.rotation,
+            r.start,
+            r.endBlockSize,
+            0
+          ])
+        });
+      },
+      cleanup: cleanupWebGpuSinglePass
+    }),
+    webgl2: Internals.createEffectImplementation({
+      setup: setupProgressivePixelate,
+      apply: ({ source, width, height, params, state, flipSourceY }) => {
+        const r = resolve(params);
+        prepareProgressivePixelate({
+          state,
+          source,
+          width,
+          height,
+          flipSourceY
+        });
+        const { gl, uniforms } = state;
+        if (uniforms.uMode)
+          gl.uniform1i(uniforms.uMode, 1);
+        if (uniforms.uCenter)
+          gl.uniform2f(uniforms.uCenter, r.center[0], r.center[1]);
+        if (uniforms.uWidth)
+          gl.uniform1f(uniforms.uWidth, r.width);
+        if (uniforms.uHeight)
+          gl.uniform1f(uniforms.uHeight, r.height);
+        if (uniforms.uRotation)
+          gl.uniform1f(uniforms.uRotation, r.rotation);
+        if (uniforms.uRadialStart)
+          gl.uniform1f(uniforms.uRadialStart, r.start);
+        if (uniforms.uStartBlockSize)
+          gl.uniform1f(uniforms.uStartBlockSize, r.startBlockSize);
+        if (uniforms.uEndBlockSize)
+          gl.uniform1f(uniforms.uEndBlockSize, r.endBlockSize);
+        drawProgressivePixelate(state);
+      },
+      cleanup: cleanupProgressivePixelate
+    })
+  },
+  schema: radialProgressivePixelateSchema,
+  validateParams
+});
+export {
+  radialProgressivePixelate
+};

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

@@ -0,0 +1,224 @@
+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
+} from "./index-4fvp93ps.mjs";
+
+// src/radial-wipe.ts
+import { Internals } from "remotion";
+var DEFAULT_PROGRESS = 0;
+var DEFAULT_START_ANGLE = 0;
+var DEFAULT_CENTER = [0.5, 0.5];
+var DEFAULT_DIRECTION = "clockwise";
+var DEFAULT_FEATHER = 0;
+var DIRECTIONS = ["clockwise", "counterclockwise", "both"];
+var radialWipeSchema = {
+  progress: {
+    type: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: DEFAULT_PROGRESS,
+    description: "Progress",
+    hiddenFromList: false
+  },
+  startAngle: {
+    type: "rotation-degrees",
+    step: 1,
+    default: DEFAULT_START_ANGLE,
+    description: "Start angle"
+  },
+  center: {
+    type: "uv-coordinate",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: DEFAULT_CENTER,
+    description: "Center"
+  },
+  direction: {
+    type: "enum",
+    variants: { clockwise: {}, counterclockwise: {}, both: {} },
+    default: DEFAULT_DIRECTION,
+    description: "Direction"
+  },
+  feather: {
+    type: "number",
+    min: 0,
+    max: 360,
+    step: 1,
+    default: DEFAULT_FEATHER,
+    description: "Feather",
+    hiddenFromList: false
+  }
+};
+var resolve = (p) => ({
+  progress: p.progress ?? DEFAULT_PROGRESS,
+  startAngle: p.startAngle ?? DEFAULT_START_ANGLE,
+  center: p.center ?? DEFAULT_CENTER,
+  direction: p.direction ?? DEFAULT_DIRECTION,
+  feather: p.feather ?? DEFAULT_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 float uStartAngle;
+uniform float uProgress;
+uniform float uFeather;
+uniform int uDirection;
+
+void main() {
+	vec4 source = texture(uSource, vUv);
+	if (uProgress <= 0.0) { fragColor = source; return; }
+	if (uProgress >= 1.0) { fragColor = vec4(0.0); return; }
+	vec2 delta = (vec2(vUv.x, 1.0 - vUv.y) - uCenter) * uResolution;
+	// atan(0, 0) is undefined; the center belongs to the erased sector.
+	if (dot(delta, delta) == 0.0) { fragColor = vec4(0.0); return; }
+	float angle = mod(degrees(atan(delta.x, -delta.y)) - uStartAngle, 360.0);
+	float sweep = 360.0;
+	if (uDirection == 1) angle = 360.0 - angle;
+	if (uDirection == 2) { angle = min(angle, 360.0 - angle); sweep = 180.0; }
+	float distance = angle - uProgress * sweep;
+	float mask = uFeather > 0.0 ? clamp(distance / uFeather + 0.5, 0.0, 1.0) : step(0.0, distance);
+	fragColor = source * mask;
+}
+`;
+var WEBGPU_SHADER = `
+${WEBGPU_SINGLE_PASS_VERTEX}
+struct Params { resolutionCenter: 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;
+@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {
+	let color = textureSampleLevel(source, sourceSampler, input.uv, 0);
+	let progress = params.controls.y;
+	if (progress <= 0.0) { return color; }
+	if (progress >= 1.0) { return vec4f(0); }
+	let delta = (input.uv - params.resolutionCenter.zw) * params.resolutionCenter.xy;
+	if (dot(delta, delta) == 0.0) { return vec4f(0); }
+	// Avoid the implementation-dependent atan2 result at a signed-zero X argument.
+	var polarAngle = atan2(delta.x, -delta.y);
+	if (delta.y == 0.0) { polarAngle = select(-1.5707963267948966, 1.5707963267948966, delta.x >= 0.0); }
+	let rawAngle = degrees(polarAngle) - params.controls.x;
+	var angle = rawAngle - 360.0 * floor(rawAngle / 360.0);
+	var sweep = 360.0;
+	if (params.controls.w == 1.0) { angle = 360.0 - angle; }
+	if (params.controls.w == 2.0) { angle = min(angle, 360.0 - angle); sweep = 180.0; }
+	let distance = angle - progress * sweep;
+	var mask = step(0.0, distance);
+	if (params.controls.z > 0.0) { mask = clamp(distance / params.controls.z + 0.5, 0.0, 1.0); }
+	return color * mask;
+}
+`;
+var radialWipe = Internals.createEffect({
+  type: "remotion/radial-wipe",
+  label: "radialWipe()",
+  documentationLink: "https://www.remotion.dev/docs/effects/radial-wipe",
+  calculateKey: (params) => `radial-wipe-${JSON.stringify(resolve(params))}`,
+  implementations: {
+    webgpu: Internals.createEffectImplementation({
+      setup: (target) => setupWebGpuSinglePass(target, "radial-wipe"),
+      apply: ({ source, width, height, params, state, gpuDevice }) => {
+        if (!gpuDevice) {
+          throw new Error("A WebGPU device is required for the radial-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.startAngle % 360,
+            r.progress,
+            r.feather,
+            DIRECTIONS.indexOf(r.direction)
+          ])
+        });
+      },
+      cleanup: cleanupWebGpuSinglePass
+    }),
+    webgl2: Internals.createEffectImplementation({
+      setup: (target) => setupSinglePass(target, FRAGMENT_SHADER, "radial wipe", [
+        "uResolution",
+        "uCenter",
+        "uStartAngle",
+        "uProgress",
+        "uFeather",
+        "uDirection"
+      ]),
+      apply: ({ source, width, height, params, state, flipSourceY }) => {
+        const r = resolve(params);
+        const { gl, uniforms } = state;
+        prepareSinglePassSource({
+          state,
+          source,
+          width,
+          height,
+          flipSourceY
+        });
+        gl.uniform2f(uniforms.uResolution, width, height);
+        gl.uniform2f(uniforms.uCenter, r.center[0], r.center[1]);
+        gl.uniform1f(uniforms.uStartAngle, r.startAngle % 360);
+        gl.uniform1f(uniforms.uProgress, r.progress);
+        gl.uniform1f(uniforms.uFeather, r.feather);
+        gl.uniform1i(uniforms.uDirection, DIRECTIONS.indexOf(r.direction));
+        drawSinglePass(state);
+      },
+      cleanup: cleanupSinglePass
+    })
+  },
+  schema: radialWipeSchema,
+  validateParams: (params) => {
+    assertEffectParamsObject(params, "Radial wipe");
+    assertOptionalFiniteNumber(params.progress, "progress");
+    assertOptionalFiniteNumber(params.startAngle, "startAngle");
+    assertOptionalFiniteNumber(params.feather, "feather");
+    if (params.center !== undefined) {
+      if (!Array.isArray(params.center) || params.center.length !== 2) {
+        throw new TypeError('"center" must be a tuple of two finite numbers');
+      }
+      assertRequiredFiniteNumber(params.center[0], "center[0]");
+      assertRequiredFiniteNumber(params.center[1], "center[1]");
+    }
+    const r = resolve(params);
+    if (params.direction !== undefined && !DIRECTIONS.includes(params.direction)) {
+      throw new TypeError('"direction" must be "clockwise", "counterclockwise" or "both"');
+    }
+    validateUnitInterval(r.progress, "progress");
+    validateUnitInterval(r.center[0], "center[0]");
+    validateUnitInterval(r.center[1], "center[1]");
+    validateNonNegative(r.feather, "feather");
+    if (r.feather > 360)
+      throw new TypeError('"feather" must be at most 360');
+  }
+});
+export {
+  radialWipe
+};

package/dist/esm/preview/rain-fall.mjs

@@ -0,0 +1,114 @@
+import {
+  COMMON_WEATHER_DEFAULTS,
+  createWeatherSchema,
+  resolveWeatherParams,
+  validateWeatherRange,
+  validateWeatherParams,
+  setupWeather,
+  drawWeather,
+  cleanupWeather,
+  setupWeatherWebGpu,
+  cleanupWeatherWebGpu,
+  drawWeatherWebGpu
+} from "./index-rswpzmm5.mjs";
+
+// src/rain-fall.ts
+import { Internals } from "remotion";
+var { createEffect } = Internals;
+var DEFAULTS = {
+  ...COMMON_WEATHER_DEFAULTS,
+  size: 1,
+  speed: 4000,
+  wind: 0,
+  windVariation: 0,
+  color: "#cccccc",
+  opacity: 0.25,
+  transferMode: "lighten",
+  drops: 1e5,
+  appearance: "refracting"
+};
+var rainFallSchema = {
+  drops: {
+    type: "number",
+    min: 0,
+    max: 1e5,
+    step: 1,
+    integer: true,
+    default: DEFAULTS.drops,
+    description: "Drops",
+    hiddenFromList: false
+  },
+  ...createWeatherSchema(DEFAULTS, 20000, 1e4),
+  appearance: {
+    type: "enum",
+    variants: { refracting: {}, "soft-solid": {} },
+    default: DEFAULTS.appearance,
+    description: "Appearance"
+  }
+};
+var resolve = (params) => ({
+  ...resolveWeatherParams(params, DEFAULTS),
+  count: params.drops ?? DEFAULTS.drops,
+  sizeVariation: 0,
+  speedVariation: 0,
+  wiggleAmount: 0,
+  wiggleAmountVariation: 0,
+  wiggleFrequency: 0,
+  wiggleFrequencyVariation: 0,
+  appearance: params.appearance ?? DEFAULTS.appearance
+});
+var rainFall = createEffect({
+  type: "remotion/rain-fall",
+  label: "rainFall()",
+  documentationLink: "https://www.remotion.dev/docs/effects/rain-fall",
+  calculateKey: (params) => `rain-fall-${JSON.stringify(resolve(params))}`,
+  implementations: {
+    webgpu: Internals.createEffectImplementation({
+      setup: setupWeatherWebGpu,
+      apply: ({ source, width, height, params, state, gpuDevice }) => {
+        if (!gpuDevice)
+          throw new Error("A WebGPU device is required for the rain fall effect");
+        drawWeatherWebGpu({
+          source,
+          width,
+          height,
+          params: resolve(params),
+          state,
+          device: gpuDevice,
+          type: "rain"
+        });
+      },
+      cleanup: cleanupWeatherWebGpu
+    }),
+    webgl2: Internals.createEffectImplementation({
+      setup: (target) => setupWeather(target, "rain fall"),
+      apply: ({ source, width, height, params, state, flipSourceY }) => {
+        drawWeather({
+          state,
+          source,
+          width,
+          height,
+          flipSourceY,
+          params: resolve(params),
+          type: "rain"
+        });
+      },
+      cleanup: cleanupWeather
+    })
+  },
+  schema: rainFallSchema,
+  validateParams: (params) => {
+    validateWeatherParams(params, "Rain fall", 20000, 1e4);
+    validateWeatherRange(params.drops, "drops", 0, 1e5);
+    if (params.drops !== undefined && !Number.isInteger(params.drops)) {
+      throw new TypeError('"drops" must be an integer');
+    }
+    if (params.appearance !== undefined && params.appearance !== "refracting" && params.appearance !== "soft-solid") {
+      throw new TypeError('"appearance" must be "refracting" or "soft-solid"');
+    }
+  }
+});
+export {
+  rainFall,
+  rainFallSchema
+};