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.tsxindex 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 systemconst 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.tsxindex 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.mdindex 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.tsindex 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.tsindex 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 };}