@remotion/effects 4.0.481 → 4.0.482

package/dist/esm/index.mjs

@@ -1431,7 +1431,7 @@ var gridlinesSchema = {
     type: "rotation-degrees",
     min: -180,
     max: 180,
-    step: 1,
+    step: 0.1,
     default: DEFAULT_ROTATION_X,
     description: "Rotation X"
   },
@@ -1439,7 +1439,7 @@ var gridlinesSchema = {
     type: "rotation-degrees",
     min: -180,
     max: 180,
-    step: 1,
+    step: 0.1,
     default: DEFAULT_ROTATION_Y,
     description: "Rotation Y"
   },
@@ -2309,10 +2309,361 @@ var zigzag = createEffect5({
   schema: zigzagSchema,
   validateParams: validateZigzagParams
 });
+// src/corner-pin/index.ts
+import { Internals as Internals7 } from "remotion";
+
+// src/corner-pin/corner-pin-runtime.ts
+import { Internals as Internals6 } from "remotion";
+
+// 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: createWebGL2ContextError6 } = Internals6;
+var compileShader6 = (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 linkProgram6 = (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 createProgram4 = (gl, vertexSource, fragmentSource) => {
+  const vs = compileShader6(gl, gl.VERTEX_SHADER, vertexSource);
+  const fs = compileShader6(gl, gl.FRAGMENT_SHADER, fragmentSource);
+  const program = linkProgram6(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 createWebGL2ContextError6("corner pin effect");
+  }
+  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+  const program = createProgram4(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: createEffect6 } = Internals7;
+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 resolve6 = (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 assertOptionalUvCoordinate2 = (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");
+  assertOptionalUvCoordinate2(params.topLeft, "topLeft");
+  assertOptionalUvCoordinate2(params.topRight, "topRight");
+  assertOptionalUvCoordinate2(params.bottomRight, "bottomRight");
+  assertOptionalUvCoordinate2(params.bottomLeft, "bottomLeft");
+};
+var cornerPin = createEffect6({
+  type: "dev.remotion.effects.cornerPin",
+  label: "cornerPin()",
+  documentationLink: "https://www.remotion.dev/docs/effects/corner-pin",
+  backend: "webgl2",
+  calculateKey: (params) => {
+    const r = resolve6(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 = resolve6(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 {
   zigzag,
   rings,
   pattern,
   gridlines,
+  cornerPin,
   checkerboard
 };