🎥 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.tsxindex 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.tsxindex 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.tsxindex 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.tsindex 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.tsindex 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.tsxindex 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%'}}+ ><TimelineSequenceItemshowBottomBorder={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.tsxindex 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.tsxindex 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.tsnew file mode 100644index 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.tsxindex 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}