Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
fix(editor): offer 3D Orbit only with a recorded cursor
EtienneLescot007714507d95
diff --git a/src/components/ai-edition/recordedCursorTypes.test.ts b/src/components/ai-edition/recordedCursorTypes.test.tsindex c20d80596..f30f81581 100644--- a/src/components/ai-edition/recordedCursorTypes.test.ts+++ b/src/components/ai-edition/recordedCursorTypes.test.ts@@ -1,5 +1,13 @@import { describe, expect, it } from "vitest";-import { cursorStateChanges, cursorStatesBetween } from "./recordedCursorTypes";+import {+ type AxcutDocument,+ type AxcutZoomRegion,+ assetSchema,+ clipSchema,+ createEmptyDocument,+ zoomRegionSchema,+} from "@/lib/ai-edition/schema";+import { cursorStateChanges, cursorStatesBetween, zoomRecordingPaths } from "./recordedCursorTypes";describe("cursorStateChanges", () => {it("keeps the changes only, and reads a sample with no state as the arrow", () => {@@ -36,3 +44,79 @@ describe("cursorStatesBetween", () => {expect(cursorStatesBetween(changes, 3500, 9000)).toEqual(new Set(["resize-ew"]));});});++describe("zoomRecordingPaths", () => {+ /** One clip per take, ten seconds each, laid end to end. */+ function project(takes: string[]): AxcutDocument {+ const assets = takes.map((take) =>+ assetSchema.parse({+ id: `a_${take}`,+ label: "take",+ originalPath: `/recordings/${take}.mp4`,+ }),+ );+ const clips = assets.map((asset, i) =>+ clipSchema.parse({+ id: `c${i}`,+ assetId: asset.id,+ sourceStartSec: 0,+ sourceEndSec: 10,+ timelineStartSec: i * 10,+ timelineEndSec: i * 10 + 10,+ origin: "user",+ }),+ );+ const document = createEmptyDocument({ projectId: "p", title: "t" });+ return { ...document, assets, timeline: { ...document.timeline, clips } };+ }++ const zoom = (id: string, clipId: string, startMs: number, endMs: number): AxcutZoomRegion =>+ zoomRegionSchema.parse({+ id,+ clipId,+ startMs,+ endMs,+ depth: 3,+ focus: { cx: 0.5, cy: 0.5 },+ focusMode: "auto",+ });++ it("names the recording of the clip the zoom is anchored to", () => {+ const document = project(["a", "b"]);+ const regions = [zoom("z", "c0", 0, 5000)];+ expect(zoomRecordingPaths(regions, "z", document)).toEqual(["/recordings/a.mp4"]);+ });++ // The same zoom, cut at the clip junction: one fragment per clip, one pill on the ruler.+ it("names every recording of a zoom cut at a clip junction", () => {+ const document = project(["a", "b"]);+ const pill = [zoom("z1", "c0", 5000, 10000), zoom("z2", "c1", 10000, 15000)];+ expect(zoomRecordingPaths(pill, "z1", document)).toEqual([+ "/recordings/a.mp4",+ "/recordings/b.mp4",+ ]);+ });++ // A document migrated before clip anchors only knows the region's raw span.+ it("falls back to the clips an unanchored zoom overlaps", () => {+ const document = project(["a", "b"]);+ const legacy = zoomRegionSchema.parse({+ id: "z",+ startMs: 8000,+ endMs: 12000,+ depth: 3,+ focus: { cx: 0.5, cy: 0.5 },+ focusMode: "auto",+ });+ expect(zoomRecordingPaths([legacy], "z", document)).toEqual([+ "/recordings/a.mp4",+ "/recordings/b.mp4",+ ]);+ });++ it("answers nothing for an unknown zoom, or without a document", () => {+ const document = project(["a"]);+ expect(zoomRecordingPaths([], "z", document)).toEqual([]);+ expect(zoomRecordingPaths([zoom("z", "c0", 0, 5000)], "z", null)).toEqual([]);+ });+});diff --git a/src/components/ai-edition/recordedCursorTypes.ts b/src/components/ai-edition/recordedCursorTypes.tsindex dc6a28c2a..9786a0544 100644--- a/src/components/ai-edition/recordedCursorTypes.ts+++ b/src/components/ai-edition/recordedCursorTypes.ts@@ -1,7 +1,8 @@import { useEffect, useMemo, useReducer, useState } from "react";-import type { AxcutDocument } from "@/lib/ai-edition/schema";+import type { AxcutDocument, AxcutZoomRegion } from "@/lib/ai-edition/schema";import { useProjectStore } from "@/lib/ai-edition/store/projectStore";import { resolveClipSourceEndSec } from "@/lib/ai-edition/timeline/clipDuration";+import { resolveRegionIds } from "@/lib/ai-edition/timeline/timelineMap";import { nativeBridgeClient } from "@/native";interface CursorStateChange {@@ -91,15 +92,29 @@ function cursorDataIn(paths: readonly string[]): boolean | null {}/**- * Whether any recording the timeline plays has cursor data, or `null` while they are read. A take- * recorded with the system cursor has it baked into the pixels and no cursor file, so every cursor- * setting would change nothing: the editor leaves them out.+ * Whether EVERY recording in `paths` has cursor data, or `null` while some are still unread.+ * One take without a cursor file is enough to answer no: a zoom over it has no track to follow.*/-export function useHasRecordedCursor(): boolean | null {- // A string, so the recordings are read again when one is swapped, not on every other edit.- const pathsJson = useProjectStore((s) =>- JSON.stringify([...new Set(clipSourceRanges(s.document).map(([path]) => path))]),- );+export function useRecordingsHaveCursor(paths: readonly string[]): boolean | null {+ // Sorted, so the same set of recordings is one read whatever order the clips name them in.+ const pathsJson = JSON.stringify([...new Set(paths)].sort());+ const read = useRecordingReads(pathsJson);+ return everyCursorDataIn(read);+}++/** Whether every one of `paths` has cursor data: `false` as soon as one answered without it,+ * `null` while one is unread. An empty list names no recording, and nothing could follow. */+function everyCursorDataIn(paths: readonly string[]): boolean | null {+ if (paths.length === 0) return false;+ if (paths.some((path) => hasCursorByPath.get(path) === false)) return false;+ return paths.every((path) => hasCursorByPath.get(path) === true) ? true : null;+}++/**+ * Reads every recording in `paths` once per session and asks for a re-render as each answer+ * lands. Returns the deduplicated paths it read, which is what the caller's answer is about.+ */+function useRecordingReads(pathsJson: string): string[] {const paths = useMemo(() => JSON.parse(pathsJson) as string[], [pathsJson]);// The answer is read off the cache on every render, so it always belongs to the current// recordings; each read finishing only asks for another render.@@ -115,9 +130,58 @@ export function useHasRecordedCursor(): boolean | null {cancelled = true;};}, [paths]);+ return paths;+}++/**+ * Whether any recording the timeline plays has cursor data, or `null` while they are read. A take+ * recorded with the system cursor has it baked into the pixels and no cursor file, so every cursor+ * setting would change nothing: the editor leaves them out.+ */+export function useHasRecordedCursor(): boolean | null {+ // A string, so the recordings are read again when one is swapped, not on every other edit.+ const pathsJson = useProjectStore((s) =>+ JSON.stringify([...new Set(clipSourceRanges(s.document).map(([path]) => path))]),+ );+ const paths = useRecordingReads(pathsJson);return cursorDataIn(paths);}+/**+ * The recordings a zoom region plays over, one path per distinct video file.+ *+ * A region cut at a clip junction is stored as one fragment per clip, so a zoom that runs from+ * one take onto another names both. A region migrated without a clip anchor only knows its raw+ * span, and the clips it overlaps are its recordings instead. Empty when nothing can be resolved+ * (never saved without clips; a fragment whose clip is gone is not rendered either).+ */+export function zoomRecordingPaths(+ regions: AxcutZoomRegion[],+ id: string,+ document: AxcutDocument | null,+): string[] {+ if (!document) return [];+ const fragments = new Set(resolveRegionIds(regions, id, 0.001));+ const clips = new Map(document.timeline.clips.map((clip) => [clip.id, clip]));+ const paths = new Set<string>();+ for (const region of regions) {+ if (!fragments.has(region.id)) continue;+ const covered = region.clipId+ ? [clips.get(region.clipId)]+ : document.timeline.clips.filter(+ (clip) =>+ clip.timelineStartSec * 1000 < region.endMs &&+ clip.timelineEndSec * 1000 > region.startMs,+ );+ for (const clip of covered) {+ if (!clip) continue;+ const asset = document.assets.find((candidate) => candidate.id === clip.assetId);+ if (asset?.kind === "video" && asset.originalPath) paths.add(asset.originalPath);+ }+ }+ return [...paths];+}+/*** Every cursor state the timeline's clips put on screen, or `null` while their recordings are* read. The cursor pane offers to redraw these and nothing else: a choice about a cursor thediff --git a/src/components/ai-edition/v4/FloatingInspector.test.tsx b/src/components/ai-edition/v4/FloatingInspector.test.tsxindex 090f87fbc..dc48c48bd 100644--- a/src/components/ai-edition/v4/FloatingInspector.test.tsx+++ b/src/components/ai-edition/v4/FloatingInspector.test.tsx@@ -367,7 +367,58 @@ describe("FloatingInspector", () => {"button",);+ /** A project whose takes recorded `samples` cursor samples each (one clip per take). */+ function openTakes(samples: number[]) {+ const run = crypto.randomUUID();+ const assets = samples.map((_, i) =>+ assetSchema.parse({+ id: `a${i}`,+ label: "take",+ originalPath: `/recordings/${run}-${i}.mp4`,+ }),+ );+ const clips = assets.map((asset, i) =>+ clipSchema.parse({+ id: `c${i}`,+ assetId: asset.id,+ sourceStartSec: 0,+ sourceEndSec: 10,+ timelineStartSec: i * 10,+ timelineEndSec: i * 10 + 10,+ origin: "user",+ }),+ );+ const samplesOf = new Map(assets.map((asset, i) => [asset.originalPath, samples[i]]));+ const read = vi+ .spyOn(nativeBridgeClient.cursor, "getRecordingData")+ .mockImplementation(async (videoPath) => ({+ version: 2,+ provider: "native",+ assets: [],+ samples: Array.from({ length: samplesOf.get(videoPath ?? "") ?? 0 }, (_, i) => ({+ timeMs: i * 100,+ cx: 0.5,+ cy: 0.5,+ })),+ }));+ const document = createEmptyDocument({ projectId: "p", title: "t" });+ useProjectStore.setState({+ projectId: "p",+ document: { ...document, assets, timeline: { ...document.timeline, clips } },+ });+ return read;+ }++ /** Lets the takes' cursor files be read, so an absence is an answer and not a wait. */+ async function readTakes(read: ReturnType<typeof openTakes>) {+ await waitFor(() => expect(read).toHaveBeenCalled());+ await act(async () => {+ await Promise.all(read.mock.results.map((result) => result.value));+ });+ }+afterEach(() => {+ vi.restoreAllMocks();useProjectStore.setState({ document: null });});@@ -459,6 +510,77 @@ describe("FloatingInspector", () => {editorSettings.autoFocusAll = false;}});++ // Issue #1397. A take recorded with the system cursor has no cursor file, so Auto focus+ // has nothing to read and 3D Orbit would hold still — exactly the camera the reporter+ // picked and then watched do nothing.+ it("leaves the orbit out under Auto focus when the take has no recorded cursor", async () => {+ const read = openTakes([0]);+ const { tl } = zoomTl({ focusMode: "auto", clipId: "c0" });+ render(<FloatingInspector {...defaultProps} tl={tl} />);+ await readTakes(read);+ expect(+ screen.queryByRole("button", { name: "settings.zoom.camera.preset.orbit" }),+ ).toBeNull();+ // The fixed angles need no cursor, so they stay.+ expect(+ screen.getByRole("button", { name: "settings.zoom.camera.preset.left" }),+ ).toBeInTheDocument();+ });++ it("offers the orbit under Auto focus once the take has a recorded cursor", async () => {+ const read = openTakes([3]);+ const { tl } = zoomTl({ focusMode: "auto", clipId: "c0" });+ render(<FloatingInspector {...defaultProps} tl={tl} />);+ await readTakes(read);+ expect(+ await screen.findByRole("button", { name: "settings.zoom.camera.preset.orbit" }),+ ).toBeInTheDocument();+ });++ // The recordings under the zoom decide, not the project: a zoom that stays on the recorded+ // take still follows the cursor, next to a system-cursor take on the same timeline.+ it("offers the orbit under Auto focus over a take with a cursor beside one without", async () => {+ const read = openTakes([3, 0]);+ const { tl } = zoomTl({ focusMode: "auto", clipId: "c0" });+ render(<FloatingInspector {...defaultProps} tl={tl} />);+ await readTakes(read);+ expect(+ await screen.findByRole("button", { name: "settings.zoom.camera.preset.orbit" }),+ ).toBeInTheDocument();+ });++ // ...and the opposite: a zoom on the system-cursor take is left out even though another+ // recording on the timeline has a cursor.+ it("leaves the orbit out under Auto focus over the take without a cursor", async () => {+ const read = openTakes([3, 0]);+ const { tl } = zoomTl({ focusMode: "auto", clipId: "c1" });+ render(<FloatingInspector {...defaultProps} tl={tl} />);+ await readTakes(read);+ expect(+ screen.queryByRole("button", { name: "settings.zoom.camera.preset.orbit" }),+ ).toBeNull();+ });++ // A zoom cut at a clip junction is one pill over both takes: the camera would follow on the+ // recorded one and hold still on the other, so Auto focus must not offer it at all.+ it("leaves the orbit out under Auto focus when the zoom runs onto a take without a cursor", async () => {+ const read = openTakes([3, 0]);+ const pill = [+ { id: "z1", clipId: "c0", startMs: 5000, endMs: 10000, depth: 3, focusMode: "auto" },+ { id: "z2", clipId: "c1", startMs: 10000, endMs: 15000, depth: 3, focusMode: "auto" },+ ];+ const tl = {+ ...defaultProps.tl,+ selection: { kind: "zoom", id: "z1" },+ zoomRegions: pill,+ } as unknown as React.ComponentProps<typeof FloatingInspector>["tl"];+ render(<FloatingInspector {...defaultProps} tl={tl} />);+ await readTakes(read);+ expect(+ screen.queryByRole("button", { name: "settings.zoom.camera.preset.orbit" }),+ ).toBeNull();+ });});describe("cursor facet", () => {diff --git a/src/components/ai-edition/v4/FloatingInspector.tsx b/src/components/ai-edition/v4/FloatingInspector.tsxindex b82a0e9cd..08c2180f5 100644--- a/src/components/ai-edition/v4/FloatingInspector.tsx+++ b/src/components/ai-edition/v4/FloatingInspector.tsx@@ -87,7 +87,11 @@ import {TranscriptPane,VideoEffectsPane,} from "../RightPanes";-import { useHasRecordedCursor } from "../recordedCursorTypes";+import {+ useHasRecordedCursor,+ useRecordingsHaveCursor,+ zoomRecordingPaths,+} from "../recordedCursorTypes";import { TextColorField } from "../TextColorField";import styles from "./EditorShellV4.module.css";@@ -759,6 +763,17 @@ function SelectionPane({ tl, onClose }: { tl: TimelineApi; onClose: () => void }() => (doc && zoomId ? zoomScaleLimit(doc, zoomId) : MAX_ZOOM_SCALE),[doc, zoomId],);+ // The recordings under the selected zoom, one per clip it covers (a region cut at a clip+ // junction is one fragment per clip), empty for a non-zoom selection.+ const zoomPaths = useMemo(+ () =>+ tl.selection?.kind === "zoom" ? zoomRecordingPaths(tl.zoomRegions, tl.selection.id, doc) : [],+ [doc, tl.selection, tl.zoomRegions],+ );+ // Every take under the zoom must carry a cursor track: the 3D Orbit follows the cursor of+ // whichever take plays, so one without a track would hold the camera still for its part of the+ // pill, and the camera is not offered there under Auto focus.+ const zoomHasCursor = useRecordingsHaveCursor(zoomPaths) === true;// Mise à jour en direct regroupée à une par frame. `updateAnnotationLive` remplace le document// dans le store, donc chaque appel fait reconstruire et re-sérialiser toute la scène avant de// la pousser au natif : c'est le juste prix une fois par image, mais un `<input type="color">`@@ -852,11 +867,12 @@ function SelectionPane({ tl, onClose }: { tl: TimelineApi; onClose: () => void }tilesoptions={["off" as const,- // The orbit follows the cursor under auto focus, and a hidden cursor drives- // nothing: not offered then, rather than a camera that silently holds still.- // Under manual focus the focus point poses it, cursor or not. Still listed- // once picked, so the row can show it.- ...(settings.cursorShow ||+ // The orbit follows the cursor under auto focus, so it needs one the compositor+ // can read: a recording made with the system cursor writes no cursor file, and+ // a hidden cursor drives nothing. Not offered then, rather than a camera that+ // silently holds still. Under manual focus the focus point poses it, cursor or+ // not. Still listed once picked, so the row can show it.+ ...((zoomHasCursor && settings.cursorShow) ||(!autoFocusAll && (region.focusMode ?? "manual") === "manual") ||region.rotationPreset === "orbit"? MOVING_ROTATION_3D_PRESETS