@remotion/effects 4.0.490 → 4.0.491

package/dist/effect-internals.d.ts

@@ -0,0 +1,8 @@
+export declare const EffectInternals: {
+    readonly halftone: (params?: (import("./halftone.js").HalftoneParams & {
+        readonly disabled?: boolean | undefined;
+    }) | undefined) => import("remotion").EffectDescriptor<unknown>;
+    readonly tint: (params: import("./tint.js").TintParams & {
+        readonly disabled?: boolean | undefined;
+    }) => import("remotion").EffectDescriptor<unknown>;
+};

package/dist/entrypoints/blur.d.ts

@@ -0,0 +1,6 @@
+import * as blurExports from '../blur/index.js';
+export type { BlurParams } from '../blur/index.js';
+declare const blur: (params: blurExports.BlurParams & {
+    readonly disabled?: boolean | undefined;
+}) => import("remotion").EffectDescriptor<unknown>;
+export { blur };

package/dist/esm/liquid-contours.mjs

@@ -0,0 +1,473 @@
+// src/liquid-contours.ts
+import { Internals } from "remotion";
+
+// src/validate-effect-param.ts
+var assertEffectParamsObject = (params, effectLabel) => {
+  if (params === null || typeof params !== "object") {
+    throw new TypeError(`${effectLabel} effect requires a parameters object, but got ${JSON.stringify(params)}`);
+  }
+};
+var assertRequiredFiniteNumber = (value, name) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new TypeError(`"${name}" must be a finite number, but got ${JSON.stringify(value)}`);
+  }
+};
+var assertRequiredColor = (value, name) => {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`"${name}" must be a non-empty string, but got ${JSON.stringify(value)}`);
+  }
+};
+var assertOptionalColor = (value, name) => {
+  if (value === undefined) {
+    return;
+  }
+  assertRequiredColor(value, name);
+};
+var assertOptionalBoolean = (value, name) => {
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value !== "boolean") {
+    throw new TypeError(`"${name}" must be a boolean, but got ${JSON.stringify(value)}`);
+  }
+};
+
+// src/color-utils.ts
+var DEFAULT_AMOUNT = 1;
+var DEFAULT_BRIGHTNESS_AMOUNT = 0;
+var DEFAULT_HUE_DEGREES = 0;
+var colorAmountSchema = {
+  type: "number",
+  min: 0,
+  max: 1,
+  step: 0.01,
+  default: DEFAULT_AMOUNT,
+  description: "Amount",
+  hiddenFromList: false
+};
+var colorMultiplierSchema = {
+  type: "number",
+  min: 0,
+  step: 0.01,
+  default: DEFAULT_AMOUNT,
+  description: "Amount",
+  hiddenFromList: false
+};
+var brightnessAmountSchema = {
+  type: "number",
+  min: -1,
+  max: 1,
+  step: 0.01,
+  default: DEFAULT_BRIGHTNESS_AMOUNT,
+  description: "Amount",
+  hiddenFromList: false
+};
+var hueDegreesSchema = {
+  type: "rotation-degrees",
+  step: 1,
+  default: DEFAULT_HUE_DEGREES,
+  description: "Degrees"
+};
+var assertOptionalFiniteNumber = (value, name) => {
+  if (value === undefined) {
+    return;
+  }
+  assertRequiredFiniteNumber(value, name);
+};
+var validateUnitInterval = (value, name) => {
+  if (value < 0) {
+    throw new TypeError(`"${name}" must be >= 0, but got ${JSON.stringify(value)}`);
+  }
+  if (value > 1) {
+    throw new TypeError(`"${name}" must be <= 1, but got ${JSON.stringify(value)}`);
+  }
+};
+var validateNonNegative = (value, name) => {
+  if (value < 0) {
+    throw new TypeError(`"${name}" must be >= 0, but got ${JSON.stringify(value)}`);
+  }
+};
+var validateSignedUnitInterval = (value, name) => {
+  if (value < -1) {
+    throw new TypeError(`"${name}" must be >= -1, but got ${JSON.stringify(value)}`);
+  }
+  if (value > 1) {
+    throw new TypeError(`"${name}" must be <= 1, but got ${JSON.stringify(value)}`);
+  }
+};
+var clampColorChannel = (value) => {
+  return Math.max(0, Math.min(255, value));
+};
+var parseColorRgba = (ctx, color) => {
+  ctx.clearRect(0, 0, 1, 1);
+  ctx.fillStyle = color;
+  ctx.fillRect(0, 0, 1, 1);
+  const { data } = ctx.getImageData(0, 0, 1, 1);
+  return [data[0], data[1], data[2], data[3]];
+};
+
+// src/liquid-contours.ts
+var { createEffect, createWebGL2ContextError } = Internals;
+var DEFAULT_FIRST_COLOR = "#ff1a0a";
+var DEFAULT_SECOND_COLOR = "#050505";
+var DEFAULT_SPACING = 62;
+var DEFAULT_SCALE = 300;
+var DEFAULT_COMPLEXITY = 0;
+var DEFAULT_SMOOTHNESS = 1;
+var DEFAULT_SEED = 4;
+var DEFAULT_OFFSET_X = 13.4;
+var DEFAULT_OFFSET_Y = 0;
+var DEFAULT_PHASE = 3.23;
+var liquidContoursSchema = {
+  firstColor: {
+    type: "color",
+    default: DEFAULT_FIRST_COLOR,
+    description: "First color"
+  },
+  secondColor: {
+    type: "color",
+    default: DEFAULT_SECOND_COLOR,
+    description: "Second color"
+  },
+  spacing: {
+    type: "number",
+    min: 2,
+    max: 300,
+    step: 1,
+    default: DEFAULT_SPACING,
+    description: "Spacing",
+    hiddenFromList: false
+  },
+  scale: {
+    type: "number",
+    min: 20,
+    max: 1000,
+    step: 1,
+    default: DEFAULT_SCALE,
+    description: "Scale",
+    hiddenFromList: false
+  },
+  complexity: {
+    type: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: DEFAULT_COMPLEXITY,
+    description: "Complexity",
+    hiddenFromList: false
+  },
+  smoothness: {
+    type: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: DEFAULT_SMOOTHNESS,
+    description: "Edge smoothness",
+    hiddenFromList: false
+  },
+  seed: {
+    type: "number",
+    step: 1,
+    default: DEFAULT_SEED,
+    description: "Seed",
+    hiddenFromList: false
+  },
+  offsetX: {
+    type: "number",
+    step: 0.1,
+    default: DEFAULT_OFFSET_X,
+    description: "Offset X",
+    hiddenFromList: false
+  },
+  offsetY: {
+    type: "number",
+    step: 0.1,
+    default: DEFAULT_OFFSET_Y,
+    description: "Offset Y",
+    hiddenFromList: false
+  },
+  phase: {
+    type: "number",
+    step: 0.01,
+    default: DEFAULT_PHASE,
+    description: "Phase",
+    hiddenFromList: false
+  }
+};
+var resolve = (params) => ({
+  firstColor: params.firstColor ?? DEFAULT_FIRST_COLOR,
+  secondColor: params.secondColor ?? DEFAULT_SECOND_COLOR,
+  spacing: params.spacing ?? DEFAULT_SPACING,
+  scale: params.scale ?? DEFAULT_SCALE,
+  complexity: params.complexity ?? DEFAULT_COMPLEXITY,
+  smoothness: params.smoothness ?? DEFAULT_SMOOTHNESS,
+  seed: params.seed ?? DEFAULT_SEED,
+  offsetX: params.offsetX ?? DEFAULT_OFFSET_X,
+  offsetY: params.offsetY ?? DEFAULT_OFFSET_Y,
+  phase: params.phase ?? DEFAULT_PHASE
+});
+var validatePositive = (value, name) => {
+  if (value <= 0) {
+    throw new TypeError(`"${name}" must be greater than 0, but got ${JSON.stringify(value)}`);
+  }
+};
+var validateLiquidContoursParams = (params) => {
+  assertEffectParamsObject(params, "Liquid contours");
+  assertOptionalColor(params.firstColor, "firstColor");
+  assertOptionalColor(params.secondColor, "secondColor");
+  assertOptionalFiniteNumber(params.spacing, "spacing");
+  assertOptionalFiniteNumber(params.scale, "scale");
+  assertOptionalFiniteNumber(params.complexity, "complexity");
+  assertOptionalFiniteNumber(params.smoothness, "smoothness");
+  assertOptionalFiniteNumber(params.seed, "seed");
+  assertOptionalFiniteNumber(params.offsetX, "offsetX");
+  assertOptionalFiniteNumber(params.offsetY, "offsetY");
+  assertOptionalFiniteNumber(params.phase, "phase");
+  const r = resolve(params);
+  validatePositive(r.spacing, "spacing");
+  validatePositive(r.scale, "scale");
+  validateUnitInterval(r.complexity, "complexity");
+  validateUnitInterval(r.smoothness, "smoothness");
+};
+var VERTEX_SHADER = `#version 300 es
+in vec2 aPos;
+in vec2 aUv;
+out vec2 vUv;
+
+void main() {
+	vUv = aUv;
+	gl_Position = vec4(aPos, 0.0, 1.0);
+}
+`;
+var FRAGMENT_SHADER = `#version 300 es
+precision highp float;
+
+in vec2 vUv;
+out vec4 fragColor;
+
+uniform vec2 uResolution;
+uniform vec4 uFirstColor;
+uniform vec4 uSecondColor;
+uniform float uSpacing;
+uniform float uScale;
+uniform float uComplexity;
+uniform float uSmoothness;
+uniform float uSeed;
+uniform vec2 uOffset;
+uniform float uPhase;
+
+float hash(vec2 p) {
+	vec3 p3 = fract(vec3(p.xyx) * 0.1031);
+	p3 += dot(p3, p3.yzx + 33.33 + uSeed * 0.013);
+	return fract((p3.x + p3.y) * p3.z);
+}
+
+float valueNoise(vec2 p) {
+	vec2 i = floor(p);
+	vec2 f = fract(p);
+	vec2 u = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
+	return mix(
+		mix(hash(i), hash(i + vec2(1.0, 0.0)), u.x),
+		mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0)), u.x),
+		u.y
+	);
+}
+
+float fbm(vec2 p) {
+	float value = 0.0;
+	float amplitude = 0.5;
+	float total = 0.0;
+	float persistence = mix(0.2, 0.58, uComplexity);
+	mat2 rotate = mat2(0.80, 0.60, -0.60, 0.80);
+
+	for (int i = 0; i < 5; i++) {
+		float octave = float(i) / 4.0;
+		float detail = mix(0.45, 1.0, uComplexity);
+		float octaveWeight = mix(1.0, 1.0 - smoothstep(0.4, 1.0, octave), 1.0 - detail);
+		value += amplitude * octaveWeight * valueNoise(p);
+		total += amplitude * octaveWeight;
+		p = rotate * p * 2.03 + vec2(13.17, 7.31);
+		amplitude *= persistence;
+	}
+
+	return value / total;
+}
+
+void main() {
+	vec2 position = vUv * uResolution + uOffset;
+	vec2 p = position / max(uScale, 0.001) + vec2(uSeed * 0.137, uSeed * 0.193);
+	vec2 warp = vec2(fbm(p + vec2(5.2, 1.3)), fbm(p + vec2(1.7, 9.2))) - 0.5;
+	mat2 roundRotation = mat2(0.7071, 0.7071, -0.7071, 0.7071);
+	float roundedField = mix(
+		valueNoise(p * 0.9),
+		valueNoise(roundRotation * p * 0.78 + vec2(8.3, 2.7)),
+		0.45
+	);
+	float detailedField = fbm(p + warp * mix(0.35, 1.8, uComplexity));
+	float detailMix = smoothstep(0.0, 1.0, uComplexity);
+	float field = mix(roundedField, detailedField, detailMix);
+	float levels = max(max(uResolution.x, uResolution.y) / max(uSpacing, 0.001), 1.0);
+	float wave = sin((field * levels + uPhase) * 6.28318530718);
+	float edgeWidth = fwidth(wave) * mix(0.15, 1.4, uSmoothness);
+	float selector = smoothstep(-edgeWidth, edgeWidth, wave);
+	vec4 color = mix(uFirstColor, uSecondColor, selector);
+	fragColor = vec4(color.rgb * color.a, color.a);
+}
+`;
+var compileShader = (gl, type, source) => {
+  const shader = gl.createShader(type);
+  if (!shader)
+    throw new Error("Failed to create WebGL shader");
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    const log = gl.getShaderInfoLog(shader);
+    gl.deleteShader(shader);
+    throw new Error(`Liquid contours shader compile failed: ${log ?? "(no log)"}`);
+  }
+  return shader;
+};
+var createProgram = (gl) => {
+  const vs = compileShader(gl, gl.VERTEX_SHADER, VERTEX_SHADER);
+  const fs = compileShader(gl, gl.FRAGMENT_SHADER, FRAGMENT_SHADER);
+  const program = gl.createProgram();
+  if (!program)
+    throw new Error("Failed to create WebGL program");
+  gl.attachShader(program, vs);
+  gl.attachShader(program, fs);
+  gl.linkProgram(program);
+  gl.deleteShader(vs);
+  gl.deleteShader(fs);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    const log = gl.getProgramInfoLog(program);
+    gl.deleteProgram(program);
+    throw new Error(`Liquid contours program link failed: ${log ?? "(no log)"}`);
+  }
+  return program;
+};
+var setup = (target) => {
+  const gl = target.getContext("webgl2", {
+    premultipliedAlpha: true,
+    alpha: true,
+    preserveDrawingBuffer: true
+  });
+  if (!gl)
+    throw createWebGL2ContextError("liquid contours effect");
+  const program = createProgram(gl);
+  const vao = gl.createVertexArray();
+  if (!vao)
+    throw new Error("Failed to create WebGL vertex array");
+  gl.bindVertexArray(vao);
+  const vbo = gl.createBuffer();
+  if (!vbo)
+    throw new Error("Failed to create WebGL buffer");
+  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+  gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 0, 0, 1, -1, 1, 0, -1, 1, 0, 1, 1, 1, 1, 1]), gl.STATIC_DRAW);
+  const aPos = gl.getAttribLocation(program, "aPos");
+  const aUv = gl.getAttribLocation(program, "aUv");
+  gl.enableVertexAttribArray(aPos);
+  gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
+  gl.enableVertexAttribArray(aUv);
+  gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
+  gl.bindVertexArray(null);
+  const colorCanvas = document.createElement("canvas");
+  colorCanvas.width = 1;
+  colorCanvas.height = 1;
+  const colorCtx = colorCanvas.getContext("2d", { willReadFrequently: true });
+  if (!colorCtx)
+    throw new Error("Failed to acquire 2D context for color parsing");
+  return {
+    gl,
+    program,
+    vao,
+    vbo,
+    colorCtx,
+    uniforms: {
+      uResolution: gl.getUniformLocation(program, "uResolution"),
+      uFirstColor: gl.getUniformLocation(program, "uFirstColor"),
+      uSecondColor: gl.getUniformLocation(program, "uSecondColor"),
+      uSpacing: gl.getUniformLocation(program, "uSpacing"),
+      uScale: gl.getUniformLocation(program, "uScale"),
+      uComplexity: gl.getUniformLocation(program, "uComplexity"),
+      uSmoothness: gl.getUniformLocation(program, "uSmoothness"),
+      uSeed: gl.getUniformLocation(program, "uSeed"),
+      uOffset: gl.getUniformLocation(program, "uOffset"),
+      uPhase: gl.getUniformLocation(program, "uPhase")
+    },
+    cachedFirstColor: "",
+    cachedFirstColorRgba: [255, 26, 10, 255],
+    cachedSecondColor: "",
+    cachedSecondColorRgba: [5, 5, 5, 255]
+  };
+};
+var normalized = (color) => [
+  color[0] / 255,
+  color[1] / 255,
+  color[2] / 255,
+  color[3] / 255
+];
+var liquidContours = createEffect({
+  type: "dev.remotion.effects.liquidContours",
+  label: "liquidContours()",
+  documentationLink: "https://www.remotion.dev/docs/effects/liquid-contours",
+  backend: "webgl2",
+  calculateKey: (params) => {
+    const r = resolve(params);
+    return `liquid-contours-${r.firstColor}-${r.secondColor}-${r.spacing}-${r.scale}-${r.complexity}-${r.smoothness}-${r.seed}-${r.offsetX}-${r.offsetY}-${r.phase}`;
+  },
+  setup,
+  apply: ({ width, height, params, state }) => {
+    const r = resolve(params);
+    if (state.cachedFirstColor !== r.firstColor) {
+      state.cachedFirstColor = r.firstColor;
+      state.cachedFirstColorRgba = parseColorRgba(state.colorCtx, r.firstColor);
+    }
+    if (state.cachedSecondColor !== r.secondColor) {
+      state.cachedSecondColor = r.secondColor;
+      state.cachedSecondColorRgba = parseColorRgba(state.colorCtx, r.secondColor);
+    }
+    const first = normalized(state.cachedFirstColorRgba);
+    const second = normalized(state.cachedSecondColorRgba);
+    const { gl, program, vao, uniforms } = state;
+    gl.viewport(0, 0, width, height);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    gl.clearColor(0, 0, 0, 0);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    gl.useProgram(program);
+    if (uniforms.uResolution)
+      gl.uniform2f(uniforms.uResolution, width, height);
+    if (uniforms.uFirstColor)
+      gl.uniform4f(uniforms.uFirstColor, ...first);
+    if (uniforms.uSecondColor)
+      gl.uniform4f(uniforms.uSecondColor, ...second);
+    if (uniforms.uSpacing)
+      gl.uniform1f(uniforms.uSpacing, r.spacing);
+    if (uniforms.uScale)
+      gl.uniform1f(uniforms.uScale, r.scale);
+    if (uniforms.uComplexity)
+      gl.uniform1f(uniforms.uComplexity, r.complexity);
+    if (uniforms.uSmoothness)
+      gl.uniform1f(uniforms.uSmoothness, r.smoothness);
+    if (uniforms.uSeed)
+      gl.uniform1f(uniforms.uSeed, r.seed);
+    if (uniforms.uOffset)
+      gl.uniform2f(uniforms.uOffset, r.offsetX, r.offsetY);
+    if (uniforms.uPhase)
+      gl.uniform1f(uniforms.uPhase, r.phase);
+    gl.bindVertexArray(vao);
+    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    gl.bindVertexArray(null);
+    gl.useProgram(null);
+  },
+  cleanup: ({ gl, program, vao, vbo }) => {
+    gl.deleteBuffer(vbo);
+    gl.deleteProgram(program);
+    gl.deleteVertexArray(vao);
+  },
+  schema: liquidContoursSchema,
+  validateParams: validateLiquidContoursParams
+});
+export {
+  liquidContoursSchema,
+  liquidContours
+};