Skip to content

🎥 Make videos programmatically with React

Share Series child rows across scenes in experimental tracks

Jonny Burgerfc935ee6938c
diff --git a/packages/core/src/Sequence.tsx b/packages/core/src/Sequence.tsx
index 882c790e80..1528b3061a 100644
--- a/packages/core/src/Sequence.tsx
+++ b/packages/core/src/Sequence.tsx
@@ -114,7 +114,10 @@ export type SequencePropsWithoutDuration = {
/**
* @deprecated For internal use only.
*/
- readonly _remotionInternalTimelineTrack?: Pick<TimelineTrackItem, 'role'>;
+ readonly _remotionInternalTimelineTrack?: Pick<
+ TimelineTrackItem,
+ 'role' | 'seriesOffset'
+ >;
/**
* @deprecated For internal use only.
*/
@@ -216,6 +219,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
const activityEnabled = activityRequested && env.isStudio && !env.isRendering;
const timelineTrack = useContext(TimelineTrackContext);
const timelineTrackRole = timelineTrackItem?.role ?? 'clip';
+ const seriesOffset = timelineTrackItem?.seriesOffset ?? null;
const parentPlaybackRate = parentSequence?.playbackRate ?? 1;
const cumulativePlaybackRate = parentPlaybackRate * playbackRate;
const cumulatedFrom = parentSequence
@@ -664,6 +668,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
timelineTrack: {
...timelineTrack,
role: timelineTrackRole,
+ seriesOffset,
},
}
: {};
@@ -767,6 +772,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
id,
timelineTrack,
timelineTrackRole,
+ seriesOffset,
getCurrentFrame,
getStack,
timelineClipName,
diff --git a/packages/core/src/Track.tsx b/packages/core/src/Track.tsx
index 27d6a7e292..41b145c794 100644
--- a/packages/core/src/Track.tsx
+++ b/packages/core/src/Track.tsx
@@ -44,7 +44,7 @@ export const TrackWithoutSchema: React.FC<SequenceProps> = ({
{...props}
name={name}
layout={layout}
- _remotionInternalTimelineTrack={{role: 'track'}}
+ _remotionInternalTimelineTrack={{role: 'track', seriesOffset: null}}
>
{children}
</SequenceWithoutSchema>
diff --git a/packages/core/src/series/index.tsx b/packages/core/src/series/index.tsx
index e35201abc4..9663fc4cc2 100644
--- a/packages/core/src/series/index.tsx
+++ b/packages/core/src/series/index.tsx
@@ -239,6 +239,10 @@ const SeriesInner: FC<SeriesProps> = (props) => {
from={currentStartFrame}
durationInFrames={durationInFramesProp}
{...passedProps}
+ _remotionInternalTimelineTrack={{
+ role: 'clip',
+ seriesOffset: offset,
+ }}
_remotionInternalSingleChildComponent={getSingleChildComponent(
sequenceChildren,
)}
diff --git a/packages/core/src/timeline-track-context.ts b/packages/core/src/timeline-track-context.ts
index 2e58e700a0..be23f3e63b 100644
--- a/packages/core/src/timeline-track-context.ts
+++ b/packages/core/src/timeline-track-context.ts
@@ -7,6 +7,7 @@ export type TimelineTrack = {
export type TimelineTrackItem = TimelineTrack & {
readonly role: 'track' | 'clip' | 'transition' | 'overlay';
+ readonly seriesOffset: number | null;
};
export const TimelineTrackContext = createContext<TimelineTrack | null>(null);
diff --git a/packages/core/src/use-media-in-timeline.ts b/packages/core/src/use-media-in-timeline.ts
index 84e6819a3c..0d0f9486f9 100644
--- a/packages/core/src/use-media-in-timeline.ts
+++ b/packages/core/src/use-media-in-timeline.ts
@@ -285,6 +285,7 @@ export const useMediaInTimelineRegistration = ({
timelineTrack: {
...timelineTrack,
role: 'clip' as const,
+ seriesOffset: null,
},
}
: {}),
diff --git a/packages/studio/src/components/Timeline/TimelineList.tsx b/packages/studio/src/components/Timeline/TimelineList.tsx
index 01217cb932..f45672cf55 100644
--- a/packages/studio/src/components/Timeline/TimelineList.tsx
+++ b/packages/studio/src/components/Timeline/TimelineList.tsx
@@ -1,4 +1,5 @@
import React from 'react';
+import {Internals} from 'remotion';
import {BACKGROUND, TIMELINE_TRACK_SEPARATOR} from '../../helpers/colors';
import {TIMELINE_PACKED_AUXILIARY_ROW_HEIGHT} from './timeline-track-groups';
import {TimelineSequenceItem} from './TimelineSequenceItem';
@@ -17,11 +18,15 @@ const noConnectedCompositions: readonly never[] = [];
const TimelineListTrack: React.FC<{
readonly row: TimelineVirtualRow;
-}> = React.memo(({row}) => {
+ readonly start: number;
+ readonly height: number;
+}> = React.memo(({row, start, height}) => {
const {afterDropLineOffset, siblingIndex, track} = row;
return (
- <>
+ <div
+ style={{height, left: 0, position: 'absolute', top: start, width: '100%'}}
+ >
<TimelineSequenceItem
showBottomBorder={row.auxiliaryRows.length === 0}
afterDropLineOffset={afterDropLineOffset}
@@ -54,10 +59,27 @@ const TimelineListTrack: React.FC<{
}}
/>
) : null}
- </>
+ </div>
);
});
+// Only labels follow the playhead. The rows and the bars keep their layout.
+const TimelineSceneListTrack: React.FC<
+ React.ComponentProps<typeof TimelineListTrack>
+> = React.memo((props) => {
+ const {row} = props;
+ const frame = Internals.Timeline.useTimelinePosition();
+ if (
+ row.sceneRange === null ||
+ frame < row.sceneRange.from ||
+ frame >= row.sceneRange.end
+ ) {
+ return null;
+ }
+
+ return <TimelineListTrack {...props} />;
+});
+
export const TimelineList: React.FC = () => {
const {rows, tracksEnd, virtualItems} = useTimelineVirtualization();
@@ -74,20 +96,23 @@ export const TimelineList: React.FC = () => {
line-height: normal;
visibility: hidden;
}`}</style>
- {virtualItems.map((virtualItem) => (
- <div
- key={virtualItem.key}
- style={{
- height: virtualItem.size,
- left: 0,
- position: 'absolute',
- top: virtualItem.start,
- width: '100%',
- }}
- >
- <TimelineListTrack row={rows[virtualItem.index]} />
- </div>
- ))}
+ {virtualItems.map((virtualItem) =>
+ rows[virtualItem.index].sceneRange === null ? (
+ <TimelineListTrack
+ key={virtualItem.key}
+ row={rows[virtualItem.index]}
+ start={virtualItem.start}
+ height={virtualItem.size}
+ />
+ ) : (
+ <TimelineSceneListTrack
+ key={virtualItem.key}
+ row={rows[virtualItem.index]}
+ start={virtualItem.start}
+ height={virtualItem.size}
+ />
+ ),
+ )}
</div>
);
};
diff --git a/packages/studio/src/components/Timeline/TimelineTracks.tsx b/packages/studio/src/components/Timeline/TimelineTracks.tsx
index d100ee9c51..8f773bf0c6 100644
--- a/packages/studio/src/components/Timeline/TimelineTracks.tsx
+++ b/packages/studio/src/components/Timeline/TimelineTracks.tsx
@@ -1,4 +1,5 @@
import React, {useContext, useImperativeHandle, useMemo} from 'react';
+import {Internals} from 'remotion';
import {TIMELINE_PADDING} from '../../helpers/timeline-layout';
import {MaxTimelineTracksReached} from './MaxTimelineTracks';
import {timelineDurationRef, timelineLayerLayoutsRef} from './timeline-refs';
@@ -22,6 +23,7 @@ const TimelineTracksInner: React.FC<{
readonly hasBeenCut: boolean;
}> = ({hasBeenCut}) => {
const {rows, tracksEnd, virtualItems} = useTimelineVirtualization();
+ const video = Internals.useUnsafeVideoConfig();
const windowWidth = useContext(TimelineWidthContext);
const renderWindow = useContext(TimelineViewportContext);
useImperativeHandle(timelineDurationRef, () => ({
@@ -75,28 +77,42 @@ const TimelineTracksInner: React.FC<{
return (
<div style={timelineStyle} {...{'oai-annotation-container': ''}}>
<div style={{...content, height: tracksEnd}}>
- {virtualItems.map((virtualItem) => (
- <div
- key={virtualItem.key}
- style={{
- height: virtualItem.size,
- left: TIMELINE_PADDING,
- position: 'absolute',
- right: TIMELINE_PADDING,
- top: virtualItem.start,
- }}
- >
- {rows[virtualItem.index].items === null ? (
- <TimelineTrack track={rows[virtualItem.index].track} />
- ) : (
- <TimelinePackedTrack
- track={rows[virtualItem.index].track}
- items={rows[virtualItem.index].items!}
- auxiliaryRows={rows[virtualItem.index].auxiliaryRows}
- />
- )}
- </div>
- ))}
+ {virtualItems.map((virtualItem) => {
+ const {sceneRange, track, items, auxiliaryRows} =
+ rows[virtualItem.index];
+ return (
+ <div
+ key={virtualItem.key}
+ style={{
+ height: virtualItem.size,
+ left: TIMELINE_PADDING,
+ position: 'absolute',
+ right: TIMELINE_PADDING,
+ // Sequence bars use the full zoomed timeline width, while this
+ // row's parent only fills the viewport. Clip in the same space.
+ width:
+ sceneRange !== null && windowWidth !== null
+ ? windowWidth - TIMELINE_PADDING * 2
+ : undefined,
+ top: virtualItem.start,
+ clipPath:
+ sceneRange === null || !video
+ ? undefined
+ : `inset(0 ${Math.max(0, 100 - (sceneRange.end / video.durationInFrames) * 100)}% 0 ${Math.max(0, (sceneRange.from / video.durationInFrames) * 100)}%)`,
+ }}
+ >
+ {items === null ? (
+ <TimelineTrack track={track} />
+ ) : (
+ <TimelinePackedTrack
+ track={track}
+ items={items}
+ auxiliaryRows={auxiliaryRows}
+ />
+ )}
+ </div>
+ );
+ })}
</div>
{hasBeenCut ? <MaxTimelineTracksReached /> : null}
</div>
diff --git a/packages/studio/src/components/Timeline/TimelineVirtualization.tsx b/packages/studio/src/components/Timeline/TimelineVirtualization.tsx
index c928dd9b2f..a7a6dc50d8 100644
--- a/packages/studio/src/components/Timeline/TimelineVirtualization.tsx
+++ b/packages/studio/src/components/Timeline/TimelineVirtualization.tsx
@@ -13,9 +13,15 @@ import React, {
useMemo,
useRef,
} from 'react';
+import {Internals} from 'remotion';
+import {getStudioShowPremounting} from '../../helpers/studio-runtime-config';
import {TIMELINE_ITEM_BORDER_BOTTOM} from '../../helpers/timeline-layout';
import {MAX_TIMELINE_TRACKS_NOTICE_HEIGHT} from './MaxTimelineTracks';
import {timelineVerticalScroll} from './timeline-refs';
+import {
+ getTimelineSeriesLayout,
+ type TimelineSceneRange,
+} from './timeline-series-layout';
import {
TIMELINE_PACKED_AUXILIARY_ROW_HEIGHT,
TIMELINE_PACKED_TRACK_HEIGHT,
@@ -33,6 +39,7 @@ import {useTimelineTrackHeights} from './use-timeline-height';
export type TimelineVirtualRow = TimelineDisplayRow & {
readonly afterDropLineOffset: number;
readonly siblingIndex: number;
+ readonly sceneRange: TimelineSceneRange | null;
};
type TimelineVirtualizationContextValue = {
@@ -62,6 +69,17 @@ export const TimelineVirtualizationProvider: React.FC<{
readonly isStill: boolean;
readonly timeline: readonly TimelineDisplayRow[];
}> = ({children, hasBeenCut, isStill, timeline}) => {
+ const sequences = Internals.useSequenceManagerSequences();
+ const experimentalTracks = useContext(
+ Internals.ExperimentalTracksEnabledContext,
+ );
+ const activitySettings = useContext(
+ Internals.SequenceActivitySettingsContext,
+ );
+ const compactSeries =
+ experimentalTracks &&
+ activitySettings?.enabled === true &&
+ !getStudioShowPremounting();
const representativeTracks = useMemo(
() => timeline.map((row) => row.track),
[timeline],
@@ -89,53 +107,40 @@ export const TimelineVirtualizationProvider: React.FC<{
const rowsRef = useRef<readonly TimelineVirtualRow[]>([]);
const layout = useMemo(() => {
- const siblingIndexes = new Array<number>(timeline.length);
- const subtreeEndIndexes = new Array<number>(timeline.length).fill(
- timeline.length,
- );
- const openTracks: Array<{depth: number; index: number}> = [];
- const siblingCounts = new Map<number | null, number>();
-
- for (let index = 0; index < timeline.length; index++) {
- const {depth} = timeline[index].track;
- while (
- openTracks.length > 0 &&
- openTracks[openTracks.length - 1].depth >= depth
- ) {
- const completed = openTracks.pop()!;
- subtreeEndIndexes[completed.index] = index;
- }
-
- const parentIndex = openTracks[openTracks.length - 1]?.index ?? null;
- const siblingIndex = siblingCounts.get(parentIndex) ?? 0;
- siblingIndexes[index] = siblingIndex;
- siblingCounts.set(parentIndex, siblingIndex + 1);
- openTracks.push({depth, index});
- }
-
- const offsets = new Array<number>(timeline.length + 1);
- offsets[0] = paddingStart;
- for (let index = 0; index < trackHeights.length; index++) {
- offsets[index + 1] = offsets[index] + trackHeights[index];
- }
+ const seriesLayout = getTimelineSeriesLayout({
+ rows: timeline,
+ heights: trackHeights,
+ sequences,
+ compactSeries,
+ paddingStart,
+ });
const rows = timeline.map(
({track, items, auxiliaryRows}, index): TimelineVirtualRow => {
- const afterDropLineOffset =
- offsets[subtreeEndIndexes[index]] - offsets[index];
- const siblingIndex = siblingIndexes[index];
+ const afterDropLineOffset = seriesLayout.afterDropLineOffsets[index];
+ const siblingIndex = seriesLayout.siblingIndexes[index];
+ const sceneRange = seriesLayout.sceneRanges[index];
const previous = rowsRef.current[index];
if (
previous?.track === track &&
previous.items === items &&
previous.auxiliaryRows === auxiliaryRows &&
previous.afterDropLineOffset === afterDropLineOffset &&
- previous.siblingIndex === siblingIndex
+ previous.siblingIndex === siblingIndex &&
+ previous.sceneRange?.from === sceneRange?.from &&
+ previous.sceneRange?.end === sceneRange?.end
) {
return previous;
}
- return {afterDropLineOffset, siblingIndex, track, items, auxiliaryRows};
+ return {
+ afterDropLineOffset,
+ siblingIndex,
+ track,
+ items,
+ auxiliaryRows,
+ sceneRange,
+ };
},
);
const rootTrackIndexes = new Map<string, number>();
@@ -154,12 +159,11 @@ export const TimelineVirtualizationProvider: React.FC<{
}
return {
- offsets,
+ ...seriesLayout,
rootTrackIndexes,
rows,
- tracksEnd: offsets[offsets.length - 1],
};
- }, [paddingStart, timeline, trackHeights]);
+ }, [compactSeries, paddingStart, sequences, timeline, trackHeights]);
useLayoutEffect(() => {
rowsRef.current = layout.rows;
}, [layout.rows]);
@@ -174,26 +178,30 @@ export const TimelineVirtualizationProvider: React.FC<{
const key = getSelectionTrackKey(selectedItem);
const index = key === null ? undefined : layout.rootTrackIndexes.get(key);
if (index !== undefined) {
- indexes.add(index);
+ indexes.add(layout.groupIndexes[index]);
}
}
return indexes;
- }, [layout.rootTrackIndexes, selectedItems]);
- const trackHeightsRef = useRef(trackHeights);
- trackHeightsRef.current = trackHeights;
+ }, [layout.groupIndexes, layout.rootTrackIndexes, selectedItems]);
+ const groupsRef = useRef(layout.groups);
+ groupsRef.current = layout.groups;
const timelineRef = useRef(timeline);
timelineRef.current = timeline;
+ const groupHeights = useMemo(
+ () => layout.groups.map((group) => group.height),
+ [layout.groups],
+ );
const estimateSize = useCallback(
- (index: number) => trackHeightsRef.current[index] ?? 0,
+ (index: number) => groupsRef.current[index]?.height ?? 0,
[],
);
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 group = groupsRef.current[index];
+ return group === undefined
+ ? index
+ : timelineRef.current[group.index].track.sequence.id;
}, []);
const rangeExtractor = useCallback(
(range: Range) => {
@@ -212,7 +220,7 @@ export const TimelineVirtualizationProvider: React.FC<{
);
const virtualizer = useVirtualizer({
- count: timeline.length,
+ count: layout.groups.length,
estimateSize,
getItemKey,
getScrollElement,
@@ -228,13 +236,13 @@ export const TimelineVirtualizationProvider: React.FC<{
useLayoutEffect(() => {
const previous = measuredLayoutRef.current;
- const keys = trackHeights.map((_, index) => getItemKey(index));
+ const keys = groupHeights.map((_, index) => getItemKey(index));
// Trimming changes timeline metadata without changing row geometry. Only
// invalidate measurements when heights or the cached row identities change.
if (
previous !== null &&
- previous.heights.length === trackHeights.length &&
- trackHeights.every(
+ previous.heights.length === groupHeights.length &&
+ groupHeights.every(
(height, index) =>
previous.heights[index] === height &&
previous.keys[index] === keys[index],
@@ -243,9 +251,9 @@ export const TimelineVirtualizationProvider: React.FC<{
return;
}
- measuredLayoutRef.current = {heights: trackHeights, keys};
+ measuredLayoutRef.current = {heights: groupHeights, keys};
virtualizer.measure();
- }, [getItemKey, trackHeights, virtualizer]);
+ }, [getItemKey, groupHeights, virtualizer]);
useEffect(() => {
if (revealRequest === null) {
@@ -274,53 +282,39 @@ export const TimelineVirtualizationProvider: React.FC<{
}
const row = layout.rows[index];
- if (row.items !== null) {
- const scrollElement = timelineVerticalScroll.current;
- if (
- scrollElement === null ||
- scrollElement.clientHeight <= paddingStart
- ) {
- return;
- }
+ const scrollElement = timelineVerticalScroll.current;
+ if (scrollElement === null || scrollElement.clientHeight <= paddingStart) {
+ return;
+ }
- const auxiliaryIndex = row.auxiliaryRows.findIndex((items) =>
- items.some(
- ({nodePathInfo}) =>
- nodePathInfo !== null &&
- getTimelineSequenceSelectionKey(nodePathInfo) === key,
- ),
- );
- const primaryHeight =
- TIMELINE_PACKED_TRACK_HEIGHT + TIMELINE_ITEM_BORDER_BOTTOM;
- const start =
- layout.offsets[index] +
- (auxiliaryIndex === -1
- ? 0
- : primaryHeight +
- auxiliaryIndex * TIMELINE_PACKED_AUXILIARY_ROW_HEIGHT);
- const height =
- auxiliaryIndex === -1
+ const auxiliaryIndex = row.auxiliaryRows.findIndex((items) =>
+ items.some(
+ ({nodePathInfo}) =>
+ nodePathInfo !== null &&
+ getTimelineSequenceSelectionKey(nodePathInfo) === key,
+ ),
+ );
+ const primaryHeight =
+ TIMELINE_PACKED_TRACK_HEIGHT + TIMELINE_ITEM_BORDER_BOTTOM;
+ const start =
+ layout.offsets[index] +
+ (auxiliaryIndex === -1
+ ? 0
+ : primaryHeight +
+ auxiliaryIndex * TIMELINE_PACKED_AUXILIARY_ROW_HEIGHT);
+ const height =
+ auxiliaryIndex !== -1
+ ? TIMELINE_PACKED_AUXILIARY_ROW_HEIGHT
+ : row.items !== null
? primaryHeight
- : TIMELINE_PACKED_AUXILIARY_ROW_HEIGHT;
- // A packed Track can exceed the viewport. Reveal the selected lane,
- // allowing for the pinned time ruler, rather than centering its owner.
- if (
- start < scrollElement.scrollTop + paddingStart ||
- start + height > scrollElement.scrollTop + scrollElement.clientHeight
- ) {
- virtualizer.scrollToOffset(
- start + height / 2 - (scrollElement.clientHeight + paddingStart) / 2,
- );
- }
- } else {
- const offset = virtualizer.getOffsetForIndex(index, 'auto');
- if (offset === undefined) {
- return;
- }
-
- if (offset[1] !== 'auto') {
- virtualizer.scrollToIndex(index, {align: 'center'});
- }
+ : trackHeights[index];
+ if (
+ start < scrollElement.scrollTop + paddingStart ||
+ start + height > scrollElement.scrollTop + scrollElement.clientHeight
+ ) {
+ virtualizer.scrollToOffset(
+ start + height / 2 - (scrollElement.clientHeight + paddingStart) / 2,
+ );
}
consumeRevealRequest(revealRequest.token);
@@ -332,6 +326,7 @@ export const TimelineVirtualizationProvider: React.FC<{
paddingStart,
revealRequest,
selectedItems,
+ trackHeights,
virtualizer,
]);
@@ -374,7 +369,23 @@ export const TimelineVirtualizationProvider: React.FC<{
};
}, [consumeRevealRequest, revealRequest]);
- const virtualItems = virtualizer.getVirtualItems();
+ const virtualGroups = virtualizer.getVirtualItems();
+ const virtualItems = useMemo(
+ () =>
+ virtualGroups.flatMap((group) =>
+ layout.groups[group.index].rows.map(
+ (index): VirtualItem => ({
+ index,
+ key: timeline[index].track.sequence.id,
+ start: layout.offsets[index],
+ end: layout.offsets[index] + trackHeights[index],
+ size: trackHeights[index],
+ lane: 0,
+ }),
+ ),
+ ),
+ [layout.groups, layout.offsets, timeline, trackHeights, virtualGroups],
+ );
const value = useMemo(
(): TimelineVirtualizationContextValue => ({
rows: layout.rows,
diff --git a/packages/studio/src/components/Timeline/timeline-series-layout.ts b/packages/studio/src/components/Timeline/timeline-series-layout.ts
new file mode 100644
index 0000000000..c36375d5d4
--- /dev/null
+++ b/packages/studio/src/components/Timeline/timeline-series-layout.ts
@@ -0,0 +1,193 @@
+import type {TSequence} from 'remotion';
+import type {TimelineTrackWithDisplayGroup} from './timeline-display-groups';
+import type {TimelineDisplayRow} from './timeline-track-groups';
+
+export type TimelineSceneRange = {
+ readonly from: number;
+ readonly end: number;
+};
+
+// Keep sequence rows and their identities intact. Only their vertical positions
+// and virtualization groups change when consecutive scenes share child space.
+export const getTimelineSeriesLayout = ({
+ rows,
+ heights,
+ sequences,
+ compactSeries,
+ paddingStart,
+}: {
+ readonly rows: readonly TimelineDisplayRow[];
+ readonly heights: readonly number[];
+ readonly sequences: readonly TSequence[];
+ readonly compactSeries: boolean;
+ readonly paddingStart: number;
+}) => {
+ const byId = new Map(sequences.map((sequence) => [sequence.id, sequence]));
+ const rowById = new Map(
+ rows.map((row, index) => [row.track.sequence.id, index]),
+ );
+ const registeredItems = new Map<string, TSequence[]>();
+ for (const sequence of sequences) {
+ const track = sequence.timelineTrack;
+ if (track && track.role !== 'track') {
+ const items = registeredItems.get(track.id) ?? [];
+ items.push(sequence);
+ registeredItems.set(track.id, items);
+ }
+ }
+
+ const scenesBySeries = new Map<number, TimelineTrackWithDisplayGroup[]>();
+ const seriesByScene = new Map<string, number>();
+ if (compactSeries) {
+ for (let index = 0; index < rows.length; index++) {
+ const row = rows[index];
+ const track = row.track.sequence.timelineTrack;
+ const registered = track ? registeredItems.get(track.id) : undefined;
+ if (
+ row.items === null ||
+ row.items.length === 0 ||
+ !registered ||
+ registered.some(
+ (item) =>
+ item.timelineTrack?.role !== 'clip' ||
+ item.timelineTrack.seriesOffset !== 0 ||
+ !item.showInTimeline,
+ )
+ ) {
+ continue;
+ }
+
+ const scenes = [...row.items].sort(
+ (a, b) => a.sequence.from - b.sequence.from,
+ );
+ if (
+ scenes.some((scene, sceneIndex) => {
+ const previous = scenes[sceneIndex - 1]?.sequence;
+ return (
+ previous && previous.from + previous.duration > scene.sequence.from
+ );
+ })
+ ) {
+ continue;
+ }
+
+ scenesBySeries.set(index, scenes);
+ for (const scene of scenes) {
+ seriesByScene.set(scene.sequence.id, index);
+ }
+ }
+ }
+
+ const childrenByScene = new Map<string, number[]>();
+ const roots: number[] = [];
+ for (let index = 0; index < rows.length; index++) {
+ let {parent} = rows[index].track.sequence;
+ while (parent !== null && !seriesByScene.has(parent)) {
+ parent = byId.get(parent)?.parent ?? null;
+ }
+
+ if (parent === null) {
+ roots.push(index);
+ } else {
+ const children = childrenByScene.get(parent) ?? [];
+ children.push(index);
+ childrenByScene.set(parent, children);
+ }
+ }
+
+ const offsets = new Array<number>(rows.length);
+ const sceneRanges = new Array<TimelineSceneRange | null>(rows.length).fill(
+ null,
+ );
+ const groupIndexes = new Array<number>(rows.length);
+ const groups: {
+ readonly index: number;
+ readonly rows: number[];
+ readonly height: number;
+ }[] = [];
+ const layoutRows = (
+ indexes: readonly number[],
+ start: number,
+ range: TimelineSceneRange | null,
+ groupRows: number[],
+ ): number => {
+ let cursor = start;
+ for (const index of indexes) {
+ offsets[index] = cursor;
+ sceneRanges[index] = range;
+ groupIndexes[index] = groups.length;
+ groupRows.push(index);
+ cursor += heights[index];
+ const scenes = scenesBySeries.get(index);
+ if (!scenes) {
+ continue;
+ }
+
+ let end = cursor;
+ for (const {sequence} of scenes) {
+ const sceneRange = {
+ from: Math.max(range?.from ?? -Infinity, sequence.from),
+ end: Math.min(
+ range?.end ?? Infinity,
+ sequence.from + sequence.duration,
+ ),
+ };
+ end = Math.max(
+ end,
+ layoutRows(
+ childrenByScene.get(sequence.id) ?? [],
+ cursor,
+ sceneRange,
+ groupRows,
+ ),
+ );
+ }
+
+ cursor = end;
+ }
+
+ return cursor;
+ };
+
+ let tracksEnd = paddingStart;
+ for (const index of roots) {
+ const groupRows: number[] = [];
+ const end = layoutRows([index], tracksEnd, null, groupRows);
+ groups.push({index, rows: groupRows, height: end - tracksEnd});
+ tracksEnd = end;
+ }
+
+ // Reordering still follows the actual sequence hierarchy, even when adjacent
+ // visual rows belong to different scenes or have different nesting depths.
+ const siblingCounts = new Map<string | null, number>();
+ const siblingIndexes = rows.map(({track}) => {
+ const index = siblingCounts.get(track.sequence.parent) ?? 0;
+ siblingCounts.set(track.sequence.parent, index + 1);
+ return index;
+ });
+ const subtreeEnds = offsets.map((offset, index) => offset + heights[index]);
+ for (let index = 0; index < rows.length; index++) {
+ let {parent} = rows[index].track.sequence;
+ while (parent !== null) {
+ const parentIndex = rowById.get(parent);
+ if (parentIndex !== undefined) {
+ subtreeEnds[parentIndex] = Math.max(
+ subtreeEnds[parentIndex],
+ offsets[index] + heights[index],
+ );
+ }
+
+ parent = byId.get(parent)?.parent ?? null;
+ }
+ }
+
+ return {
+ offsets,
+ sceneRanges,
+ groupIndexes,
+ groups,
+ tracksEnd,
+ siblingIndexes,
+ afterDropLineOffsets: subtreeEnds.map((end, index) => end - offsets[index]),
+ };
+};
diff --git a/packages/transitions/src/TransitionSeries.tsx b/packages/transitions/src/TransitionSeries.tsx
index 724e947f08..8b484dfda3 100644
--- a/packages/transitions/src/TransitionSeries.tsx
+++ b/packages/transitions/src/TransitionSeries.tsx
@@ -333,6 +333,7 @@ const TransitionSeriesChildren: FC<{readonly children: React.ReactNode}> = ({
name="<TS.Overlay>"
_remotionInternalTimelineTrack={{
role: 'overlay',
+ seriesOffset: null,
}}
_remotionInternalDocumentationLink="https://www.remotion.dev/docs/transitions/transitionseries"
controls={info.controls ?? undefined}
@@ -567,6 +568,7 @@ const TransitionSeriesChildren: FC<{readonly children: React.ReactNode}> = ({
name="<TS.Transition>"
_remotionInternalTimelineTrack={{
role: 'transition',
+ seriesOffset: null,
}}
_remotionInternalDocumentationLink="https://www.remotion.dev/docs/transitions/transitionseries"
controls={transitionProps.controls ?? undefined}