Skip to content

πŸŽ₯ Make videos programmatically with React

`remotion`: Prototype `<Track>` for single-row Studio timelines

Jonny Burgerf7f123a88460
diff --git a/packages/core/src/CompositionManager.tsx b/packages/core/src/CompositionManager.tsx
index ac7361ddf7..464495026c 100644
--- a/packages/core/src/CompositionManager.tsx
+++ b/packages/core/src/CompositionManager.tsx
@@ -10,6 +10,7 @@ import type {
RuntimeValueSnapshot,
RuntimeValueStore,
} from './runtime-value-store.js';
+import type {TimelineTrackItem} from './Track.js';
import type {VideoConfigValues} from './video-config.js';
export type TComposition<
@@ -134,6 +135,7 @@ export type TSequence = {
parent: string | null;
showInTimeline: boolean;
timelineOrder: number | null;
+ timelineTrack?: TimelineTrackItem;
loopDisplay: LoopDisplay | undefined;
getStack: () => string | null;
premountDisplay: number | null;
diff --git a/packages/core/src/Sequence.tsx b/packages/core/src/Sequence.tsx
index f765b03dfc..aaa2cfefc2 100644
--- a/packages/core/src/Sequence.tsx
+++ b/packages/core/src/Sequence.tsx
@@ -43,6 +43,7 @@ import {SequenceContext} from './SequenceContext.js';
import {SequenceRegistrationContext} from './SequenceManager.js';
import {IsInsideSeriesContext} from './series/is-inside-series.js';
import {useTimelinePosition} from './timeline-position-state.js';
+import {TimelineTrackContext, type TimelineTrackItem} from './Track.js';
import type {BasicMediaInTimelineReturnType} from './use-media-in-timeline.js';
import {usePremounting} from './use-premounting.js';
import {useRemotionEnvironment} from './use-remotion-environment.js';
@@ -91,6 +92,13 @@ export type SequencePropsWithoutDuration = {
readonly hidden?: boolean;
readonly controls?: SequenceControls;
readonly _remotionInternalEffects?: readonly EffectDefinition<unknown>[];
+ /**
+ * @deprecated For internal use only.
+ */
+ readonly _remotionInternalTimelineTrack?: Pick<
+ TimelineTrackItem,
+ 'role' | 'anchor'
+ >;
/**
* @deprecated For internal use only.
*/
@@ -165,6 +173,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
hidden = false,
controls,
_remotionInternalEffects,
+ _remotionInternalTimelineTrack: timelineTrackItem,
_remotionInternalLoopDisplay: loopDisplay,
_remotionInternalStack: stack,
_remotionInternalDocumentationLink: documentationLink,
@@ -185,6 +194,9 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
const [id] = useState(() => String(Math.random()));
const parentSequence = useContext(SequenceContext);
+ const timelineTrack = useContext(TimelineTrackContext);
+ const timelineTrackRole =
+ timelineTrackItem?.role ?? (showInTimeline ? 'clip' : 'container');
const parentPlaybackRate = parentSequence?.playbackRate ?? 1;
const cumulativePlaybackRate = parentPlaybackRate * playbackRate;
const cumulatedFrom = parentSequence
@@ -596,9 +608,19 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
]);
const getSequenceForRegistration = useCallback((): TSequence => {
+ const trackRegistration = timelineTrack
+ ? {
+ timelineTrack: {
+ ...timelineTrack,
+ role: timelineTrackRole,
+ anchor: timelineTrackItem?.anchor ?? null,
+ },
+ }
+ : {};
if (isMedia) {
if (isMedia.type === 'image') {
return {
+ ...trackRegistration,
sequencePlaybackRate: playbackRate,
type: 'image',
controls: registrationControls,
@@ -626,6 +648,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
}
return {
+ ...trackRegistration,
type: isMedia.type,
sequencePlaybackRate: playbackRate,
controls: registrationControls,
@@ -660,6 +683,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
}
return {
+ ...trackRegistration,
from,
sequencePlaybackRate: playbackRate,
trimBefore: registeredTrimBefore,
@@ -685,6 +709,9 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
};
}, [
id,
+ timelineTrack,
+ timelineTrackRole,
+ timelineTrackItem?.anchor,
timelineClipName,
playbackRate,
parentSequence?.id,
@@ -799,7 +826,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
) : null;
}
- const sequence = (
+ const sequenceContent = (
<SequenceContext.Provider value={contextValue}>
{loopedContent === null ? null : other.layout === 'none' ? (
loopedContent
@@ -814,6 +841,14 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
)}
</SequenceContext.Provider>
);
+ const sequence =
+ timelineTrack === null || timelineTrackRole === 'container' ? (
+ sequenceContent
+ ) : (
+ <TimelineTrackContext.Provider value={null}>
+ {sequenceContent}
+ </TimelineTrackContext.Provider>
+ );
return shouldDiscoverOutline ? (
<SequenceOrderMarker
diff --git a/packages/core/src/Track.tsx b/packages/core/src/Track.tsx
new file mode 100644
index 0000000000..edc585d6a1
--- /dev/null
+++ b/packages/core/src/Track.tsx
@@ -0,0 +1,31 @@
+import React, {createContext, useMemo, useState} from 'react';
+
+export type TimelineTrack = {
+ readonly id: string;
+ readonly name: string;
+};
+
+export type TimelineTrackItem = TimelineTrack & {
+ readonly role: 'clip' | 'container' | 'transition' | 'overlay';
+ /** Position in the containing sequence's clock, used for overlay markers. */
+ readonly anchor: number | null;
+};
+
+export const TimelineTrackContext = createContext<TimelineTrack | null>(null);
+
+export type TrackProps = {
+ readonly name: string;
+ readonly children: React.ReactNode;
+};
+
+/** Groups clips on one Studio timeline row without changing their rendering. */
+export const Track: React.FC<TrackProps> = ({name, children}) => {
+ const [id] = useState(() => String(Math.random()));
+ const value = useMemo(() => ({id, name}), [id, name]);
+
+ return (
+ <TimelineTrackContext.Provider value={value}>
+ {children}
+ </TimelineTrackContext.Provider>
+ );
+};
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 85de6a2000..dcf268ed9f 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -249,6 +249,7 @@ export * from './spring/index.js';
export {staticFile} from './static-file.js';
export * from './Still.js';
export type {PlayableMediaTag} from './timeline-position-state.js';
+export {Track, type TrackProps} from './Track.js';
export {useBufferState} from './use-buffer-state';
export {useCurrentFrame} from './use-current-frame.js';
export {
diff --git a/packages/core/src/internals.ts b/packages/core/src/internals.ts
index 8d1c05c949..7f7449fad1 100644
--- a/packages/core/src/internals.ts
+++ b/packages/core/src/internals.ts
@@ -225,6 +225,7 @@ import {
type SetTimelineContextValue,
type TimelineContextValue,
} from './TimelineContext.js';
+import {TimelineTrackContext} from './Track.js';
import {truthy} from './truthy.js';
import {useBuffering} from './use-buffering.js';
import {useCropStyle} from './use-crop-style.js';
@@ -383,6 +384,7 @@ export const Internals = {
useLazyComponent,
truthy,
SequenceContext,
+ TimelineTrackContext,
PremountContext,
usePremounting,
resolveSequenceDuration,
diff --git a/packages/core/src/series/index.tsx b/packages/core/src/series/index.tsx
index 31445dfb7c..e16541e9b1 100644
--- a/packages/core/src/series/index.tsx
+++ b/packages/core/src/series/index.tsx
@@ -262,6 +262,7 @@ const SeriesInner: FC<SeriesProps> = (props) => {
name="<Series>"
_remotionInternalDocumentationLink="https://www.remotion.dev/docs/series"
{...props}
+ _remotionInternalTimelineTrack={{role: 'container', anchor: null}}
>
<IsInsideSeriesContainer>{childrenValue}</IsInsideSeriesContainer>
</Sequence>
diff --git a/packages/core/src/use-media-in-timeline.ts b/packages/core/src/use-media-in-timeline.ts
index 744f3e9339..ce8b148965 100644
--- a/packages/core/src/use-media-in-timeline.ts
+++ b/packages/core/src/use-media-in-timeline.ts
@@ -14,6 +14,7 @@ import {
} from './sequence-outline.js';
import {SequenceContext} from './SequenceContext.js';
import {SequenceRegistrationContext} from './SequenceManager.js';
+import {TimelineTrackContext} from './Track.js';
import {useRemotionEnvironment} from './use-remotion-environment.js';
import {useSequenceRegistration} from './use-sequence-registration.js';
import {useVideoConfig} from './use-video-config.js';
@@ -169,6 +170,7 @@ export const useMediaInTimeline = ({
muted: boolean;
}) => {
const parentSequence = useContext(SequenceContext);
+ const timelineTrack = useContext(TimelineTrackContext);
const mediaTrimBefore = useContext(Html5MediaTrimContext);
const sequenceRegistrationEnabled = useContext(SequenceRegistrationContext);
const {durationInFrames} = useVideoConfig();
@@ -274,6 +276,15 @@ export const useMediaInTimeline = ({
return {
effectRuntimeValues: null,
+ ...(timelineTrack
+ ? {
+ timelineTrack: {
+ ...timelineTrack,
+ role: 'clip' as const,
+ anchor: null,
+ },
+ }
+ : {}),
type: mediaType,
src,
id,
@@ -306,6 +317,7 @@ export const useMediaInTimeline = ({
}, [
duration,
id,
+ timelineTrack,
parentSequence,
src,
volumes,
diff --git a/packages/example/src/Root.tsx b/packages/example/src/Root.tsx
index baa666cf6e..cd8ddde677 100644
--- a/packages/example/src/Root.tsx
+++ b/packages/example/src/Root.tsx
@@ -307,6 +307,7 @@ import {TikTokTextBoxPlayground} from './TikTokTextbox/TikTokTextBox';
import {TimelineNegativeFromResize} from './TimelineNegativeFromResize';
import {FitTextOnNLines, fitTextOnNLinesSchema} from './Title/FitTextOnNLines';
import {Issue7359FitTextOnNLines} from './Title/Issue7359FitTextOnNLines';
+import {TrackPrototype} from './TrackPrototype';
import {TransitionRounding} from './TransitionRounding';
import {WebGlTransition} from './Transitions/WebGlTransition';
import {
@@ -3027,6 +3028,14 @@ export const Index: React.FC = () => {
/>
</Folder>
<Folder name="video-editing">
+ <Composition
+ id="track-prototype"
+ component={TrackPrototype}
+ width={1280}
+ height={720}
+ fps={30}
+ durationInFrames={240}
+ />
<Composition
id="hour-long-timeline"
component={HourLongTimelineTestbed}
diff --git a/packages/example/src/TrackPrototype.tsx b/packages/example/src/TrackPrototype.tsx
new file mode 100644
index 0000000000..20dfd0c6d1
--- /dev/null
+++ b/packages/example/src/TrackPrototype.tsx
@@ -0,0 +1,263 @@
+import {linearTiming, TransitionSeries} from '@remotion/transitions';
+import {fade} from '@remotion/transitions/fade';
+import React from 'react';
+import {
+ interpolate,
+ Sequence,
+ Series,
+ Track,
+ useCurrentFrame,
+ useVideoConfig,
+} from 'remotion';
+
+const DemoCard: React.FC<{
+ readonly title: string;
+ readonly description: string;
+ readonly children: React.ReactNode;
+}> = ({title, description, children}) => {
+ return (
+ <div>
+ <div style={{fontSize: 21, fontWeight: 600, marginBottom: 5}}>
+ {title}
+ </div>
+ <div style={{fontSize: 15, color: '#a7b0c0', marginBottom: 12}}>
+ {description}
+ </div>
+ <div
+ style={{
+ position: 'relative',
+ height: 128,
+ overflow: 'hidden',
+ borderRadius: 12,
+ backgroundColor: '#202936',
+ }}
+ >
+ {children}
+ </div>
+ </div>
+ );
+};
+
+const Scene: React.FC<{
+ readonly color: string;
+ readonly children: React.ReactNode;
+}> = ({color, children}) => {
+ return (
+ <div
+ style={{
+ position: 'absolute',
+ inset: 0,
+ backgroundColor: color,
+ display: 'flex',
+ alignItems: 'center',
+ justifyContent: 'center',
+ fontSize: 34,
+ fontWeight: 600,
+ }}
+ >
+ {children}
+ </div>
+ );
+};
+
+const Flash: React.FC = () => {
+ const frame = useCurrentFrame();
+ const {durationInFrames} = useVideoConfig();
+
+ return (
+ <div
+ style={{
+ position: 'absolute',
+ inset: 0,
+ backgroundColor: '#fff2b8',
+ opacity: interpolate(
+ frame,
+ [0, durationInFrames / 2, durationInFrames],
+ [0, 0.95, 0],
+ {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'},
+ ),
+ }}
+ />
+ );
+};
+
+export const TrackPrototype: React.FC = () => {
+ const frame = useCurrentFrame();
+
+ return (
+ <div
+ style={{
+ position: 'absolute',
+ inset: 0,
+ backgroundColor: '#101720',
+ color: 'white',
+ fontFamily: 'Arial, sans-serif',
+ padding: 48,
+ }}
+ >
+ <div style={{display: 'flex', justifyContent: 'space-between'}}>
+ <div style={{fontSize: 36, fontWeight: 700}}>Track prototype</div>
+ <div
+ style={{
+ fontSize: 22,
+ color: '#a7b0c0',
+ fontVariantNumeric: 'tabular-nums',
+ }}
+ >
+ Frame {frame} / 239
+ </div>
+ </div>
+ <div style={{fontSize: 18, color: '#a7b0c0', marginTop: 8}}>
+ Five named tracks. Each occupies one timeline row.
+ </div>
+ <div
+ style={{
+ display: 'grid',
+ gridTemplateColumns: '1fr 1fr',
+ gap: '28px 32px',
+ marginTop: 30,
+ }}
+ >
+ <DemoCard
+ title="Series"
+ description="Three consecutive clips, 80 frames each."
+ >
+ <Track name="Series">
+ <Series>
+ <Series.Sequence name="Series A" durationInFrames={80}>
+ <Scene color="#3268a8">A</Scene>
+ </Series.Sequence>
+ <Series.Sequence name="Series B" durationInFrames={80}>
+ <Scene color="#6a4daf">B</Scene>
+ </Series.Sequence>
+ <Series.Sequence name="Series C" durationInFrames={80}>
+ <Scene color="#a34777">C</Scene>
+ </Series.Sequence>
+ </Series>
+ </Track>
+ </DemoCard>
+ <DemoCard
+ title="TransitionSeries"
+ description="90-frame clips with 15-frame fades: 240 frames total."
+ >
+ <Track name="Transitions">
+ <TransitionSeries>
+ <TransitionSeries.Sequence name="Fade A" durationInFrames={90}>
+ <Scene color="#327e79">A</Scene>
+ </TransitionSeries.Sequence>
+ <TransitionSeries.Transition
+ presentation={fade()}
+ timing={linearTiming({durationInFrames: 15})}
+ />
+ <TransitionSeries.Sequence name="Fade B" durationInFrames={90}>
+ <Scene color="#967130">B</Scene>
+ </TransitionSeries.Sequence>
+ <TransitionSeries.Transition
+ presentation={fade()}
+ timing={linearTiming({durationInFrames: 15})}
+ />
+ <TransitionSeries.Sequence name="Fade C" durationInFrames={90}>
+ <Scene color="#a34a43">C</Scene>
+ </TransitionSeries.Sequence>
+ </TransitionSeries>
+ </Track>
+ </DemoCard>
+ <DemoCard
+ title="TransitionSeries.Overlay"
+ description="24-frame flashes: centered at cut 80; shifted +20 at cut 160."
+ >
+ <Track name="Overlays">
+ <TransitionSeries>
+ <TransitionSeries.Sequence name="Overlay A" durationInFrames={80}>
+ <Scene color="#436582">A</Scene>
+ </TransitionSeries.Sequence>
+ <TransitionSeries.Overlay durationInFrames={24}>
+ <Flash />
+ </TransitionSeries.Overlay>
+ <TransitionSeries.Sequence name="Overlay B" durationInFrames={80}>
+ <Scene color="#774e90">B</Scene>
+ </TransitionSeries.Sequence>
+ <TransitionSeries.Overlay durationInFrames={24} offset={20}>
+ <Flash />
+ </TransitionSeries.Overlay>
+ <TransitionSeries.Sequence name="Overlay C" durationInFrames={80}>
+ <Scene color="#8f5f48">C</Scene>
+ </TransitionSeries.Sequence>
+ </TransitionSeries>
+ </Track>
+ </DemoCard>
+ <DemoCard
+ title="Negative offsets"
+ description="Later clips start 20 frames early and cover the previous clip."
+ >
+ <Track name="Overlapping clips">
+ <Series>
+ <Series.Sequence name="Overlap A" durationInFrames={100}>
+ <Scene color="#517345">A</Scene>
+ </Series.Sequence>
+ <Series.Sequence
+ name="Overlap B"
+ durationInFrames={100}
+ offset={-20}
+ >
+ <Scene color="#92742d">B</Scene>
+ </Series.Sequence>
+ <Series.Sequence
+ name="Overlap C"
+ durationInFrames={80}
+ offset={-20}
+ >
+ <Scene color="#a15437">C</Scene>
+ </Series.Sequence>
+ </Series>
+ </Track>
+ </DemoCard>
+ </div>
+ <div
+ style={{
+ fontSize: 18,
+ color: '#a7b0c0',
+ marginTop: 28,
+ marginBottom: 12,
+ }}
+ >
+ Tokens β€” all eight sequences stay registered while one word is visible.
+ </div>
+ <div
+ style={{
+ position: 'relative',
+ height: 65,
+ borderRadius: 12,
+ overflow: 'hidden',
+ }}
+ >
+ <Track name="Caption tokens">
+ <Sequence name="Every" durationInFrames={30}>
+ <Scene color="#27354a">Every</Scene>
+ </Sequence>
+ <Sequence name="caption" from={30} durationInFrames={30}>
+ <Scene color="#27354a">caption</Scene>
+ </Sequence>
+ <Sequence name="token" from={60} durationInFrames={30}>
+ <Scene color="#27354a">token</Scene>
+ </Sequence>
+ <Sequence name="stays" from={90} durationInFrames={30}>
+ <Scene color="#27354a">stays</Scene>
+ </Sequence>
+ <Sequence name="visible" from={120} durationInFrames={30}>
+ <Scene color="#27354a">visible</Scene>
+ </Sequence>
+ <Sequence name="in" from={150} durationInFrames={30}>
+ <Scene color="#27354a">in</Scene>
+ </Sequence>
+ <Sequence name="one" from={180} durationInFrames={30}>
+ <Scene color="#27354a">one</Scene>
+ </Sequence>
+ <Sequence name="track" from={210} durationInFrames={30}>
+ <Scene color="#27354a">track</Scene>
+ </Sequence>
+ </Track>
+ </div>
+ </div>
+ );
+};
diff --git a/packages/studio/src/components/Timeline/Timeline.tsx b/packages/studio/src/components/Timeline/Timeline.tsx
index 08aa57d054..d9eaf627f7 100644
--- a/packages/studio/src/components/Timeline/Timeline.tsx
+++ b/packages/studio/src/components/Timeline/Timeline.tsx
@@ -43,6 +43,10 @@ import {
type TimelineTrackWithDisplayGroup,
} from './timeline-display-groups';
import {timelineVerticalScroll} from './timeline-refs';
+import {
+ filterTimelineTrackContents,
+ getTimelineDisplayRows,
+} from './timeline-track-groups';
import {TimelineDragHandler} from './TimelineDragHandler';
import {TimelineHeightContainer} from './TimelineHeightContainer';
import {TimelineInOutDragHandler} from './TimelineInOutDragHandler';
@@ -330,8 +334,8 @@ const TimelineInner: React.FC = () => {
// instance without recalculating the timeline or losing its instance index.
const collapsed = useMemo(() => {
const seenDisplayGroups = new Set<string>();
- return filtered.filter((track) => {
- if (track.displayGroup === null) {
+ return filterTimelineTrackContents(filtered, sequences).filter((track) => {
+ if (track.sequence.timelineTrack || track.displayGroup === null) {
return true;
}
@@ -342,7 +346,7 @@ const TimelineInner: React.FC = () => {
seenDisplayGroups.add(track.displayGroup.key);
return true;
});
- }, [filtered]);
+ }, [filtered, sequences]);
const {visibleTracks, value: layerChildrenValue} = useTimelineLayerChildren(
collapsed,
@@ -442,14 +446,21 @@ const TimelineInner: React.FC = () => {
]);
const maxTimelineTracks = getStudioMaxTimelineTracks();
- const shown = useMemo(() => {
- return maxTimelineTracks !== null &&
- visibleTracks.length > maxTimelineTracks
- ? visibleTracks.slice(0, maxTimelineTracks)
- : visibleTracks;
- }, [visibleTracks, maxTimelineTracks]);
+ const displayRows = useMemo(
+ () => getTimelineDisplayRows(visibleTracks),
+ [visibleTracks],
+ );
+ const shownRows = useMemo(() => {
+ return maxTimelineTracks !== null && displayRows.length > maxTimelineTracks
+ ? displayRows.slice(0, maxTimelineTracks)
+ : displayRows;
+ }, [displayRows, maxTimelineTracks]);
+ const shown = useMemo(
+ () => shownRows.flatMap((row) => row.items ?? [row.track]),
+ [shownRows],
+ );
- const hasBeenCut = visibleTracks.length > shown.length;
+ const hasBeenCut = displayRows.length > shownRows.length;
return (
<TimelineContextMenuArea>
@@ -477,7 +488,7 @@ const TimelineInner: React.FC = () => {
<TimelineVirtualizationProvider
hasBeenCut={hasBeenCut}
isStill={isStill}
- timeline={shown}
+ timeline={shownRows}
>
{isStudioInteractivityEnabled() ? (
<TimelineSelectAllKeybindings timeline={shown} />
diff --git a/packages/studio/src/components/Timeline/TimelineLayerChildren.tsx b/packages/studio/src/components/Timeline/TimelineLayerChildren.tsx
index 00d579122c..e83027df19 100644
--- a/packages/studio/src/components/Timeline/TimelineLayerChildren.tsx
+++ b/packages/studio/src/components/Timeline/TimelineLayerChildren.tsx
@@ -116,7 +116,11 @@ export const useTimelineLayerChildren = (
.concat(track.sequence.id)
.map((id) => siblingIndices.get(id)),
];
- keys.set(track.sequence.id, JSON.stringify([compositionId, identity]));
+ // Packed clips have no child-collapse control. Do not let a saved
+ // layer collapse make an explicit nested Track inaccessible.
+ if (!track.sequence.timelineTrack) {
+ keys.set(track.sequence.id, JSON.stringify([compositionId, identity]));
+ }
}
return {keys, parents, ancestors};
diff --git a/packages/studio/src/components/Timeline/TimelineList.tsx b/packages/studio/src/components/Timeline/TimelineList.tsx
index 4d85afaa7f..5a820e1983 100644
--- a/packages/studio/src/components/Timeline/TimelineList.tsx
+++ b/packages/studio/src/components/Timeline/TimelineList.tsx
@@ -1,5 +1,6 @@
import React from 'react';
import {BACKGROUND} from '../../helpers/colors';
+import {TimelinePackedTrackName} from './TimelinePackedTrack';
import {TimelineSequenceItem} from './TimelineSequenceItem';
import {
type TimelineVirtualRow,
@@ -18,6 +19,9 @@ const TimelineListTrack: React.FC<{
readonly row: TimelineVirtualRow;
}> = React.memo(({row}) => {
const {afterDropLineOffset, siblingIndex, track} = row;
+ if (row.items !== null) {
+ return <TimelinePackedTrackName items={row.items} />;
+ }
return (
<TimelineSequenceItem
diff --git a/packages/studio/src/components/Timeline/TimelinePackedTrack.tsx b/packages/studio/src/components/Timeline/TimelinePackedTrack.tsx
new file mode 100644
index 0000000000..6fc24b1c5b
--- /dev/null
+++ b/packages/studio/src/components/Timeline/TimelinePackedTrack.tsx
@@ -0,0 +1,168 @@
+import React, {useContext, useMemo} from 'react';
+import {Internals} from 'remotion';
+import {
+ BACKGROUND,
+ LIGHT_TEXT,
+ TIMELINE_TRACK_SEPARATOR,
+ TRANSPARENT,
+ WHITE,
+} from '../../helpers/colors';
+import {
+ FOCUS_VISIBLE_ONLY_CLASS_NAME,
+ HOVERABLE_CLASS_NAME,
+ hoverableStyle,
+} from '../../helpers/hoverable';
+import {TIMELINE_PADDING} from '../../helpers/timeline-layout';
+import type {TimelineTrackWithDisplayGroup} from './timeline-display-groups';
+import {TIMELINE_PACKED_TRACK_HEIGHT} from './timeline-track-groups';
+import {
+ getTimelineSelectionFromNodePathInfo,
+ useTimelineSelection,
+} from './TimelineSelection';
+import {TimelineSequence} from './TimelineSequence';
+import {TimelineWidthContext} from './TimelineWidthProvider';
+
+const noConnectedCompositions = [] as const;
+
+export const TimelinePackedTrackName: React.FC<{
+ readonly items: readonly TimelineTrackWithDisplayGroup[];
+}> = ({items}) => {
+ const {canSelect, selectItem} = useTimelineSelection();
+ const name = items[0].sequence.timelineTrack?.name ?? 'Track';
+
+ return (
+ <div
+ style={{
+ height: TIMELINE_PACKED_TRACK_HEIGHT + 1,
+ borderBottom: `1px solid ${TIMELINE_TRACK_SEPARATOR}`,
+ display: 'flex',
+ alignItems: 'center',
+ padding: '0 8px',
+ }}
+ >
+ <select
+ aria-label={`Select an item in ${name}`}
+ className={`${HOVERABLE_CLASS_NAME} ${FOCUS_VISIBLE_ONLY_CLASS_NAME}`}
+ value=""
+ onPointerDown={(event) => event.stopPropagation()}
+ onChange={(event) => {
+ const item = items.find(
+ (candidate) => candidate.sequence.id === event.target.value,
+ );
+ const selection = getTimelineSelectionFromNodePathInfo(
+ item?.nodePathInfo ?? null,
+ );
+ if (selection && canSelect) {
+ selectItem(selection, undefined, undefined, {
+ reveal: true,
+ revealInInspector: true,
+ });
+ }
+ }}
+ style={{
+ ...hoverableStyle({
+ idleBackground: TRANSPARENT,
+ hoverBackground: TRANSPARENT,
+ idleColor: LIGHT_TEXT,
+ hoverColor: WHITE,
+ }),
+ border: 0,
+ cursor: 'default',
+ fontSize: 12,
+ minWidth: 0,
+ width: '100%',
+ }}
+ >
+ <option
+ value=""
+ disabled
+ style={{background: BACKGROUND, fontSize: 12}}
+ >
+ {name} Β· {items.length} items
+ </option>
+ {items.map((item) => (
+ <option
+ key={item.sequence.id}
+ value={item.sequence.id}
+ disabled={!canSelect || item.nodePathInfo === null}
+ style={{background: BACKGROUND, color: WHITE, fontSize: 12}}
+ >
+ {item.sequence.displayName} ({Math.round(item.sequence.from)}–
+ {Math.round(item.sequence.from + item.sequence.duration)})
+ </option>
+ ))}
+ </select>
+ </div>
+ );
+};
+
+export const TimelinePackedTrack: React.FC<{
+ readonly items: readonly TimelineTrackWithDisplayGroup[];
+}> = ({items}) => {
+ const width = useContext(TimelineWidthContext);
+ const video = Internals.useVideo();
+ const ordered = useMemo(() => {
+ const clips = items.filter(
+ (item) => item.sequence.timelineTrack?.role === 'clip',
+ );
+ const effects = items.filter(
+ (item) => item.sequence.timelineTrack?.role !== 'clip',
+ );
+ return [...clips, ...effects];
+ }, [items]);
+
+ return (
+ <div
+ data-timeline-track={items[0].sequence.timelineTrack?.name}
+ style={{height: TIMELINE_PACKED_TRACK_HEIGHT, position: 'relative'}}
+ >
+ {ordered.map((item) => (
+ <TimelineSequence
+ key={item.sequence.id}
+ s={item.sequence}
+ cascadedStart={item.cascadedStart}
+ localStart={item.localStart}
+ connectedCompositions={
+ item.connectedCompositions ?? noConnectedCompositions
+ }
+ nodePathInfo={item.nodePathInfo}
+ keyframeDisplayOffset={item.keyframeDisplayOffset}
+ keyframePlaybackRate={item.keyframePlaybackRate}
+ sequenceFrameOffset={item.sequenceFrameOffset}
+ />
+ ))}
+ {width === null || video === null
+ ? null
+ : items.map((item) => {
+ const anchor = item.sequence.timelineTrack?.anchor ?? null;
+ if (anchor === null) {
+ return null;
+ }
+
+ const frame =
+ item.cascadedStart +
+ (anchor - item.localStart) / item.keyframePlaybackRate;
+ if (frame < 0 || frame > video.durationInFrames) {
+ return null;
+ }
+
+ return (
+ <div
+ key={`anchor-${item.sequence.id}`}
+ aria-hidden="true"
+ style={{
+ position: 'absolute',
+ left:
+ (frame / video.durationInFrames) *
+ (width - TIMELINE_PADDING * 2),
+ top: 0,
+ height: TIMELINE_PACKED_TRACK_HEIGHT,
+ borderLeft: `1px solid ${WHITE}`,
+ pointerEvents: 'none',
+ }}
+ />
+ );
+ })}
+ </div>
+ );
+};
diff --git a/packages/studio/src/components/Timeline/TimelineSelection.tsx b/packages/studio/src/components/Timeline/TimelineSelection.tsx
index 2dce6cf14e..a162943e02 100644
--- a/packages/studio/src/components/Timeline/TimelineSelection.tsx
+++ b/packages/studio/src/components/Timeline/TimelineSelection.tsx
@@ -685,7 +685,7 @@ export const getSelectableTimelineItems = ({
return [];
}
- if (!getIsExpanded(nodePathInfo)) {
+ if (track.sequence.timelineTrack || !getIsExpanded(nodePathInfo)) {
return [sequenceSelection];
}
diff --git a/packages/studio/src/components/Timeline/TimelineSequence.tsx b/packages/studio/src/components/Timeline/TimelineSequence.tsx
index 3d8620b18c..dae99bebec 100644
--- a/packages/studio/src/components/Timeline/TimelineSequence.tsx
+++ b/packages/studio/src/components/Timeline/TimelineSequence.tsx
@@ -18,6 +18,7 @@ import type {
import {Internals, useCurrentFrame} from 'remotion';
import {StudioServerConnectionCtx} from '../../helpers/client-id';
import {
+ BLACK,
BLUE,
TIMELINE_AUDIO_GRADIENT,
TIMELINE_BACKGROUND_COLOR,
@@ -28,6 +29,7 @@ import {
WHITE,
WHITE_ALPHA_20,
WHITE_ALPHA_50,
+ WARNING_COLOR,
} from '../../helpers/colors';
import {createDragAwareDoubleClickTracker} from '../../helpers/drag-aware-double-click';
import {
@@ -70,6 +72,7 @@ import {LoopedTimelineIndicator} from './LoopedTimelineIndicators';
import {splitSelectedTimelineItems} from './split-selected-timeline-item';
import {getTimelineAssetLinkInfo} from './timeline-asset-link';
import {timelineLeftEdgeCursor} from './timeline-left-edge-cursor';
+import {TIMELINE_PACKED_TRACK_HEIGHT} from './timeline-track-groups';
import {timelineTrimEdgeCursor} from './timeline-trim-edge-cursor';
import {TimelineImageInfo} from './TimelineImageInfo';
import {
@@ -401,8 +404,15 @@ const TimelineSequenceCurrentFrame: React.FC<{
return {
...style,
background: negativeStart ? TRANSPARENT : sequenceBackground,
+ boxShadow: s.timelineTrack
+ ? `inset 0 0 0 ${selected || containsSelection ? 2 : 1}px ${selected || containsSelection ? WHITE : WHITE_ALPHA_20}`
+ : style.boxShadow,
opacity:
- activeTrimEdge !== null || selected || containsSelection || isAsset
+ activeTrimEdge !== null ||
+ selected ||
+ containsSelection ||
+ isAsset ||
+ s.timelineTrack
? 1
: 0.75,
};
@@ -414,6 +424,7 @@ const TimelineSequenceCurrentFrame: React.FC<{
selected,
sequenceBackground,
style,
+ s.timelineTrack,
]);
const content = (
@@ -456,7 +467,32 @@ const TimelineSequenceCurrentFrame: React.FC<{
{children}
- {s.type !== 'audio' &&
+ {s.timelineTrack ? (
+ <div
+ style={{
+ position: 'absolute',
+ left: 5 + negativeStartEnd + (premount?.width ?? 0),
+ right: 4,
+ bottom: 1,
+ fontSize: 11,
+ lineHeight: '15px',
+ color: s.timelineTrack.role === 'overlay' ? BLACK : WHITE,
+ whiteSpace: 'nowrap',
+ overflow: 'hidden',
+ textOverflow: 'ellipsis',
+ pointerEvents: 'none',
+ }}
+ >
+ {s.timelineTrack.role === 'transition'
+ ? 'Transition'
+ : s.timelineTrack.role === 'overlay'
+ ? 'Overlay'
+ : s.displayName}
+ </div>
+ ) : null}
+
+ {!s.timelineTrack &&
+ s.type !== 'audio' &&
s.type !== 'video' &&
s.type !== 'image' &&
s.loopDisplay === undefined &&
@@ -503,6 +539,7 @@ const TimelineSequenceCurrentFrame: React.FC<{
{...{[TIMELINE_MARQUEE_ITEM_ATTR]: true}}
style={actualStyle}
aria-label={s.displayName}
+ data-track-item={s.timelineTrack?.role}
onPointerDownCapture={onPointerDownCapture}
onPointerDown={selectable ? onPointerDown : undefined}
onClick={onClick ?? undefined}
@@ -1378,26 +1415,47 @@ const TimelineSequenceInner: React.FC<{
(endsAtContainerBoundary || endsAtNaturalMediaDuration);
const style: React.CSSProperties = useMemo(() => {
+ const role = s.timelineTrack?.role;
+ const isEffect = role === 'transition' || role === 'overlay';
return {
background:
- s.type === 'audio'
- ? TIMELINE_AUDIO_GRADIENT
- : s.type === 'video'
- ? TIMELINE_VIDEO_GRADIENT
- : BLUE,
+ role === 'transition'
+ ? `repeating-linear-gradient(135deg, ${BLUE} 0 5px, ${WHITE_ALPHA_20} 5px 7px), ${BLUE}`
+ : role === 'overlay'
+ ? WARNING_COLOR
+ : s.type === 'audio'
+ ? TIMELINE_AUDIO_GRADIENT
+ : s.type === 'video'
+ ? TIMELINE_VIDEO_GRADIENT
+ : BLUE,
borderTopLeftRadius: showLeftBorderRadius ? 2 : 0,
borderBottomLeftRadius: showLeftBorderRadius ? 2 : 0,
borderTopRightRadius: showRightBorderRadius ? 2 : 0,
borderBottomRightRadius: showRightBorderRadius ? 2 : 0,
position: 'absolute',
- height: getTimelineLayerHeight(s.type),
+ isolation: s.timelineTrack ? 'isolate' : undefined,
+ height: isEffect
+ ? 16
+ : s.timelineTrack
+ ? TIMELINE_PACKED_TRACK_HEIGHT
+ : getTimelineLayerHeight(s.type),
+ top: s.timelineTrack ? 0 : undefined,
+ boxShadow: s.timelineTrack
+ ? `inset 0 0 0 1px ${WHITE_ALPHA_20}`
+ : undefined,
marginLeft: visibleLayout?.marginLeft ?? 0,
width: visibleLayout?.width ?? 0,
color: WHITE,
// Edge handles extend outside the layer; media is clipped separately.
overflow: 'visible',
};
- }, [s.type, showLeftBorderRadius, showRightBorderRadius, visibleLayout]);
+ }, [
+ s.type,
+ s.timelineTrack,
+ showLeftBorderRadius,
+ showRightBorderRadius,
+ visibleLayout,
+ ]);
const showRightEdgeDragHandle =
isTimelineSequenceDurationDraggable(s) &&
diff --git a/packages/studio/src/components/Timeline/TimelineTracks.tsx b/packages/studio/src/components/Timeline/TimelineTracks.tsx
index 4b94bae99f..503daacc9a 100644
--- a/packages/studio/src/components/Timeline/TimelineTracks.tsx
+++ b/packages/studio/src/components/Timeline/TimelineTracks.tsx
@@ -1,6 +1,7 @@
import React, {useMemo} from 'react';
import {TIMELINE_PADDING} from '../../helpers/timeline-layout';
import {MaxTimelineTracksReached} from './MaxTimelineTracks';
+import {TimelinePackedTrack} from './TimelinePackedTrack';
import {TimelineTrack} from './TimelineTrack';
import {useTimelineVirtualization} from './TimelineVirtualization';
@@ -39,7 +40,11 @@ const TimelineTracksInner: React.FC<{
top: virtualItem.start,
}}
>
- <TimelineTrack track={rows[virtualItem.index].track} />
+ {rows[virtualItem.index].items === null ? (
+ <TimelineTrack track={rows[virtualItem.index].track} />
+ ) : (
+ <TimelinePackedTrack items={rows[virtualItem.index].items!} />
+ )}
</div>
))}
</div>
diff --git a/packages/studio/src/components/Timeline/TimelineVirtualization.tsx b/packages/studio/src/components/Timeline/TimelineVirtualization.tsx
index 2e0441cc60..5e9131e340 100644
--- a/packages/studio/src/components/Timeline/TimelineVirtualization.tsx
+++ b/packages/studio/src/components/Timeline/TimelineVirtualization.tsx
@@ -17,6 +17,10 @@ import {TIMELINE_ITEM_BORDER_BOTTOM} from '../../helpers/timeline-layout';
import {MAX_TIMELINE_TRACKS_NOTICE_HEIGHT} from './MaxTimelineTracks';
import type {TimelineTrackWithDisplayGroup} from './timeline-display-groups';
import {timelineVerticalScroll} from './timeline-refs';
+import {
+ TIMELINE_PACKED_TRACK_HEIGHT,
+ type TimelineDisplayRow,
+} from './timeline-track-groups';
import {
getTimelineSelectionKey,
getTimelineSequenceSelectionKey,
@@ -30,6 +34,7 @@ export type TimelineVirtualRow = {
readonly afterDropLineOffset: number;
readonly siblingIndex: number;
readonly track: TimelineTrackWithDisplayGroup;
+ readonly items: readonly TimelineTrackWithDisplayGroup[] | null;
};
type TimelineVirtualizationContextValue = {
@@ -54,9 +59,24 @@ export const TimelineVirtualizationProvider: React.FC<{
readonly children: React.ReactNode;
readonly hasBeenCut: boolean;
readonly isStill: boolean;
- readonly timeline: readonly TimelineTrackWithDisplayGroup[];
+ readonly timeline: readonly TimelineDisplayRow[];
}> = ({children, hasBeenCut, isStill, timeline}) => {
- const trackHeights = useTimelineTrackHeights({timeline});
+ const representativeTracks = useMemo(
+ () => timeline.map((row) => row.track),
+ [timeline],
+ );
+ const individualHeights = useTimelineTrackHeights({
+ timeline: representativeTracks,
+ });
+ const trackHeights = useMemo(
+ () =>
+ timeline.map((row, index) =>
+ row.items === null
+ ? individualHeights[index]
+ : TIMELINE_PACKED_TRACK_HEIGHT + TIMELINE_ITEM_BORDER_BOTTOM,
+ ),
+ [individualHeights, timeline],
+ );
const {consumeRevealRequest, revealRequest, selectedItems} =
useTimelineSelection();
const paddingStart = isStill ? 0 : TIMELINE_TIME_INDICATOR_HEIGHT;
@@ -73,7 +93,7 @@ export const TimelineVirtualizationProvider: React.FC<{
const siblingCounts = new Map<number | null, number>();
for (let index = 0; index < timeline.length; index++) {
- const {depth} = timeline[index];
+ const {depth} = timeline[index].track;
while (
openTracks.length > 0 &&
openTracks[openTracks.length - 1].depth >= depth
@@ -96,20 +116,24 @@ export const TimelineVirtualizationProvider: React.FC<{
}
const rows = timeline.map(
- (track, index): TimelineVirtualRow => ({
+ ({track, items}, index): TimelineVirtualRow => ({
afterDropLineOffset: offsets[subtreeEndIndexes[index]] - offsets[index],
siblingIndex: siblingIndexes[index],
track,
+ items,
}),
);
const rootTrackIndexes = new Map<string, number>();
for (let index = 0; index < timeline.length; index++) {
- const {nodePathInfo} = timeline[index];
- if (nodePathInfo !== null) {
- rootTrackIndexes.set(
- getTimelineSequenceSelectionKey(nodePathInfo),
- index,
- );
+ for (const {nodePathInfo} of timeline[index].items ?? [
+ timeline[index].track,
+ ]) {
+ if (nodePathInfo !== null) {
+ rootTrackIndexes.set(
+ getTimelineSequenceSelectionKey(nodePathInfo),
+ index,
+ );
+ }
}
}
@@ -145,10 +169,12 @@ export const TimelineVirtualizationProvider: React.FC<{
(index: number) => trackHeightsRef.current[index] ?? 0,
[],
);
- const getItemKey = useCallback(
- (index: number) => timelineRef.current[index]?.sequence.id ?? index,
- [],
- );
+ const getItemKey = useCallback((index: number) => {
+ const row = timelineRef.current[index];
+ return row?.items
+ ? (row.track.sequence.timelineTrack?.id ?? index)
+ : (row?.track.sequence.id ?? index);
+ }, []);
const rangeExtractor = useCallback(
(range: Range) => {
const indexes = new Set(defaultRangeExtractor(range));
diff --git a/packages/studio/src/components/Timeline/timeline-track-groups.ts b/packages/studio/src/components/Timeline/timeline-track-groups.ts
new file mode 100644
index 0000000000..7b7c0fc6c2
--- /dev/null
+++ b/packages/studio/src/components/Timeline/timeline-track-groups.ts
@@ -0,0 +1,71 @@
+import type {TSequence} from 'remotion';
+import type {TimelineTrackWithDisplayGroup} from './timeline-display-groups';
+
+export const TIMELINE_PACKED_TRACK_HEIGHT = 36;
+
+export type TimelineDisplayRow = {
+ readonly track: TimelineTrackWithDisplayGroup;
+ readonly items: readonly TimelineTrackWithDisplayGroup[] | null;
+};
+
+export const filterTimelineTrackContents = (
+ tracks: readonly TimelineTrackWithDisplayGroup[],
+ sequences: readonly TSequence[],
+): TimelineTrackWithDisplayGroup[] => {
+ const byId = new Map(sequences.map((sequence) => [sequence.id, sequence]));
+
+ return tracks.flatMap((track) => {
+ if (track.sequence.timelineTrack?.role === 'container') {
+ return [];
+ }
+
+ let {parent} = track.sequence;
+ let hiddenAncestors = 0;
+ while (parent !== null) {
+ const ancestor = byId.get(parent);
+ if (!ancestor) {
+ break;
+ }
+
+ if (ancestor.timelineTrack) {
+ if (ancestor.timelineTrack.role === 'container') {
+ hiddenAncestors += Number(ancestor.showInTimeline);
+ } else if (!track.sequence.timelineTrack) {
+ // A clip owns its internal layers. Explicit nested tracks still
+ // keep their own rows.
+ return [];
+ }
+ }
+
+ parent = ancestor.parent;
+ }
+
+ return [{...track, depth: Math.max(0, track.depth - hiddenAncestors)}];
+ });
+};
+
+export const getTimelineDisplayRows = (
+ tracks: readonly TimelineTrackWithDisplayGroup[],
+): TimelineDisplayRow[] => {
+ const rows: TimelineDisplayRow[] = [];
+ const groupedItems = new Map<string, TimelineTrackWithDisplayGroup[]>();
+ for (const track of tracks) {
+ const group = track.sequence.timelineTrack;
+ if (!group) {
+ rows.push({track, items: null});
+ continue;
+ }
+
+ const existing = groupedItems.get(group.id);
+ if (existing) {
+ existing.push(track);
+ continue;
+ }
+
+ const items = [track];
+ groupedItems.set(group.id, items);
+ rows.push({track, items});
+ }
+
+ return rows;
+};
diff --git a/packages/transitions/src/TransitionSeries.tsx b/packages/transitions/src/TransitionSeries.tsx
index cb70ca12ac..baaf978bac 100644
--- a/packages/transitions/src/TransitionSeries.tsx
+++ b/packages/transitions/src/TransitionSeries.tsx
@@ -331,6 +331,10 @@ const TransitionSeriesChildren: FC<{readonly children: React.ReactNode}> = ({
from={Math.round(info.overlayFrom)}
durationInFrames={info.durationInFrames}
name="<TS.Overlay>"
+ _remotionInternalTimelineTrack={{
+ role: 'overlay',
+ anchor: info.cutPoint,
+ }}
_remotionInternalDocumentationLink="https://www.remotion.dev/docs/transitions/transitionseries"
controls={info.controls ?? undefined}
hidden={info.hidden}
@@ -563,6 +567,10 @@ const TransitionSeriesChildren: FC<{readonly children: React.ReactNode}> = ({
from={transitionFrom}
durationInFrames={transitionDuration}
name="<TS.Transition>"
+ _remotionInternalTimelineTrack={{
+ role: 'transition',
+ anchor: null,
+ }}
_remotionInternalDocumentationLink="https://www.remotion.dev/docs/transitions/transitionseries"
controls={transitionProps.controls ?? undefined}
layout="none"
@@ -1020,6 +1028,7 @@ const TransitionSeriesInner: FC<SequencePropsWithoutDuration> = (props) => {
}
{...otherProps}
controls={controls ?? undefined}
+ _remotionInternalTimelineTrack={{role: 'container', anchor: null}}
>
<TransitionSeriesChildren>{children}</TransitionSeriesChildren>
</Sequence>