Skip to content

πŸŽ₯ Make videos programmatically with React

`@remotion/studio`: Compact scene layers during transitions

Jonny Burgerd03a32ddc019
diff --git a/packages/core/src/Sequence.tsx b/packages/core/src/Sequence.tsx
index 87195141ae..cc6be450ab 100644
--- a/packages/core/src/Sequence.tsx
+++ b/packages/core/src/Sequence.tsx
@@ -60,6 +60,7 @@ import {IsInsideSeriesContext} from './series/is-inside-series.js';
import {useTimelinePosition} from './timeline-position-state.js';
import {
TimelineTrackContext,
+ TrackValidationContext,
type TimelineTrackItem,
} from './timeline-track-context.js';
import type {BasicMediaInTimelineReturnType} from './use-media-in-timeline.js';
@@ -217,6 +218,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
const env = useRemotionEnvironment();
const activityEnabled = activityRequested && env.isStudio && !env.isRendering;
const timelineTrack = useContext(TimelineTrackContext);
+ const trackValidation = useContext(TrackValidationContext);
const timelineTrackRole = timelineTrackItem?.role ?? 'clip';
const seriesOffset = timelineTrackItem?.seriesOffset ?? null;
const parentPlaybackRate = parentSequence?.playbackRate ?? 1;
@@ -575,6 +577,32 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
currentFrameRef.current = currentFrame;
}, [currentFrame]);
const getCurrentFrame = useCallback(() => currentFrameRef.current, []);
+ const validateTrackClip =
+ timelineTrackRole === 'clip' && (showInTimeline || Boolean(isMedia));
+ const trackClipEnd = Math.min(
+ videoConfig.durationInFrames,
+ cumulatedFrom + (from + actualDurationInFrames) / parentPlaybackRate,
+ );
+ useLayoutEffect(() => {
+ if (!trackValidation || !validateTrackClip || trackClipEnd <= firstFrame) {
+ return;
+ }
+
+ return trackValidation.register({
+ id,
+ name: timelineClipName || controls?.componentName || '<Sequence>',
+ from: firstFrame,
+ end: trackClipEnd,
+ });
+ }, [
+ trackValidation,
+ validateTrackClip,
+ trackClipEnd,
+ firstFrame,
+ id,
+ timelineClipName,
+ controls?.componentName,
+ ]);
const registeredTrimBefore = trimBefore === 0 ? null : trimBefore;
const parentCumulatedNegativeFrom =
parentSequence?.cumulatedNegativeFrom ?? 0;
@@ -977,16 +1005,20 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
);
// Keep the provider mounted when track grouping changes so clip state survives.
const sequence = (
- <TimelineTrackContext.Provider
- value={
- timelineTrackRole === 'track' ||
- (timelineTrackRole === 'clip' && !showInTimeline)
- ? timelineTrack
- : null
- }
+ <TrackValidationContext.Provider
+ value={validateTrackClip ? null : trackValidation}
>
- {sequenceContent}
- </TimelineTrackContext.Provider>
+ <TimelineTrackContext.Provider
+ value={
+ timelineTrackRole === 'track' ||
+ (timelineTrackRole === 'clip' && !showInTimeline)
+ ? timelineTrack
+ : null
+ }
+ >
+ {sequenceContent}
+ </TimelineTrackContext.Provider>
+ </TrackValidationContext.Provider>
);
return sequence;
diff --git a/packages/core/src/Track.tsx b/packages/core/src/Track.tsx
index 40fc23a813..4906cf4675 100644
--- a/packages/core/src/Track.tsx
+++ b/packages/core/src/Track.tsx
@@ -1,4 +1,4 @@
-import React, {useContext, useMemo, useState} from 'react';
+import React, {useCallback, useContext, useMemo, useRef, useState} from 'react';
import {addSequenceStackTraces} from './enable-sequence-stack-traces.js';
import {
sequenceSchema,
@@ -12,6 +12,8 @@ import {
import {
ExperimentalTracksEnabledContext,
TimelineTrackContext,
+ TrackValidationContext,
+ type TrackClip,
} from './timeline-track-context.js';
import {withInteractivitySchema} from './with-interactivity-schema.js';
@@ -58,37 +60,80 @@ const trackSchema = {
// Series variants share the Track foundation while retaining their own
// Sequence props, layout defaults, and interactivity schemas.
-export const TrackWithoutSchema: React.FC<SequenceProps> = ({
+export const TrackWithoutSchema: React.FC<
+ SequenceProps & {readonly _remotionInternalAllowOverlap: boolean}
+> = ({
name = 'Track',
children,
layout = 'none',
+ _remotionInternalAllowOverlap,
...props
}) => {
const [id] = useState(() => String(Math.random()));
+ const clips = useRef(new Map<string, TrackClip>());
+ const [, setRevision] = useState(0);
+ const register = useCallback((clip: TrackClip) => {
+ clips.current.set(clip.id, clip);
+ setRevision((revision) => revision + 1);
+ return () => {
+ clips.current.delete(clip.id);
+ setRevision((revision) => revision + 1);
+ };
+ }, []);
+ const validation = useMemo(
+ () => (_remotionInternalAllowOverlap ? null : {register}),
+ [_remotionInternalAllowOverlap, register],
+ );
const tracksEnabled = useContext(ExperimentalTracksEnabledContext);
const value = useMemo(
() => (tracksEnabled ? {id, name} : null),
[id, name, tracksEnabled],
);
+ if (!_remotionInternalAllowOverlap) {
+ const ordered = [...clips.current.values()].sort((a, b) => a.from - b.from);
+ for (let index = 1; index < ordered.length; index++) {
+ const previous = ordered[index - 1];
+ const current = ordered[index];
+ const overlapEnd = Math.min(previous.end, current.end);
+ const overlap = overlapEnd - current.from;
+ const tolerance =
+ Number.EPSILON *
+ Math.max(1, Math.abs(overlapEnd), Math.abs(current.from)) *
+ 4;
+ if (overlap > tolerance) {
+ throw new Error(
+ `<Track name="${name}"> contains overlapping items: "${previous.name}" (frames ${previous.from}–${previous.end}) and "${current.name}" (frames ${current.from}–${current.end}) overlap by ${overlap} frames, from frame ${current.from} up to frame ${overlapEnd} (exclusive). Items in a <Track> must not overlap. Shorten the earlier item's durationInFrames, move the later item's from, or put the items on separate Tracks. Use <Series> or <TransitionSeries> for overlaps managed by a series.`,
+ );
+ }
+ }
+ }
return (
- <TimelineTrackContext.Provider value={value}>
- <SequenceWithoutSchema
- _remotionInternalDocumentationLink="https://www.remotion.dev/docs/track"
- {...props}
- name={name}
- layout={layout}
- _remotionInternalTimelineTrack={{role: 'track', seriesOffset: null}}
- >
- {children}
- </SequenceWithoutSchema>
- </TimelineTrackContext.Provider>
+ <TrackValidationContext.Provider value={validation}>
+ <TimelineTrackContext.Provider value={value}>
+ <SequenceWithoutSchema
+ _remotionInternalDocumentationLink="https://www.remotion.dev/docs/track"
+ {...props}
+ name={name}
+ layout={layout}
+ _remotionInternalTimelineTrack={{role: 'track', seriesOffset: null}}
+ >
+ {children}
+ </SequenceWithoutSchema>
+ </TimelineTrackContext.Provider>
+ </TrackValidationContext.Provider>
);
};
/** Groups clips on one Studio timeline row and applies Sequence timing. */
export const Track = withInteractivitySchema<typeof trackSchema, TrackProps>({
- Component: (props) => <TrackWithoutSchema {...props} layout="none" />,
+ Component: (props) => (
+ <TrackWithoutSchema
+ {...props}
+ layout="none"
+ _remotionInternalAllowOverlap={false}
+ />
+ ),
componentName: '<Track>',
componentIdentity: 'dev.remotion.remotion.Track',
schema: trackSchema,
diff --git a/packages/core/src/series/index.tsx b/packages/core/src/series/index.tsx
index e7580fbe3c..6aa7a319cd 100644
--- a/packages/core/src/series/index.tsx
+++ b/packages/core/src/series/index.tsx
@@ -263,6 +263,7 @@ const SeriesInner: FC<SeriesProps> = (props) => {
return (
<TrackWithoutSchema
+ _remotionInternalAllowOverlap
layout="none"
_remotionInternalDocumentationLink="https://www.remotion.dev/docs/series"
{...props}
diff --git a/packages/core/src/timeline-track-context.ts b/packages/core/src/timeline-track-context.ts
index be23f3e63b..b24309f110 100644
--- a/packages/core/src/timeline-track-context.ts
+++ b/packages/core/src/timeline-track-context.ts
@@ -13,3 +13,15 @@ export type TimelineTrackItem = TimelineTrack & {
export const TimelineTrackContext = createContext<TimelineTrack | null>(null);
export const ExperimentalTracksEnabledContext = createContext(false);
+
+export type TrackClip = {
+ readonly id: string;
+ readonly name: string;
+ readonly from: number;
+ readonly end: number;
+};
+
+// Validation remains active when experimental timeline grouping is disabled.
+export const TrackValidationContext = createContext<{
+ readonly register: (clip: TrackClip) => () => void;
+} | null>(null);
diff --git a/packages/jonnys-videos/src/roller-skis-new/RollerSkiCommute.tsx b/packages/jonnys-videos/src/roller-skis-new/RollerSkiCommute.tsx
index 2e5c54968e..8c79dab566 100644
--- a/packages/jonnys-videos/src/roller-skis-new/RollerSkiCommute.tsx
+++ b/packages/jonnys-videos/src/roller-skis-new/RollerSkiCommute.tsx
@@ -112,14 +112,14 @@ export const RollerSkiCommute: React.FC = () => {
'https://remotion.media/jonnys-videos/roller-skis-new/music/sunset-render-deja-vu.mp3'
}
trimBefore={1207}
- durationInFrames={4048}
+ durationInFrames={4042}
premountFor={fps}
volume={interpolate(
frame,
[
0, 20, 520, 529, 611, 617, 656, 662, 722, 728, 786, 792, 969, 984,
2000, 2006, 2052, 2058, 2480, 2492, 2990, 3002, 3238, 3242, 3281,
- 3300, 4036, 4048,
+ 3300, 4036, 4042,
],
[
0, 0.07, 0.07, 0.5, 0.5, 0.14, 0.14, 0.5, 0.5, 0.14, 0.14, 0.5,
@@ -136,11 +136,11 @@ export const RollerSkiCommute: React.FC = () => {
}
from={4042}
trimBefore={3468}
- durationInFrames={1720}
+ durationInFrames={1708}
premountFor={fps}
volume={interpolate(
frame,
- [4042, 4046, 4392, 4404, 4689, 4699, 5740, 5762],
+ [4042, 4046, 4392, 4404, 4689, 4699, 5740, 5750],
[0, 0.55, 0.55, 0.1, 0.1, 0.07, 0.07, 0],
{extrapolateLeft: 'clamp', extrapolateRight: 'clamp'},
)}
diff --git a/packages/jonnys-videos/src/roller-skis-new/scenes/BestCommute.tsx b/packages/jonnys-videos/src/roller-skis-new/scenes/BestCommute.tsx
index af0fd2e519..f3756aa4c9 100644
--- a/packages/jonnys-videos/src/roller-skis-new/scenes/BestCommute.tsx
+++ b/packages/jonnys-videos/src/roller-skis-new/scenes/BestCommute.tsx
@@ -234,7 +234,7 @@ const BestCommuteInner: React.FC<InteractiveTransformProps> = ({style}) => {
'https://remotion.media/jonnys-videos/roller-skis/footage/IMG_0463.MOV'
}
from={347}
- durationInFrames={38}
+ durationInFrames={37}
trimBefore={219}
muted
premountFor={fps}
diff --git a/packages/studio/src/components/Timeline/TimelinePackedTrack.tsx b/packages/studio/src/components/Timeline/TimelinePackedTrack.tsx
index d7c41b3116..99d139e381 100644
--- a/packages/studio/src/components/Timeline/TimelinePackedTrack.tsx
+++ b/packages/studio/src/components/Timeline/TimelinePackedTrack.tsx
@@ -1,11 +1,13 @@
-import React, {useMemo} from 'react';
+import React, {useContext, useMemo} from 'react';
import {TIMELINE_TRACK_SEPARATOR} from '../../helpers/colors';
import {TIMELINE_ITEM_BORDER_BOTTOM} from '../../helpers/timeline-layout';
+import {getTimelineSceneRange} from './get-timeline-scene-range';
import type {TimelineTrackWithDisplayGroup} from './timeline-display-groups';
import {
TIMELINE_PACKED_AUXILIARY_ROW_HEIGHT,
TIMELINE_PACKED_TRACK_HEIGHT,
} from './timeline-track-groups';
+import {TimelineSceneRangeContext} from './TimelineSceneRangeContext';
import {TimelineSequence} from './TimelineSequence';
import {useSeriesReorder} from './use-series-reorder';
@@ -19,13 +21,17 @@ export const TimelinePackedTrack: React.FC<{
readonly auxiliaryRowOffsets: readonly number[];
readonly auxiliaryRows: readonly (readonly TimelineTrackWithDisplayGroup[])[];
}> = ({track, items, auxiliaryRows, auxiliaryRowOffsets}) => {
+ const parentSceneRange = useContext(TimelineSceneRangeContext);
const {dropIndicatorLeft, onClickCapture, onPointerDownCapture} =
useSeriesReorder(items);
const rows = useMemo(() => {
const clips = items
.filter((item) => item.sequence.timelineTrack?.role === 'clip')
.sort((a, b) => a.sequence.from - b.sequence.from);
- return [clips, ...auxiliaryRows].map((row, index) => ({
+ const transitions = items.filter(
+ (item) => item.sequence.timelineTrack?.role === 'transition',
+ );
+ return [[...clips, ...transitions], ...auxiliaryRows].map((row, index) => ({
items: row,
top: index === 0 ? 0 : auxiliaryRowOffsets[index - 1],
height:
@@ -40,6 +46,8 @@ export const TimelinePackedTrack: React.FC<{
onPointerDownCapture={onPointerDownCapture}
style={{
position: 'relative',
+ // Keep clip stacking inside the track, below the pinned timeline ruler.
+ isolation: 'isolate',
height: Math.max(
primaryRowHeight,
...auxiliaryRowOffsets.map(
@@ -69,42 +77,62 @@ export const TimelinePackedTrack: React.FC<{
{/* Keep clips under the same parent when timing edits move them to another row. */}
{rows.flatMap((row) =>
row.items.map((item, index) => (
- <div
+ <TimelineSceneRangeContext.Provider
key={item.sequence.id}
- data-timeline-track-item-id={item.sequence.id}
- style={{
- position: 'absolute',
- top: row.top,
- left: 0,
- // The clip supplies its own pixel width. Empty row space must
- // not intercept clicks on other clips or the marquee.
- width: 0,
- height: row.height - TIMELINE_ITEM_BORDER_BOTTOM,
- }}
+ value={
+ item.sequence.timelineTrack?.role === 'clip'
+ ? getTimelineSceneRange({
+ sequence: item.sequence,
+ seriesItems: items.map((entry) => entry.sequence),
+ previous: row.items[index - 1]?.sequence ?? null,
+ next:
+ row.items[index + 1]?.sequence.timelineTrack?.role ===
+ 'clip'
+ ? row.items[index + 1].sequence
+ : null,
+ // The containing row already applies the parent fade.
+ range: parentSceneRange
+ ? {
+ ...parentSceneRange,
+ fadeInEnd: null,
+ fadeOutStart: null,
+ }
+ : null,
+ })
+ : parentSceneRange
+ }
>
- <TimelineSequence
- s={item.sequence}
- labelStartFrame={null}
- paintEndFrame={
- row.top === 0 &&
- (row.items[index + 1]?.sequence.from ?? -Infinity) >
- item.sequence.from
- ? (row.items[index + 1]?.sequence.from ?? null)
- : null
- }
- cascadedStart={item.cascadedStart}
- localStart={item.localStart}
- parentVisibleStart={item.parentVisibleStart}
- parentVisibleEnd={item.parentVisibleEnd}
- connectedCompositions={
- item.connectedCompositions ?? noConnectedCompositions
- }
- nodePathInfo={item.nodePathInfo}
- keyframeDisplayOffset={item.keyframeDisplayOffset}
- keyframePlaybackRate={item.keyframePlaybackRate}
- sequenceFrameOffset={item.sequenceFrameOffset}
- />
- </div>
+ <div
+ data-timeline-track-item-id={item.sequence.id}
+ style={{
+ position: 'absolute',
+ zIndex:
+ item.sequence.timelineTrack?.role === 'transition' ? 1 : 0,
+ top: row.top,
+ left: 0,
+ // The clip supplies its own pixel width. Empty row space must
+ // not intercept clicks on other clips or the marquee.
+ width: 0,
+ height: row.height - TIMELINE_ITEM_BORDER_BOTTOM,
+ }}
+ >
+ <TimelineSequence
+ s={item.sequence}
+ labelStartFrame={null}
+ cascadedStart={item.cascadedStart}
+ localStart={item.localStart}
+ parentVisibleStart={item.parentVisibleStart}
+ parentVisibleEnd={item.parentVisibleEnd}
+ connectedCompositions={
+ item.connectedCompositions ?? noConnectedCompositions
+ }
+ nodePathInfo={item.nodePathInfo}
+ keyframeDisplayOffset={item.keyframeDisplayOffset}
+ keyframePlaybackRate={item.keyframePlaybackRate}
+ sequenceFrameOffset={item.sequenceFrameOffset}
+ />
+ </div>
+ </TimelineSceneRangeContext.Provider>
)),
)}
{dropIndicatorLeft === null ? null : (
diff --git a/packages/studio/src/components/Timeline/TimelineSequence.tsx b/packages/studio/src/components/Timeline/TimelineSequence.tsx
index 64265ed3b4..77b90e2ac1 100644
--- a/packages/studio/src/components/Timeline/TimelineSequence.tsx
+++ b/packages/studio/src/components/Timeline/TimelineSequence.tsx
@@ -73,6 +73,7 @@ import {
getKeyframePlaybackRate,
} from './get-timeline-keyframes';
import {getTimelineMediaStartFrame} from './get-timeline-media-start-frame';
+import {getTimelineSceneMask} from './get-timeline-scene-mask';
import {getTimelineSequenceVisibleLayout} from './get-timeline-sequence-visible-layout';
import {getCurrentFrame} from './imperative-state';
import {LoopedTimelineIndicator} from './LoopedTimelineIndicators';
@@ -218,7 +219,6 @@ export const TimelineEdgeHighlightProvider: React.FC<{
const TimelineSequenceFn: React.FC<{
readonly s: TimelineTrackData['sequence'];
readonly labelStartFrame: number | null;
- readonly paintEndFrame: number | null;
readonly connectedCompositions: readonly _InternalTypes['AnyComposition'][];
readonly nodePathInfo: SequenceNodePathInfo | null;
readonly keyframeDisplayOffset: number;
@@ -231,7 +231,6 @@ const TimelineSequenceFn: React.FC<{
}> = ({
s,
labelStartFrame,
- paintEndFrame,
connectedCompositions,
nodePathInfo,
keyframeDisplayOffset,
@@ -253,7 +252,6 @@ const TimelineSequenceFn: React.FC<{
windowWidth={windowWidth}
s={s}
labelStartFrame={labelStartFrame}
- paintEndFrame={paintEndFrame}
connectedCompositions={connectedCompositions}
nodePathInfo={nodePathInfo}
keyframeDisplayOffset={keyframeDisplayOffset}
@@ -327,7 +325,6 @@ const TimelineSequenceBar: React.FC<{
readonly labelOffset: number;
readonly connectedComposition: _InternalTypes['AnyComposition'] | null;
readonly annotationLocation: ResolvedStackLocation | null;
- readonly paintEndFrame: number | null;
readonly activeTrimEdge: 'left' | 'right' | null;
readonly leftTrimHighlight: {
readonly left: number;
@@ -371,7 +368,6 @@ const TimelineSequenceBar: React.FC<{
activeTrimEdge,
leftTrimHighlight,
annotationLocation,
- paintEndFrame,
displayDurationInFrames,
selectionBounds,
premount,
@@ -447,25 +443,14 @@ const TimelineSequenceBar: React.FC<{
? sceneRange.end * frameIncrement - Number(style.marginLeft)
: Infinity;
const paintedStart = Math.max(negativeStartEnd, sceneLeft);
- // Packed scene clips overlap during transitions. Stop the outgoing paint at
- // the incoming scene so its trailing gap cannot be covered by the next clip.
- const packedRight =
- paintEndFrame !== null && frameIncrement !== null
- ? paintEndFrame * frameIncrement - Number(style.marginLeft)
- : Infinity;
- const paintedEnd = Math.max(
- 0,
- Math.min(Number(style.width), sceneRight, packedRight),
- );
+ const paintedEnd = Math.max(0, Math.min(Number(style.width), sceneRight));
// Shared child rows need the same gap as Track clips, including when the
// scene clips their trailing edge. Only inset the paint: timing, hit areas,
// and trim handles keep their full width. Preserve tiny clips when zoomed out.
const visualRightInset =
(s.timelineTrack || sceneRange !== null) &&
transitionWidth === null &&
- (rightEdgeVisible ||
- sceneRight <= Number(style.width) ||
- packedRight <= Number(style.width))
+ (rightEdgeVisible || sceneRight <= Number(style.width))
? Number(style.width) -
paintedEnd +
Math.min(1, Math.max(0, paintedEnd - paintedStart - 1))
@@ -482,8 +467,27 @@ const TimelineSequenceBar: React.FC<{
...style,
background: TRANSPARENT,
opacity: 1,
+ maskImage:
+ s.timelineTrack?.role === 'clip' && frameIncrement !== null
+ ? getTimelineSceneMask({
+ sceneRange,
+ offsetInFrames: Number(style.marginLeft) / frameIncrement,
+ durationInFrames: Number(style.width) / frameIncrement,
+ })
+ : undefined,
+ clipPath:
+ s.timelineTrack?.role === 'clip' && sceneRange !== null
+ ? `inset(0 ${Math.max(0, Number(style.width) - sceneRight)}px 0 ${Math.max(0, sceneLeft)}px)`
+ : undefined,
};
- }, [style]);
+ }, [
+ style,
+ s.timelineTrack?.role,
+ frameIncrement,
+ sceneRange,
+ sceneLeft,
+ sceneRight,
+ ]);
const premountIndicator = premount ? (
<div
@@ -755,7 +759,6 @@ const TimelineSequenceBar: React.FC<{
const TimelineSequenceInner: React.FC<{
readonly s: TimelineTrackData['sequence'];
readonly labelStartFrame: number | null;
- readonly paintEndFrame: number | null;
readonly connectedCompositions: readonly _InternalTypes['AnyComposition'][];
readonly windowWidth: number;
readonly nodePathInfo: SequenceNodePathInfo | null;
@@ -769,7 +772,6 @@ const TimelineSequenceInner: React.FC<{
}> = ({
s,
labelStartFrame,
- paintEndFrame,
connectedCompositions,
windowWidth,
nodePathInfo,
@@ -1540,8 +1542,7 @@ const TimelineSequenceInner: React.FC<{
(windowWidth - TIMELINE_PADDING * 2) / video.durationInFrames;
const isMedia = s.type === 'audio' || s.type === 'video';
const layerHeight =
- s.timelineTrack?.role === 'overlay' ||
- s.timelineTrack?.role === 'transition'
+ s.timelineTrack?.role === 'overlay'
? TIMELINE_PACKED_AUXILIARY_ROW_HEIGHT - TIMELINE_ITEM_BORDER_BOTTOM
: s.timelineTrack
? TIMELINE_PACKED_TRACK_HEIGHT
@@ -1788,7 +1789,6 @@ const TimelineSequenceInner: React.FC<{
}
connectedComposition={connectedCompositions[0] ?? null}
annotationLocation={originalLocation}
- paintEndFrame={paintEndFrame}
activeTrimEdge={activeTrimEdge}
leftTrimHighlight={
visibleLayout.media?.offset === 0 ? visibleLayout.media : null
diff --git a/packages/studio/src/components/Timeline/TimelineTrack.tsx b/packages/studio/src/components/Timeline/TimelineTrack.tsx
index d22d2e300b..e61222d97b 100644
--- a/packages/studio/src/components/Timeline/TimelineTrack.tsx
+++ b/packages/studio/src/components/Timeline/TimelineTrack.tsx
@@ -74,7 +74,6 @@ const TimelineTrackUnmemoized: React.FC<{
<TimelineSequence
s={track.sequence}
labelStartFrame={null}
- paintEndFrame={null}
cascadedStart={track.cascadedStart}
localStart={track.localStart}
parentVisibleStart={track.parentVisibleStart}
diff --git a/packages/studio/src/components/Timeline/TimelineTracks.tsx b/packages/studio/src/components/Timeline/TimelineTracks.tsx
index de16d178f2..0450bd3231 100644
--- a/packages/studio/src/components/Timeline/TimelineTracks.tsx
+++ b/packages/studio/src/components/Timeline/TimelineTracks.tsx
@@ -1,6 +1,7 @@
import React, {useContext, useImperativeHandle, useMemo} from 'react';
import {Internals} from 'remotion';
import {TIMELINE_PADDING} from '../../helpers/timeline-layout';
+import {getTimelineSceneMask} from './get-timeline-scene-mask';
import {MaxTimelineTracksReached} from './MaxTimelineTracks';
import {timelineDurationRef, timelineLayerLayoutsRef} from './timeline-refs';
import type {TimelineSceneRange} from './timeline-series-layout';
@@ -108,6 +109,7 @@ const TimelineTracksInner: React.FC<{
auxiliaryRowOffsets={auxiliaryRowOffsets}
/>
);
+
return (
<div
key={virtualItem.key}
@@ -123,6 +125,14 @@ const TimelineTracksInner: React.FC<{
? windowWidth - TIMELINE_PADDING * 2
: undefined,
top: virtualItem.start,
+ // Fade the shared rows on either side of the transition midpoint.
+ maskImage: video
+ ? getTimelineSceneMask({
+ sceneRange,
+ durationInFrames: video.durationInFrames,
+ offsetInFrames: 0,
+ })
+ : undefined,
clipPath:
sceneRange === null || !video
? undefined
diff --git a/packages/studio/src/components/Timeline/TimelineVirtualization.tsx b/packages/studio/src/components/Timeline/TimelineVirtualization.tsx
index dd09932d6f..16b1773f24 100644
--- a/packages/studio/src/components/Timeline/TimelineVirtualization.tsx
+++ b/packages/studio/src/components/Timeline/TimelineVirtualization.tsx
@@ -135,7 +135,9 @@ export const TimelineVirtualizationProvider: React.FC<{
previous.siblingIndex === siblingIndex &&
previous.sceneGroupId === sceneGroupId &&
previous.sceneRange?.from === sceneRange?.from &&
- previous.sceneRange?.end === sceneRange?.end
+ previous.sceneRange?.end === sceneRange?.end &&
+ previous.sceneRange?.fadeInEnd === sceneRange?.fadeInEnd &&
+ previous.sceneRange?.fadeOutStart === sceneRange?.fadeOutStart
) {
return previous;
}
diff --git a/packages/studio/src/components/Timeline/get-timeline-scene-mask.ts b/packages/studio/src/components/Timeline/get-timeline-scene-mask.ts
new file mode 100644
index 0000000000..2bca6fb4d9
--- /dev/null
+++ b/packages/studio/src/components/Timeline/get-timeline-scene-mask.ts
@@ -0,0 +1,49 @@
+import type {TimelineSceneRange} from './timeline-series-layout';
+
+export const getTimelineSceneMask = ({
+ sceneRange,
+ durationInFrames,
+ offsetInFrames,
+}: {
+ readonly sceneRange: TimelineSceneRange | null;
+ readonly durationInFrames: number;
+ readonly offsetInFrames: number;
+}): string | undefined => {
+ if (
+ sceneRange === null ||
+ durationInFrames <= 0 ||
+ (sceneRange.fadeInEnd === null && sceneRange.fadeOutStart === null)
+ ) {
+ return undefined;
+ }
+
+ const stops: string[] = [];
+ for (const direction of ['in', 'out'] as const) {
+ const boundary =
+ direction === 'in' ? sceneRange.fadeInEnd : sceneRange.fadeOutStart;
+ if (boundary === null) {
+ stops.push(direction === 'in' ? 'black 0%' : 'black 100%');
+ continue;
+ }
+
+ const from =
+ direction === 'in'
+ ? sceneRange.from
+ : Math.max(sceneRange.from, boundary);
+ const end =
+ direction === 'in' ? Math.min(sceneRange.end, boundary) : sceneRange.end;
+ // Approximate smootherstep with gradual stops so neither end
+ // has an abrupt change in the gradient's slope.
+ for (let step = 0; step <= 8; step++) {
+ const progress = step / 8;
+ const eased = progress ** 3 * (progress * (progress * 6 - 15) + 10);
+ const alpha = direction === 'in' ? eased : 1 - eased;
+ const position =
+ ((from + (end - from) * progress - offsetInFrames) / durationInFrames) *
+ 100;
+ stops.push(`rgba(0, 0, 0, ${alpha}) ${position}%`);
+ }
+ }
+
+ return `linear-gradient(to right, ${stops.join(', ')})`;
+};
diff --git a/packages/studio/src/components/Timeline/get-timeline-scene-range.ts b/packages/studio/src/components/Timeline/get-timeline-scene-range.ts
new file mode 100644
index 0000000000..4b4b515428
--- /dev/null
+++ b/packages/studio/src/components/Timeline/get-timeline-scene-range.ts
@@ -0,0 +1,54 @@
+import type {TSequence} from 'remotion';
+import type {TimelineSceneRange} from './timeline-series-layout';
+
+export const getTimelineSceneRange = ({
+ sequence,
+ previous,
+ next,
+ range,
+ seriesItems,
+}: {
+ readonly sequence: TSequence;
+ readonly previous: TSequence | null;
+ readonly next: TSequence | null;
+ readonly range: TimelineSceneRange | null;
+ readonly seriesItems: readonly TSequence[];
+}): TimelineSceneRange => {
+ const sceneEnd = sequence.from + sequence.duration;
+ const previousEnd = previous
+ ? previous.from + previous.duration
+ : sequence.from;
+ const incomingOverlap =
+ sequence.timelineTrack?.role === 'clip' &&
+ previousEnd > sequence.from &&
+ seriesItems.some(
+ (item) =>
+ item.timelineTrack?.role === 'transition' &&
+ item.from === sequence.from,
+ );
+ const outgoingOverlap =
+ sequence.timelineTrack?.role === 'clip' &&
+ next !== null &&
+ next.from < sceneEnd &&
+ seriesItems.some(
+ (item) =>
+ item.timelineTrack?.role === 'transition' && item.from === next.from,
+ );
+
+ return {
+ from: Math.max(
+ range?.from ?? -Infinity,
+ incomingOverlap ? (sequence.from + previousEnd) / 2 : sequence.from,
+ ),
+ end: Math.min(
+ range?.end ?? Infinity,
+ outgoingOverlap ? (next.from + sceneEnd) / 2 : sceneEnd,
+ ),
+ fadeInEnd: incomingOverlap
+ ? Math.max(range?.fadeInEnd ?? -Infinity, previousEnd)
+ : (range?.fadeInEnd ?? null),
+ fadeOutStart: outgoingOverlap
+ ? Math.min(range?.fadeOutStart ?? Infinity, next.from)
+ : (range?.fadeOutStart ?? null),
+ };
+};
diff --git a/packages/studio/src/components/Timeline/timeline-series-layout.ts b/packages/studio/src/components/Timeline/timeline-series-layout.ts
index 9fde5e5d2c..a711fd2894 100644
--- a/packages/studio/src/components/Timeline/timeline-series-layout.ts
+++ b/packages/studio/src/components/Timeline/timeline-series-layout.ts
@@ -1,4 +1,5 @@
import type {TSequence} from 'remotion';
+import {getTimelineSceneRange} from './get-timeline-scene-range';
import type {TimelineTrackWithDisplayGroup} from './timeline-display-groups';
import {
TIMELINE_PACKED_AUXILIARY_ROW_HEIGHT,
@@ -8,6 +9,8 @@ import {
export type TimelineSceneRange = {
readonly from: number;
readonly end: number;
+ readonly fadeInEnd: number | null;
+ readonly fadeOutStart: number | null;
};
// Keep sequence rows and their identities intact. Only their vertical positions
@@ -129,73 +132,52 @@ export const getTimelineSeriesLayout = ({
continue;
}
- // Keep transitions by the scene track, but place overlays after scene children.
- const overlayRows = rows[index].auxiliaryRows.flatMap(
- (items, auxiliaryIndex) =>
- items[0]?.sequence.timelineTrack?.role === 'overlay'
- ? [auxiliaryIndex]
- : [],
- );
- cursor -= overlayRows.length * TIMELINE_PACKED_AUXILIARY_ROW_HEIGHT;
+ const overlayRowCount = rows[index].auxiliaryRows.length;
+ cursor -= overlayRowCount * TIMELINE_PACKED_AUXILIARY_ROW_HEIGHT;
// Overlay contents get their own space below the scene contents.
for (const role of ['clip', 'overlay'] as const) {
if (role === 'overlay') {
- for (const auxiliaryIndex of overlayRows) {
+ for (
+ let auxiliaryIndex = 0;
+ auxiliaryIndex < overlayRowCount;
+ auxiliaryIndex++
+ ) {
auxiliaryRowOffsets[index][auxiliaryIndex] =
cursor - offsets[index];
cursor += TIMELINE_PACKED_AUXILIARY_ROW_HEIGHT;
}
- if (overlayRows.length > 0) {
+ if (overlayRowCount > 0) {
rowHeights[index] = cursor - offsets[index];
}
}
- const lanes: {end: number; height: number}[] = [];
- const placements: {lane: number; rows: number[]}[] = [];
- for (const {sequence} of scenes) {
- if (sequence.timelineTrack?.role !== role) {
- continue;
- }
-
- const sceneRange = {
- from: Math.max(range?.from ?? -Infinity, sequence.from),
- end: Math.min(
- range?.end ?? Infinity,
- sequence.from + sequence.duration,
- ),
- };
- const firstRow = groupRows.length;
+ let sceneHeight = 0;
+ const roleScenes = scenes.filter(
+ ({sequence}) => sequence.timelineTrack?.role === role,
+ );
+ for (let sceneIndex = 0; sceneIndex < roleScenes.length; sceneIndex++) {
+ const {sequence} = roleScenes[sceneIndex];
+ const previous = roleScenes[sceneIndex - 1]?.sequence;
+ const next = roleScenes[sceneIndex + 1]?.sequence;
+ const sceneRange = getTimelineSceneRange({
+ sequence,
+ seriesItems: rows[index].items?.map((item) => item.sequence) ?? [],
+ previous: previous ?? null,
+ next: next ?? null,
+ range,
+ });
const end = layoutRows(
childrenByScene.get(sequence.id) ?? [],
cursor,
sceneRange,
groupRows,
);
- let lane = lanes.findIndex((item) => item.end <= sceneRange.from);
- if (lane === -1) {
- lane = lanes.length;
- lanes.push({end: sceneRange.end, height: end - cursor});
- } else {
- lanes[lane].end = sceneRange.end;
- lanes[lane].height = Math.max(lanes[lane].height, end - cursor);
- }
-
- placements.push({lane, rows: groupRows.slice(firstRow)});
- }
-
- // Assign lanes even to dormant scenes without registered children.
- // Reserve the largest child stack in every lane: otherwise a lane
- // collapses when its scene unmounts and moves a still-active scene.
- const laneHeight = Math.max(0, ...lanes.map((lane) => lane.height));
-
- for (const placement of placements) {
- for (const childIndex of placement.rows) {
- offsets[childIndex] += placement.lane * laneHeight;
- }
+ sceneHeight = Math.max(sceneHeight, end - cursor);
}
- cursor += lanes.length * laneHeight;
+ // Scenes share child space, handing it off at transition midpoints.
+ cursor += sceneHeight;
}
}
diff --git a/packages/studio/src/components/Timeline/timeline-track-groups.ts b/packages/studio/src/components/Timeline/timeline-track-groups.ts
index 262a90efb2..ac6f8cb753 100644
--- a/packages/studio/src/components/Timeline/timeline-track-groups.ts
+++ b/packages/studio/src/components/Timeline/timeline-track-groups.ts
@@ -143,16 +143,10 @@ export const getTimelineDisplayRows = (
const items = groupedItems.get(group.id) ?? [];
const auxiliaryRows: TimelineTrackWithDisplayGroup[][] = [];
- // Transitions occupy their own row, followed by overlay rows.
- const effects = [
- ...items.filter(
- (item) => item.sequence.timelineTrack?.role === 'transition',
- ),
- ...items.filter(
- (item) => item.sequence.timelineTrack?.role === 'overlay',
- ),
- ];
- for (const item of effects) {
+ // Transitions paint over scene clips. Only overlays need extra rows.
+ for (const item of items.filter(
+ (candidate) => candidate.sequence.timelineTrack?.role === 'overlay',
+ )) {
const start = item.sequence.from;
const end =
item.sequence.from +
@@ -168,11 +162,7 @@ export const getTimelineDisplayRows = (
(sequence.postmountDisplay ?? 0);
return start < otherEnd && otherStart < end;
});
- if (
- overlaps ||
- auxiliaryRows[index][0].sequence.timelineTrack?.role !==
- item.sequence.timelineTrack?.role
- ) {
+ if (overlaps) {
// Later overlays paint above earlier ones. Keep them below every
// overlapping overlay, even if a higher row has free space.
rowIndex = index + 1;
diff --git a/packages/transitions/src/TransitionSeries.tsx b/packages/transitions/src/TransitionSeries.tsx
index e55aa0103d..e27f4ac89d 100644
--- a/packages/transitions/src/TransitionSeries.tsx
+++ b/packages/transitions/src/TransitionSeries.tsx
@@ -1013,6 +1013,7 @@ const TransitionSeriesInner: FC<SequenceProps> = (props) => {
return (
<TrackWithoutSchema
+ _remotionInternalAllowOverlap
name={displayName}
layout={layout}
_remotionInternalDocumentationLink="https://www.remotion.dev/docs/transitions/transitionseries"