@remotion/effects 4.0.481 → 4.0.483

package/dist/corner-pin/corner-pin-runtime.d.ts

@@ -0,0 +1,27 @@
+export type CornerPinState = {
+    gl: WebGL2RenderingContext;
+    program: WebGLProgram;
+    vao: WebGLVertexArrayObject;
+    vbo: WebGLBuffer;
+    textureSource: WebGLTexture;
+    uniforms: {
+        uSource: WebGLUniformLocation | null;
+        uTopLeft: WebGLUniformLocation | null;
+        uTopRight: WebGLUniformLocation | null;
+        uBottomRight: WebGLUniformLocation | null;
+        uBottomLeft: WebGLUniformLocation | null;
+    };
+};
+export declare const setupCornerPin: (target: HTMLCanvasElement) => CornerPinState;
+export declare const cleanupCornerPin: (state: CornerPinState) => void;
+export declare const applyCornerPin: ({ state, source, width, height, topLeft, topRight, bottomRight, bottomLeft, flipSourceY, }: {
+    readonly state: CornerPinState;
+    readonly source: CanvasImageSource;
+    readonly width: number;
+    readonly height: number;
+    readonly topLeft: readonly [number, number];
+    readonly topRight: readonly [number, number];
+    readonly bottomRight: readonly [number, number];
+    readonly bottomLeft: readonly [number, number];
+    readonly flipSourceY: boolean;
+}) => void;

package/dist/corner-pin/corner-pin-shaders.d.ts

@@ -0,0 +1,2 @@
+export declare const CORNER_PIN_VS = "#version 300 es\nlayout(location = 0) in vec2 aPos;\nlayout(location = 1) in vec2 aUv;\nout vec2 vUv;\n\nvoid main() {\n\tvUv = aUv;\n\tgl_Position = vec4(aPos, 0.0, 1.0);\n}\n";
+export declare const CORNER_PIN_FS = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform sampler2D uSource;\nuniform vec2 uTopLeft;\nuniform vec2 uTopRight;\nuniform vec2 uBottomRight;\nuniform vec2 uBottomLeft;\n\nfloat cross2(vec2 a, vec2 b) {\n\treturn a.x * b.y - a.y * b.x;\n}\n\nbool solveBilinearInverse(vec2 p, out vec2 uv) {\n\tvec2 a = uBottomLeft;\n\tvec2 b = uBottomRight - uBottomLeft;\n\tvec2 c = uTopLeft - uBottomLeft;\n\tvec2 d = uBottomLeft - uBottomRight + uTopRight - uTopLeft;\n\tvec2 q = p - a;\n\n\tfloat linearDenominator = cross2(b, c);\n\tif (abs(cross2(b, d)) < 0.000001) {\n\t\tif (abs(linearDenominator) < 0.000001) {\n\t\t\treturn false;\n\t\t}\n\n\t\tuv.x = cross2(q, c) / linearDenominator;\n\t\tuv.y = cross2(q, b) / cross2(c, b);\n\t\treturn true;\n\t}\n\n\tfloat qa = -cross2(b, d);\n\tfloat qb = cross2(q, d) - cross2(b, c);\n\tfloat qc = cross2(q, c);\n\tfloat discriminant = qb * qb - 4.0 * qa * qc;\n\n\tif (discriminant < 0.0) {\n\t\treturn false;\n\t}\n\n\tfloat sqrtDiscriminant = sqrt(discriminant);\n\tfloat u1 = (-qb + sqrtDiscriminant) / (2.0 * qa);\n\tfloat u2 = (-qb - sqrtDiscriminant) / (2.0 * qa);\n\tfloat u = u1;\n\tif (u1 < -0.001 || u1 > 1.001) {\n\t\tu = u2;\n\t}\n\n\tvec2 denominator = c + d * u;\n\tfloat v = abs(denominator.x) > abs(denominator.y)\n\t\t? (q.x - b.x * u) / denominator.x\n\t\t: (q.y - b.y * u) / denominator.y;\n\n\tuv = vec2(u, v);\n\treturn true;\n}\n\nvoid main() {\n\tvec2 sourceUv;\n\tif (!solveBilinearInverse(vUv, sourceUv)) {\n\t\tfragColor = vec4(0.0);\n\t\treturn;\n\t}\n\n\tif (\n\t\tsourceUv.x < 0.0 ||\n\t\tsourceUv.x > 1.0 ||\n\t\tsourceUv.y < 0.0 ||\n\t\tsourceUv.y > 1.0\n\t) {\n\t\tfragColor = vec4(0.0);\n\t\treturn;\n\t}\n\n\tfragColor = texture(uSource, sourceUv);\n}\n";

package/dist/corner-pin/index.d.ts

@@ -0,0 +1,14 @@
+export type CornerPinUvCoordinate = readonly [number, number];
+export type CornerPinParams = {
+    /** Top-left output corner in UV coordinates. Defaults to `[0, 0]`. */
+    readonly topLeft?: CornerPinUvCoordinate;
+    /** Top-right output corner in UV coordinates. Defaults to `[1, 0]`. */
+    readonly topRight?: CornerPinUvCoordinate;
+    /** Bottom-right output corner in UV coordinates. Defaults to `[1, 1]`. */
+    readonly bottomRight?: CornerPinUvCoordinate;
+    /** Bottom-left output corner in UV coordinates. Defaults to `[0, 1]`. */
+    readonly bottomLeft?: CornerPinUvCoordinate;
+};
+export declare const cornerPin: (params?: (CornerPinParams & {
+    readonly disabled?: boolean | undefined;
+}) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/corner-pin.d.ts

@@ -0,0 +1 @@
+export { cornerPin, type CornerPinParams, type CornerPinUvCoordinate, } from './corner-pin/index.js';

package/dist/esm/corner-pin.mjs

@@ -0,0 +1,389 @@
+// src/corner-pin/index.ts
+import { Internals as Internals2 } 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/corner-pin/corner-pin-runtime.ts
+import { Internals } from "remotion";
+
+// src/uv-coordinate.ts
+var publicUvToShaderUv = (uv) => {
+  return [uv[0], 1 - uv[1]];
+};
+
+// src/corner-pin/corner-pin-shaders.ts
+var CORNER_PIN_VS = `#version 300 es
+layout(location = 0) in vec2 aPos;
+layout(location = 1) in vec2 aUv;
+out vec2 vUv;
+
+void main() {
+	vUv = aUv;
+	gl_Position = vec4(aPos, 0.0, 1.0);
+}
+`;
+var CORNER_PIN_FS = `#version 300 es
+precision highp float;
+
+in vec2 vUv;
+out vec4 fragColor;
+
+uniform sampler2D uSource;
+uniform vec2 uTopLeft;
+uniform vec2 uTopRight;
+uniform vec2 uBottomRight;
+uniform vec2 uBottomLeft;
+
+float cross2(vec2 a, vec2 b) {
+	return a.x * b.y - a.y * b.x;
+}
+
+bool solveBilinearInverse(vec2 p, out vec2 uv) {
+	vec2 a = uBottomLeft;
+	vec2 b = uBottomRight - uBottomLeft;
+	vec2 c = uTopLeft - uBottomLeft;
+	vec2 d = uBottomLeft - uBottomRight + uTopRight - uTopLeft;
+	vec2 q = p - a;
+
+	float linearDenominator = cross2(b, c);
+	if (abs(cross2(b, d)) < 0.000001) {
+		if (abs(linearDenominator) < 0.000001) {
+			return false;
+		}
+
+		uv.x = cross2(q, c) / linearDenominator;
+		uv.y = cross2(q, b) / cross2(c, b);
+		return true;
+	}
+
+	float qa = -cross2(b, d);
+	float qb = cross2(q, d) - cross2(b, c);
+	float qc = cross2(q, c);
+	float discriminant = qb * qb - 4.0 * qa * qc;
+
+	if (discriminant < 0.0) {
+		return false;
+	}
+
+	float sqrtDiscriminant = sqrt(discriminant);
+	float u1 = (-qb + sqrtDiscriminant) / (2.0 * qa);
+	float u2 = (-qb - sqrtDiscriminant) / (2.0 * qa);
+	float u = u1;
+	if (u1 < -0.001 || u1 > 1.001) {
+		u = u2;
+	}
+
+	vec2 denominator = c + d * u;
+	float v = abs(denominator.x) > abs(denominator.y)
+		? (q.x - b.x * u) / denominator.x
+		: (q.y - b.y * u) / denominator.y;
+
+	uv = vec2(u, v);
+	return true;
+}
+
+void main() {
+	vec2 sourceUv;
+	if (!solveBilinearInverse(vUv, sourceUv)) {
+		fragColor = vec4(0.0);
+		return;
+	}
+
+	if (
+		sourceUv.x < 0.0 ||
+		sourceUv.x > 1.0 ||
+		sourceUv.y < 0.0 ||
+		sourceUv.y > 1.0
+	) {
+		fragColor = vec4(0.0);
+		return;
+	}
+
+	fragColor = texture(uSource, sourceUv);
+}
+`;
+
+// src/corner-pin/corner-pin-runtime.ts
+var { createWebGL2ContextError } = Internals;
+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(`Shader compile failed: ${log ?? "(no log)"}`);
+  }
+  return shader;
+};
+var linkProgram = (gl, vs, fs) => {
+  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);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    const log = gl.getProgramInfoLog(program);
+    gl.deleteProgram(program);
+    throw new Error(`Program link failed: ${log ?? "(no log)"}`);
+  }
+  return program;
+};
+var createProgram = (gl, vertexSource, fragmentSource) => {
+  const vs = compileShader(gl, gl.VERTEX_SHADER, vertexSource);
+  const fs = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSource);
+  const program = linkProgram(gl, vs, fs);
+  gl.deleteShader(vs);
+  gl.deleteShader(fs);
+  return program;
+};
+var createRgbaTexture = (gl) => {
+  const texture = gl.createTexture();
+  if (!texture) {
+    throw new Error("Failed to create WebGL texture");
+  }
+  gl.bindTexture(gl.TEXTURE_2D, texture);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+  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);
+  gl.bindTexture(gl.TEXTURE_2D, null);
+  return texture;
+};
+var setupCornerPin = (target) => {
+  const gl = target.getContext("webgl2", {
+    premultipliedAlpha: true,
+    alpha: true,
+    preserveDrawingBuffer: true
+  });
+  if (!gl) {
+    throw createWebGL2ContextError("corner pin effect");
+  }
+  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+  const program = createProgram(gl, CORNER_PIN_VS, CORNER_PIN_FS);
+  const vao = gl.createVertexArray();
+  if (!vao) {
+    throw new Error("Failed to create WebGL vertex array");
+  }
+  gl.bindVertexArray(vao);
+  const data = new Float32Array([
+    -1,
+    -1,
+    0,
+    0,
+    1,
+    -1,
+    1,
+    0,
+    -1,
+    1,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1
+  ]);
+  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, data, gl.STATIC_DRAW);
+  gl.enableVertexAttribArray(0);
+  gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 16, 0);
+  gl.enableVertexAttribArray(1);
+  gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 16, 8);
+  gl.bindVertexArray(null);
+  const textureSource = createRgbaTexture(gl);
+  return {
+    gl,
+    program,
+    vao,
+    vbo,
+    textureSource,
+    uniforms: {
+      uSource: gl.getUniformLocation(program, "uSource"),
+      uTopLeft: gl.getUniformLocation(program, "uTopLeft"),
+      uTopRight: gl.getUniformLocation(program, "uTopRight"),
+      uBottomRight: gl.getUniformLocation(program, "uBottomRight"),
+      uBottomLeft: gl.getUniformLocation(program, "uBottomLeft")
+    }
+  };
+};
+var cleanupCornerPin = (state) => {
+  const { gl, program, vao, vbo, textureSource } = state;
+  gl.deleteTexture(textureSource);
+  gl.deleteBuffer(vbo);
+  gl.deleteProgram(program);
+  gl.deleteVertexArray(vao);
+};
+var drawFullscreenQuad = (state) => {
+  const { gl, vao } = state;
+  gl.bindVertexArray(vao);
+  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+  gl.bindVertexArray(null);
+};
+var setUvUniform = (gl, location, uv) => {
+  if (!location) {
+    return;
+  }
+  const shaderUv = publicUvToShaderUv(uv);
+  gl.uniform2f(location, shaderUv[0], shaderUv[1]);
+};
+var applyCornerPin = ({
+  state,
+  source,
+  width,
+  height,
+  topLeft,
+  topRight,
+  bottomRight,
+  bottomLeft,
+  flipSourceY
+}) => {
+  const { gl, program, textureSource, uniforms } = state;
+  gl.viewport(0, 0, width, height);
+  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipSourceY);
+  gl.bindTexture(gl.TEXTURE_2D, textureSource);
+  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
+  gl.bindTexture(gl.TEXTURE_2D, null);
+  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+  gl.clearColor(0, 0, 0, 0);
+  gl.clear(gl.COLOR_BUFFER_BIT);
+  gl.useProgram(program);
+  if (uniforms.uSource)
+    gl.uniform1i(uniforms.uSource, 0);
+  setUvUniform(gl, uniforms.uTopLeft, topLeft);
+  setUvUniform(gl, uniforms.uTopRight, topRight);
+  setUvUniform(gl, uniforms.uBottomRight, bottomRight);
+  setUvUniform(gl, uniforms.uBottomLeft, bottomLeft);
+  gl.activeTexture(gl.TEXTURE0);
+  gl.bindTexture(gl.TEXTURE_2D, textureSource);
+  drawFullscreenQuad(state);
+  gl.bindTexture(gl.TEXTURE_2D, null);
+  gl.useProgram(null);
+};
+
+// src/corner-pin/index.ts
+var { createEffect } = Internals2;
+var DEFAULT_TOP_LEFT = [0, 0];
+var DEFAULT_TOP_RIGHT = [1, 0];
+var DEFAULT_BOTTOM_RIGHT = [1, 1];
+var DEFAULT_BOTTOM_LEFT = [0, 1];
+var cornerSchema = (defaultValue) => ({
+  type: "uv-coordinate",
+  min: -1,
+  max: 2,
+  step: 0.01,
+  default: defaultValue,
+  description: "Corner"
+});
+var cornerPinSchema = {
+  topLeft: {
+    ...cornerSchema(DEFAULT_TOP_LEFT),
+    description: "Top left"
+  },
+  topRight: {
+    ...cornerSchema(DEFAULT_TOP_RIGHT),
+    description: "Top right"
+  },
+  bottomRight: {
+    ...cornerSchema(DEFAULT_BOTTOM_RIGHT),
+    description: "Bottom right"
+  },
+  bottomLeft: {
+    ...cornerSchema(DEFAULT_BOTTOM_LEFT),
+    description: "Bottom left"
+  }
+};
+var resolve = (p) => ({
+  topLeft: [...p.topLeft ?? DEFAULT_TOP_LEFT],
+  topRight: [...p.topRight ?? DEFAULT_TOP_RIGHT],
+  bottomRight: [
+    ...p.bottomRight ?? DEFAULT_BOTTOM_RIGHT
+  ],
+  bottomLeft: [
+    ...p.bottomLeft ?? DEFAULT_BOTTOM_LEFT
+  ]
+});
+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 validateCornerPinParams = (params) => {
+  assertEffectParamsObject(params, "Corner pin");
+  assertOptionalUvCoordinate(params.topLeft, "topLeft");
+  assertOptionalUvCoordinate(params.topRight, "topRight");
+  assertOptionalUvCoordinate(params.bottomRight, "bottomRight");
+  assertOptionalUvCoordinate(params.bottomLeft, "bottomLeft");
+};
+var cornerPin = createEffect({
+  type: "dev.remotion.effects.cornerPin",
+  label: "cornerPin()",
+  documentationLink: "https://www.remotion.dev/docs/effects/corner-pin",
+  backend: "webgl2",
+  calculateKey: (params) => {
+    const r = resolve(params);
+    return `corner-pin-${r.topLeft.join(":")}-${r.topRight.join(":")}-${r.bottomRight.join(":")}-${r.bottomLeft.join(":")}`;
+  },
+  setup: (target) => setupCornerPin(target),
+  apply: ({ source, width, height, params, state, flipSourceY }) => {
+    const r = resolve(params);
+    applyCornerPin({
+      state,
+      source,
+      width,
+      height,
+      topLeft: r.topLeft,
+      topRight: r.topRight,
+      bottomRight: r.bottomRight,
+      bottomLeft: r.bottomLeft,
+      flipSourceY
+    });
+  },
+  cleanup: (state) => cleanupCornerPin(state),
+  schema: cornerPinSchema,
+  validateParams: validateCornerPinParams
+});
+export {
+  cornerPin
+};

package/dist/esm/gridlines.mjs

@@ -160,7 +160,7 @@ var gridlinesSchema = {
     type: "rotation-degrees",
     min: -180,
     max: 180,
-    step: 1,
+    step: 0.1,
     default: DEFAULT_ROTATION_X,
     description: "Rotation X"
   },
@@ -168,7 +168,7 @@ var gridlinesSchema = {
     type: "rotation-degrees",
     min: -180,
     max: 180,
-    step: 1,
+    step: 0.1,
     default: DEFAULT_ROTATION_Y,
     description: "Rotation Y"
   },

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

@@ -142,7 +142,10 @@ var halftoneLinearGradientSchema = {
     step: 0.01,
     default: DEFAULT_FIRST_STOP_POSITION,
     description: "First stop position",
-    lineTo: "secondStopPosition"
+    visual: {
+      type: "line",
+      to: "secondStopPosition"
+    }
   },
   secondStopPosition: {
     type: "uv-coordinate",