Skip to content

Create professional demos and 3D mockups in seconds, directly in your browser

feat: Refactor zoom fragment handling to ensure entry and exit ramps occur within fragment bounds, improving synchronization between preview and export

CristianOlivera1715f43fc0abe
diff --git a/app/components/ui/editor/VideoCanvas.tsx b/app/components/ui/editor/VideoCanvas.tsx
index 63f5166..90df710 100644
--- a/app/components/ui/editor/VideoCanvas.tsx
+++ b/app/components/ui/editor/VideoCanvas.tsx
@@ -274,20 +274,18 @@ function VideoCanvasInner({
// Calculate zoom transform for visual preview using 3-phase system
const zoomTransform = useMemo(() => {
- // No active fragment - smooth exit to base scale
+ // No active fragment - zoom has already settled to scale=1 at the end
+ // of the previous fragment (exit now completes WITHIN the fragment), so
+ // there is no invisible exit tail to animate after endTime.
if (!activeZoomFragment) {
- const lastFragment = zoomFragments
- .filter(f => f.endTime < currentTime)
- .sort((a, b) => b.endTime - a.endTime)[0];
- const exitMs = lastFragment ? speedToTransitionMs(lastFragment.speed) : speedToTransitionMs(3);
return {
scale: 1,
translateX: 0,
translateY: 0,
- transitionMs: exitMs,
+ transitionMs: 0,
rotateX: 0,
rotateY: 0,
- perspective: lastFragment?.enable3D ? 600 : 0,
+ perspective: 0,
isMoving: false,
};
}
@@ -312,7 +310,7 @@ function VideoCanvasInner({
perspective: phaseState.perspective,
isMoving,
};
- }, [activeZoomFragment, zoomFragments, currentTime, zoomMovements]);
+ }, [activeZoomFragment, currentTime, zoomMovements]);
const shouldShowUnsplashOverride = backgroundTab === "wallpaper" && unsplashOverrideUrl !== "";
const shouldShowWallpaper = backgroundTab === "wallpaper" && selectedWallpaper >= 0 && !shouldShowUnsplashOverride;
diff --git a/app/components/ui/editor/ZoomFragmentTrackItem.tsx b/app/components/ui/editor/ZoomFragmentTrackItem.tsx
index 8fe33ae..d2fef0b 100644
--- a/app/components/ui/editor/ZoomFragmentTrackItem.tsx
+++ b/app/components/ui/editor/ZoomFragmentTrackItem.tsx
@@ -82,9 +82,13 @@ export function ZoomFragmentTrackItem({
}, [otherFragments, fragment.startTime, fragment.endTime, videoDuration, contentDuration]);
const minDurationSeconds = useMemo(() => {
- if (!fragment.movementEnabled) return MIN_FRAGMENT_DURATION;
const transitionSec = speedToTransitionMs(fragment.speed) / 1000;
- return Math.max(MIN_FRAGMENT_DURATION, MIN_MOVEMENT_TRACK_DURATION + transitionSec);
+ // Entry + exit ramps must both fit within the fragment, so the minimum
+ // duration is 2 * transitionSec (or MIN_FRAGMENT_DURATION, whichever
+ // is larger). When movement is enabled, add the movement track minimum.
+ const baseMin = Math.max(MIN_FRAGMENT_DURATION, transitionSec * 2);
+ if (!fragment.movementEnabled) return baseMin;
+ return Math.max(baseMin, MIN_MOVEMENT_TRACK_DURATION + transitionSec);
}, [fragment.movementEnabled, fragment.speed]);
diff --git a/claude.md b/claude.md
index 7f54c44..08733da 100644
--- a/claude.md
+++ b/claude.md
@@ -40,16 +40,16 @@ Unidad atómica de zoom aplicada a un rango temporal del video:
Particiona la vida del fragmento en **entry → hold → exit** usando `transitionSeconds = speedToTransitionMs(speed)/1000`:
```
-|<── entry (transitionSec) ──>|<──── hold ────>|<── exit (transitionSec, post-endTime) ──>|
-startTime endTime
+|<── entry (T) ──>|<──── hold ────>|<── exit (T) ──>|
+startTime endTime
```
- **Entry** (`time < startTime + transitionSec`): zoom-in con `easeOutQuart`. Solo `forExport=true` interpola `scale`; en preview el scale lo gestiona `calculateSmoothZoom` (ver §4).
-- **Exit** (`time >= endTime` y dentro de `transitionSec` post-fin): zoom-out con `easeOutQuart`; el foco salta a `movementEndX/Y` si hay movement.
+- **Exit** (`time >= endTime - transitionSec`): zoom-out con `easeOutQuart` que termina en `scale=1` exactamente en `endTime`; el foco salta a `movementEndX/Y` si hay movement.
- **Hold** (entre entry y exit): scale = `targetScale`; si `movementEnabled` se interpola foco A→B con `easeInOutQuart`, respetando `movementStartOffset/EndOffset` como ventanas dentro del hold.
> El cálculo del **scale lo hace el caller** según el modo:
-> - Preview (CSS): `calculateSmoothZoom` redefine el scale para coincidir con exportación (entry dentro del fragmento + exit *después* del endTime).
+> - Preview (CSS): `calculateSmoothZoom` redefine el scale para coincidir con exportación (entry y exit *dentro* del fragmento).
> - Export (canvas): `forExport=true` interpola el scale en entry/exit *dentro* de `calculateZoomPhaseState` porque se llama por frame.
### Capa 3D (independiente del zoom)
@@ -126,7 +126,7 @@ Aquí viven **dos cálculos** según el modo:
`useMemo` que determina el transform CSS del "zoom + translate layer":
1. **Fragmento activo** (`activeZoomFragment`): el que contiene `currentTime` en `[startTime, endTime]`.
-2. Si no hay activo: busca el **último fragmento anterior** (`endTime < currentTime`); usa su `speed` para una "salida suave" a `scale=1` con su `perspective` si era 3D.
+2. Si no hay activo: retorna directamente `scale=1` sin transición (el zoom ya completó su exit *dentro* del fragmento anterior, en `endTime`).
3. Si hay activo: llama `calculateZoomPhaseState(fragment, currentTime)` (sin `forExport`) y traducefocus → translate:
```
translateX = 50 - focusX
@@ -136,15 +136,12 @@ Aquí viven **dos cálculos** según el modo:
### 4.2 Exportación (Canvas 2D) — `calculateSmoothZoom` (líneas 1434+ en `VideoCanvas.tsx`, impl en `lib/canvas.utils.ts`)
-> Divergencia intencional con `calculateZoomPhaseState` para que **la escala coincida visualmente entre preview y export**: el exit ocurre *después* de `endTime`, no dentro.
-
`calculateSmoothZoom(frameTime, fragments)`:
- `activeFragment`: `frameTime` en `[start,end]`.
- - `scale = computeHeldScale`: rampa de 1→target con `easeOutQuart` durante `transitionSec` desde `startTime`; luego `target` constante.
+ - `scale = computeFragmentScale`: cubre las 3 fases (entry, hold, exit) *dentro* de `[start,end]`. Entry: rampa 1→target con `easeOutQuart` durante `transitionSec` desde `startTime`. Exit: rampa target→1 durante `transitionSec` antes de `endTime`. Hold: `target` constante.
- Si `isAdvancedZoom` (`enable3D || movementEnabled`) → delega focus/rotateX/rotateY/perspective a `calculateZoomPhaseState(fragment, frameTime, forExport=true)`; **sobreescribe solo `scale`**.
- Si no → focusX/Y del fragmento, rotación 0.
-- `previousFragment`: si no hay activo, calcula `computeExitScale` (decay post-endTime). Devuelve `null` cuando pasó `transitionSec` desde `endTime` → cae a `DEFAULT_STATE` {scale:1, focus 50/50}.
-- Default: scale 1, sin rotación.
+- Default: scale 1, sin rotación. (Ya no hay `previousFragment`/`computeExitScale` porque el exit completa dentro del fragmento.)
### 4.3 Transform CSS aplicado al DOM (líneas 2242–2320)
Estructura anidada:
diff --git a/lib/canvas.utils.ts b/lib/canvas.utils.ts
index 4f179d0..99d7802 100644
--- a/lib/canvas.utils.ts
+++ b/lib/canvas.utils.ts
@@ -190,17 +190,18 @@ export interface ZoomStateCanvasExport extends ZoomStateCanvas {
/**
* Calculate smooth zoom for canvas export.
*
- * IMPORTANT: scale now uses the SAME "entry inside fragment, exit AFTER
- * fragment ends" behavior for BOTH simple and advanced (3D/movement) zoom,
- * mirroring exactly what the preview does via CSS transitions:
- * - entry ramp: [start, start+T] (T = speedToTransitionMs)
- * - hold: [start+T, end] (flat at targetScale)
- * - exit ramp: [end, end+T] (AFTER the fragment, not before)
+ * Both entry AND exit ramps occur WITHIN the fragment bounds [startTime, endTime]:
+ * - entry ramp: [start, start+T] (T = speedToTransitionMs, clamped to dur/2)
+ * - hold: [start+T, end-T] (flat at targetScale)
+ * - exit ramp: [end-T, end] (back to scale=1 by endTime)
*
- * rotateX/rotateY/focus for advanced zoom keep using the existing
- * within-fragment 3-phase system (calculateZoomPhaseState), since those
- * already match preview and already settle to their end-state (0 rotation,
- * movement-end focus) by the time frameTime reaches endTime.
+ * This means the zoom is fully complete at endTime: no invisible exit tail
+ * after the fragment, so adjacent fragments/content never collide with an
+ * unseen zoom-out.
+ *
+ * For advanced zoom (3D/movement), focus/rotation come from
+ * calculateZoomPhaseState(forExport=true), which now uses the same within-
+ * fragment exit window, so scale and 3D effects stay in sync.
*/
export function calculateSmoothZoom(
frameTime: number,
@@ -215,34 +216,37 @@ export function calculateSmoothZoom(
const sortedFragments = [...zoomFragments].sort((a, b) => a.startTime - b.startTime);
const activeFragment = sortedFragments.find(f => frameTime >= f.startTime && frameTime <= f.endTime);
- const previousFragment = sortedFragments.filter(f => f.endTime < frameTime).sort((a, b) => b.endTime - a.endTime)[0];
const isAdvancedZoom = (f: ZoomFragment) => f.enable3D || f.movementEnabled;
const movementsFor = (fragmentId: string) => zoomMovements.filter(m => m.zoomFragmentId === fragmentId);
- const computeHeldScale = (fragment: ZoomFragment, time: number): number => {
- const transitionSec = speedToTransitionMs(fragment.speed) / 1000;
+
+ // Compute scale for a fragment at a given time, covering all 3 phases
+ // (entry, hold, exit) entirely WITHIN [startTime, endTime].
+ const computeFragmentScale = (fragment: ZoomFragment, time: number): number => {
+ const totalDuration = fragment.endTime - fragment.startTime;
+ const transitionSec = Math.min(speedToTransitionMs(fragment.speed) / 1000, totalDuration / 2);
const targetScale = zoomLevelToFactor(fragment.zoomLevel);
const timeIntoFragment = time - fragment.startTime;
+
+ // Entry ramp [start, start+T]
if (transitionSec > 0 && timeIntoFragment < transitionSec) {
const progress = Math.min(1, Math.max(0, timeIntoFragment / transitionSec));
return 1 + (targetScale - 1) * easeOutQuart(progress);
}
- return targetScale;
- };
- const computeExitScale = (fragment: ZoomFragment, time: number): number | null => {
- const transitionSec = speedToTransitionMs(fragment.speed) / 1000;
- if (transitionSec <= 0) return null;
- const timeSinceEnd = time - fragment.endTime;
- if (timeSinceEnd >= transitionSec) return null;
- const targetScale = zoomLevelToFactor(fragment.zoomLevel);
- const progress = Math.min(1, Math.max(0, timeSinceEnd / transitionSec));
- const easedProgress = easeOutQuart(progress);
- return targetScale - (targetScale - 1) * easedProgress;
+ // Exit ramp [end-T, end]
+ const timeBeforeEnd = fragment.endTime - time;
+ if (transitionSec > 0 && timeBeforeEnd < transitionSec) {
+ const progress = Math.min(1, Math.max(0, timeBeforeEnd / transitionSec));
+ return 1 + (targetScale - 1) * easeOutQuart(progress);
+ }
+
+ // Hold
+ return targetScale;
};
if (activeFragment) {
- const scale = computeHeldScale(activeFragment, frameTime);
+ const scale = computeFragmentScale(activeFragment, frameTime);
if (isAdvancedZoom(activeFragment)) {
const phaseState = calculateZoomPhaseState(activeFragment, frameTime, movementsFor(activeFragment.id), true);
return { scale, focusX: phaseState.focusX, focusY: phaseState.focusY, rotateX: phaseState.rotateX, rotateY: phaseState.rotateY, perspective: phaseState.perspective };
@@ -250,17 +254,6 @@ export function calculateSmoothZoom(
return { scale, focusX: activeFragment.focusX, focusY: activeFragment.focusY, rotateX: 0, rotateY: 0, perspective: 0 };
}
- if (previousFragment) {
- const exitScale = computeExitScale(previousFragment, frameTime);
- if (exitScale !== null) {
- if (isAdvancedZoom(previousFragment)) {
- const phaseState = calculateZoomPhaseState(previousFragment, frameTime, movementsFor(previousFragment.id), true);
- return { scale: exitScale, focusX: phaseState.focusX, focusY: phaseState.focusY, rotateX: phaseState.rotateX, rotateY: phaseState.rotateY, perspective: phaseState.perspective };
- }
- return { scale: exitScale, focusX: previousFragment.focusX, focusY: previousFragment.focusY, rotateX: 0, rotateY: 0, perspective: 0 };
- }
- }
-
return DEFAULT_STATE;
}
diff --git a/types/zoom.types.ts b/types/zoom.types.ts
index 41a10c4..9852978 100644
--- a/types/zoom.types.ts
+++ b/types/zoom.types.ts
@@ -74,9 +74,13 @@ export function calculateZoomPhaseState(
const targetScale = zoomLevelToFactor(fragment.zoomLevel);
const enable3D = fragment.enable3D ?? false;
- const transitionSeconds = speedToTransitionMs(fragment.speed) / 1000;
+ // Exit now occurs WITHIN the fragment (ending at endTime), not after it.
+ // Clamp transition so entry + exit always fit: if the fragment is too
+ // short, each ramp gets at most half the duration (no hold phase).
+ const rawTransitionSeconds = speedToTransitionMs(fragment.speed) / 1000;
+ const transitionSeconds = Math.min(rawTransitionSeconds, totalDuration / 2);
const entryEndTime = fragment.startTime + transitionSeconds;
- const exitStartTime = fragment.endTime;
+ const exitStartTime = fragment.endTime - transitionSeconds;
let rotateX = 0;
let rotateY = 0;
@@ -282,9 +286,10 @@ export interface ZoomMovement {
}
export function getFragmentHoldBounds(fragment: ZoomFragment): { start: number; end: number } {
- const transitionSec = speedToTransitionMs(fragment.speed) / 1000;
+ const totalDuration = fragment.endTime - fragment.startTime;
+ const transitionSec = Math.min(speedToTransitionMs(fragment.speed) / 1000, totalDuration / 2);
const start = fragment.startTime + transitionSec;
- const end = fragment.endTime;
+ const end = fragment.endTime - transitionSec;
return start <= end ? { start, end } : { start: fragment.startTime, end: fragment.startTime };
}