Skip to content

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

feat: reset selected IDs in selectCanvasElement callback, update PlaceholderEditor background color, enhance video export settings, and improve perspective 3D rendering

CristianOlivera18fed8f32a60f
diff --git a/app/[locale]/(editor)/editor/page.tsx b/app/[locale]/(editor)/editor/page.tsx
index 3a1fbc4..fd544a2 100644
--- a/app/[locale]/(editor)/editor/page.tsx
+++ b/app/[locale]/(editor)/editor/page.tsx
@@ -558,6 +558,9 @@ export default function Editor() {
const selectCanvasElement = useCallback((id: string | null) => {
setSelectedElementId(id);
if (id) {
+ setSelectedZoomFragmentId(null);
+ setSelectedVideoClipId(null);
+ setSelectedAudioTrackId(null);
setActiveTool("elements");
}
}, []);
diff --git a/app/components/ui/PlaceholderEditor.tsx b/app/components/ui/PlaceholderEditor.tsx
index 888701c..68f7272 100644
--- a/app/components/ui/PlaceholderEditor.tsx
+++ b/app/components/ui/PlaceholderEditor.tsx
@@ -104,7 +104,7 @@ export default function PlaceholderEditor({
</div>
<div
- className="flex-1 flex items-center justify-center bg-transparent p-6 sm:p-12"
+ className="flex-1 flex items-center justify-center p-6 sm:p-12 bg-black/20"
onDragEnter={handleDragEnter}
onDragOver={handleDragOver}
onDrop={handleDrop}
diff --git a/app/components/ui/editor/VideoCanvas.tsx b/app/components/ui/editor/VideoCanvas.tsx
index 73bdb25..063635e 100644
--- a/app/components/ui/editor/VideoCanvas.tsx
+++ b/app/components/ui/editor/VideoCanvas.tsx
@@ -1691,7 +1691,7 @@ function VideoCanvasInner({
}
fgCtx.restore();
- applyPerspective3D(fgCanvas, zoomState.rotateX, zoomState.rotateY, zoomState.perspective * BLEED_FACTOR);
+ applyPerspective3D(fgCanvas, zoomState.rotateX, zoomState.rotateY, zoomState.perspective / BLEED_FACTOR);
ctx.save();
applyVideoZoom(ctx);
ctx.drawImage(fgCanvas, -fgOffsetX, -fgOffsetY, fgWidth, fgHeight);
diff --git a/hooks/useVideoExport.ts b/hooks/useVideoExport.ts
index 774570c..930707a 100644
--- a/hooks/useVideoExport.ts
+++ b/hooks/useVideoExport.ts
@@ -373,8 +373,10 @@ async function exportWithMediabunny(
const videoSource = new CanvasSource(canvas, {
codec: "avc",
bitrate: bitrate,
+ bitrateMode: "variable",
+ latencyMode: "quality",
+ fullCodecString: "avc1.640033",
});
-
output.addVideoTrack(videoSource, {
frameRate: fps,
});
@@ -522,8 +524,10 @@ async function exportWithMediabunnyAndAudio(
const videoSource = new CanvasSource(canvas, {
codec: "avc",
bitrate: bitrate,
+ bitrateMode: "variable",
+ latencyMode: "quality",
+ fullCodecString: "avc1.640033",
});
-
output.addVideoTrack(videoSource, {
frameRate: fps,
});
diff --git a/lib/canvas.utils.ts b/lib/canvas.utils.ts
index f96c775..b2da080 100644
--- a/lib/canvas.utils.ts
+++ b/lib/canvas.utils.ts
@@ -187,115 +187,138 @@ export interface ZoomStateCanvasExport extends ZoomStateCanvas {
rotateY: number;
perspective: number;
}
-
/**
* Calculate smooth zoom for canvas export.
- *
- * IMPORTANT: Two different zoom behaviors:
- * 1. Simple zoom (no 3D, no movement): Entry inside fragment, Exit AFTER fragment ends
- * 2. Advanced zoom (3D or movement): 3-phase system (Entry → Hold → Exit) all within fragment
+ *
+ * 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)
+ *
+ * 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.
*/
export function calculateSmoothZoom(
- frameTime: number,
- zoomFragments: ZoomFragment[]
+ frameTime: number,
+ zoomFragments: ZoomFragment[]
): ZoomStateCanvasExport {
- const DEFAULT_STATE: ZoomStateCanvasExport = {
- scale: 1,
- focusX: 50,
- focusY: 50,
+ const DEFAULT_STATE: ZoomStateCanvasExport = {
+ scale: 1,
+ focusX: 50,
+ focusY: 50,
+ rotateX: 0,
+ rotateY: 0,
+ perspective: 0,
+ };
+
+ if (!zoomFragments.length) return DEFAULT_STATE;
+
+ 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;
+
+ // Shared scale curve: entry ramps INSIDE the fragment, then holds flat.
+ // Used for BOTH simple and advanced zoom while the fragment is active.
+ const computeHeldScale = (fragment: ZoomFragment, time: number): number => {
+ const transitionSec = speedToTransitionMs(fragment.speed) / 1000;
+ const targetScale = zoomLevelToFactor(fragment.zoomLevel);
+ const timeIntoFragment = time - fragment.startTime;
+ if (transitionSec > 0 && timeIntoFragment < transitionSec) {
+ const progress = Math.min(1, Math.max(0, timeIntoFragment / transitionSec));
+ return 1 + (targetScale - 1) * easeOutQuart(progress);
+ }
+ return targetScale;
+ };
+
+ // Shared exit curve: decays AFTER the fragment ends. Returns null once
+ // the exit transition has fully finished (caller falls through to default).
+ 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;
+ };
+
+ if (activeFragment) {
+ const scale = computeHeldScale(activeFragment, frameTime);
+
+ if (isAdvancedZoom(activeFragment)) {
+ // Rotation + focus/movement still use the existing 3-phase system —
+ // that part already matches preview, we only override `scale`.
+ const phaseState = calculateZoomPhaseState(activeFragment, frameTime, true);
+ return {
+ scale,
+ focusX: phaseState.focusX,
+ focusY: phaseState.focusY,
+ rotateX: phaseState.rotateX,
+ rotateY: phaseState.rotateY,
+ perspective: phaseState.perspective,
+ };
+ }
+
+ return {
+ scale,
+ focusX: activeFragment.focusX,
+ focusY: activeFragment.focusY,
+ rotateX: 0,
+ rotateY: 0,
+ perspective: 0,
+ };
+ }
+
+ // Not inside any fragment — check exit transition from previous fragment.
+ if (previousFragment) {
+ const exitScale = computeExitScale(previousFragment, frameTime);
+ if (exitScale !== null) {
+ if (isAdvancedZoom(previousFragment)) {
+ // By the time frameTime > endTime, rotation has already settled to 0
+ // (calculateZoomPhaseState's exit fade completes before endTime) and
+ // focus has already settled to its movement-end value — so we just
+ // keep those static while the scale finishes decaying.
+ const focusX = previousFragment.movementEnabled
+ ? (previousFragment.movementEndX ?? previousFragment.focusX)
+ : previousFragment.focusX;
+ const focusY = previousFragment.movementEnabled
+ ? (previousFragment.movementEndY ?? previousFragment.focusY)
+ : previousFragment.focusY;
+ return {
+ scale: exitScale,
+ focusX,
+ focusY,
+ rotateX: 0,
+ rotateY: 0,
+ perspective: 0,
+ };
+ }
+
+ return {
+ scale: exitScale,
+ focusX: previousFragment.focusX,
+ focusY: previousFragment.focusY,
rotateX: 0,
rotateY: 0,
perspective: 0,
- };
-
- if (!zoomFragments.length) return DEFAULT_STATE;
-
- const sortedFragments = [...zoomFragments].sort((a, b) => a.startTime - b.startTime);
-
- const activeFragment = sortedFragments.find(
- f => frameTime >= f.startTime && frameTime <= f.endTime
- );
-
- // Find previous fragment for exit transition (only used for simple zoom)
- const previousFragment = sortedFragments
- .filter(f => f.endTime < frameTime)
- .sort((a, b) => b.endTime - a.endTime)[0];
-
- // Helper to check if fragment uses advanced features
- const isAdvancedZoom = (f: ZoomFragment) => f.enable3D || f.movementEnabled;
-
- if (activeFragment) {
- // Check if this fragment uses 3D or movement
- if (isAdvancedZoom(activeFragment)) {
- // ADVANCED ZOOM: Use 3-phase system (entry, hold, exit all within fragment)
- const phaseState = calculateZoomPhaseState(activeFragment, frameTime, true);
- return {
- scale: phaseState.scale,
- focusX: phaseState.focusX,
- focusY: phaseState.focusY,
- rotateX: phaseState.rotateX,
- rotateY: phaseState.rotateY,
- perspective: phaseState.perspective,
- };
- } else {
- // SIMPLE ZOOM: Entry transition inside fragment, no exit inside (exit happens after)
- const transitionMs = speedToTransitionMs(activeFragment.speed);
- const transitionSec = transitionMs / 1000;
- const targetScale = zoomLevelToFactor(activeFragment.zoomLevel);
- const timeIntoFragment = frameTime - activeFragment.startTime;
-
- let scale: number;
- if (timeIntoFragment < transitionSec) {
- // Entry: animate from 1 to target
- const progress = Math.min(1, timeIntoFragment / transitionSec);
- const easedProgress = easeOutQuart(progress);
- scale = 1 + (targetScale - 1) * easedProgress;
- } else {
- // Hold: maintain target scale (no exit inside fragment for simple zoom)
- scale = targetScale;
- }
-
- return {
- scale,
- focusX: activeFragment.focusX,
- focusY: activeFragment.focusY,
- rotateX: 0,
- rotateY: 0,
- perspective: 0,
- };
- }
- }
-
- // Not inside any fragment - check exit transition from previous fragment
- if (previousFragment) {
- if (isAdvancedZoom(previousFragment)) {
- // ADVANCED ZOOM: Exit already happened inside fragment, return default
- return DEFAULT_STATE;
- } else {
- // SIMPLE ZOOM: Exit happens AFTER fragment ends
- const exitTransitionMs = speedToTransitionMs(previousFragment.speed);
- const exitTransitionSec = exitTransitionMs / 1000;
- const timeSinceEnd = frameTime - previousFragment.endTime;
-
- if (timeSinceEnd < exitTransitionSec) {
- const progress = Math.min(1, timeSinceEnd / exitTransitionSec);
- const easedProgress = easeOutQuart(progress);
- const targetScale = zoomLevelToFactor(previousFragment.zoomLevel);
- const scale = targetScale - (targetScale - 1) * easedProgress;
-
- return {
- scale,
- focusX: previousFragment.focusX,
- focusY: previousFragment.focusY,
- rotateX: 0,
- rotateY: 0,
- perspective: 0,
- };
- }
- }
+ };
}
+ }
- return DEFAULT_STATE;
+ return DEFAULT_STATE;
}
// Functions to determine nearest corner and corner styles for rotating elements
diff --git a/lib/perspective3d.ts b/lib/perspective3d.ts
index 8911762..f094908 100644
--- a/lib/perspective3d.ts
+++ b/lib/perspective3d.ts
@@ -10,139 +10,140 @@ let _offscreen: HTMLCanvasElement | null = null;
let _lastAspect = 0;
function buildRenderer(): THREE.WebGLRenderer {
- const r = new THREE.WebGLRenderer({
- alpha: true,
- antialias: true,
- preserveDrawingBuffer: true,
- premultipliedAlpha: false,
- });
- r.outputColorSpace = THREE.SRGBColorSpace;
- r.toneMapping = THREE.NoToneMapping;
- r.setClearColor(0x000000, 0);
- return r;
+ const r = new THREE.WebGLRenderer({
+ alpha: true,
+ antialias: true,
+ preserveDrawingBuffer: true,
+ premultipliedAlpha: false,
+ });
+ r.outputColorSpace = THREE.SRGBColorSpace;
+ r.toneMapping = THREE.NoToneMapping;
+ r.setClearColor(0x000000, 0);
+ return r;
}
function ensureScene(aspect: number): { scene: THREE.Scene; plane: THREE.Mesh } {
- if (!_scene) {
- _scene = new THREE.Scene();
- }
-
- if (!_texture || !_offscreen) {
- _offscreen = document.createElement("canvas");
- _texture = new THREE.CanvasTexture(_offscreen);
- _texture.colorSpace = THREE.SRGBColorSpace;
- _texture.generateMipmaps = true;
- _texture.minFilter = THREE.LinearMipmapLinearFilter;
- _texture.magFilter = THREE.LinearFilter;
- _texture.wrapS = THREE.ClampToEdgeWrapping;
- _texture.wrapT = THREE.ClampToEdgeWrapping;
- }
-
- if (!_material) {
- _material = new THREE.MeshBasicMaterial({
- map: _texture,
- transparent: true,
- side: THREE.FrontSide,
- depthTest: false,
- depthWrite: false,
- });
- }
+ if (!_scene) {
+ _scene = new THREE.Scene();
+ }
+
+ if (!_texture || !_offscreen) {
+ _offscreen = document.createElement("canvas");
+ _texture = new THREE.CanvasTexture(_offscreen);
+ _texture.colorSpace = THREE.SRGBColorSpace;
+ _texture.generateMipmaps = true;
+ _texture.minFilter = THREE.LinearMipmapLinearFilter;
+ _texture.magFilter = THREE.LinearFilter;
+ _texture.wrapS = THREE.ClampToEdgeWrapping;
+ _texture.wrapT = THREE.ClampToEdgeWrapping;
+ _texture.premultiplyAlpha = true;
+ }
+
+ if (!_material) {
+ _material = new THREE.MeshBasicMaterial({
+ map: _texture,
+ transparent: true,
+ side: THREE.FrontSide,
+ depthTest: false,
+ depthWrite: false,
+ });
+ _material.premultipliedAlpha = true;
+ }
- if (!_plane || Math.abs(_lastAspect - aspect) > 0.0001) {
- if (_plane) {
- _plane.geometry.dispose();
- _scene.remove(_plane);
- }
- const geo = new THREE.PlaneGeometry(2 * aspect, 2);
- _plane = new THREE.Mesh(geo, _material);
- _scene.add(_plane);
- _lastAspect = aspect;
+ if (!_plane || Math.abs(_lastAspect - aspect) > 0.0001) {
+ if (_plane) {
+ _plane.geometry.dispose();
+ _scene.remove(_plane);
}
+ const geo = new THREE.PlaneGeometry(2 * aspect, 2);
+ _plane = new THREE.Mesh(geo, _material);
+ _scene.add(_plane);
+ _lastAspect = aspect;
+ }
- return { scene: _scene, plane: _plane };
+ return { scene: _scene, plane: _plane };
}
export function applyPerspective3D(
- canvas: HTMLCanvasElement,
- rotateXDeg: number,
- rotateYDeg: number,
- perspectivePx: number
+ canvas: HTMLCanvasElement,
+ rotateXDeg: number,
+ rotateYDeg: number,
+ perspectivePx: number
): void {
- if (rotateXDeg === 0 && rotateYDeg === 0) return;
- if (typeof window === "undefined") return;
-
- const w = canvas.width;
- const h = canvas.height;
- if (w === 0 || h === 0) return;
-
- const aspect = w / h;
-
- if (!_renderer) {
- _renderer = buildRenderer();
- _renderer.setPixelRatio(1);
- }
- if (_renderer.domElement.width !== w || _renderer.domElement.height !== h) {
- _renderer.setSize(w, h, false);
- }
-
- const { scene, plane } = ensureScene(aspect);
-
- if (_texture!.anisotropy < 2) {
- _texture!.anisotropy = _renderer.capabilities.getMaxAnisotropy();
- }
-
- const off = _offscreen!;
- if (off.width !== w || off.height !== h) {
- off.width = w;
- off.height = h;
- }
- const offCtx = off.getContext("2d", { alpha: true, willReadFrequently: false })!;
- offCtx.clearRect(0, 0, w, h);
- offCtx.drawImage(canvas, 0, 0);
-
- _texture!.image = off;
- _texture!.needsUpdate = true;
-
- const PERSPECTIVE_REFERENCE_HEIGHT = 1080;
- const cameraZ = (2 * perspectivePx) / PERSPECTIVE_REFERENCE_HEIGHT;
- const fovDeg = (2 * Math.atan(1 / cameraZ) * 180) / Math.PI;
-
- if (!_camera) {
- _camera = new THREE.PerspectiveCamera(fovDeg, aspect, 0.001, cameraZ * 20);
- _camera.position.set(0, 0, cameraZ);
- } else {
- _camera.fov = fovDeg;
- _camera.aspect = aspect;
- _camera.near = 0.001;
- _camera.far = cameraZ * 20;
- _camera.position.set(0, 0, cameraZ);
- }
- _camera.lookAt(0, 0, 0);
- _camera.updateProjectionMatrix();
- plane.rotation.x = -(rotateXDeg * Math.PI) / 180;
- plane.rotation.y = (rotateYDeg * Math.PI) / 180;
- plane.rotation.z = 0;
-
- _renderer.render(scene, _camera);
-
- const ctx2d = canvas.getContext("2d", { alpha: true, willReadFrequently: false })!;
- ctx2d.clearRect(0, 0, w, h);
- ctx2d.drawImage(_renderer.domElement, 0, 0);
+ if (rotateXDeg === 0 && rotateYDeg === 0) return;
+ if (typeof window === "undefined") return;
+
+ const w = canvas.width;
+ const h = canvas.height;
+ if (w === 0 || h === 0) return;
+ const aspect = w / h;
+
+ if (!_renderer) {
+ _renderer = buildRenderer();
+ _renderer.setPixelRatio(1);
+ }
+ if (_renderer.domElement.width !== w || _renderer.domElement.height !== h) {
+ _renderer.setSize(w, h, false);
+ }
+
+ const { scene, plane } = ensureScene(aspect);
+
+ if (_texture!.anisotropy < 2) {
+ _texture!.anisotropy = _renderer.capabilities.getMaxAnisotropy();
+ }
+
+ const off = _offscreen!;
+ if (off.width !== w || off.height !== h) {
+ off.width = w;
+ off.height = h;
+ }
+ const offCtx = off.getContext("2d", { alpha: true, willReadFrequently: false })!;
+ offCtx.clearRect(0, 0, w, h);
+ offCtx.drawImage(canvas, 0, 0);
+ _texture!.image = off;
+ _texture!.needsUpdate = true;
+
+ const PERSPECTIVE_REFERENCE_HEIGHT = 1080;
+ const cameraZ = (2 * perspectivePx) / PERSPECTIVE_REFERENCE_HEIGHT;
+ const fovDeg = (2 * Math.atan(1 / cameraZ) * 180) / Math.PI;
+
+ if (!_camera) {
+ _camera = new THREE.PerspectiveCamera(fovDeg, aspect, 0.001, cameraZ * 20);
+ _camera.position.set(0, 0, cameraZ);
+ } else {
+ _camera.fov = fovDeg;
+ _camera.aspect = aspect;
+ _camera.near = 0.001;
+ _camera.far = cameraZ * 20;
+ _camera.position.set(0, 0, cameraZ);
+ }
+ _camera.lookAt(0, 0, 0);
+ _camera.updateProjectionMatrix();
+
+ plane.rotation.x = -(rotateXDeg * Math.PI) / 180;
+ plane.rotation.y = (rotateYDeg * Math.PI) / 180;
+ plane.rotation.z = 0;
+
+ _renderer.render(scene, _camera);
+
+ const ctx2d = canvas.getContext("2d", { alpha: true, willReadFrequently: false })!;
+ ctx2d.clearRect(0, 0, w, h);
+ ctx2d.drawImage(_renderer.domElement, 0, 0);
}
export function disposePerspective3D(): void {
- _texture?.dispose();
- _material?.dispose();
- if (_plane) {
- _plane.geometry.dispose();
- }
- _renderer?.dispose();
- _renderer = null;
- _scene = null;
- _camera = null;
- _plane = null;
- _material = null;
- _texture = null;
- _offscreen = null;
- _lastAspect = 0;
-}
+ _texture?.dispose();
+ _material?.dispose();
+ if (_plane) {
+ _plane.geometry.dispose();
+ }
+ _renderer?.dispose();
+ _renderer = null;
+ _scene = null;
+ _camera = null;
+ _plane = null;
+ _material = null;
+ _texture = null;
+ _offscreen = null;
+ _lastAspect = 0;
+}
\ No newline at end of file