Create polished demo videos without editing skills. Mac/Windows/Linux
import { Container } from "pixi.js";
import { MotionBlurFilter } from "pixi-filters/motion-blur";
import { ZoomBlurFilter } from "pixi-filters/zoom-blur";
import { DEFAULT_ZOOM_MOTION_BLUR_TUNING, type ZoomMotionBlurTuning } from "../types";
const MIN_DIRECTIONAL_BLUR_MAGNITUDE = 0.01;
const DIRECTIONAL_BLUR_KERNEL_SIZE = 13;
const DIRECTIONAL_BLUR_OFFSET_DIVISOR = 32;
const SPATIAL_PAN_SHUTTER_MULTIPLIER = 4;
// Spatial equivalent of a longer exposure. This extends the one-pass zoom
// trail without multiplying scene renders like temporal accumulation does.
const SPATIAL_ZOOM_SHUTTER_MULTIPLIER = 4;
export interface DirectionalMotionBlur {
velocity: { x: number; y: number };
magnitude: number;
kernelSize: number;
offset: number;
}
export interface MotionBlurState {
lastFrameTimeMs: number;
prevCamX: number;
prevCamY: number;
prevCamScale: number;
initialized: boolean;
}
export function createMotionBlurState(): MotionBlurState {
return {
lastFrameTimeMs: 0,
prevCamX: 0,
prevCamY: 0,
prevCamScale: 1,
initialized: false,
};
}
interface TransformParams {
cameraContainer: Container;
zoomBlurFilter?: ZoomBlurFilter | null;
motionBlurFilter?: MotionBlurFilter | null;
stageSize: { width: number; height: number };
baseMask: { x: number; y: number; width: number; height: number };
zoomScale: number;
zoomProgress?: number;
focusX: number;
focusY: number;
isPlaying: boolean;
motionBlurAmount?: number;
motionBlurTuning?: ZoomMotionBlurTuning;
transformOverride?: AppliedTransform;
motionBlurState?: MotionBlurState;
frameTimeMs?: number;
motionSample?: { previousTransform: AppliedTransform; deltaMs: number } | null;
}
interface AppliedTransform {
scale: number;
x: number;
y: number;
}
interface Point2D {
x: number;
y: number;
}
interface TransformQuad {
center: Point2D;
corners: [Point2D, Point2D, Point2D, Point2D];
diagonal: number;
size: Point2D;
}
interface CameraStepAnalysis {
mode: "move" | "zoom" | null;
moveVelocity: Point2D;
moveBlurVelocity: Point2D;
moveBlurOffset: number;
zoomCenter: Point2D;
zoomStrength: number;
}
interface FocusFromTransformGeometry {
stageSize: { width: number; height: number };
baseMask: { x: number; y: number; width: number; height: number };
zoomScale: number;
x: number;
y: number;
}
interface ZoomTransformGeometry {
stageSize: { width: number; height: number };
baseMask: { x: number; y: number; width: number; height: number };
zoomScale: number;
zoomProgress?: number;
focusX: number;
focusY: number;
}
function resetMotionEffects(
zoomBlurFilter?: ZoomBlurFilter | null,
motionBlurFilter?: MotionBlurFilter | null,
motionBlurState?: MotionBlurState,
) {
if (motionBlurFilter) {
motionBlurFilter.velocity = { x: 0, y: 0 };
motionBlurFilter.kernelSize = 5;
motionBlurFilter.offset = 0;
}
if (zoomBlurFilter) {
zoomBlurFilter.strength = 0;
zoomBlurFilter.innerRadius = 0;
zoomBlurFilter.radius = -1;
}
if (motionBlurState) {
motionBlurState.lastFrameTimeMs = 0;
motionBlurState.prevCamX = 0;
motionBlurState.prevCamY = 0;
motionBlurState.prevCamScale = 1;
motionBlurState.initialized = false;
}
}
function resolveMotionBlurTuning(motionBlurTuning?: ZoomMotionBlurTuning): ZoomMotionBlurTuning {
if (!motionBlurTuning) {
return DEFAULT_ZOOM_MOTION_BLUR_TUNING;
}
return {
...DEFAULT_ZOOM_MOTION_BLUR_TUNING,
...motionBlurTuning,
};
}
function computeTransformQuad(
baseMask: { x: number; y: number; width: number; height: number },
transform: AppliedTransform,
): TransformQuad {
const topLeft = {
x: transform.x + baseMask.x * transform.scale,
y: transform.y + baseMask.y * transform.scale,
};
const topRight = {
x: transform.x + (baseMask.x + baseMask.width) * transform.scale,
y: transform.y + baseMask.y * transform.scale,
};
const bottomRight = {
x: transform.x + (baseMask.x + baseMask.width) * transform.scale,
y: transform.y + (baseMask.y + baseMask.height) * transform.scale,
};
const bottomLeft = {
x: transform.x + baseMask.x * transform.scale,
y: transform.y + (baseMask.y + baseMask.height) * transform.scale,
};
const center = {
x: (topLeft.x + bottomRight.x) * 0.5,
y: (topLeft.y + bottomRight.y) * 0.5,
};
return {
center,
corners: [topLeft, topRight, bottomRight, bottomLeft],
diagonal: Math.hypot(bottomRight.x - topLeft.x, bottomRight.y - topLeft.y),
size: {
x: Math.hypot(topRight.x - topLeft.x, topRight.y - topLeft.y),
y: Math.hypot(bottomLeft.x - topLeft.x, bottomLeft.y - topLeft.y),
},
};
}
function crossProduct(a: Point2D, b: Point2D) {
return a.x * b.y - a.y * b.x;
}
function clamp(value: number, min: number, max: number) {
return Math.min(max, Math.max(min, value));
}
function intersectInfiniteLines(
aStart: Point2D,
aEnd: Point2D,
bStart: Point2D,
bEnd: Point2D,
): Point2D | null {
const aDelta = { x: aEnd.x - aStart.x, y: aEnd.y - aStart.y };
const bDelta = { x: bEnd.x - bStart.x, y: bEnd.y - bStart.y };
const denominator = crossProduct(aDelta, bDelta);
if (Math.abs(denominator) < 0.0001) {
return null;
}
const originDelta = { x: bStart.x - aStart.x, y: bStart.y - aStart.y };
const t = crossProduct(originDelta, bDelta) / denominator;
return {
x: aStart.x + aDelta.x * t,
y: aStart.y + aDelta.y * t,
};
}
function inferZoomCenterFromQuads(
previousQuad: TransformQuad,
currentQuad: TransformQuad,
stageSize: { width: number; height: number },
) {
const hasMeaningfulChange =
Math.abs(currentQuad.center.x - previousQuad.center.x) > 0.001 ||
Math.abs(currentQuad.center.y - previousQuad.center.y) > 0.001 ||
Math.abs(currentQuad.diagonal - previousQuad.diagonal) > 0.001;
if (!hasMeaningfulChange) {
return previousQuad.center;
}
const motionSegments: Array<{ start: Point2D; end: Point2D }> = [];
for (let i = 0; i < previousQuad.corners.length; i += 1) {
const start = previousQuad.corners[i];
const end = currentQuad.corners[i];
if (Math.hypot(end.x - start.x, end.y - start.y) < 0.5) {
continue;
}
motionSegments.push({ start, end });
}
for (let i = 0; i < motionSegments.length; i += 1) {
for (let j = i + 1; j < motionSegments.length; j += 1) {
const intersection = intersectInfiniteLines(
motionSegments[i].start,
motionSegments[i].end,
motionSegments[j].start,
motionSegments[j].end,
);
if (!intersection) {
continue;
}
const marginX = stageSize.width;
const marginY = stageSize.height;
return {
x: clamp(intersection.x, -marginX, stageSize.width + marginX),
y: clamp(intersection.y, -marginY, stageSize.height + marginY),
};
}
}
return currentQuad.center;
}
function resolveFpsScale(deltaSeconds: number) {
const fps = 1 / Math.max(1 / 240, deltaSeconds);
return fps / 60;
}
export function computeDirectionalMotionBlur(
delta: { x: number; y: number },
motionBlurAmount: number,
deltaSeconds: number,
strengthMultiplier = 1,
): DirectionalMotionBlur {
const scale = motionBlurAmount * resolveFpsScale(deltaSeconds) * strengthMultiplier;
const velocity = {
x: delta.x * scale,
y: delta.y * scale,
};
const magnitude = Math.hypot(velocity.x, velocity.y);
const isActive = magnitude >= MIN_DIRECTIONAL_BLUR_MAGNITUDE;
return {
velocity: isActive ? velocity : createZeroPoint(),
magnitude: isActive ? magnitude : 0,
kernelSize: DIRECTIONAL_BLUR_KERNEL_SIZE,
offset: isActive ? -magnitude / DIRECTIONAL_BLUR_OFFSET_DIVISOR : 0,
};
}
function resolveZoomBlurStrength(
motionBlurAmount: number,
motionBlurTuning: ZoomMotionBlurTuning,
deltaSeconds: number,
) {
const fpsScale = resolveFpsScale(deltaSeconds);
return (
motionBlurAmount *
fpsScale *
SPATIAL_ZOOM_SHUTTER_MULTIPLIER *
(motionBlurTuning.maxRadialBlurStrength /
DEFAULT_ZOOM_MOTION_BLUR_TUNING.maxRadialBlurStrength)
);
}
function computeMoveDelta(previousQuad: TransformQuad, currentQuad: TransformQuad) {
return {
x: currentQuad.center.x - previousQuad.center.x,
y: currentQuad.center.y - previousQuad.center.y,
};
}
function computeSizeDelta(previousQuad: TransformQuad, currentQuad: TransformQuad) {
return {
x: Math.abs(currentQuad.size.x - previousQuad.size.x),
y: Math.abs(currentQuad.size.y - previousQuad.size.y),
};
}
function computeZoomStrength(previousQuad: TransformQuad, currentQuad: TransformQuad) {
// Keep the spatial approximation sampling inward. Sampling outward during
// expansion can leave the filter's captured texture and produce transparent
// or black frames; true directionality requires temporal/overscanned input.
return Math.abs(1 - currentQuad.diagonal / Math.max(0.0001, previousQuad.diagonal));
}
function classifyMotionMode(
previousQuad: TransformQuad,
currentQuad: TransformQuad,
motionBlurTuning: ZoomMotionBlurTuning,
deltaSeconds: number,
) {
const moveDelta = computeMoveDelta(previousQuad, currentQuad);
const sizeDelta = computeSizeDelta(previousQuad, currentQuad);
const moveDistance = Math.hypot(moveDelta.x, moveDelta.y);
const zoomDistance = Math.hypot(sizeDelta.x, sizeDelta.y);
const moveVelocity = Math.hypot(moveDelta.x, moveDelta.y) / Math.max(0.0001, deltaSeconds);
const zoomVelocity =
Math.abs(
Math.log(
Math.max(0.0001, currentQuad.diagonal) / Math.max(0.0001, previousQuad.diagonal),
),
) / Math.max(0.0001, deltaSeconds);
const moveActive = moveDistance > 0.001 && moveVelocity > motionBlurTuning.panVelocityThreshold;
const zoomActive =
zoomDistance > 0.001 && zoomVelocity > motionBlurTuning.zoomVelocityThreshold;
if (!moveActive && !zoomActive) {
return null;
}
// Any meaningful scale change is a zoom. The inferred zoom center already
// accounts for the translation caused by an off-center zoom, so routing it
// through pan blur would turn a straight radial zoom into a directional smear.
if (zoomActive) {
return "zoom";
}
return "move";
}
function createZeroPoint(): Point2D {
return { x: 0, y: 0 };
}
function analyzeCameraStep({
previousQuad,
currentQuad,
stageSize,
motionBlurAmount,
motionBlurTuning,
deltaSeconds,
}: {
previousQuad: TransformQuad;
currentQuad: TransformQuad;
stageSize: { width: number; height: number };
motionBlurAmount: number;
motionBlurTuning: ZoomMotionBlurTuning;
deltaSeconds: number;
}): CameraStepAnalysis {
const mode = classifyMotionMode(previousQuad, currentQuad, motionBlurTuning, deltaSeconds);
const moveDelta = computeMoveDelta(previousQuad, currentQuad);
const zoomBlurStrength = resolveZoomBlurStrength(
motionBlurAmount,
motionBlurTuning,
deltaSeconds,
);
const directionalBlur = computeDirectionalMotionBlur(
moveDelta,
motionBlurAmount,
deltaSeconds,
SPATIAL_PAN_SHUTTER_MULTIPLIER *
(motionBlurTuning.maxDirectionalBlurPx /
DEFAULT_ZOOM_MOTION_BLUR_TUNING.maxDirectionalBlurPx),
);
return {
mode,
moveVelocity: moveDelta,
moveBlurVelocity: mode === "move" ? directionalBlur.velocity : createZeroPoint(),
moveBlurOffset: mode === "move" ? directionalBlur.offset : 0,
zoomCenter: inferZoomCenterFromQuads(previousQuad, currentQuad, stageSize),
zoomStrength:
mode === "zoom" ? computeZoomStrength(previousQuad, currentQuad) * zoomBlurStrength : 0,
};
}
function applyCameraStepBlur({
analysis,
motionBlurFilter,
zoomBlurFilter,
}: {
analysis: CameraStepAnalysis;
motionBlurFilter: MotionBlurFilter;
zoomBlurFilter?: ZoomBlurFilter | null;
}) {
motionBlurFilter.velocity = analysis.moveBlurVelocity;
motionBlurFilter.kernelSize = DIRECTIONAL_BLUR_KERNEL_SIZE;
motionBlurFilter.offset = analysis.moveBlurOffset;
if (zoomBlurFilter) {
zoomBlurFilter.center = analysis.zoomCenter;
zoomBlurFilter.strength = analysis.zoomStrength;
zoomBlurFilter.innerRadius = 0;
zoomBlurFilter.radius = -1;
}
}
export function computeZoomTransform({
stageSize,
baseMask,
zoomScale,
zoomProgress = 1,
focusX,
focusY,
}: ZoomTransformGeometry): AppliedTransform {
if (
stageSize.width <= 0 ||
stageSize.height <= 0 ||
baseMask.width <= 0 ||
baseMask.height <= 0
) {
return { scale: 1, x: 0, y: 0 };
}
const progress = Math.min(1, Math.max(0, zoomProgress));
const focusStagePxX = baseMask.x + focusX * baseMask.width;
const focusStagePxY = baseMask.y + focusY * baseMask.height;
const stageCenterX = stageSize.width / 2;
const stageCenterY = stageSize.height / 2;
const scale = 1 + (zoomScale - 1) * progress;
const finalX = stageCenterX - focusStagePxX * zoomScale;
const finalY = stageCenterY - focusStagePxY * zoomScale;
return {
scale,
x: finalX * progress,
y: finalY * progress,
};
}
export function computeFocusFromTransform({
stageSize,
baseMask,
zoomScale,
x,
y,
}: FocusFromTransformGeometry) {
if (
stageSize.width <= 0 ||
stageSize.height <= 0 ||
baseMask.width <= 0 ||
baseMask.height <= 0 ||
zoomScale <= 0
) {
return { cx: 0.5, cy: 0.5 };
}
const stageCenterX = stageSize.width / 2;
const stageCenterY = stageSize.height / 2;
const focusStagePxX = (stageCenterX - x) / zoomScale;
const focusStagePxY = (stageCenterY - y) / zoomScale;
return {
cx: (focusStagePxX - baseMask.x) / baseMask.width,
cy: (focusStagePxY - baseMask.y) / baseMask.height,
};
}
export function applyZoomTransform({
cameraContainer,
zoomBlurFilter,
motionBlurFilter,
stageSize,
baseMask,
zoomScale,
zoomProgress = 1,
focusX,
focusY,
isPlaying,
motionBlurAmount = 0,
motionBlurTuning,
transformOverride,
motionBlurState,
frameTimeMs,
motionSample,
}: TransformParams): AppliedTransform {
if (
stageSize.width <= 0 ||
stageSize.height <= 0 ||
baseMask.width <= 0 ||
baseMask.height <= 0
) {
cameraContainer.scale.set(1);
cameraContainer.position.set(0, 0);
resetMotionEffects(zoomBlurFilter, motionBlurFilter, motionBlurState);
return { scale: 1, x: 0, y: 0 };
}
const transform =
transformOverride ??
computeZoomTransform({
stageSize,
baseMask,
zoomScale,
zoomProgress,
focusX,
focusY,
});
// Apply position & scale to camera container
cameraContainer.scale.set(transform.scale);
cameraContainer.position.set(transform.x, transform.y);
const resolvedTuning = resolveMotionBlurTuning(motionBlurTuning);
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) {
motionBlurState.prevCamX = transform.x;
motionBlurState.prevCamY = transform.y;
motionBlurState.prevCamScale = transform.scale;
motionBlurState.lastFrameTimeMs = now;
motionBlurState.initialized = true;
motionBlurFilter.velocity = { x: 0, y: 0 };
motionBlurFilter.kernelSize = DIRECTIONAL_BLUR_KERNEL_SIZE;
motionBlurFilter.offset = 0;
if (zoomBlurFilter) {
zoomBlurFilter.strength = 0;
}
} else {
const dtMs = Math.min(80, Math.max(1, now - motionBlurState.lastFrameTimeMs));
const dtSeconds = dtMs / 1000;
motionBlurState.lastFrameTimeMs = now;
const previousTransform = {
scale: motionBlurState.prevCamScale,
x: motionBlurState.prevCamX,
y: motionBlurState.prevCamY,
};
const previousQuad = computeTransformQuad(baseMask, previousTransform);
const currentQuad = computeTransformQuad(baseMask, transform);
const analysis = analyzeCameraStep({
previousQuad,
currentQuad,
stageSize,
motionBlurAmount,
motionBlurTuning: resolvedTuning,
deltaSeconds: dtSeconds,
});
motionBlurState.prevCamX = transform.x;
motionBlurState.prevCamY = transform.y;
motionBlurState.prevCamScale = transform.scale;
applyCameraStepBlur({ analysis, motionBlurFilter, zoomBlurFilter });
}
} else {
resetMotionEffects(zoomBlurFilter, motionBlurFilter, motionBlurState);
}
return {
scale: transform.scale,
x: transform.x,
y: transform.y,
};
}