@remotion/transitions 4.0.522 → 4.0.524

package/blur-slide.js

@@ -0,0 +1,2 @@
+// For backwards compatibility when you use `esm-wallaby`
+module.exports = require('./dist/presentations/blur-slide.js');

package/dist/esm/blur-slide.mjs

@@ -0,0 +1,527 @@
+// src/html-in-canvas-presentation.tsx
+import { useCallback, useLayoutEffect, useMemo, useRef, useState } from "react";
+import {
+  AbsoluteFill,
+  HTML_IN_CANVAS_UNSUPPORTED_MESSAGE,
+  HtmlInCanvas,
+  Internals,
+  useDelayRender
+} from "remotion";
+import { jsx, jsxs } from "react/jsx-runtime";
+var HtmlInCanvasPresentation = ({
+  children,
+  onElementImage,
+  onUnmount,
+  presentationProgress,
+  presentationDirection,
+  shader,
+  effects,
+  passedProps,
+  bothEnteringAndExiting
+}) => {
+  if (!HtmlInCanvas.isSupported()) {
+    throw new Error(HTML_IN_CANVAS_UNSUPPORTED_MESSAGE);
+  }
+  const canvasRef = useRef(null);
+  const outputCanvasRef = useRef(null);
+  const canvasSubtreeStyle = useMemo(() => {
+    return {
+      width: "100%",
+      height: "100%",
+      position: "absolute",
+      top: 0,
+      left: 0,
+      right: 0,
+      bottom: 0
+    };
+  }, []);
+  const outputCanvasStyle = useMemo(() => {
+    return {
+      width: "100%",
+      height: "100%",
+      position: "absolute",
+      top: 0,
+      left: 0,
+      right: 0,
+      bottom: 0,
+      pointerEvents: "none"
+    };
+  }, []);
+  const captureCanvasRef = useRef(null);
+  const captureContextRef = useRef(null);
+  const [shaderCanvas] = useState(() => new OffscreenCanvas(1, 1));
+  const passedPropsRef = useRef(passedProps);
+  passedPropsRef.current = passedProps;
+  const memoizedEffects = Internals.useMemoizedEffects({
+    effects: effects ?? [],
+    overrideId: null
+  });
+  const effectsRef = useRef(memoizedEffects);
+  effectsRef.current = memoizedEffects;
+  const [instance] = useState(() => shader(shaderCanvas));
+  useLayoutEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas) {
+      return () => {
+        instance.cleanup();
+      };
+    }
+    const captureCanvas = canvas.transferControlToOffscreen();
+    const captureContext = captureCanvas.getContext("2d");
+    if (!captureContext) {
+      throw new Error("Failed to create capture canvas context");
+    }
+    captureCanvasRef.current = captureCanvas;
+    captureContextRef.current = captureContext;
+    return () => {
+      instance.cleanup();
+      captureCanvasRef.current = null;
+      captureContextRef.current = null;
+    };
+  }, [instance]);
+  const chainState = Internals.useEffectChainState();
+  const { delayRender, continueRender, cancelRender } = useDelayRender();
+  const draw = useCallback(async (prevImage, nextImage, progress) => {
+    const outputCanvas = outputCanvasRef.current;
+    if (!outputCanvas) {
+      throw new Error("Canvas not found");
+    }
+    const handle = delayRender("onPaint");
+    try {
+      const clearOutput = () => {
+        const context = outputCanvas.getContext("2d");
+        if (!context) {
+          throw new Error("Failed to create output canvas context");
+        }
+        context.clearRect(0, 0, outputCanvas.width, outputCanvas.height);
+      };
+      if (!prevImage && !nextImage) {
+        instance.clear();
+        clearOutput();
+        continueRender(handle);
+        return;
+      }
+      const width = prevImage?.width ?? nextImage?.width ?? 0;
+      const height = prevImage?.height ?? nextImage?.height ?? 0;
+      if (width === 0 || height === 0) {
+        instance.clear();
+        clearOutput();
+        continueRender(handle);
+        return;
+      }
+      shaderCanvas.width = width;
+      shaderCanvas.height = height;
+      instance.draw({
+        prevImage,
+        nextImage,
+        width,
+        height,
+        time: progress,
+        passedProps: passedPropsRef.current
+      });
+      await Internals.runEffectChain({
+        state: chainState.get(width, height),
+        source: shaderCanvas,
+        effects: effectsRef.current ?? [],
+        width,
+        height,
+        output: outputCanvas
+      });
+      continueRender(handle);
+    } catch (error) {
+      cancelRender(error);
+    }
+  }, [
+    cancelRender,
+    chainState,
+    continueRender,
+    delayRender,
+    instance,
+    shaderCanvas
+  ]);
+  const passThrough = bothEnteringAndExiting && presentationDirection === "exiting";
+  useLayoutEffect(() => {
+    if (passThrough) {
+      return;
+    }
+    const canvas = canvasRef.current;
+    if (!canvas) {
+      throw new Error("Canvas not found");
+    }
+    canvas.layoutSubtree = true;
+    const onPaint = () => {
+      const firstChild = canvas.firstChild;
+      const captureCanvas = captureCanvasRef.current;
+      const captureContext = captureContextRef.current;
+      if (!firstChild || !captureCanvas || !captureContext) {
+        return;
+      }
+      const elementImage = canvas.captureElementImage(firstChild);
+      try {
+        captureContext.reset();
+        captureContext.drawElementImage(elementImage, 0, 0);
+      } finally {
+        elementImage.close();
+      }
+      onElementImage(captureCanvas, draw);
+    };
+    canvas.addEventListener("paint", onPaint);
+    return () => {
+      canvas.removeEventListener("paint", onPaint);
+    };
+  }, [onElementImage, presentationDirection, draw, passThrough]);
+  useLayoutEffect(() => {
+    if (passThrough) {
+      return;
+    }
+    const canvas = canvasRef.current;
+    if (!canvas) {
+      throw new Error("Canvas not found");
+    }
+    canvas.requestPaint?.();
+  }, [presentationProgress, passThrough, memoizedEffects]);
+  useLayoutEffect(() => {
+    if (passThrough) {
+      return;
+    }
+    return () => {
+      onUnmount();
+    };
+  }, [onUnmount, passThrough]);
+  useLayoutEffect(() => {
+    if (passThrough) {
+      return;
+    }
+    const canvas = canvasRef.current;
+    if (!canvas) {
+      return;
+    }
+    const observer = new ResizeObserver(([entry]) => {
+      const outputCanvas = outputCanvasRef.current;
+      const captureCanvas = captureCanvasRef.current;
+      if (!outputCanvas || !captureCanvas) {
+        return;
+      }
+      const width = entry.devicePixelContentBoxSize[0].inlineSize;
+      const height = entry.devicePixelContentBoxSize[0].blockSize;
+      captureCanvas.width = width;
+      captureCanvas.height = height;
+      outputCanvas.width = width;
+      outputCanvas.height = height;
+      canvas.requestPaint?.();
+    });
+    observer.observe(canvas, { box: "device-pixel-content-box" });
+    return () => {
+      observer.disconnect();
+    };
+  }, [passThrough]);
+  if (passThrough) {
+    return children;
+  }
+  return /* @__PURE__ */ jsxs(AbsoluteFill, {
+    children: [
+      /* @__PURE__ */ jsx("canvas", {
+        ref: canvasRef,
+        style: canvasSubtreeStyle,
+        children
+      }),
+      /* @__PURE__ */ jsx("canvas", {
+        ref: outputCanvasRef,
+        style: outputCanvasStyle
+      })
+    ]
+  });
+};
+var makeHtmlInCanvasPresentation = (shader) => {
+  const CompWithShader = (props) => {
+    const { passedProps, ...otherProps } = props;
+    const { effects, ...restPassedProps } = props.passedProps;
+    return /* @__PURE__ */ jsx(HtmlInCanvasPresentation, {
+      shader,
+      passedProps: restPassedProps,
+      effects,
+      ...otherProps
+    });
+  };
+  return (props) => {
+    return {
+      component: CompWithShader,
+      props
+    };
+  };
+};
+
+// src/presentations/upload-element-image.ts
+var uploadElementImage = (gl, elementImage) => {
+  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, elementImage);
+};
+
+// src/presentations/blur-slide.tsx
+var DEFAULT_DIRECTION = "from-left";
+var DEFAULT_BLUR = 0.5;
+var VALID_DIRECTIONS = [
+  "from-left",
+  "from-right",
+  "from-top",
+  "from-bottom"
+];
+var VERTEX_SHADER = `#version 300 es
+in vec2 a_pos;
+out vec2 v_uv;
+void main() {
+	v_uv = vec2(a_pos.x * 0.5 + 0.5, 0.5 - a_pos.y * 0.5);
+	gl_Position = vec4(a_pos, 0.0, 1.0);
+}`;
+var SAMPLES = 32;
+var SLIDE_FRAGMENT_SHADER = `#version 300 es
+precision highp float;
+
+uniform sampler2D u_prev;
+uniform sampler2D u_next;
+uniform float u_progress;
+uniform vec2 u_direction;
+uniform float u_blur_length;
+
+in vec2 v_uv;
+out vec4 outColor;
+
+const int SAMPLES = ${SAMPLES};
+
+void main() {
+	// Both scenes travel together; the exiting scene wraps around the edges
+	// while the entering scene takes over through a crossfade in the middle.
+	vec2 slidUv = v_uv - u_direction * u_progress;
+	float mixFactor = smoothstep(0.3, 0.7, u_progress);
+
+	vec4 color = vec4(0.0);
+	for (int i = 0; i < SAMPLES; i++) {
+		float t = (float(i) / float(SAMPLES - 1) - 0.5) * u_blur_length;
+		vec2 uv = slidUv + u_direction * t;
+		color += mix(texture(u_prev, uv), texture(u_next, uv), mixFactor);
+	}
+
+	outColor = color / float(SAMPLES);
+}`;
+var BLUR_FRAGMENT_SHADER = `#version 300 es
+precision highp float;
+
+uniform sampler2D u_source;
+uniform vec2 u_direction;
+uniform float u_blur_length;
+
+in vec2 v_uv;
+out vec4 outColor;
+
+const int SAMPLES = ${SAMPLES};
+
+void main() {
+	vec4 color = vec4(0.0);
+	for (int i = 0; i < SAMPLES; i++) {
+		float t = ((float(i) + 0.5) / float(SAMPLES) - 0.5) * u_blur_length;
+		vec2 uv = v_uv + u_direction * t;
+		// The framebuffer texture is stored bottom-up, so flip Y when sampling it.
+		color += texture(u_source, vec2(uv.x, 1.0 - uv.y));
+	}
+
+	outColor = color / float(SAMPLES);
+}`;
+var compileShader = (gl, source, type) => {
+  const shader = gl.createShader(type);
+  if (!shader) {
+    throw new Error("Failed to create 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(`Failed to compile shader: ${log}`);
+  }
+  return shader;
+};
+var createProgram = (gl, fragmentShader) => {
+  const program = gl.createProgram();
+  if (!program) {
+    throw new Error("Failed to create WebGL program");
+  }
+  const vs = compileShader(gl, VERTEX_SHADER, gl.VERTEX_SHADER);
+  const fs = compileShader(gl, fragmentShader, gl.FRAGMENT_SHADER);
+  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(`Failed to link program: ${log}`);
+  }
+  return program;
+};
+var createTexture = (gl) => {
+  const tex = gl.createTexture();
+  if (!tex) {
+    throw new Error("Failed to create texture");
+  }
+  gl.bindTexture(gl.TEXTURE_2D, tex);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array([0, 0, 0, 0]));
+  return tex;
+};
+var getDirectionVector = (direction) => {
+  switch (direction) {
+    case "from-left":
+      return [1, 0];
+    case "from-right":
+      return [-1, 0];
+    case "from-top":
+      return [0, 1];
+    case "from-bottom":
+      return [0, -1];
+    default:
+      throw new Error(`Invalid direction: ${direction}`);
+  }
+};
+var validateProps = (props) => {
+  const direction = props.direction ?? DEFAULT_DIRECTION;
+  const blur = props.blur ?? DEFAULT_BLUR;
+  if (!VALID_DIRECTIONS.includes(direction)) {
+    throw new TypeError(`direction passed to blurSlide() must be one of ${VALID_DIRECTIONS.map((d) => `"${d}"`).join(", ")}, received ${JSON.stringify(direction)}`);
+  }
+  if (typeof blur !== "number" || !Number.isFinite(blur)) {
+    throw new TypeError(`blur passed to blurSlide() must be a finite number, received ${blur}`);
+  }
+  if (blur < 0) {
+    throw new TypeError(`blur passed to blurSlide() must be greater than or equal to 0, received ${blur}`);
+  }
+};
+var blurSlideShader = (canvas) => {
+  const gl = canvas.getContext("webgl2", { premultipliedAlpha: true });
+  if (!gl) {
+    throw new Error("Failed to create WebGL2 context");
+  }
+  const slideProgram = createProgram(gl, SLIDE_FRAGMENT_SHADER);
+  const blurProgram = createProgram(gl, BLUR_FRAGMENT_SHADER);
+  const prevTex = createTexture(gl);
+  const nextTex = createTexture(gl);
+  const intermediateTex = createTexture(gl);
+  const framebuffer = gl.createFramebuffer();
+  if (!framebuffer) {
+    throw new Error("Failed to create framebuffer");
+  }
+  gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+  gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, intermediateTex, 0);
+  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+  let intermediateWidth = 1;
+  let intermediateHeight = 1;
+  const vao = gl.createVertexArray();
+  gl.bindVertexArray(vao);
+  const buffer = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+  gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]), gl.STATIC_DRAW);
+  const aPos = gl.getAttribLocation(slideProgram, "a_pos");
+  gl.enableVertexAttribArray(aPos);
+  gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 0, 0);
+  const uPrev = gl.getUniformLocation(slideProgram, "u_prev");
+  const uNext = gl.getUniformLocation(slideProgram, "u_next");
+  const uProgress = gl.getUniformLocation(slideProgram, "u_progress");
+  const uSlideDirection = gl.getUniformLocation(slideProgram, "u_direction");
+  const uSlideBlurLength = gl.getUniformLocation(slideProgram, "u_blur_length");
+  const uSource = gl.getUniformLocation(blurProgram, "u_source");
+  const uBlurDirection = gl.getUniformLocation(blurProgram, "u_direction");
+  const uBlurBlurLength = gl.getUniformLocation(blurProgram, "u_blur_length");
+  const cleanup = () => {
+    gl.deleteProgram(slideProgram);
+    gl.deleteProgram(blurProgram);
+    gl.deleteTexture(prevTex);
+    gl.deleteTexture(nextTex);
+    gl.deleteTexture(intermediateTex);
+    gl.deleteFramebuffer(framebuffer);
+    gl.deleteBuffer(buffer);
+    gl.deleteVertexArray(vao);
+  };
+  const clear = () => {
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    gl.clearColor(0, 0, 0, 0);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+  };
+  const draw = ({
+    prevImage,
+    nextImage,
+    width,
+    height,
+    time,
+    passedProps
+  }) => {
+    const { direction = DEFAULT_DIRECTION, blur = DEFAULT_BLUR } = passedProps;
+    if (!prevImage && !nextImage) {
+      return;
+    }
+    if (prevImage && (prevImage.width === 0 || prevImage.height === 0)) {
+      return;
+    }
+    if (nextImage && (nextImage.width === 0 || nextImage.height === 0)) {
+      return;
+    }
+    const effectiveTime = !prevImage ? 0 : !nextImage ? 1 : time;
+    const p = 1 - effectiveTime;
+    const progress = p * p * p * (p * (p * 6 - 15) + 10);
+    const blurLength = blur * 2 * Math.min(progress, 1 - progress);
+    const coarseTapSpacing = blurLength / (SAMPLES - 1);
+    const [dirX, dirY] = getDirectionVector(direction);
+    gl.bindVertexArray(vao);
+    if (intermediateWidth !== width || intermediateHeight !== height) {
+      gl.bindTexture(gl.TEXTURE_2D, intermediateTex);
+      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+      intermediateWidth = width;
+      intermediateHeight = height;
+    }
+    gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+    gl.viewport(0, 0, width, height);
+    gl.clearColor(0, 0, 0, 0);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    gl.useProgram(slideProgram);
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, prevTex);
+    if (prevImage) {
+      uploadElementImage(gl, prevImage);
+    }
+    gl.uniform1i(uPrev, 0);
+    gl.activeTexture(gl.TEXTURE1);
+    gl.bindTexture(gl.TEXTURE_2D, nextTex);
+    if (nextImage) {
+      uploadElementImage(gl, nextImage);
+    }
+    gl.uniform1i(uNext, 1);
+    gl.uniform1f(uProgress, progress);
+    gl.uniform2f(uSlideDirection, dirX, dirY);
+    gl.uniform1f(uSlideBlurLength, blurLength);
+    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    gl.viewport(0, 0, width, height);
+    gl.clearColor(0, 0, 0, 0);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    gl.useProgram(blurProgram);
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, intermediateTex);
+    gl.uniform1i(uSource, 0);
+    gl.uniform2f(uBlurDirection, dirX, dirY);
+    gl.uniform1f(uBlurBlurLength, coarseTapSpacing);
+    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+  };
+  return {
+    clear,
+    cleanup,
+    draw
+  };
+};
+var makeBlurSlide = makeHtmlInCanvasPresentation(blurSlideShader);
+var blurSlide = (props = {}) => {
+  validateProps(props);
+  return makeBlurSlide(props);
+};
+export {
+  blurSlideShader,
+  blurSlide
+};