Skip to content

Create polished demo videos without editing skills. Mac/Windows/Linux

Render motion blur in paused timeline previews

webadderall47839808972e
diff --git a/src/components/video-editor/VideoPlayback.tsx b/src/components/video-editor/VideoPlayback.tsx
index 90a8533a..744dc9a1 100644
--- a/src/components/video-editor/VideoPlayback.tsx
+++ b/src/components/video-editor/VideoPlayback.tsx
@@ -111,6 +111,7 @@ import {
} from "./videoPlayback/motionSmoothing";
import { updateOverlayIndicator } from "./videoPlayback/overlayUtils";
import { supportsPreviewPlaybackRate } from "./videoPlayback/playbackRate";
+import { getFrameMotionSample } from "./videoPlayback/frameMotionSample";
import { PreviewVideoSource } from "./videoPlayback/previewVideoSource";
import { usePreviewVideoReady } from "./videoPlayback/usePreviewVideoReady";
import { getSceneEffectMetrics } from "./videoPlayback/sceneEffects";
@@ -1973,6 +1974,10 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
const applyTransform = (
transform: { scale: number; x: number; y: number },
focus: ZoomFocus,
+ motionSample?: {
+ previousTransform: { scale: number; x: number; y: number };
+ deltaMs: number;
+ } | null,
) => {
const cameraContainer = cameraContainerRef.current;
if (!cameraContainer) return;
@@ -1995,6 +2000,7 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
transformOverride: transform,
motionBlurState: motionBlurStateRef.current,
frameTimeMs: timelineTimeRef.current * 1000,
+ motionSample,
});
state.x = appliedTransform.x;
@@ -2051,17 +2057,56 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
}
lastRenderedContentTimeRef.current = contentTimeMs;
- const target = resolveSceneZoomTarget({
- zoomRegions: zoomRegionsRef.current,
- timeMs: timelineTimeRef.current * 1000,
- cursorTimeMs: currentTimeRef.current,
- connectZooms: connectZoomsRef.current,
- zoomInDurationMs: zoomInDurationMsRef.current,
- zoomOutDurationMs: zoomOutDurationMsRef.current,
- zoomClassicMode: zoomClassicModeRef.current,
- cursorTelemetry: cursorTelemetryRef.current,
- cursorFollowCamera: cursorFollowCameraRef.current,
- });
+ const sampleFrozenFrame = motionMode === "snap" && !isPlayingRef.current;
+ const frameSample = sampleFrozenFrame
+ ? getFrameMotionSample(contentTimeMs, clipRegionsRef.current)
+ : null;
+ const resolveTarget = (
+ timeMs: number,
+ cursorTimeMs: number,
+ cursorFollowCamera: CursorFollowCameraState,
+ ) =>
+ resolveSceneZoomTarget({
+ zoomRegions: zoomRegionsRef.current,
+ timeMs,
+ cursorTimeMs,
+ connectZooms: connectZoomsRef.current,
+ zoomInDurationMs: zoomInDurationMsRef.current,
+ zoomOutDurationMs: zoomOutDurationMsRef.current,
+ zoomClassicMode: zoomClassicModeRef.current,
+ cursorTelemetry: cursorTelemetryRef.current,
+ cursorFollowCamera,
+ });
+
+ const target = resolveTarget(
+ contentTimeMs,
+ currentTimeRef.current,
+ sampleFrozenFrame
+ ? createCursorFollowCameraState()
+ : cursorFollowCameraRef.current,
+ );
+ const previousTarget = frameSample
+ ? resolveTarget(
+ frameSample.previousTimeMs,
+ frameSample.previousSourceTimeMs,
+ createCursorFollowCameraState(),
+ )
+ : null;
+ const motionSample = sampleFrozenFrame
+ ? frameSample && previousTarget
+ ? {
+ previousTransform: computeZoomTransform({
+ stageSize: stageSizeRef.current,
+ baseMask: baseMaskRef.current,
+ zoomScale: previousTarget.scale,
+ zoomProgress: previousTarget.progress,
+ focusX: previousTarget.focus.cx,
+ focusY: previousTarget.focus.cy,
+ }),
+ deltaMs: frameSample.deltaMs,
+ }
+ : null
+ : undefined;
const state = animationStateRef.current;
@@ -2126,7 +2171,11 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
appliedY = state.y;
}
- applyTransform({ scale: appliedScale, x: appliedX, y: appliedY }, target.focus);
+ applyTransform(
+ { scale: appliedScale, x: appliedX, y: appliedY },
+ target.focus,
+ motionSample,
+ );
applyWebcamBubbleLayout(animationStateRef.current.appliedScale || 1);
@@ -2139,6 +2188,7 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
baseMaskRef.current,
showCursorRef.current,
isSeekingRef.current || shouldSnapPausedFrameRef.current,
+ sampleFrozenFrame ? (frameSample?.previousSourceTimeMs ?? null) : undefined,
);
}
diff --git a/src/components/video-editor/videoPlayback/cursorPosition.ts b/src/components/video-editor/videoPlayback/cursorPosition.ts
new file mode 100644
index 00000000..0c61e5f4
--- /dev/null
+++ b/src/components/video-editor/videoPlayback/cursorPosition.ts
@@ -0,0 +1,41 @@
+import type { CursorTelemetryPoint } from "../types";
+/** Linearly interpolate the neighboring telemetry samples at a media timestamp. */
+export function interpolateCursorPosition(
+ samples: CursorTelemetryPoint[],
+ timeMs: number,
+): { cx: number; cy: number } | null {
+ if (!samples || samples.length === 0) return null;
+
+ if (timeMs <= samples[0].timeMs) {
+ return { cx: samples[0].cx, cy: samples[0].cy };
+ }
+
+ if (timeMs >= samples[samples.length - 1].timeMs) {
+ return {
+ cx: samples[samples.length - 1].cx,
+ cy: samples[samples.length - 1].cy,
+ };
+ }
+
+ let lo = 0;
+ let hi = samples.length - 1;
+ while (lo < hi - 1) {
+ const mid = (lo + hi) >> 1;
+ if (samples[mid].timeMs <= timeMs) {
+ lo = mid;
+ } else {
+ hi = mid;
+ }
+ }
+
+ const a = samples[lo];
+ const b = samples[hi];
+ const span = b.timeMs - a.timeMs;
+ if (span <= 0) return { cx: a.cx, cy: a.cy };
+
+ const t = (timeMs - a.timeMs) / span;
+ return {
+ cx: a.cx + (b.cx - a.cx) * t,
+ cy: a.cy + (b.cy - a.cy) * t,
+ };
+}
diff --git a/src/components/video-editor/videoPlayback/cursorRenderer.ts b/src/components/video-editor/videoPlayback/cursorRenderer.ts
index 7988c857..bde9bfd6 100644
--- a/src/components/video-editor/videoPlayback/cursorRenderer.ts
+++ b/src/components/video-editor/videoPlayback/cursorRenderer.ts
@@ -27,6 +27,9 @@ import {
} from "./motionSmoothing";
import { cursorSetAssets, getCursorStyleSizeMultiplier } from "./uploadedCursorAssets";
import { computeDirectionalMotionBlur } from "./zoomTransform";
+import { interpolateCursorPosition } from "./cursorPosition";
+import { computeCursorFrameBlur } from "./frameMotionSample";
+export { interpolateCursorPosition } from "./cursorPosition";
type CursorAssetKey = NonNullable<CursorTelemetryPoint["cursorType"]>;
type StatefulCursorStyle = Extract<CursorStyle, "macos" | "tahoe" | "tahoe-inverted" | "windows11">;
@@ -703,50 +706,6 @@ export async function buildNativeCursorAtlas(
};
}
-/**
- * Interpolates cursor position from telemetry samples at a given time.
- * Uses linear interpolation between the two nearest samples.
- */
-export function interpolateCursorPosition(
- samples: CursorTelemetryPoint[],
- timeMs: number,
-): { cx: number; cy: number } | null {
- if (!samples || samples.length === 0) return null;
-
- if (timeMs <= samples[0].timeMs) {
- return { cx: samples[0].cx, cy: samples[0].cy };
- }
-
- if (timeMs >= samples[samples.length - 1].timeMs) {
- return {
- cx: samples[samples.length - 1].cx,
- cy: samples[samples.length - 1].cy,
- };
- }
-
- let lo = 0;
- let hi = samples.length - 1;
- while (lo < hi - 1) {
- const mid = (lo + hi) >> 1;
- if (samples[mid].timeMs <= timeMs) {
- lo = mid;
- } else {
- hi = mid;
- }
- }
-
- const a = samples[lo];
- const b = samples[hi];
- const span = b.timeMs - a.timeMs;
- if (span <= 0) return { cx: a.cx, cy: a.cy };
-
- const t = (timeMs - a.timeMs) / span;
- return {
- cx: a.cx + (b.cx - a.cx) * t,
- cy: a.cy + (b.cy - a.cy) * t,
- };
-}
-
function findLatestSample(samples: CursorTelemetryPoint[], timeMs: number) {
if (samples.length === 0) return null;
@@ -1327,6 +1286,7 @@ export class PixiCursorOverlay {
viewport: CursorViewportRect,
visible: boolean,
freeze = false,
+ previousFrameTimeMs?: number | null,
): void {
if (samples.length === 0 || viewport.width <= 0 || viewport.height <= 0) {
this.container.visible = false;
@@ -1536,7 +1496,21 @@ export class PixiCursorOverlay {
this.customCursorSprite.rotation = swayRotation;
}
- this.applyCursorMotionBlur(px, py, timeMs, shouldFreezeCursorMotion);
+ if (shouldFreezeCursorMotion && previousFrameTimeMs !== undefined) {
+ const blur = computeCursorFrameBlur(
+ samples,
+ timeMs,
+ previousFrameTimeMs,
+ viewport,
+ this.config.motionBlur,
+ CURSOR_DIRECTIONAL_BLUR_STRENGTH,
+ );
+ this.cursorMotionBlurFilter.velocity = blur.velocity;
+ this.cursorMotionBlurFilter.kernelSize = blur.kernelSize;
+ this.cursorMotionBlurFilter.offset = blur.offset;
+ } else {
+ this.applyCursorMotionBlur(px, py, timeMs, shouldFreezeCursorMotion);
+ }
this.lastRenderedPoint = shouldShowCursorSprite ? { px, py } : null;
this.lastRenderedTimeMs = timeMs;
}
diff --git a/src/components/video-editor/videoPlayback/frameMotionSample.test.ts b/src/components/video-editor/videoPlayback/frameMotionSample.test.ts
new file mode 100644
index 00000000..8dbdefc8
--- /dev/null
+++ b/src/components/video-editor/videoPlayback/frameMotionSample.test.ts
@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { computeCursorFrameBlur, getFrameMotionSample } from "./frameMotionSample";
+
+const clips = [
+ { id: "a", startMs: 0, endMs: 1000, sourceStartMs: 0, speed: 1 },
+ { id: "b", startMs: 1000, endMs: 2000, sourceStartMs: 10000, speed: 2 },
+];
+describe("frozen frame motion sampling", () => {
+ it("samples the same neighboring frame regardless of scrub direction", () => {
+ const sample = getFrameMotionSample(1500, clips)!;
+ expect(sample.previousTimeMs).toBeCloseTo(1500 - 1000 / 60);
+ expect(sample.previousSourceTimeMs).toBe(10966);
+ expect(sample.deltaMs).toBeCloseTo(1000 / 60);
+ });
+ it("never samples across a cut or a gap", () => {
+ expect(getFrameMotionSample(1000, clips)).toBeNull();
+ expect(getFrameMotionSample(1005, clips)?.previousTimeMs).toBe(1000);
+ expect(getFrameMotionSample(2500, clips)).toBeNull();
+ expect(getFrameMotionSample(0, [])).toBeNull();
+ });
+ it("uses nearby telemetry for cursor blur and clears it for stationary frames or cuts", () => {
+ const samples = [
+ { timeMs: 0, cx: 0.2, cy: 0.5 },
+ { timeMs: 1000, cx: 0.8, cy: 0.5 },
+ ];
+ const viewport = { x: 0, y: 0, width: 1000, height: 500 };
+ const blur = computeCursorFrameBlur(samples, 500, 500 - 1000 / 60, viewport, 1, 1);
+ expect(blur.velocity.x).toBeCloseTo(10);
+ expect(blur.velocity.y).toBe(0);
+ expect(computeCursorFrameBlur(samples, 500, null, viewport, 1, 1).magnitude).toBe(0);
+ expect(computeCursorFrameBlur(samples, 1500, 1483, viewport, 1, 1).magnitude).toBe(0);
+ });
+ it("does not smear a cursor entering a crop from outside", () => {
+ const samples = [
+ { timeMs: 0, cx: 0, cy: 0.5 },
+ { timeMs: 1000, cx: 1, cy: 0.5 },
+ ];
+ expect(
+ computeCursorFrameBlur(
+ samples,
+ 500,
+ 400,
+ {
+ x: 0,
+ y: 0,
+ width: 1000,
+ height: 500,
+ sourceCrop: { x: 0.45, y: 0, width: 0.5, height: 1 },
+ },
+ 1,
+ 1,
+ ).magnitude,
+ ).toBe(0);
+ });
+});
diff --git a/src/components/video-editor/videoPlayback/frameMotionSample.ts b/src/components/video-editor/videoPlayback/frameMotionSample.ts
new file mode 100644
index 00000000..9bca7473
--- /dev/null
+++ b/src/components/video-editor/videoPlayback/frameMotionSample.ts
@@ -0,0 +1,48 @@
+import {
+ findClipAtTimelineTime,
+ mapTimelineTimeToSourceTime,
+ type ClipRegion,
+ type CursorTelemetryPoint,
+} from "../types";
+import { interpolateCursorPosition } from "./cursorPosition";
+import { projectCursorPositionToViewport, type CursorViewportRect } from "./cursorViewport";
+import { computeDirectionalMotionBlur } from "./zoomTransform";
+
+/** Sample one media-frame interval, never the distance between playhead seeks. */
+export function getFrameMotionSample(timeMs: number, clips: ClipRegion[]) {
+ if (!Number.isFinite(timeMs) || timeMs <= 0) return null;
+ const clip = findClipAtTimelineTime(timeMs, clips);
+ if (clips.length && !clip) return null;
+ const previousTimeMs = Math.max(clip?.startMs ?? 0, timeMs - 1000 / 60);
+ if (previousTimeMs >= timeMs) return null;
+ return {
+ previousTimeMs,
+ previousSourceTimeMs: mapTimelineTimeToSourceTime(previousTimeMs, clips),
+ deltaMs: timeMs - previousTimeMs,
+ };
+}
+
+/** Telemetry motion for a frozen frame, independent of the previous rendered seek. */
+export function computeCursorFrameBlur(
+ samples: CursorTelemetryPoint[],
+ timeMs: number,
+ previousTimeMs: number | null,
+ viewport: CursorViewportRect,
+ amount: number,
+ strength: number,
+) {
+ const zero = () => computeDirectionalMotionBlur({ x: 0, y: 0 }, 0, 1 / 60);
+ if (previousTimeMs === null || previousTimeMs >= timeMs || amount <= 0) return zero();
+ const current = interpolateCursorPosition(samples, timeMs);
+ const previous = interpolateCursorPosition(samples, previousTimeMs);
+ if (!current || !previous) return zero();
+ const a = projectCursorPositionToViewport(previous, viewport.sourceCrop);
+ const b = projectCursorPositionToViewport(current, viewport.sourceCrop);
+ if (!a.visible || !b.visible) return zero();
+ return computeDirectionalMotionBlur(
+ { x: (b.cx - a.cx) * viewport.width, y: (b.cy - a.cy) * viewport.height },
+ amount,
+ (timeMs - previousTimeMs) / 1000,
+ strength,
+ );
+}
diff --git a/src/components/video-editor/videoPlayback/zoomTransform.test.ts b/src/components/video-editor/videoPlayback/zoomTransform.test.ts
index 79333ec9..09542534 100644
--- a/src/components/video-editor/videoPlayback/zoomTransform.test.ts
+++ b/src/components/video-editor/videoPlayback/zoomTransform.test.ts
@@ -182,3 +182,35 @@ describe("applyZoomTransform motion blur routing", () => {
expect(zoomBlurFilter.innerRadius).toBe(0);
});
});
+
+describe("paused camera frame blur", () => {
+ it("reconstructs blur without playback or prior render history and remains stable", () => {
+ const motionBlurFilter = { velocity: { x: 0, y: 0 }, kernelSize: 5, offset: 0 };
+ const zoomBlurFilter = { strength: 0, center: { x: 0, y: 0 }, innerRadius: 0, radius: -1 };
+ const params = {
+ cameraContainer: createStubContainer() as never,
+ motionBlurFilter: motionBlurFilter as never,
+ zoomBlurFilter: zoomBlurFilter as never,
+ stageSize: { width: 1000, height: 800 },
+ baseMask: { x: 0, y: 0, width: 1000, height: 800 },
+ zoomScale: 1,
+ focusX: 0.5,
+ focusY: 0.5,
+ isPlaying: false,
+ motionBlurAmount: 1,
+ transformOverride: { scale: 1, x: 10, y: 0 },
+ motionSample: { previousTransform: { scale: 1, x: 0, y: 0 }, deltaMs: 1000 / 60 },
+ };
+ applyZoomTransform(params);
+ expect(motionBlurFilter.velocity.x).toBeGreaterThan(0);
+ const velocity = { ...motionBlurFilter.velocity };
+ applyZoomTransform(params);
+ expect(motionBlurFilter.velocity).toEqual(velocity);
+ applyZoomTransform({ ...params, transformOverride: { scale: 1.01, x: 0, y: 0 } });
+ expect(zoomBlurFilter.strength).toBeGreaterThan(0);
+ expect(motionBlurFilter.velocity.x).toBe(0);
+ applyZoomTransform({ ...params, motionSample: null });
+ expect(zoomBlurFilter.strength).toBe(0);
+ expect(motionBlurFilter.velocity.x).toBe(0);
+ });
+});
diff --git a/src/components/video-editor/videoPlayback/zoomTransform.ts b/src/components/video-editor/videoPlayback/zoomTransform.ts
index 55ace06a..f884ecfc 100644
--- a/src/components/video-editor/videoPlayback/zoomTransform.ts
+++ b/src/components/video-editor/videoPlayback/zoomTransform.ts
@@ -52,6 +52,7 @@ interface TransformParams {
transformOverride?: AppliedTransform;
motionBlurState?: MotionBlurState;
frameTimeMs?: number;
+ motionSample?: { previousTransform: AppliedTransform; deltaMs: number } | null;
}
interface AppliedTransform {
@@ -495,6 +496,7 @@ export function applyZoomTransform({
transformOverride,
motionBlurState,
frameTimeMs,
+ motionSample,
}: TransformParams): AppliedTransform {
if (
stageSize.width <= 0 ||
@@ -524,7 +526,26 @@ export function applyZoomTransform({
cameraContainer.position.set(transform.x, transform.y);
const resolvedTuning = resolveMotionBlurTuning(motionBlurTuning);
- if (motionBlurState && motionBlurFilter && motionBlurAmount > 0 && isPlaying) {
+ if (motionBlurFilter && motionBlurAmount > 0 && motionSample && motionSample.deltaMs > 0) {
+ const analysis = analyzeCameraStep({
+ previousQuad: computeTransformQuad(baseMask, motionSample.previousTransform),
+ currentQuad: computeTransformQuad(baseMask, transform),
+ stageSize,
+ motionBlurAmount,
+ motionBlurTuning: resolvedTuning,
+ deltaSeconds: motionSample.deltaMs / 1000,
+ });
+ applyCameraStepBlur({ analysis, motionBlurFilter, zoomBlurFilter });
+ if (motionBlurState) {
+ motionBlurState.prevCamX = transform.x;
+ motionBlurState.prevCamY = transform.y;
+ motionBlurState.prevCamScale = transform.scale;
+ motionBlurState.lastFrameTimeMs = frameTimeMs ?? performance.now();
+ motionBlurState.initialized = true;
+ }
+ } else if (motionSample === null) {
+ resetMotionEffects(zoomBlurFilter, motionBlurFilter, motionBlurState);
+ } else if (motionBlurState && motionBlurFilter && motionBlurAmount > 0 && isPlaying) {
const now = frameTimeMs ?? performance.now();
if (!motionBlurState.initialized) {
diff --git a/tests/ui/paused-motion.html b/tests/ui/paused-motion.html
new file mode 100644
index 00000000..1ecc51d1
--- /dev/null
+++ b/tests/ui/paused-motion.html
@@ -0,0 +1 @@
+<!doctype html><html><head><meta charset="UTF-8"/><title>Paused motion preview test</title></head><body><div id="root"></div><script type="module" src="./paused-motion.tsx"></script></body></html>
diff --git a/tests/ui/paused-motion.spec.ts b/tests/ui/paused-motion.spec.ts
new file mode 100644
index 00000000..cad4a88d
--- /dev/null
+++ b/tests/ui/paused-motion.spec.ts
@@ -0,0 +1,33 @@
+import { expect, test } from "@playwright/test";
+import { installDesktopBridge } from "./bridge";
+for (const cursor of [false, true]) {
+ test(`paused ${cursor ? "cursor" : "camera"} blur survives scrubbing and holds its frame`, async ({
+ page,
+ }) => {
+ const errors: string[] = [];
+ page.on("pageerror", (error) => errors.push(error.message));
+ await installDesktopBridge(page, "filmstrip.mp4");
+ await page.goto(`/tests/ui/paused-motion.html${cursor ? "?cursor" : ""}`);
+ await expect(page.locator("main")).toHaveAttribute("data-ready", "true");
+ const canvas = page.locator("canvas").first();
+ const snapshot = async () => (await canvas.screenshot()).toString("base64");
+ const blurred = await snapshot();
+ await expect.poll(snapshot).toBe(blurred);
+ await page.getByRole("button", { name: "Toggle blur" }).click();
+ await expect.poll(snapshot).not.toBe(blurred);
+ await page.getByRole("button", { name: "Toggle blur" }).click();
+ await expect.poll(snapshot).toBe(blurred);
+ await page.getByRole("button", { name: "Seek elsewhere" }).click();
+ await expect
+ .poll(() =>
+ page
+ .locator("video")
+ .first()
+ .evaluate((v: HTMLVideoElement) => v.currentTime),
+ )
+ .toBeCloseTo(3, 2);
+ await page.getByRole("button", { name: "Seek back" }).click();
+ await expect.poll(snapshot).toBe(blurred);
+ expect(errors).toEqual([]);
+ });
+}
diff --git a/tests/ui/paused-motion.tsx b/tests/ui/paused-motion.tsx
new file mode 100644
index 00000000..9289aae8
--- /dev/null
+++ b/tests/ui/paused-motion.tsx
@@ -0,0 +1,66 @@
+import { useState } from "react";
+import { createRoot } from "react-dom/client";
+import VideoPlayback from "@/components/video-editor/VideoPlayback";
+import { I18nProvider } from "@/contexts/I18nContext";
+import "@/index.css";
+const cursor = new URLSearchParams(location.search).has("cursor");
+const noop = () => undefined;
+const clips = [{ id: "clip", startMs: 0, endMs: 6000, speed: 1 }];
+const zooms = [
+ {
+ id: "zoom",
+ startMs: 0,
+ endMs: 4000,
+ depth: 2 as const,
+ focus: { cx: 0.5, cy: 0.5 },
+ mode: "manual" as const,
+ },
+];
+const telemetry = [
+ { timeMs: 0, cx: 0.1, cy: 0.5 },
+ { timeMs: 1000, cx: 0.9, cy: 0.5 },
+ { timeMs: 6000, cx: 0.9, cy: 0.5 },
+];
+function Preview() {
+ const [time, setTime] = useState(0.8);
+ const [blur, setBlur] = useState(true);
+ const [ready, setReady] = useState(false);
+ return (
+ <main style={{ width: 900 }} data-ready={ready}>
+ <button onClick={() => setBlur((value) => !value)}>Toggle blur</button>
+ <button onClick={() => setTime(3)}>Seek elsewhere</button>
+ <button onClick={() => setTime(0.8)}>Seek back</button>
+ <VideoPlayback
+ videoPath="/tests/ui/fixtures/filmstrip.mp4"
+ clipRegions={clips}
+ currentTime={time}
+ onTimeUpdate={setTime}
+ onDurationChange={noop}
+ onPlayStateChange={noop}
+ onError={(error) => {
+ throw new Error(error);
+ }}
+ onPreviewReadyChange={setReady}
+ zoomRegions={cursor ? [] : zooms}
+ selectedZoomId={null}
+ onSelectZoom={noop}
+ onZoomFocusChange={noop}
+ isPlaying={false}
+ aspectRatio="16:9"
+ wallpaper="#111111"
+ showShadow={false}
+ padding={20}
+ showCursor={cursor}
+ cursorStyle="dot"
+ cursorTelemetry={telemetry}
+ cursorMotionBlur={cursor && blur ? 1 : 0}
+ zoomMotionBlur={!cursor && blur ? 1 : 0}
+ />
+ </main>
+ );
+}
+createRoot(document.getElementById("root")!).render(
+ <I18nProvider>
+ <Preview />
+ </I18nProvider>,
+);