feat(timeline): 支持拖拽调整时长与运镜/轨迹关键帧时间

This commit is contained in:
tongtong committed 2026-09-17 17:30:22 +08:00
1 parent bab92c05b8
commit 8d67f17a84
21 files changed
+2556 -194

No files matched your search

+653 -78
View File
@@ -1,4 +1,5 @@
import { useEffect, useMemo, useRef, useState } from "react";
import { createPortal } from "react-dom";
import type {
CSSProperties,
KeyboardEvent as ReactKeyboardEvent,
@@ -9,6 +10,7 @@ import {
Camera,
ChevronDown,
ChevronRight,
ChevronUp,
DiamondPlus,
Eraser,
Film,
@@ -17,16 +19,38 @@ import {
PersonStanding,
Play,
RefreshCw,
Settings2,
SkipBack,
SkipForward,
Square,
Trash2,
Video,
X,
type LucideIcon,
} from "lucide-react";
import type { CameraKeyframeValue, KeyframeTransformValue } from "../schema/timeline";
import {
CAMERA_KEYFRAME_MIN_GAP,
DEFAULT_TIMELINE_FPS,
MAX_TIMELINE_DURATION,
MAX_TIMELINE_FPS,
MIN_TIMELINE_DURATION,
MIN_TIMELINE_FPS,
TIMELINE_DURATION_STEP,
getCameraClipSpan,
moveCameraKeyframeTime,
normalizeTimelineDuration,
normalizeTimelineFps,
scaleCameraKeyframeTimes,
type CameraKeyframeValue,
type KeyframeTransformValue,
} from "../schema/timeline";
import type { MotionKind } from "../schema/directorProject";
import { getTrajectoryPointTime } from "../schema/trajectoryMotion";
import {
getTrajectoryPointTimes,
getTrajectoryStartTime,
moveTrajectoryPointTime,
scaleTrajectoryPointTimes,
} from "../schema/trajectoryMotion";
import { useDirectorStore } from "../store/directorStore";
import { usePlaybackStore } from "../runtime/playbackStore";
import { exportVideo, type VideoExportView } from "../io/videoExport";
@@ -37,6 +61,15 @@ interface SelectedKeyframe {
keyframeId: string;
}
/**
* 时间滑块手势的数据主人:
* - trajectory:人物轨迹(拖单个点走 updateTrajectoryPoint,按点 id 定位)
* - camera:运镜片段(拖把手 / 拖关键帧都整条覆盖时间,按索引对应)
*/
type TimelineTimeDragOwner =
| { kind: "trajectory"; objectId: string; pointId: string }
| { kind: "camera"; cameraId: string };
function formatTime(t: number) {
return `${t.toFixed(1)}s`;
}
@@ -56,13 +89,22 @@ export const TIMELINE_RULER_MINOR_STEP = 0.1;
/** 细刻度数量上限:再密就糊成一条色带、没有读数意义,此时干脆不画 */
const TIMELINE_RULER_MINOR_MAX_COUNT = 200;
/** 时间轴帧率:读数里的帧号按它换算,与视频导出帧率保持一致 */
export const TIMELINE_FPS = 30;
/** 把秒换算成帧号(四舍五入到最近的一帧) */
export function getTimelineFrame(time: number): number {
/** 把秒换算成帧号(四舍五入到最近的一帧);帧率来自工程设置,默认 30fps */
export function getTimelineFrame(time: number, fps: number = DEFAULT_TIMELINE_FPS): number {
const safeTime = Number.isFinite(time) ? Math.max(0, time) : 0;
return Math.round(safeTime * TIMELINE_FPS);
const safeFps = Number.isFinite(fps) && fps > 0 ? fps : DEFAULT_TIMELINE_FPS;
return Math.round(safeTime * safeFps);
}
/** 拖动总时长时的灵敏度:横向 25px = 1s,拖起来不会太窜 */
export const TIMELINE_DURATION_DRAG_PIXELS_PER_SECOND = 25;
/**
* 把秒数对齐到 0.1s 刻度。
* 顺带消掉浮点尾巴:5 + 0.1 会得到 5.0999999999999996,直接塞进 number 输入框会显示出这一长串小数。
*/
export function alignTimelineDuration(seconds: number): number {
return Number(seconds.toFixed(2));
}
export interface TimelineRulerTick {
@@ -261,16 +303,21 @@ export function TimelinePanel() {
const addCameraKeyframe = useDirectorStore((state) => state.addCameraKeyframe);
const removeCameraKeyframe = useDirectorStore((state) => state.removeCameraKeyframe);
const updateCameraKeyframeValue = useDirectorStore((state) => state.updateCameraKeyframeValue);
const setCameraKeyframeTimes = useDirectorStore((state) => state.setCameraKeyframeTimes);
const applyCameraKeyframeToShot = useDirectorStore((state) => state.applyCameraKeyframeToShot);
const setTimelineDuration = useDirectorStore((state) => state.setTimelineDuration);
const clearAllKeyframes = useDirectorStore((state) => state.clearAllKeyframes);
const selectedTrajectoryPoint = useDirectorStore((state) => state.selectedTrajectoryPoint);
const selectTrajectoryPoint = useDirectorStore((state) => state.selectTrajectoryPoint);
const removeTrajectoryPoint = useDirectorStore((state) => state.removeTrajectoryPoint);
const updateTrajectoryPoint = useDirectorStore((state) => state.updateTrajectoryPoint);
const setTrajectoryPointTimes = useDirectorStore((state) => state.setTrajectoryPointTimes);
const setTrajectoryClipStart = useDirectorStore((state) => state.setTrajectoryClipStart);
const timelineTrackOrder = useDirectorStore((state) => state.timelineTrackOrder);
const timelineCollapsedTracks = useDirectorStore((state) => state.timelineCollapsedTracks);
const setTimelineTrackOrder = useDirectorStore((state) => state.setTimelineTrackOrder);
const toggleTimelineTrackCollapsed = useDirectorStore((state) => state.toggleTimelineTrackCollapsed);
const setTimelinePlaybackSettings = useDirectorStore((state) => state.setTimelinePlaybackSettings);
const isPlaying = usePlaybackStore((state) => state.isPlaying);
const playhead = usePlaybackStore((state) => state.playhead);
@@ -280,9 +327,22 @@ export function TimelinePanel() {
const setPlaying = usePlaybackStore((state) => state.setPlaying);
const setPlayhead = usePlaybackStore((state) => state.setPlayhead);
// 帧率 / 循环来自工程设置(旧工程在 store 迁移时补默认值)
const fps = project.timeline.fps ?? DEFAULT_TIMELINE_FPS;
const loop = project.timeline.loop === true;
// 时长编辑以工程里的值为准:playbackStore 那份是给播放用的副本,靠帧驱动同步、会慢一拍,
// 连续拖 / 连续点微调按钮时会把上一次的结果吞掉。
const editableDuration = project.timeline.duration ?? duration;
const [selectedKeyframe, setSelectedKeyframe] = useState<SelectedKeyframe | null>(null);
const [isRecording, setIsRecording] = useState(false);
const [exportMenuOpen, setExportMenuOpen] = useState(false);
// 设置弹窗:fps / loop 先放草稿里改,点「完成」才写回工程(不点则原样丢弃)
const [settingsOpen, setSettingsOpen] = useState(false);
const [draftFps, setDraftFps] = useState(fps);
const [draftLoop, setDraftLoop] = useState(loop);
/** 拖动总时长:按下时记一次起始时长与指针位置,移动中只做线性换算 */
const durationDragRef = useRef<{ pointerId: number; startClientX: number; startDuration: number } | null>(null);
// 轨道拖拽:生命周期(谁在拖 → 高亮 / 毛玻璃降级)走 React state,一次拖拽只重渲染两次;
// 高频的落点线则完全不经过 React(ref + transform),详见 getTrackDragProps。
const [draggingTrackKey, setDraggingTrackKey] = useState<string | null>(null);
@@ -296,6 +356,23 @@ export function TimelinePanel() {
startX: number;
startY: number;
} | null>(null);
/**
* 正在拖时间滑块(人物轨迹条 / 运镜片段条共用):
* - point:拖单个关键帧,只改这一帧的时间
* - duration:拖条右端把手,整段时长按比例缩放
* - clip:拖条本体,整段左右平移(可以脱离 0s 往后放)
*/
const timeDragRef = useRef<{
pointerId: number;
owner: TimelineTimeDragOwner;
kind: "point" | "duration" | "clip";
index: number;
startTimes: number[];
/** 片段左端在按下时的位置(平移基准) */
startEdge: number;
startClientX: number;
secondsPerPixel: number;
} | null>(null);
/** 拖拽开始时一次性量好的行几何:移动中只查表,绝不在事件里读布局(强制同步布局 = layout thrashing) */
const trackRectsRef = useRef(new Map<string, TrackRowRect>());
const trackLayoutOriginRef = useRef(0);
@@ -355,6 +432,18 @@ export function TimelinePanel() {
};
}, [exportMenuOpen]);
// 设置弹窗:Esc 直接关掉(等同取消,草稿值丢弃)
useEffect(() => {
if (!settingsOpen) return;
function closeSettingsOnEscape(event: KeyboardEvent) {
if (event.key === "Escape") setSettingsOpen(false);
}
document.addEventListener("keydown", closeSettingsOnEscape);
return () => document.removeEventListener("keydown", closeSettingsOnEscape);
}, [settingsOpen]);
const timeline = project.timeline;
// 选中目标解析:物体 or 相机
@@ -431,6 +520,72 @@ export function TimelinePanel() {
selectTrajectoryPoint(objectId, pointId);
}
/** 总时长微调(上下按钮 / 键盘左右键):按 0.1s 刻度走,统一交给 store 夹取 */
function nudgeDuration(offsetSeconds: number) {
setTimelineDuration(normalizeTimelineDuration(alignTimelineDuration(editableDuration + offsetSeconds)));
}
/**
* 总时长拖动把手(「总时长」左边的双向箭头):左右拖动减 / 加总时长。
* 灵敏度固定(25px = 1s)并对齐到 0.1s,避免拖一下跳一大截。
*/
function handleDurationDragMove(event: ReactPointerEvent<HTMLElement>) {
const drag = durationDragRef.current;
if (!drag || drag.pointerId !== event.pointerId) return;
event.preventDefault();
const deltaSeconds = (event.clientX - drag.startClientX) / TIMELINE_DURATION_DRAG_PIXELS_PER_SECOND;
setTimelineDuration(normalizeTimelineDuration(alignTimelineDuration(drag.startDuration + deltaSeconds)));
}
function handleDurationDragEnd(event: ReactPointerEvent<HTMLElement>) {
const drag = durationDragRef.current;
if (!drag || drag.pointerId !== event.pointerId) return;
durationDragRef.current = null;
try {
event.currentTarget.releasePointerCapture(event.pointerId);
} catch {
// jsdom 等环境不支持 pointer capture,忽略后仍能继续拖动
}
}
function getDurationDragProps() {
return {
onPointerDown: (event: ReactPointerEvent<HTMLElement>) => {
if (event.button !== 0) return;
// 这次手势归总时长把手,不要被下面的轨道拖拽抢走
event.stopPropagation();
durationDragRef.current = {
pointerId: event.pointerId,
startClientX: event.clientX,
startDuration: editableDuration,
};
try {
event.currentTarget.setPointerCapture(event.pointerId);
} catch {
// 同上
}
},
onPointerMove: handleDurationDragMove,
onPointerUp: handleDurationDragEnd,
onPointerCancel: handleDurationDragEnd,
};
}
function openSettings() {
// 每次打开都从当前工程值重新生成草稿,避免上次没点「完成」的残留值
setDraftFps(fps);
setDraftLoop(loop);
setSettingsOpen(true);
}
/** 「完成」才保存并应用:帧率 / 循环一次性写回工程,弹窗随之关闭 */
function confirmSettings() {
setTimelinePlaybackSettings({ fps: normalizeTimelineFps(draftFps), loop: draftLoop });
setSettingsOpen(false);
}
function handleClearAll() {
if (timeline.tracks.length === 0 && timeline.cameraTracks.length === 0) return;
if (window.confirm("确定清空所有关键帧吗?此操作可用撤销恢复。")) {
@@ -481,8 +636,8 @@ export function TimelinePanel() {
),
[rulerMinorTicks, rulerTicks]
);
const playheadFrame = getTimelineFrame(playhead);
const totalFrames = getTimelineFrame(duration);
const playheadFrame = getTimelineFrame(playhead, fps);
const totalFrames = getTimelineFrame(duration, fps);
const playheadPercent = duration === 0 ? 0 : Math.min(100, Math.max(0, (playhead / duration) * 100));
const hasKeyframes = timeline.tracks.length > 0 || timeline.cameraTracks.length > 0;
// 相邻刻度间距(百分比)交给 CSS:轨道底色用它画贯穿网格线,与刻度尺天然对齐
@@ -603,6 +758,181 @@ export function TimelinePanel() {
};
}
/** 拖整段时长(条右端把手 / 键盘微调):末帧落到 newEnd,其余关键帧按比例缩放,片段起点固定 */
function scaleClipDuration(
owner: TimelineTimeDragOwner,
times: number[],
startEdge: number,
deltaSeconds: number
) {
const targetEnd = (times[times.length - 1] ?? startEdge) + deltaSeconds;
if (owner.kind === "trajectory") {
setTrajectoryPointTimes(
owner.objectId,
scaleTrajectoryPointTimes(times, targetEnd, duration, startEdge)
);
return;
}
setCameraKeyframeTimes(owner.cameraId, scaleCameraKeyframeTimes(times, targetEnd, duration));
}
/** 拖单个关键帧:只改它自己的时间(被前后邻居夹住) */
function moveClipKeyframe(
owner: TimelineTimeDragOwner,
times: number[],
index: number,
startEdge: number,
deltaSeconds: number
) {
const targetTime = (times[index] ?? 0) + deltaSeconds;
if (owner.kind === "trajectory") {
const nextTimes = moveTrajectoryPointTime(times, index, targetTime, duration, startEdge);
updateTrajectoryPoint(owner.objectId, owner.pointId, { time: nextTimes[index] });
return;
}
setCameraKeyframeTimes(owner.cameraId, moveCameraKeyframeTime(times, index, targetTime, duration));
}
/**
* 拖条本体:整段片段左右平移,可以脱离 0s 往后放(前面那段时间角色原地等待 / 相机保持首帧机位)。
* 先把位移夹住(片段两端都不越出时间轴),再整体平移 —— 片段刚性移动,各关键帧的节奏不变。
*/
function shiftClip(
owner: TimelineTimeDragOwner,
times: number[],
startEdge: number,
deltaSeconds: number
) {
const endEdge = times.length > 0 ? times[times.length - 1] : startEdge;
const minShift = -startEdge;
const maxShift = Math.max(duration - endEdge, minShift);
const shift = Math.min(Math.max(deltaSeconds, minShift), maxShift);
// 顶到头(例如片段已经占满整条时间轴)时什么都不写,避免留下没有变化的一步撤销
if (shift === 0) return;
if (owner.kind === "trajectory") {
setTrajectoryClipStart(owner.objectId, startEdge + shift);
return;
}
setCameraKeyframeTimes(owner.cameraId, times.map((time) => time + shift));
}
/**
* 时间滑块(人物轨迹条 / 运镜片段条同构):拖动关键帧改「这一帧的时间」,
* 拖动条右端把手改「整段时长」(其余帧按比例缩放)。像素 → 秒用轨道宽度换算,宽度只在按下时量一次。
*/
function beginTimeDrag(
event: ReactPointerEvent<HTMLElement>,
owner: TimelineTimeDragOwner,
kind: "point" | "duration" | "clip",
index: number,
times: number[],
startEdge = 0
) {
if (event.button !== 0) return;
if (isTrackDragBlockedTarget(event.target)) return;
const lane = event.currentTarget.closest(".timeline-track-lane");
const laneWidth = lane instanceof HTMLElement ? lane.getBoundingClientRect().width : 0;
if (laneWidth <= 0 || duration <= 0) return;
// 这次手势归时间滑块,轨道行的「拖动排序」不要来抢
event.stopPropagation();
timeDragRef.current = {
pointerId: event.pointerId,
owner,
kind,
index,
startTimes: [...times],
startEdge,
startClientX: event.clientX,
secondsPerPixel: duration / laneWidth,
};
// 拖动时冻结全站毛玻璃:条 / 关键帧每次重绘都会让背后 WebGL 画布重算一次模糊
document.body.classList.add("is-timeline-dragging");
try {
event.currentTarget.setPointerCapture(event.pointerId);
} catch {
// jsdom 等环境不支持 pointer capture,忽略后仍能继续拖动
}
}
function handleTimeDragMove(event: ReactPointerEvent<HTMLElement>) {
const drag = timeDragRef.current;
if (!drag || drag.pointerId !== event.pointerId) return;
event.preventDefault();
event.stopPropagation();
const deltaTime = (event.clientX - drag.startClientX) * drag.secondsPerPixel;
if (drag.kind === "duration") {
scaleClipDuration(drag.owner, drag.startTimes, drag.startEdge, deltaTime);
return;
}
if (drag.kind === "clip") {
shiftClip(drag.owner, drag.startTimes, drag.startEdge, deltaTime);
return;
}
moveClipKeyframe(drag.owner, drag.startTimes, drag.index, drag.startEdge, deltaTime);
}
function handleTimeDragEnd(event: ReactPointerEvent<HTMLElement>) {
const drag = timeDragRef.current;
if (!drag || drag.pointerId !== event.pointerId) return;
timeDragRef.current = null;
document.body.classList.remove("is-timeline-dragging");
try {
event.currentTarget.releasePointerCapture(event.pointerId);
} catch {
// 同上,忽略不支持的环境
}
}
/** 把某个关键帧 / 时长把手 / 条本体接到同一套拖拽手势上 */
function getTimeDragProps(
owner: TimelineTimeDragOwner,
kind: "point" | "duration" | "clip",
index: number,
times: number[],
startEdge = 0
) {
return {
onPointerDown: (event: ReactPointerEvent<HTMLElement>) =>
beginTimeDrag(event, owner, kind, index, times, startEdge),
onPointerMove: handleTimeDragMove,
onPointerUp: handleTimeDragEnd,
onPointerCancel: handleTimeDragEnd,
};
}
/** 时长把手支持键盘微调(左右方向键 ±0.1s,按住 Shift ±0.5s) */
function handleTimeHandleKeyDown(
event: ReactKeyboardEvent<HTMLElement>,
owner: TimelineTimeDragOwner,
times: number[],
startEdge = 0
) {
const step = event.shiftKey ? 0.5 : 0.1;
const delta = event.key === "ArrowLeft" ? -step : event.key === "ArrowRight" ? step : 0;
if (delta === 0 || times.length === 0) return;
event.preventDefault();
scaleClipDuration(owner, times, startEdge, delta);
}
function handleTrackPointerMove(event: ReactPointerEvent<HTMLDivElement>) {
const gesture = dragGestureRef.current;
if (!gesture || gesture.pointerId !== event.pointerId) return;
@@ -767,7 +1097,7 @@ export function TimelinePanel() {
{/* 读数 = 当前帧号 / 当前时间;总时长单独放在右边的时长输入框里 */}
<span
className="timeline-time-readout"
title={`当前第 ${playheadFrame} 帧 / 共 ${totalFrames} 帧(${TIMELINE_FPS}fps)`}
title={`当前第 ${playheadFrame} 帧 / 共 ${totalFrames} 帧(${fps}fps)`}
>
<span className="timeline-time-readout-frame">F{playheadFrame}</span>
<span className="timeline-time-readout-divider" aria-hidden="true">
@@ -775,20 +1105,63 @@ export function TimelinePanel() {
</span>
<span className="timeline-time-readout-clock">{formatReadoutTime(playhead)}</span>
</span>
<label className="timeline-duration-chip" title="时间轴总时长(秒)">
<MoveHorizontal aria-hidden="true" size={14} strokeWidth={1.8} />
<div className="timeline-duration-chip" title="时间轴总时长(秒):左右拖动箭头调整,或用上下按钮 ±0.1s">
{/* 拖动把手:按住左右拖动即可减 / 加总时长(也可以聚焦后用左右方向键) */}
<span
className="timeline-duration-drag-handle"
role="slider"
tabIndex={0}
aria-label="拖动调整总时长"
aria-valuemin={MIN_TIMELINE_DURATION}
aria-valuemax={MAX_TIMELINE_DURATION}
aria-valuenow={Number(editableDuration.toFixed(2))}
aria-valuetext={formatTime(editableDuration)}
title="按住左右拖动调整总时长(← / → 每次 0.1s)"
onKeyDown={(event) => {
const delta =
event.key === "ArrowLeft" ? -TIMELINE_DURATION_STEP : event.key === "ArrowRight" ? TIMELINE_DURATION_STEP : 0;
if (delta === 0) return;
event.preventDefault();
nudgeDuration(delta);
}}
{...getDurationDragProps()}
>
<MoveHorizontal aria-hidden="true" size={14} strokeWidth={1.8} />
</span>
<span className="timeline-duration-caption">总时长</span>
<input
className="timeline-duration-input"
aria-label="时间轴总时长"
type="number"
min={0.1}
step={0.5}
value={duration}
min={MIN_TIMELINE_DURATION}
max={MAX_TIMELINE_DURATION}
step={TIMELINE_DURATION_STEP}
value={editableDuration}
onChange={(event) => setTimelineDuration(Number(event.target.value))}
/>
<span aria-hidden="true">s</span>
</label>
{/* 上下微调:以 0.1s 为刻度增减总时长 */}
<span className="timeline-duration-spinner">
<button
className="timeline-duration-spinner-button"
type="button"
aria-label={`总时长增加 ${TIMELINE_DURATION_STEP}s`}
title={`+${TIMELINE_DURATION_STEP}s`}
onClick={() => nudgeDuration(TIMELINE_DURATION_STEP)}
>
<ChevronUp aria-hidden="true" size={12} strokeWidth={2.2} />
</button>
<button
className="timeline-duration-spinner-button"
type="button"
aria-label={`总时长减少 ${TIMELINE_DURATION_STEP}s`}
title={`-${TIMELINE_DURATION_STEP}s`}
onClick={() => nudgeDuration(-TIMELINE_DURATION_STEP)}
>
<ChevronDown aria-hidden="true" size={12} strokeWidth={2.2} />
</button>
</span>
</div>
</div>
<div className="timeline-toolbar-group timeline-toolbar-center">
@@ -862,6 +1235,18 @@ export function TimelinePanel() {
</div>
<div className="timeline-toolbar-group timeline-toolbar-end">
<button
className="timeline-icon-button"
type="button"
aria-haspopup="dialog"
aria-expanded={settingsOpen}
aria-label="时间轴设置"
title="时间轴设置:每秒帧数 / 播放循环"
onClick={openSettings}
>
<Settings2 aria-hidden="true" size={15} strokeWidth={1.8} />
</button>
{hasKeyframes ? (
<button className="timeline-action-button" type="button" onClick={handleClearAll}>
<Eraser aria-hidden="true" size={14} strokeWidth={1.8} />
@@ -1022,6 +1407,15 @@ export function TimelinePanel() {
const trackKey = getTimelineTrackKey("camera", track.cameraId);
const collapsed = timelineCollapsedTracks.includes(trackKey);
const dragProps = getTrackDragProps(trackKey);
// 运镜片段:第一个关键帧 → 最后一个关键帧,这段区间就是「这一段运镜」的时长
const cameraTimes = track.keyframes.map((keyframe) => keyframe.time);
const clipSpan = getCameraClipSpan(track.keyframes);
const clipStart = clipSpan?.start ?? 0;
const clipEnd = clipSpan?.end ?? 0;
const clipDuration = clipEnd - clipStart;
const clipLeftPercent = duration > 0 ? (clipStart / duration) * 100 : 0;
const clipWidthPercent = duration > 0 ? (clipDuration / duration) * 100 : 0;
const clipOwner: TimelineTimeDragOwner = { kind: "camera", cameraId: track.cameraId };
return (
<div
@@ -1043,37 +1437,79 @@ export function TimelinePanel() {
{collapsed ? (
<span className="timeline-track-summary">{track.keyframes.length} 个运镜关键帧</span>
) : (
track.keyframes.map((kf) => {
const leftPercent = duration === 0 ? 0 : (kf.time / duration) * 100;
const isSelected =
selectedKeyframe?.kind === "camera" &&
selectedKeyframe.targetId === track.cameraId &&
selectedKeyframe.keyframeId === kf.id;
return (
<>
{/* 运镜片段条:拖条本体可整段左右平移(前面那段时间相机保持首帧机位),
拖右端把手整体缩放这段运镜的时长;只有一个关键帧时没有「运镜过程」,不画条。 */}
{cameraTimes.length >= 2 && duration > 0 ? (
<div
key={kf.id}
className={`timeline-keyframe timeline-keyframe-camera${isSelected ? " is-selected" : ""}`}
style={{ left: `${leftPercent}%` }}
role="button"
tabIndex={0}
aria-label={`运镜关键帧 ${formatTime(kf.time)}`}
onClick={() => handleSelectCameraKeyframe(track.cameraId, kf.id, kf.time, kf.value)}
className="timeline-trajectory-bar timeline-clip-bar-camera"
style={{ left: `${clipLeftPercent}%`, width: `${clipWidthPercent}%` }}
title={`运镜片段 ${formatTime(clipStart)} → ${formatTime(
clipEnd
)}(时长 ${formatTime(clipDuration)}):拖动条本体整段平移,拖动右端把手改时长`}
{...getTimeDragProps(clipOwner, "clip", 0, cameraTimes, clipStart)}
>
<span className="timeline-keyframe-dot" aria-hidden="true" />
<button
type="button"
className="timeline-keyframe-delete"
aria-label={`删除运镜关键帧 ${formatTime(kf.time)}`}
onClick={(event) => {
event.stopPropagation();
removeCameraKeyframe(track.cameraId, kf.id);
}}
>
×
</button>
<span className="timeline-trajectory-bar-label">{formatTime(clipDuration)}</span>
<span
className="timeline-trajectory-handle"
role="slider"
tabIndex={0}
aria-label={`${trackName} 运镜时长`}
aria-valuemin={Math.min(clipStart + CAMERA_KEYFRAME_MIN_GAP, clipEnd)}
aria-valuemax={Math.max(duration, clipEnd)}
aria-valuenow={Number(clipEnd.toFixed(2))}
aria-valuetext={`${formatTime(clipDuration)},结束于 ${formatTime(clipEnd)}`}
title="拖动整体缩放这段运镜的时长(第一个运镜关键帧固定不动),或用左右方向键微调"
onKeyDown={(event) =>
handleTimeHandleKeyDown(event, clipOwner, cameraTimes, clipStart)
}
{...getTimeDragProps(
clipOwner,
"duration",
cameraTimes.length - 1,
cameraTimes,
clipStart
)}
/>
</div>
);
})
) : null}
{track.keyframes.map((kf, index) => {
const leftPercent = duration === 0 ? 0 : (kf.time / duration) * 100;
const isSelected =
selectedKeyframe?.kind === "camera" &&
selectedKeyframe.targetId === track.cameraId &&
selectedKeyframe.keyframeId === kf.id;
return (
<div
key={kf.id}
className={`timeline-keyframe timeline-keyframe-camera${
isSelected ? " is-selected" : ""
}`}
style={{ left: `${leftPercent}%` }}
role="button"
tabIndex={0}
aria-label={`运镜关键帧 ${formatTime(kf.time)}`}
title={`运镜关键帧 · ${formatTime(kf.time)}(左右拖动调整时间)`}
onClick={() => handleSelectCameraKeyframe(track.cameraId, kf.id, kf.time, kf.value)}
{...getTimeDragProps(clipOwner, "point", index, cameraTimes)}
>
<span className="timeline-keyframe-dot" aria-hidden="true" />
<button
type="button"
className="timeline-keyframe-delete"
aria-label={`删除运镜关键帧 ${formatTime(kf.time)}`}
onClick={(event) => {
event.stopPropagation();
removeCameraKeyframe(track.cameraId, kf.id);
}}
>
×
</button>
</div>
);
})}
</>
)}
</div>
</div>
@@ -1091,6 +1527,20 @@ export function TimelinePanel() {
const trackKey = getTimelineTrackKey("character", character.id);
const collapsed = timelineCollapsedTracks.includes(trackKey);
const dragProps = getTrackDragProps(trackKey);
// 轨迹片段的起点(拖条本体可整段平移,0 表示从 0s 就走)与每个轨迹点的关键帧时间
const trajectoryStart = getTrajectoryStartTime(character, duration);
const trajectoryTimes = getTrajectoryPointTimes(trajectoryPoints, duration, trajectoryStart);
const trajectoryEndTime =
trajectoryTimes.length > 0 ? trajectoryTimes[trajectoryTimes.length - 1] : trajectoryStart;
const trajectoryLeftPercent = duration > 0 ? (trajectoryStart / duration) * 100 : 0;
const trajectoryWidthPercent =
duration > 0 ? Math.min(100, ((trajectoryEndTime - trajectoryStart) / duration) * 100) : 0;
// 条右端把手 / 键盘微调改的是「整段轨迹时长」,不针对某个点,pointId 留空
const trajectoryOwner: TimelineTimeDragOwner = {
kind: "trajectory",
objectId: character.id,
pointId: "",
};
return (
<div
@@ -1133,46 +1583,98 @@ export function TimelinePanel() {
</div>
</div>
{/* 人物轨迹:轨迹点即关键帧,0s 从角色起始位置出发,末点落在时间轴结束时刻 */}
{/* 人物轨迹:一条「轨迹条」= 角色从起点走到最后一个轨迹点所需的时长。
条本体可左右拖动整段平移(脱离 0s,前面那段时间角色原地等待),
右端把手拖动改整段时长,条上的关键帧可单独拖动改时间 */}
<div
className="timeline-subtrack"
title="人物轨迹:轨迹点即关键帧,0s 从角色起始位置出发,最后一个轨迹点落在时间轴结束时刻"
title="人物轨迹:拖动条本体可整段左右平移(起点之前角色原地等待);拖动右端把手调整整段时长;拖动关键帧调整该点时间"
>
<div className="timeline-subtrack-label">轨迹</div>
<div className="timeline-track-lane">
{trajectoryPoints.map((point, index) => {
const pointTime = getTrajectoryPointTime(index, trajectoryPoints.length, duration);
const leftPercent = duration === 0 ? 0 : (pointTime / duration) * 100;
const isSelected =
selectedTrajectoryPoint?.objectId === character.id &&
selectedTrajectoryPoint.pointId === point.id;
return (
<div className="timeline-track-lane timeline-trajectory-lane">
{trajectoryTimes.length > 0 && duration > 0 ? (
<>
<div
key={point.id}
className={`timeline-keyframe timeline-keyframe-trajectory${isSelected ? " is-selected" : ""}`}
style={{ left: `${leftPercent}%` }}
role="button"
tabIndex={0}
aria-label={`轨迹关键帧 ${formatTime(pointTime)}`}
title={`第 ${index + 1} 个轨迹点 · ${formatTime(pointTime)}`}
onClick={() => handleSelectTrajectoryKeyframe(character.id, point.id, pointTime)}
className="timeline-trajectory-bar"
style={{ left: `${trajectoryLeftPercent}%`, width: `${trajectoryWidthPercent}%` }}
title={`轨迹片段 ${formatTime(trajectoryStart)} → ${formatTime(
trajectoryEndTime
)}(时长 ${formatTime(trajectoryEndTime - trajectoryStart)}):拖动条本体整段平移,拖动右端把手改时长`}
{...getTimeDragProps(
trajectoryOwner,
"clip",
0,
trajectoryTimes,
trajectoryStart
)}
>
<span className="timeline-keyframe-dot" aria-hidden="true" />
<button
type="button"
className="timeline-keyframe-delete"
aria-label={`删除轨迹关键帧 ${formatTime(pointTime)}`}
onClick={(event) => {
event.stopPropagation();
removeTrajectoryPoint(character.id, point.id);
}}
>
×
</button>
<span className="timeline-trajectory-bar-label">{formatTime(trajectoryEndTime)}</span>
<span
className="timeline-trajectory-handle"
role="slider"
tabIndex={0}
aria-label={`${character.name} 轨迹时长`}
aria-valuemin={0}
aria-valuemax={duration}
aria-valuenow={Number(trajectoryEndTime.toFixed(2))}
aria-valuetext={formatTime(trajectoryEndTime)}
title="拖动调整轨迹时长(所有轨迹点按比例缩放),或用左右方向键微调"
onKeyDown={(event) =>
handleTimeHandleKeyDown(event, trajectoryOwner, trajectoryTimes, trajectoryStart)
}
{...getTimeDragProps(
trajectoryOwner,
"duration",
trajectoryTimes.length - 1,
trajectoryTimes,
trajectoryStart
)}
/>
</div>
);
})}
{trajectoryPoints.map((point, index) => {
const pointTime = trajectoryTimes[index] ?? 0;
const leftPercent = duration === 0 ? 0 : (pointTime / duration) * 100;
const isSelected =
selectedTrajectoryPoint?.objectId === character.id &&
selectedTrajectoryPoint.pointId === point.id;
return (
<div
key={point.id}
className={`timeline-keyframe timeline-keyframe-trajectory${
isSelected ? " is-selected" : ""
}`}
style={{ left: `${leftPercent}%` }}
role="button"
tabIndex={0}
aria-label={`轨迹关键帧 ${formatTime(pointTime)}`}
title={`第 ${index + 1} 个轨迹点 · ${formatTime(pointTime)}(左右拖动调整时间)`}
onClick={() => handleSelectTrajectoryKeyframe(character.id, point.id, pointTime)}
{...getTimeDragProps(
{ kind: "trajectory", objectId: character.id, pointId: point.id },
"point",
index,
trajectoryTimes
)}
>
<span className="timeline-keyframe-dot" aria-hidden="true" />
<button
type="button"
className="timeline-keyframe-delete"
aria-label={`删除轨迹关键帧 ${formatTime(pointTime)}`}
onClick={(event) => {
event.stopPropagation();
removeTrajectoryPoint(character.id, point.id);
}}
>
×
</button>
</div>
);
})}
</>
) : null}
</div>
</div>
</>
@@ -1192,6 +1694,79 @@ export function TimelinePanel() {
</div>
</div>
</div>
{/* 时间轴设置:帧率 / 循环先改草稿,点「完成」才写回工程并生效。
用 portal 挂到 body:时间轴面板带 backdrop-filter,会成为 fixed 元素的包含块,
直接挂在面板里会被缩在面板内并被裁掉。 */}
{settingsOpen && typeof document !== "undefined"
? createPortal(
<div
className="timeline-settings-overlay"
data-testid="timeline-settings-overlay"
onClick={() => setSettingsOpen(false)}
>
<div
className="timeline-settings-dialog"
role="dialog"
aria-modal="true"
aria-label="时间轴设置"
onClick={(event) => event.stopPropagation()}
>
<div className="timeline-settings-head">
<h3 className="timeline-settings-title">时间轴设置</h3>
{/* 右上角关闭按钮:等同取消,草稿值不写回工程 */}
<button
className="timeline-settings-close"
type="button"
aria-label="关闭设置"
title="关闭(不保存设置)"
onClick={() => setSettingsOpen(false)}
>
<X aria-hidden="true" size={14} strokeWidth={2} />
</button>
</div>
<label className="timeline-settings-field">
<span className="timeline-settings-field-label">每秒帧数</span>
<span className="timeline-settings-field-control">
<input
className="timeline-settings-input"
aria-label="每秒帧数"
type="number"
min={MIN_TIMELINE_FPS}
max={MAX_TIMELINE_FPS}
step={1}
value={draftFps}
onChange={(event) => setDraftFps(Number(event.target.value))}
/>
<span className="timeline-settings-unit">fps</span>
</span>
</label>
<label className="timeline-settings-toggle">
<input
type="checkbox"
aria-label="播放循环"
checked={draftLoop}
onChange={(event) => setDraftLoop(event.target.checked)}
/>
<span>播放循环(播到末尾自动回到起点接着播)</span>
</label>
<p className="timeline-settings-hint">
帧率决定时间读数与导出视频的帧数;点「完成」后才保存并应用。
</p>
<div className="timeline-settings-actions">
<button className="timeline-settings-confirm" type="button" onClick={confirmSettings}>
完成
</button>
</div>
</div>
</div>,
document.body
)
: null}
</section>
);
}