Create professional demos and 3D mockups in seconds, directly in your browser
import { getDefault3DFragmentDuration, type Mockup3DMotionPresetId } from "./mockup-motion-3d";
export type MockupMotionPresetId =
| "none"
| "focus-in"
| "cinematic-showcase"
| "isometric-lift"
| "macro-track"
| "depth-emerge"
| "whip-showcase"
| "exit-fade-down"
| "exit-scale-blur"
| "spatial-roam"
| "rise-crash"
| "crane-sweep"
| "z-spin-reveal"
| "orbit-entrance"
| "flick-exit"
| "hero-reveal"
| "macro-pan"
| "screen-glide"
| "float-hold"
| "spiral-drop"
| "duo-unfold"
| "duo-fold"
| "duo-cycle";
export type MockupMotionMode = "2d" | "3d";
export interface MockupMotionPresetDef {
id: MockupMotionPresetId;
category: "Entrance" | "Continue" | "Exit";
mode: MockupMotionMode;
}
export const MOCKUP_MOTION_PRESETS: MockupMotionPresetDef[] = [
{ id: "focus-in", category: "Entrance", mode: "2d" },
{ id: "depth-emerge", category: "Entrance", mode: "2d" },
{ id: "z-spin-reveal", category: "Entrance", mode: "2d" },
{ id: "isometric-lift", category: "Entrance", mode: "2d" },
{ id: "cinematic-showcase", category: "Continue", mode: "2d" },
{ id: "macro-track", category: "Continue", mode: "2d" },
{ id: "whip-showcase", category: "Continue", mode: "2d" },
{ id: "spatial-roam", category: "Continue", mode: "2d" },
{ id: "crane-sweep", category: "Continue", mode: "2d" },
{ id: "rise-crash", category: "Continue", mode: "2d" },
{ id: "exit-fade-down", category: "Exit", mode: "2d" },
{ id: "exit-scale-blur", category: "Exit", mode: "2d" },
{ id: "duo-unfold", category: "Entrance", mode: "3d" },
{ id: "duo-cycle", category: "Continue", mode: "3d" },
{ id: "duo-fold", category: "Exit", mode: "3d" },
{ id: "orbit-entrance", category: "Entrance", mode: "3d" },
{ id: "flick-exit", category: "Exit", mode: "3d" },
{ id: "hero-reveal", category: "Entrance", mode: "3d" },
{ id: "macro-pan", category: "Continue", mode: "3d" },
{ id: "screen-glide", category: "Continue", mode: "3d" },
{ id: "float-hold", category: "Continue", mode: "3d" },
{ id: "spiral-drop", category: "Exit", mode: "3d" },
];
/** IDs that belong to 3D mode (used for routing to the 3D sampler). */
export const MOTION_PRESET_3D_IDS: ReadonlySet<MockupMotionPresetId> = new Set(
MOCKUP_MOTION_PRESETS.filter((p) => p.mode === "3d").map((p) => p.id)
);
export function getMotionPresetMode(id: MockupMotionPresetId): MockupMotionMode {
return MOCKUP_MOTION_PRESETS.find((p) => p.id === id)?.mode ?? "2d";
}
export interface MockupMotionConfig {
presetId: MockupMotionPresetId;
intensity: number;
speed: number;
}
export const DEFAULT_MOCKUP_MOTION_CONFIG: MockupMotionConfig = {
presetId: "none",
intensity: 50,
speed: 50,
};
export interface MockupMotionTransform {
scale: number;
translateXPct: number;
translateYPct: number;
rotateX: number;
rotateY: number;
rotateZ: number;
opacity: number;
blurPx: number;
perspectivePx: number;
}
export const REST_MOCKUP_MOTION: MockupMotionTransform = {
scale: 1,
translateXPct: 0,
translateYPct: 0,
rotateX: 0,
rotateY: 0,
rotateZ: 0,
opacity: 1,
blurPx: 0,
perspectivePx: 0,
};
const clamp01 = (n: number) => Math.max(0, Math.min(1, n));
const lerp = (a: number, b: number, t: number) => a + (b - a) * t;
function easeOutCubic(t: number) {
return 1 - (1 - t) ** 3;
}
function easeOutBack(t: number) {
const c1 = 1.70158;
const c3 = c1 + 1;
return 1 + c3 * (t - 1) ** 3 + c1 * (t - 1) ** 2;
}
function easeInOutCubic(t: number) {
return t < 0.5 ? 4 * t ** 3 : 1 - (-2 * t + 2) ** 3 / 2;
}
function easeOutQuint(t: number) {
return 1 - (1 - t) ** 5;
}
function speedToDurationSec(speed: number): number {
return lerp(1.4, 0.35, clamp01(speed / 100));
}
export function sampleMockupMotion(
config: MockupMotionConfig,
currentTime: number,
clipDurationSec: number
): MockupMotionTransform {
const { presetId, intensity, speed } = config;
const i = clamp01(intensity / 100);
if (presetId === "none" || clipDurationSec <= 0) return REST_MOCKUP_MOTION;
switch (presetId) {
case "focus-in": {
const dur = Math.min(speedToDurationSec(speed), clipDurationSec);
const t = clamp01(currentTime / dur);
const eased = easeOutCubic(t);
const startBlur = lerp(6, 22, i);
return {
...REST_MOCKUP_MOTION,
scale: lerp(1.06, 1, eased),
blurPx: lerp(startBlur, 0, eased),
opacity: lerp(0.3, 1, easeOutCubic(clamp01(t * 2))),
};
}
case "z-spin-reveal": {
const speedT = clamp01(speed / 100);
const animationEnd = lerp(0.95, 0.85, speedT);
const p = clamp01(currentTime / clipDurationSec);
const xRot0 = lerp(45, 60, i);
const yRot0 = lerp(10, 20, i);
const zRot0 = lerp(-85, -95, i);
const zoomStart = lerp(0.7, 0.8, i);
let scale = 1;
let tiltX = 0;
let tiltY = 0;
let tiltZ = 0;
if (p <= animationEnd) {
const lp = easeInOutCubic(clamp01(p / animationEnd));
scale = lerp(zoomStart, 1, lp);
tiltX = lerp(xRot0, 0, lp);
tiltY = lerp(yRot0, 0, lp);
tiltZ = lerp(zRot0, 0, lp);
}
const tiltRatio = clamp01(Math.abs(tiltX) / (xRot0 || 1));
const perspective = lerp(2000, 1000, tiltRatio);
return {
...REST_MOCKUP_MOTION,
scale,
translateXPct: 0,
translateYPct: 0,
rotateX: tiltX,
rotateY: tiltY,
rotateZ: tiltZ,
perspectivePx: perspective,
};
}
case "cinematic-showcase": {
const speedT = clamp01(speed / 100);
const impactEnd = lerp(0.12, 0.05, speedT);
const panEnd = lerp(0.68, 0.55, speedT);
const p = clamp01(currentTime / clipDurationSec);
const zoomStart = lerp(1.5, 2.4, i);
const zoomPan = lerp(1.15, 1.35, i);
const tiltX0 = lerp(2, 6, i);
const tiltY0 = lerp(4, 10, i);
const anchorX0 = lerp(0.25, 0.4, i);
const anchorY0 = lerp(0.2, 0.35, i);
const anchorX1 = lerp(0.05, 0.15, i);
const anchorY1 = lerp(0.04, 0.12, i);
let scale: number;
let anchorX: number;
let anchorY: number;
let tiltX: number;
let tiltY: number;
let blur = 0;
if (p <= impactEnd) {
const lp = easeOutCubic(clamp01(p / Math.max(impactEnd, 0.0001)));
scale = lerp(zoomStart * 1.04, zoomStart, lp);
anchorX = anchorX0;
anchorY = anchorY0;
tiltX = lerp(tiltX0 * 1.1, tiltX0, lp);
tiltY = lerp(tiltY0 * 1.1, tiltY0, lp);
} else if (p <= panEnd) {
const lp = easeInOutCubic(clamp01((p - impactEnd) / (panEnd - impactEnd)));
scale = lerp(zoomStart, zoomPan, lp);
anchorX = lerp(anchorX0, anchorX1, lp);
anchorY = lerp(anchorY0, anchorY1, lp);
tiltX = lerp(tiltX0, tiltX0 * 0.4, lp);
tiltY = lerp(tiltY0, tiltY0 * 0.4, lp);
blur = Math.sin(Math.PI * lp) * lerp(1.5, 4, i);
} else {
const lp = easeOutQuint(clamp01((p - panEnd) / (1 - panEnd)));
scale = lerp(zoomPan, 1, lp);
anchorX = lerp(anchorX1, 0, lp);
anchorY = lerp(anchorY1, 0, lp);
tiltX = lerp(tiltX0 * 0.4, 0, lp);
tiltY = lerp(tiltY0 * 0.4, 0, lp);
blur = 0;
}
const translateXPct = scale * anchorX * 100;
const translateYPct = scale * anchorY * 100;
const tiltRatio = clamp01((Math.abs(tiltX) + Math.abs(tiltY)) / (tiltX0 + tiltY0 || 1));
const perspective = lerp(2500, 1500, tiltRatio);
return {
...REST_MOCKUP_MOTION,
scale,
translateXPct,
translateYPct,
rotateX: tiltX,
rotateY: tiltY,
blurPx: blur,
perspectivePx: perspective,
};
}
case "depth-emerge": {
const dur = Math.min(speedToDurationSec(speed) * 1.3, clipDurationSec);
const t = clamp01(currentTime / dur);
const emergeEnd = 0.45;
const blurFadeEnd = 0.55;
const startScale = lerp(0.35, 0.15, i);
const startBlur = lerp(12, 28, i);
const startRotateX = lerp(25, 55, i);
const startRotateY = lerp(-20, -45, i);
const startOpacity = 0;
let scale: number;
let blur: number;
let rotX: number;
let rotY: number;
let opacity: number;
if (t <= emergeEnd) {
const lp = easeOutCubic(clamp01(t / emergeEnd));
scale = lerp(startScale, 1.08, lp);
blur = lerp(startBlur, 0, easeOutCubic(clamp01(t / blurFadeEnd)));
rotX = lerp(startRotateX, 8, lp);
rotY = lerp(startRotateY, -8, lp);
opacity = lerp(startOpacity, 1, easeOutCubic(clamp01(t * 2.2)));
} else {
const lp = easeOutBack(clamp01((t - emergeEnd) / (1 - emergeEnd)));
scale = lerp(1.08, 1, lp);
blur = 0;
rotX = lerp(8, 0, lp);
rotY = lerp(-8, 0, lp);
opacity = 1;
}
const tiltRatio = clamp01(
(Math.abs(rotX) + Math.abs(rotY)) / (startRotateX + Math.abs(startRotateY) || 1)
);
const perspective = lerp(1800, 900, tiltRatio);
return {
...REST_MOCKUP_MOTION,
scale,
rotateX: rotX,
rotateY: rotY,
blurPx: blur,
opacity,
perspectivePx: perspective,
};
}
case "isometric-lift": {
const speedT = clamp01(speed / 100);
const liftEnd = lerp(0.75, 0.6, speedT);
const p = clamp01(currentTime / clipDurationSec);
const xRot0 = lerp(35, 60, i);
const zRot0 = lerp(-15, -40, i);
const yRot0 = lerp(10, 25, i);
const zoomStart = lerp(1.1, 1.45, i);
let scale = 1;
let tiltX = 0;
let tiltY = 0;
let tiltZ = 0;
let translateYPct = 0;
if (p <= liftEnd) {
const lp = easeInOutCubic(clamp01(p / liftEnd));
scale = lerp(zoomStart, 1.05, lp);
tiltX = lerp(xRot0, xRot0 * 0.15, lp);
tiltY = lerp(yRot0, yRot0 * 0.15, lp);
tiltZ = lerp(zRot0, 0, lp);
} else {
const lp = easeOutQuint(clamp01((p - liftEnd) / (1 - liftEnd)));
scale = lerp(1.05, 1, lp);
tiltX = lerp(xRot0 * 0.15, 0, lp);
tiltY = lerp(yRot0 * 0.15, 0, lp);
tiltZ = 0;
translateYPct = 0;
}
const tiltRatio = clamp01(Math.abs(tiltX) / (xRot0 || 1));
const perspective = lerp(2000, 1100, tiltRatio);
return {
...REST_MOCKUP_MOTION,
scale,
translateXPct: 0,
translateYPct,
rotateX: tiltX,
rotateY: tiltY,
rotateZ: tiltZ,
perspectivePx: perspective,
};
}
case "macro-track": {
const speedT = clamp01(speed / 100);
const trackEnd = lerp(0.75, 0.6, speedT);
const p = clamp01(currentTime / clipDurationSec);
const zoom0 = lerp(2.2, 3.2, i);
const xRot0 = lerp(45, 65, i);
const zRot0 = lerp(8, 22, i);
const anchorX0 = lerp(0.3, 0.45, i);
const anchorY0 = lerp(0.35, 0.48, i);
const anchorX1 = lerp(-0.05, -0.1, i);
const anchorY1 = lerp(-0.05, -0.1, i);
let scale = 1;
let anchorX = 0;
let anchorY = 0;
let tiltX = 0;
let tiltZ = 0;
if (p <= trackEnd) {
const lp = easeInOutCubic(clamp01(p / trackEnd));
scale = lerp(zoom0, zoom0 * 0.6, lp);
anchorX = lerp(anchorX0, anchorX1, lp);
anchorY = lerp(anchorY0, anchorY1, lp);
tiltX = lerp(xRot0, xRot0 * 0.3, lp);
tiltZ = lerp(zRot0, zRot0 * 0.2, lp);
} else {
const lp = easeOutQuint(clamp01((p - trackEnd) / (1 - trackEnd)));
scale = lerp(zoom0 * 0.6, 1, lp);
anchorX = lerp(anchorX1, 0, lp);
anchorY = lerp(anchorY1, 0, lp);
tiltX = lerp(xRot0 * 0.3, 0, lp);
tiltZ = lerp(zRot0 * 0.2, 0, lp);
}
const perspective = 2500;
return {
...REST_MOCKUP_MOTION,
scale,
translateXPct: scale * anchorX * 100,
translateYPct: scale * anchorY * 100,
rotateX: tiltX,
rotateY: 0,
rotateZ: tiltZ,
blurPx: 0,
perspectivePx: perspective,
};
}
case "spatial-roam": {
const speedT = clamp01(speed / 100);
const i = clamp01(intensity / 100);
const p = clamp01(currentTime / clipDurationSec);
const act1 = lerp(0.12, 0.10, speedT);
const act2 = lerp(0.32, 0.28, speedT);
const act3 = lerp(0.42, 0.36, speedT);
const act4 = lerp(0.60, 0.52, speedT);
const act5 = lerp(0.70, 0.62, speedT);
const act6 = lerp(0.85, 0.78, speedT);
const heroScale = lerp(1.02, 1.05, i);
const orbitScale = lerp(1.1, 1.2, i);
const macroScale = lerp(1.6, 1.85, i);
const tiltXMax = lerp(20, 35, i);
const tiltYMax = lerp(20, 35, i);
const ptBottomRight = { x: -lerp(0.15, 0.22, i), y: -lerp(0.15, 0.22, i) };
const ptTopRight = { x: -lerp(0.15, 0.22, i), y: lerp(0.15, 0.22, i) };
const ptTopLeft = { x: lerp(0.15, 0.22, i), y: lerp(0.15, 0.22, i) };
const ptBottomLeft = { x: lerp(0.15, 0.22, i), y: -lerp(0.15, 0.22, i) };
const ptCenter = { x: 0, y: 0 };
const easeInOutCubic = (t: number) => t < 0.5 ? 4 * t ** 3 : 1 - (-2 * t + 2) ** 3 / 2;
const smootherStep = (t: number) => t * t * t * (t * (t * 6 - 15) + 10);
const lensBreath = 1 + Math.sin(currentTime * Math.PI * 1.5) * 0.015 * i;
let scale = 1;
let anchorX = 0;
let anchorY = 0;
let tiltX = 0;
let tiltY = 0;
let tiltZ = 0;
let blur = 0;
if (p <= act1) {
const t = clamp01(p / act1);
const lp = smootherStep(t);
scale = lerp(1.2, macroScale, lp);
anchorX = lerp(0, ptBottomRight.x, lp);
anchorY = lerp(0, ptBottomRight.y, lp);
tiltX = lerp(0, tiltXMax, lp);
tiltY = lerp(0, -tiltYMax, lp);
blur = lerp(lerp(10, 20, i), 0, easeInOutCubic(t));
} else if (p <= act2) {
const t = clamp01((p - act1) / (act2 - act1));
scale = macroScale * lensBreath;
anchorX = ptBottomRight.x;
anchorY = lerp(ptBottomRight.y, ptTopRight.y, t);
tiltX = tiltXMax;
tiltY = lerp(-tiltYMax, -tiltYMax * 0.6, t);
} else if (p <= act3) {
const t = clamp01((p - act2) / (act3 - act2));
const lp = easeInOutCubic(t);
const arc = Math.sin(t * Math.PI);
scale = lerp(macroScale, macroScale * 0.85, lp) - (arc * 0.15);
anchorX = lerp(ptTopRight.x, ptTopLeft.x, lp);
anchorY = lerp(ptTopRight.y, ptTopLeft.y, lp);
tiltX = lerp(tiltXMax, tiltXMax * 0.5, lp) + (arc * 15);
tiltY = lerp(-tiltYMax * 0.6, tiltYMax, lp);
tiltZ = arc * lerp(6, 12, i);
blur = arc * lerp(12, 24, i);
} else if (p <= act4) {
const t = clamp01((p - act3) / (act4 - act3));
const lp = smootherStep(t);
scale = lerp(macroScale * 0.85, orbitScale, lp) * lensBreath;
anchorX = lerp(ptTopLeft.x, ptCenter.x, lp);
anchorY = lerp(ptTopLeft.y, ptCenter.y, lp);
tiltX = lerp(tiltXMax * 0.5, -tiltXMax * 0.5, lp);
tiltY = lerp(tiltYMax, -tiltYMax * 0.2, lp);
} else if (p <= act5) {
const t = clamp01((p - act4) / (act5 - act4));
const lp = easeInOutCubic(t);
scale = lerp(orbitScale, macroScale, lp);
anchorX = lerp(ptCenter.x, ptBottomLeft.x, lp);
anchorY = lerp(ptCenter.y, ptBottomLeft.y, lp);
tiltX = lerp(-tiltXMax * 0.5, tiltXMax * 0.8, lp);
tiltY = lerp(-tiltYMax * 0.2, tiltYMax, lp);
blur = Math.sin(t * Math.PI) * lerp(4, 10, i);
} else if (p <= act6) {
const t = clamp01((p - act5) / (act6 - act5));
scale = macroScale * lensBreath;
anchorX = lerp(ptBottomLeft.x, ptCenter.x, t);
anchorY = lerp(ptBottomLeft.y, ptCenter.y - lerp(0.05, 0.1, i), t);
tiltX = lerp(tiltXMax * 0.8, tiltXMax, t);
tiltY = lerp(tiltYMax, 0, t);
} else {
const t = clamp01((p - act6) / (1 - act6));
const lp = smootherStep(t);
scale = lerp(macroScale, heroScale, lp);
anchorX = lerp(0, 0, lp);
anchorY = lerp(ptCenter.y - lerp(0.05, 0.1, i), 0, lp);
tiltX = lerp(tiltXMax, 0, lp);
tiltY = 0;
tiltZ = 0;
}
const translateXPct = scale * anchorX * 100;
const translateYPct = scale * anchorY * 100;
const tiltRatio = clamp01((Math.abs(tiltX) + Math.abs(tiltY)) / (tiltXMax + tiltYMax || 1));
const perspective = lerp(3200, 1100, tiltRatio);
return {
...REST_MOCKUP_MOTION,
scale,
translateXPct,
translateYPct,
rotateX: tiltX,
rotateY: tiltY,
rotateZ: tiltZ,
blurPx: blur,
perspectivePx: perspective,
};
}
case "crane-sweep": {
const speedT = clamp01(speed / 100);
const i = clamp01(intensity / 100);
const p = clamp01(currentTime / clipDurationSec);
const a1 = lerp(0.12, 0.09, speedT);
const a2 = lerp(0.30, 0.25, speedT);
const a3 = lerp(0.44, 0.38, speedT);
const a4 = lerp(0.54, 0.47, speedT);
const a5 = lerp(0.68, 0.62, speedT);
const a6 = lerp(0.84, 0.78, speedT);
const cenitalScale = lerp(0.88, 0.98, i);
const heroScale = lerp(1.02, 1.08, i);
const macroScale = lerp(1.50, 1.80, i);
const cenitalTiltX = -lerp(55, 82, i);
const hoverTiltX = -lerp(18, 32, i);
const levelTiltX = lerp(2, 5, i);
const tiltYMax = lerp(16, 28, i);
const ptCenter = { x: 0, y: 0 };
const ptRightFeature = { x: -lerp(0.18, 0.28, i), y: lerp(0.02, 0.06, i) };
const ptLeftFeature = { x: lerp(0.18, 0.28, i), y: lerp(-0.02, -0.06, i) };
const smoothStep = (t: number): number => t * t * (3 - 2 * t);
const smootherStep = (t: number): number => t * t * t * (t * (t * 6 - 15) + 10);
const easeInOutCubic = (t: number): number =>
t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2;
const easeOutCubic = (t: number): number => 1 - (1 - t) ** 3;
const easeOutExpo = (t: number): number => t === 1 ? 1 : 1 - Math.pow(2, -10 * t);
const hSeed = currentTime * lerp(0.6, 1.4, i);
const hAmp = lerp(0.06, 0.16, i);
const handX = Math.sin(hSeed * 2.7) * Math.cos(hSeed * 1.3) * hAmp;
const handY = Math.sin(hSeed * 1.9) * Math.cos(hSeed * 4.3) * hAmp;
const handRot = Math.sin(hSeed * 3.9) * 0.035 * (i * 0.5 + 0.5);
const breath = 1 + Math.sin(currentTime * Math.PI * 2 * lerp(0.20, 0.45, i)) * lerp(0.003, 0.008, i);
const orbitRollMax = lerp(4, 10, i);
const motionBlurMax = lerp(8, 20, i);
const h0 = {
s: cenitalScale, x: 0, y: 0,
tx: cenitalTiltX, ty: 0, tz: 0, blur: 0
};
const h1 = {
s: cenitalScale, x: 0, y: 0,
tx: cenitalTiltX * 0.85, ty: tiltYMax * 0.10, tz: 0, blur: 0
};
const h2 = {
s: heroScale, x: lerp(0.04, 0.10, i), y: lerp(0.02, 0.05, i),
tx: hoverTiltX, ty: tiltYMax * 0.35, tz: 0, blur: 0
};
const h3 = {
s: macroScale, x: ptRightFeature.x, y: ptRightFeature.y,
tx: levelTiltX, ty: -tiltYMax * 0.25, tz: 0, blur: 0
};
const h4 = {
s: macroScale * 0.92, x: ptLeftFeature.x, y: ptLeftFeature.y,
tx: levelTiltX * 0.8, ty: tiltYMax * 0.30, tz: 0, blur: 0
};
const h5 = {
s: macroScale, x: ptLeftFeature.x + lerp(0.01, 0.03, i), y: ptLeftFeature.y,
tx: levelTiltX * 0.6, ty: tiltYMax * 0.20, tz: 0, blur: 0
};
const h6 = {
s: heroScale, x: 0, y: 0,
tx: lerp(5, 12, i), ty: -lerp(10, 18, i), tz: 0, blur: 0
};
const h7_end = {
s: heroScale * lerp(1.1, 1.18, i),
x: 0,
y: 0,
tx: lerp(25, 38, i),
ty: -lerp(20, 32, i),
tz: 0,
blur: 0
};
let scale: number;
let anchorX: number;
let anchorY: number;
let tiltX: number;
let tiltY: number;
let tiltZ: number;
let blur: number;
if (p <= a1) {
const t = clamp01(p / a1);
const lp = easeOutCubic(t);
scale = lerp(h0.s, h1.s, lp) * breath;
anchorX = lerp(h0.x, h1.x, lp);
anchorY = lerp(h0.y, h1.y, lp);
tiltX = lerp(h0.tx, h1.tx, lp);
tiltY = lerp(h0.ty, h1.ty, lp);
tiltZ = handRot * 0.2;
blur = 0;
} else if (p <= a2) {
const t = clamp01((p - a1) / (a2 - a1));
const lp = smootherStep(t);
scale = lerp(h1.s, h2.s, lp) * breath;
anchorX = lerp(h1.x, h2.x, lp);
anchorY = lerp(h1.y, h2.y, lp);
tiltX = lerp(h1.tx, h2.tx, lp);
tiltY = lerp(h1.ty, h2.ty, lp);
tiltZ = handRot * 0.4;
blur = 0;
} else if (p <= a3) {
const t = clamp01((p - a2) / (a3 - a2));
const lp = smoothStep(t);
scale = lerp(h2.s, h3.s, lp) * breath;
anchorX = lerp(h2.x, h3.x, lp);
anchorY = lerp(h2.y, h3.y, lp);
tiltX = lerp(h2.tx, h3.tx, lp);
tiltY = lerp(h2.ty, h3.ty, lp);
tiltZ = handRot * 0.5;
blur = 0;
} else if (p <= a4) {
const t = clamp01((p - a3) / (a4 - a3));
const lp = easeInOutCubic(t);
const arc = Math.sin(Math.PI * lp);
const arcAsym = Math.sin(Math.PI * Math.pow(lp, 0.8));
scale = lerp(h3.s, h4.s, lp) * lerp(1, 0.88, arc);
const midX = (h3.x + h4.x) * 0.5;
const midY = Math.max(h3.y, h4.y) + lerp(0.04, 0.10, i);
const u = 1 - lp;
anchorX = u * u * h3.x + 2 * u * lp * midX + lp * lp * h4.x;
anchorY = u * u * h3.y + 2 * u * lp * midY + lp * lp * h4.y;
const flare = arcAsym * lerp(0.55, 1.0, i);
tiltX = lerp(h3.tx, h4.tx, lp) + flare * hoverTiltX * 0.5;
tiltY = lerp(h3.ty, h4.ty, lp) + flare * tiltYMax * 0.6;
tiltZ = arc * orbitRollMax + handRot * 0.2;
blur = arcAsym * motionBlurMax;
} else if (p <= a5) {
const t = clamp01((p - a4) / (a5 - a4));
const lp = smoothStep(t);
scale = lerp(h4.s, h5.s, lp) * breath;
const driftT = lp * Math.PI * 1.1;
const driftX = Math.sin(driftT) * lerp(0.006, 0.016, i);
const driftY = Math.cos(driftT * 0.6) * lerp(0.004, 0.012, i);
anchorX = lerp(h4.x, h5.x, lp) + driftX;
anchorY = lerp(h4.y, h5.y, lp) + driftY;
tiltX = lerp(h4.tx, h5.tx, lp) + driftX * lerp(10, 24, i);
tiltY = lerp(h4.ty, h5.ty, lp) + driftY * lerp(8, 16, i);
tiltZ = handRot * 0.4;
blur = lerp(lerp(2, 5, i), 0, lp);
} else if (p <= a6) {
const t = clamp01((p - a5) / (a6 - a5));
const lp = smootherStep(t);
scale = lerp(h5.s, h6.s, lp) * breath;
anchorX = lerp(h5.x, h6.x, lp);
anchorY = lerp(h5.y, h6.y, lp);
tiltX = lerp(h5.tx, h6.tx, lp);
tiltY = lerp(h5.ty, h6.ty, lp);
tiltZ = handRot * 0.3;
blur = 0;
} else {
const t = clamp01((p - a6) / (1 - a6));
const lp = easeOutExpo(t);
scale = lerp(h6.s, h7_end.s, lp) * breath;
anchorX = lerp(h6.x, h7_end.x, lp);
anchorY = lerp(h6.y, h7_end.y, lp);
tiltX = lerp(h6.tx, h7_end.tx, lp);
tiltY = lerp(h6.ty, h7_end.ty, lp);
const finalSettle = 1 - lp;
tiltZ = handRot * 0.2 * finalSettle;
blur = 0;
}
const inWhip = (p > a3 && p < a4);
const isSettling = p > a6;
if (!inWhip) {
const noiseMultiplier = isSettling ? 1 - clamp01((p - a6) / (1 - a6)) : 1;
anchorX += handX * 0.001 * noiseMultiplier;
anchorY += handY * 0.001 * noiseMultiplier;
}
const translateXPct = scale * anchorX * 100;
const translateYPct = scale * anchorY * 100;
const tiltMag = Math.abs(tiltX) + Math.abs(tiltY);
const tiltNorm = clamp01(tiltMag / (Math.abs(cenitalTiltX) + tiltYMax || 1));
const perspective = lerp(3500, 900, tiltNorm);
return {
...REST_MOCKUP_MOTION,
scale,
translateXPct,
translateYPct,
rotateX: tiltX,
rotateY: tiltY,
rotateZ: tiltZ,
opacity: 1,
blurPx: blur,
perspectivePx: perspective,
};
}
case "rise-crash": {
const speedT = clamp01(speed / 100);
const i = clamp01(intensity / 100);
const p = clamp01(currentTime / clipDurationSec);
const act1 = lerp(0.12, 0.10, speedT);
const act2 = lerp(0.30, 0.26, speedT);
const act3 = lerp(0.44, 0.38, speedT);
const act4 = lerp(0.62, 0.56, speedT);
const act5 = lerp(0.74, 0.68, speedT);
const act6 = lerp(0.90, 0.84, speedT);
const heroScale = lerp(1.02, 1.08, i);
const macroScale = lerp(1.55, 1.85, i);
const crashScale = lerp(1.35, 1.65, i);
const tiltXMax = lerp(22, 38, i);
const tiltYMax = lerp(14, 26, i);
const ptTop = { x: lerp(0.06, 0.12, i), y: lerp(0.18, 0.32, i) };
const ptBottom = { x: lerp(-0.08, -0.16, i), y: -lerp(0.18, 0.32, i) };
const ptCenter = { x: 0, y: 0 };
const easeInOutCubic = (t: number): number =>
t < 0.5 ? 4 * t ** 3 : 1 - (-2 * t + 2) ** 3 / 2;
const smootherStep = (t: number): number => t * t * t * (t * (t * 6 - 15) + 10);
let scale = 1;
let anchorX = 0;
let anchorY = 0;
let tiltX = 0;
let tiltY = 0;
let tiltZ = 0;
let blur = 0;
if (p <= act1) {
const t = clamp01(p / act1);
const lp = smootherStep(t);
scale = lerp(heroScale, macroScale, lp);
anchorX = lerp(0, ptTop.x, lp);
anchorY = lerp(0, ptTop.y, lp);
tiltX = lerp(tiltXMax, tiltXMax * 0.25, lp);
tiltY = lerp(0, tiltYMax * 0.3, lp);
blur = 0;
} else if (p <= act2) {
const t = clamp01((p - act1) / (act2 - act1));
scale = macroScale;
anchorX = ptTop.x;
anchorY = lerp(ptTop.y, ptTop.y + lerp(0.02, 0.05, i), t);
tiltX = tiltXMax * 0.25;
tiltY = lerp(tiltYMax * 0.3, tiltYMax * 0.15, t);
} else if (p <= act3) {
const t = clamp01((p - act2) / (act3 - act2));
const lp = easeInOutCubic(t);
const arc = Math.sin(t * Math.PI);
scale = lerp(macroScale, crashScale, lp) * lerp(1, 0.88, arc);
anchorX = lerp(ptTop.x, ptBottom.x, lp);
anchorY = lerp(ptTop.y, ptBottom.y, lp);
tiltX = lerp(tiltXMax * 0.25, -tiltXMax * 0.6, lp) + arc * lerp(8, 18, i);
tiltY = lerp(tiltYMax * 0.15, -tiltYMax * 0.4, lp);
tiltZ = arc * lerp(-5, -12, i);
blur = arc * lerp(14, 28, i);
} else if (p <= act4) {
const t = clamp01((p - act3) / (act4 - act3));
const lp = smootherStep(t);
scale = lerp(crashScale, macroScale, lp);
anchorX = lerp(ptBottom.x, ptBottom.x + lerp(0.02, 0.06, i), lp);
anchorY = ptBottom.y;
tiltX = lerp(-tiltXMax * 0.6, -tiltXMax * 0.35, lp);
tiltY = lerp(-tiltYMax * 0.4, -tiltYMax * 0.2, lp);
blur = lerp(lerp(3, 6, i), 0, lp);
} else if (p <= act5) {
const t = clamp01((p - act4) / (act5 - act4));
const lp = easeInOutCubic(t);
const arc = Math.sin(t * Math.PI);
scale = lerp(macroScale, macroScale * 1.05, lp) * lerp(1, 0.92, arc);
anchorX = lerp(ptBottom.x + lerp(0.02, 0.06, i), ptCenter.x, lp);
anchorY = lerp(ptBottom.y, ptCenter.y, lp);
tiltX = lerp(-tiltXMax * 0.35, 0, lp) + arc * tiltXMax * 0.25;
tiltY = lerp(-tiltYMax * 0.2, 0, lp) + arc * tiltYMax * 0.2;
tiltZ = arc * lerp(4, 10, i);
blur = arc * lerp(10, 20, i);
} else if (p <= act6) {
const t = clamp01((p - act5) / (act6 - act5));
const lp = smootherStep(t);
scale = lerp(macroScale * 1.05, heroScale, lp);
anchorX = lerp(ptCenter.x, 0, lp);
anchorY = lerp(ptCenter.y, 0, lp);
tiltX = lerp(0, tiltXMax, lp);
tiltY = 0;
tiltZ = 0;
blur = 0;
} else {
const t = clamp01((p - act6) / (1 - act6));
const lp = smootherStep(t);
scale = heroScale;
anchorX = 0;
anchorY = 0;
tiltX = tiltXMax;
tiltY = 0;
tiltZ = 0;
blur = 0;
}
const translateXPct = scale * anchorX * 100;
const translateYPct = scale * anchorY * 100;
const tiltRatio = clamp01((Math.abs(tiltX) + Math.abs(tiltY)) / (tiltXMax + tiltYMax || 1));
const perspective = lerp(3200, 1100, tiltRatio);
return {
...REST_MOCKUP_MOTION,
scale,
translateXPct,
translateYPct,
rotateX: tiltX,
rotateY: tiltY,
rotateZ: tiltZ,
blurPx: blur,
perspectivePx: perspective,
};
}
case "whip-showcase": {
const speedT = clamp01(speed / 100);
const i = clamp01(intensity / 100);
const a1 = lerp(0.12, 0.08, speedT);
const a2 = lerp(0.28, 0.22, speedT);
const a3 = lerp(0.44, 0.36, speedT);
const a4 = lerp(0.52, 0.44, speedT);
const a5 = lerp(0.68, 0.60, speedT);
const a6 = lerp(0.80, 0.72, speedT);
const a7 = lerp(0.90, 0.84, speedT);
const p = clamp01(currentTime / clipDurationSec);
const anchorHero = { x: 0, y: 0 };
const anchorFeatA = { x: lerp(0.26, 0.16, i), y: lerp(-0.14, -0.30, i) };
const anchorFeatB = { x: lerp(-0.18, -0.28, i), y: lerp(0.18, 0.34, i) };
const zoomHero = lerp(1.02, 1.08, i);
const zoomFeatA = lerp(1.40, 1.95, i);
const zoomFeatB = lerp(1.52, 2.20, i);
const zoomMacro = lerp(1.65, 2.35, i);
const heroTiltX = lerp(10, 16, i);
const heroTiltY = lerp(14, 24, i);
const featATiltX = lerp(2, 4, i);
const featATiltY = lerp(2.5, 5.5, i);
const featBTiltX = lerp(1.5, 3.5, i);
const featBTiltY = lerp(2, 5, i);
const handoffA = {
scale: zoomFeatA,
anchorX: anchorFeatA.x,
anchorY: anchorFeatA.y,
tiltX: featATiltX,
tiltY: featATiltY,
};
const handoffAEnd = {
scale: zoomFeatA * lerp(1.01, 1.03, i),
anchorX: anchorFeatA.x + lerp(0.03, 0.08, i),
anchorY: anchorFeatA.y + lerp(0.015, 0.04, i),
tiltX: featATiltX * lerp(0.7, 0.5, i),
tiltY: featATiltY * lerp(0.7, 0.5, i),
};
const handoffBEnd = {
scale: zoomMacro * lerp(1.005, 1.015, i),
anchorX: anchorFeatB.x + lerp(0.008, 0.02, i),
anchorY: anchorFeatB.y + lerp(0.004, 0.012, i),
tiltX: featBTiltX * 0.4,
tiltY: featBTiltY * 0.4,
};
const handoff6End = {
scale: zoomHero * lerp(1.06, 1.12, i),
anchorX: lerp(0.04, 0.10, i),
anchorY: lerp(0.01, 0.03, i),
tiltX: heroTiltX * lerp(0.85, 0.95, i),
tiltY: heroTiltY * lerp(0.85, 0.95, i),
};
const handoff7End = {
scale: zoomHero * lerp(1.02, 1.06, i),
anchorX: -lerp(0.04, 0.10, i),
anchorY: lerp(0.005, 0.015, i),
tiltX: heroTiltX * lerp(0.9, 1.0, i),
tiltY: heroTiltY * lerp(0.9, 1.0, i),
};
const smoothStep = (t: number): number => t * t * (3 - 2 * t);
const smootherStep = (t: number): number => t * t * t * (t * (t * 6 - 15) + 10);
const easeInOutQuart = (t: number): number =>
t < 0.5 ? 8 * t * t * t * t : 1 - Math.pow(-2 * t + 2, 4) / 2;
const easeOutBack = (t: number, o: number = 1.70158): number =>
1 + (o + 1) * Math.pow(t - 1, 3) + o * Math.pow(t - 1, 2);
const hSeed = currentTime * lerp(0.8, 1.8, i);
const hAmp = lerp(0.08, 0.20, i);
const handX = Math.sin(hSeed * 3.1) * Math.cos(hSeed * 1.7) * hAmp;
const handY = Math.sin(hSeed * 2.3) * Math.cos(hSeed * 5.1) * hAmp;
const handRot = Math.sin(hSeed * 4.7) * 0.04 * (i * 0.5 + 0.5);
const breath = 1 + Math.sin(currentTime * Math.PI * 2 * lerp(0.28, 0.55, i)) * lerp(0.003, 0.010, i);
const whipRollMax = lerp(2.5, 6.5, i);
const motionBlurMax = lerp(6, 18, i);
let scale: number;
let anchorX: number;
let anchorY: number;
let tiltX: number;
let tiltY: number;
let tiltZ: number;
let blur: number;
if (p <= a1) {
const t = clamp01(p / a1);
const lp = easeOutCubic(t);
scale = zoomHero;
anchorX = anchorHero.x;
anchorY = anchorHero.y;
tiltX = lerp(heroTiltX * 1.2, heroTiltX, lp);
tiltY = lerp(heroTiltY * 1.15, heroTiltY, lp);
tiltZ = handRot * 0.3;
blur = 0;
} else if (p <= a2) {
const t = clamp01((p - a1) / (a2 - a1));
const lp = smootherStep(t);
scale = lerp(zoomHero, handoffA.scale, lp) * breath;
anchorX = lerp(anchorHero.x, handoffA.anchorX, lp);
anchorY = lerp(anchorHero.y, handoffA.anchorY, lp);
tiltX = lerp(heroTiltX, handoffA.tiltX, lp);
tiltY = lerp(heroTiltY, handoffA.tiltY, lp);
tiltZ = handRot * 0.6;
blur = 0;
} else if (p <= a3) {
const t = clamp01((p - a2) / (a3 - a2));
const lp = smoothStep(t);
scale = lerp(handoffA.scale, handoffAEnd.scale, lp) * breath;
anchorX = lerp(handoffA.anchorX, handoffAEnd.anchorX, lp);
anchorY = lerp(handoffA.anchorY, handoffAEnd.anchorY, lp);
tiltX = lerp(handoffA.tiltX, handoffAEnd.tiltX, lp);
tiltY = lerp(handoffA.tiltY, handoffAEnd.tiltY, lp);
tiltZ = handRot;
blur = 0;
} else if (p <= a4) {
const t = clamp01((p - a3) / (a4 - a3));
const lp = easeInOutQuart(t);
const arc = Math.sin(Math.PI * lp);
const arcAsym = Math.sin(Math.PI * Math.pow(lp, 0.8));
const zoomSuck = 1 - arc * 0.05;
scale = lerp(handoffAEnd.scale, zoomFeatB, lp) * zoomSuck;
const midX = (handoffAEnd.anchorX + anchorFeatB.x) * 0.5 + lerp(0.03, 0.08, i);
const midY = (handoffAEnd.anchorY + anchorFeatB.y) * 0.5 - lerp(0.02, 0.05, i);
const u = 1 - lp;
anchorX = u * u * handoffAEnd.anchorX + 2 * u * lp * midX + lp * lp * anchorFeatB.x;
anchorY = u * u * handoffAEnd.anchorY + 2 * u * lp * midY + lp * lp * anchorFeatB.y;
const flare = arcAsym * lerp(0.45, 0.85, i);
tiltX = lerp(handoffAEnd.tiltX, featBTiltX, lp) + flare * heroTiltX * 0.4;
tiltY = lerp(handoffAEnd.tiltY, featBTiltY, lp) + flare * heroTiltY * 0.4;
tiltZ = arc * -whipRollMax + handRot * 0.2;
blur = arcAsym * motionBlurMax;
} else if (p <= a5) {
const t = clamp01((p - a4) / (a5 - a4));
const lp = smoothStep(t);
scale = lerp(zoomFeatB, handoffBEnd.scale, lp) * breath;
const microT = lp * Math.PI * 1.2;
const microX = Math.sin(microT) * lerp(0.006, 0.018, i);
const microY = Math.sin(microT * 0.7) * lerp(0.004, 0.012, i);
anchorX = lerp(anchorFeatB.x, handoffBEnd.anchorX, lp) + microX;
anchorY = lerp(anchorFeatB.y, handoffBEnd.anchorY, lp) + microY;
tiltX = lerp(featBTiltX, handoffBEnd.tiltX, lp) + microX * lerp(10, 22, i);
tiltY = lerp(featBTiltY, handoffBEnd.tiltY, lp) - microY * lerp(6, 14, i);
tiltZ = handRot * 0.5;
blur = 0;
} else if (p <= a6) {
const t = clamp01((p - a5) / (a6 - a5));
const lp = easeOutCubic(t);
scale = lerp(handoffBEnd.scale, handoff6End.scale, lp) * breath;
anchorX = lerp(handoffBEnd.anchorX, handoff6End.anchorX, lp);
anchorY = lerp(handoffBEnd.anchorY, handoff6End.anchorY, lp);
tiltX = lerp(handoffBEnd.tiltX, handoff6End.tiltX, lp);
tiltY = lerp(handoffBEnd.tiltY, handoff6End.tiltY, lp);
tiltZ = handRot * 0.6;
blur = 0;
} else if (p <= a7) {
const t = clamp01((p - a6) / (a7 - a6));
const lp = smoothStep(t);
scale = lerp(handoff6End.scale, handoff7End.scale, lp) * breath;
anchorX = lerp(handoff6End.anchorX, handoff7End.anchorX, lp);
anchorY = lerp(handoff6End.anchorY, handoff7End.anchorY, lp);
tiltX = lerp(handoff6End.tiltX, handoff7End.tiltX, lp);
tiltY = lerp(handoff6End.tiltY, handoff7End.tiltY, lp);
tiltZ = handRot + (anchorX - handoff6End.anchorX) * lerp(2, 5, i);
blur = 0;
} else {
const t = clamp01((p - a7) / (1 - a7));
const lp = easeOutCubic(t);
scale = lerp(handoff7End.scale, zoomHero, lp) * breath;
anchorX = lerp(handoff7End.anchorX, anchorHero.x, lp);
anchorY = lerp(handoff7End.anchorY, anchorHero.y, lp);
tiltX = lerp(handoff7End.tiltX, heroTiltX, lp);
tiltY = lerp(handoff7End.tiltY, heroTiltY, lp);
tiltZ = handRot * 0.3;
blur = 0;
}
const inWhip = (p > a3 && p < a4);
if (!inWhip) {
anchorX += handX * 0.001;
anchorY += handY * 0.001;
}
const translateXPct = scale * anchorX * 100;
const translateYPct = scale * anchorY * 100;
const tiltMag = Math.abs(tiltX) + Math.abs(tiltY);
const tiltNorm = clamp01(tiltMag / (heroTiltX + heroTiltY || 1));
const perspective = lerp(3000, 1200, tiltNorm);
return {
...REST_MOCKUP_MOTION,
scale,
translateXPct,
translateYPct,
rotateX: tiltX,
rotateY: tiltY,
rotateZ: tiltZ,
opacity: 1,
blurPx: blur,
perspectivePx: perspective,
};
}
case "exit-fade-down": {
const dur = Math.min(speedToDurationSec(speed), clipDurationSec);
const startAt = Math.max(0, clipDurationSec - dur);
const t = clamp01((currentTime - startAt) / dur);
const eased = easeOutCubic(t);
const distance = lerp(6, 24, i);
return {
...REST_MOCKUP_MOTION,
translateYPct: lerp(0, distance, eased),
opacity: lerp(1, 0, eased),
};
}
case "exit-scale-blur": {
const dur = Math.min(speedToDurationSec(speed), clipDurationSec);
const startAt = Math.max(0, clipDurationSec - dur);
const t = clamp01((currentTime - startAt) / dur);
const eased = easeOutCubic(t);
return {
...REST_MOCKUP_MOTION,
scale: lerp(1, lerp(1.02, 1.25, i), eased),
blurPx: lerp(0, lerp(4, 16, i), eased),
opacity: lerp(1, 0, eased),
};
}
default:
return REST_MOCKUP_MOTION;
}
}
const ENTRANCE_EXIT_PADDING = 1.4;
const DEFAULT_CONTINUOUS_DURATION = 3;
const SMALL_DURATION_PRESETS = new Set<MockupMotionPresetId>([
"cinematic-showcase",
"isometric-lift",
"macro-track",
"z-spin-reveal"
]);
const LONG_DURATION_PRESETS = new Set<MockupMotionPresetId>([
"whip-showcase",
"rise-crash"
]);
const EXTRA_LONG_DURATION_PRESETS = new Set<MockupMotionPresetId>([
"spatial-roam",
"crane-sweep"
]);
export function getDefaultFragmentDuration(
presetId: MockupMotionPresetId,
speed: number
): number {
if (EXTRA_LONG_DURATION_PRESETS.has(presetId)) {
return lerp(12, 10.0, clamp01(speed / 100));
}
if (LONG_DURATION_PRESETS.has(presetId)) {
return lerp(12, 6.0, clamp01(speed / 100));
}
if (SMALL_DURATION_PRESETS.has(presetId)) {
return lerp(7, 4.5, clamp01(speed / 100));
}
const category = getMotionPresetCategory(presetId);
if (category === "Entrance" || category === "Exit") {
return speedToDurationSec(speed) * ENTRANCE_EXIT_PADDING;
}
return DEFAULT_CONTINUOUS_DURATION;
}
export function buildMockupMotionCss(m: MockupMotionTransform): string {
return [
`translate(${m.translateXPct}%, ${m.translateYPct}%)`,
`scale(${m.scale})`,
m.rotateX !== 0 ? `rotateX(${m.rotateX}deg)` : "",
m.rotateY !== 0 ? `rotateY(${m.rotateY}deg)` : "",
m.rotateZ !== 0 ? `rotateZ(${m.rotateZ}deg)` : "",
]
.filter(Boolean)
.join(" ");
}
export interface MotionCustomOffsets {
positionX: number;
positionY: number;
zoomMultiplier: number;
rotateX: number;
rotateY: number;
rotateZ: number;
blur: number;
reverse: boolean;
}
export const DEFAULT_MOTION_CUSTOM_OFFSETS: MotionCustomOffsets = {
positionX: 0,
positionY: 0,
zoomMultiplier: 1,
rotateX: 0,
rotateY: 0,
rotateZ: 0,
blur: 0,
reverse: false,
};
export interface MockupMotionFragment extends MockupMotionConfig {
id: string;
startTime: number;
endTime: number;
custom?: MotionCustomOffsets;
/** Custom offsets for 3D presets. Only used when presetId is a 3D preset. */
custom3D?: import("./mockup-motion-3d").Mockup3DMotionCustomOffsets;
}
export function getMotionPresetCategory(
id: MockupMotionPresetId
): (typeof MOCKUP_MOTION_PRESETS)[number]["category"] {
return MOCKUP_MOTION_PRESETS.find((p) => p.id === id)?.category ?? "Continue";
}
function applyMotionCustomOffsets(
base: MockupMotionTransform,
custom: MotionCustomOffsets | undefined
): MockupMotionTransform {
if (!custom) return base;
const sign = custom.reverse ? -1 : 1;
return {
...base,
scale: base.scale * custom.zoomMultiplier,
translateXPct: base.translateXPct * sign + custom.positionX,
translateYPct: base.translateYPct * sign + custom.positionY,
rotateX: base.rotateX * sign + custom.rotateX,
rotateY: base.rotateY * sign + custom.rotateY,
rotateZ: base.rotateZ * sign + custom.rotateZ,
blurPx: Math.max(0, base.blurPx + custom.blur),
};
}
export function sampleFragmentMotion(
fragment: MockupMotionFragment,
currentTime: number
): MockupMotionTransform {
if (currentTime < fragment.startTime || currentTime > fragment.endTime) {
return REST_MOCKUP_MOTION;
}
const localTime = currentTime - fragment.startTime;
const localDuration = fragment.endTime - fragment.startTime;
// 3D presets produce CSS-compatible values by mapping the 3D transform
// back into the 2D transform space so the existing CSS pipeline keeps
// working. The real 3D application happens in Mockup3DStage via
// sampleCombined3DMotion.
if (MOTION_PRESET_3D_IDS.has(fragment.presetId)) {
return REST_MOCKUP_MOTION;
}
const base = sampleMockupMotion(
{ presetId: fragment.presetId, intensity: fragment.intensity, speed: fragment.speed },
localTime,
localDuration
);
return applyMotionCustomOffsets(base, fragment.custom);
}
export function sampleCombinedMockupMotion(
fragments: MockupMotionFragment[],
currentTime: number
): MockupMotionTransform {
const active = fragments.filter(
(f) => currentTime >= f.startTime && currentTime <= f.endTime
);
if (active.length === 0) return REST_MOCKUP_MOTION;
return active.reduce<MockupMotionTransform>(
(acc, fragment) => {
const t = sampleFragmentMotion(fragment, currentTime);
return {
scale: acc.scale * t.scale,
translateXPct: acc.translateXPct + t.translateXPct,
translateYPct: acc.translateYPct + t.translateYPct,
rotateX: acc.rotateX + t.rotateX,
rotateY: acc.rotateY + t.rotateY,
rotateZ: acc.rotateZ + t.rotateZ,
opacity: acc.opacity * t.opacity,
blurPx: Math.max(acc.blurPx, t.blurPx),
perspectivePx: Math.max(acc.perspectivePx, t.perspectivePx),
};
},
{ ...REST_MOCKUP_MOTION }
);
}
export function findValidMotionPlacement(
presetId: MockupMotionPresetId,
speed: number,
hintTime: number,
existingFragments: MockupMotionFragment[],
clipDurationSec: number
): { startTime: number; endTime: number } | null {
const is3D = MOTION_PRESET_3D_IDS.has(presetId);
const defaultDur = is3D
? getDefault3DFragmentDuration(presetId as Mockup3DMotionPresetId, speed)
: getDefaultFragmentDuration(presetId, speed);
const duration = Math.min(defaultDur, clipDurationSec);
if (duration <= 0 || clipDurationSec <= 0) return null;
const category = getMotionPresetCategory(presetId);
const sorted = [...existingFragments].sort((a, b) => a.startTime - b.startTime);
const overlaps = (start: number, end: number) =>
sorted.some((f) => start < f.endTime && end > f.startTime);
const tryPlace = (start: number) => {
const end = start + duration;
if (start < 0 || end > clipDurationSec) return null;
return overlaps(start, end) ? null : { startTime: start, endTime: end };
};
const preferredStart =
category === "Entrance"
? 0
: category === "Exit"
? Math.max(0, clipDurationSec - duration)
: Math.max(0, Math.min(hintTime - duration / 2, clipDurationSec - duration));
const direct = tryPlace(preferredStart);
if (direct) return direct;
const gaps: { start: number; end: number }[] = [];
let cursor = 0;
for (const f of sorted) {
if (f.startTime > cursor) gaps.push({ start: cursor, end: f.startTime });
cursor = Math.max(cursor, f.endTime);
}
if (cursor < clipDurationSec) gaps.push({ start: cursor, end: clipDurationSec });
const fitting = gaps.filter((g) => g.end - g.start >= duration);
if (fitting.length === 0) return null;
fitting.sort((a, b) => {
const da = Math.min(
Math.abs(a.start - preferredStart),
Math.abs(a.end - duration - preferredStart)
);
const db = Math.min(
Math.abs(b.start - preferredStart),
Math.abs(b.end - duration - preferredStart)
);
return da - db;
});
const gap = fitting[0];
const start = Math.max(gap.start, Math.min(preferredStart, gap.end - duration));
return { startTime: start, endTime: start + duration };
}
// Re-export 3D helpers so consumers can import everything from one module.
export {
getDefault3DFragmentDuration,
sampleCombined3DMotion,
type Mockup3DMotionTransform,
type Mockup3DMotionCustomOffsets,
DEFAULT_3D_MOTION_CUSTOM_OFFSETS,
REST_MOCKUP_3D_MOTION,
} from "./mockup-motion-3d";