@remotion/effects 4.0.539 → 4.0.541

package/dist/esm/corner-pin.mjs

@@ -1,392 +1,6 @@
-// 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;
-
-bool solveProjectiveInverse(vec2 p, out vec2 uv) {
-	vec2 p0 = uBottomLeft;
-	vec2 p1 = uBottomRight;
-	vec2 p2 = uTopRight;
-	vec2 p3 = uTopLeft;
-
-	vec2 dx1 = p1 - p2;
-	vec2 dx2 = p3 - p2;
-	vec2 dx3 = p0 - p1 + p2 - p3;
-
-	float g = 0.0;
-	float h = 0.0;
-
-	if (abs(dx3.x) > 0.000001 || abs(dx3.y) > 0.000001) {
-		float denominator = dx1.x * dx2.y - dx2.x * dx1.y;
-		if (abs(denominator) < 0.000001) {
-			return false;
-		}
-
-		g = (dx3.x * dx2.y - dx2.x * dx3.y) / denominator;
-		h = (dx1.x * dx3.y - dx3.x * dx1.y) / denominator;
-	}
-
-	float a = p1.x - p0.x + g * p1.x;
-	float b = p3.x - p0.x + h * p3.x;
-	float c = p0.x;
-	float d = p1.y - p0.y + g * p1.y;
-	float e = p3.y - p0.y + h * p3.y;
-	float f = p0.y;
-
-	float inverseX =
-		(e - f * h) * p.x +
-		(c * h - b) * p.y +
-		(b * f - c * e);
-	float inverseY =
-		(f * g - d) * p.x +
-		(a - c * g) * p.y +
-		(c * d - a * f);
-	float inverseW =
-		(d * h - e * g) * p.x +
-		(b * g - a * h) * p.y +
-		(a * e - b * d);
-
-	if (abs(inverseW) < 0.000001) {
-		return false;
-	}
-
-	uv = vec2(inverseX / inverseW, inverseY / inverseW);
-	return true;
-}
-
-void main() {
-	vec2 sourceUv;
-	if (!solveProjectiveInverse(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
-});
+import {
+  cornerPin2
+} from "./index-r0v18b2n.mjs";
 export {
-  cornerPin
+  cornerPin2 as cornerPin
 };