🎥 Make videos programmatically with React
import {PlayerInternals} from '@remotion/player';
import {CanvasInternals} from '@remotion/sdk';
import React, {
useCallback,
useContext,
useLayoutEffect,
useMemo,
useRef,
useState,
} from 'react';
import {
Internals,
type GetDragOverrides,
type InteractivitySchema,
type RuntimeValueStore,
type TSequence,
} from 'remotion';
import {NoReactInternals} from 'remotion/no-react';
import {useTimelineCalculator} from '../helpers/calculate-timeline';
import {StudioServerConnectionCtx} from '../helpers/client-id';
import {
isStudioInteractivityEnabled,
isStudioSelectionEnabled,
} from '../helpers/interactivity-enabled';
import {useIsFullscreen} from '../helpers/use-is-fullscreen';
import {useRuntimeValueSnapshots} from '../helpers/use-runtime-values';
import {EditorShowOutlinesContext} from '../state/editor-outlines';
import {ScaleLockContext} from '../state/scale-lock';
import {
useSetTimelineSequenceHover,
useTimelineSequenceHoverState,
} from '../state/timeline-sequence-hover';
import {Transform3DModeStateContext} from '../state/transform-3d-mode';
import {getSelectedOutlineActiveSchema} from './selected-outline-drag';
import {
getSelectedCropInfo,
getSelectedEffectFieldsBySequenceKey,
getSelectedRotationInfo,
getSelectedSequenceKeys,
getSelectedTransformOriginInfo,
getSequenceKeysContainingSelection,
} from './selected-outline-measurement';
import {orderOutlinesForRendering} from './selected-outline-order';
import {
canEditSelectedOutlineCrop,
cropFieldKeys,
rotateFieldKey,
scaleFieldKey,
transformOriginFieldKey,
translateFieldKey,
type SelectedOutlineCropDragTarget,
type SelectedOutlineCropFieldKey,
type SelectedOutlineDragTarget,
type SelectedOutlineLayoutTarget,
type SelectedOutlineTarget,
} from './selected-outline-types';
import {SelectedOutlineKeyboardControls} from './SelectedOutlineKeyboardControls';
import {SelectedOutlineRenderer} from './SelectedOutlineRenderer';
import {getKeyframeDisplayOffset} from './Timeline/get-timeline-keyframes';
import {
useCurrentTimelineSelectionStateAsRef,
useTimelineSelection,
type TimelineSelection,
type TimelineSelectionInteraction,
} from './Timeline/TimelineSelection';
import {propStatusHas3DTransformValue} from './Timeline/transform-3d-mode';
const {
createCanvasOutlineLayoutTargetLookup,
getCanvasSelectableOutlines,
getCanvasVisibleOutlineTargets,
getCanvasActiveOutlineTargets,
getCanvasOutlineActivity,
getCanvasOutlineLayoutTargets,
} = CanvasInternals;
export {orderOutlinesForRendering};
export {
applySelectedOutlineTransformOriginAxisLock,
compensateTranslateForTransformOrigin,
getSelectedOutline3DRotationDragValues,
getSelectedOutlineActiveSchema,
getSelectedOutlineCropDragChanges,
getSelectedOutlineCropDragValues,
getSelectedOutlineCropFollowingTransformOrigin,
getSelectedOutlineRotationDragChanges,
getSelectedOutlineRotationDragStates,
getSelectedOutlineRotationDragValues,
getSelectedOutlineScaleDragChanges,
getSelectedOutlineScaleDragStates,
getSelectedOutlineScaleDragValues,
getSelectedOutlineScaleEdgeInfo,
getSelectedOutlineTransformOriginDragChanges,
getSelectedOutlineTransformOriginLockedAxis,
selectedOutlineTransformOriginSnapThresholdPx,
selectedOutlineUvSnapThresholdPx,
snapSelectedOutlineRotationDeltaDegrees,
snapSelectedOutlineTransformOriginUv,
snapSelectedOutlineUv,
} from './selected-outline-drag';
export {
getOutlineSelectionInteraction,
getSelectedCropInfo,
getSelectedEffectFieldsBySequenceKey,
getSelectedOutlineRotationCornerInfo,
getSelectedOutlineRotationDeltaDegrees,
getSelectedOutlineRotationPivot,
getSelectedSequenceKeys,
getTransformedSvgViewportPoints,
} from './selected-outline-measurement';
const getEffectiveCropValue = ({
activeSchema,
dragOverrides,
fieldKey,
frame,
propStatuses,
runtimeValues,
}: {
readonly activeSchema: InteractivitySchema | null;
readonly dragOverrides: ReturnType<GetDragOverrides>;
readonly fieldKey: string;
readonly frame: number;
readonly propStatuses: ReturnType<typeof Internals.getPropStatusesCtx>;
readonly runtimeValues: Readonly<Record<string, unknown>>;
}): number => {
const fieldSchema = activeSchema?.[fieldKey];
if (fieldSchema?.type !== 'number') {
return 0;
}
const propStatus = propStatuses?.[fieldKey];
const value =
propStatus?.status === 'static' || propStatus?.status === 'keyframed'
? Internals.getEffectiveVisualModeValue({
propStatus,
dragOverrideValue: dragOverrides[fieldKey],
defaultValue: fieldSchema.default,
frame,
shouldResortToDefaultValueIfUndefined: true,
})
: (runtimeValues[fieldKey] ?? fieldSchema.default);
return typeof value === 'number' && Number.isFinite(value) ? value : 0;
};
const getCropDragFields = ({
activeSchema,
cropValues,
propStatuses,
}: {
readonly activeSchema: InteractivitySchema | null;
readonly cropValues: Record<SelectedOutlineCropFieldKey, number>;
readonly propStatuses: ReturnType<typeof Internals.getPropStatusesCtx>;
}): SelectedOutlineCropDragTarget['fields'] | null => {
if (
!canEditSelectedOutlineCrop({
schema: activeSchema,
propStatuses,
})
) {
return null;
}
const fields: Partial<SelectedOutlineCropDragTarget['fields']> = {};
for (const fieldKey of Object.values(cropFieldKeys)) {
const fieldSchema = activeSchema?.[fieldKey];
const propStatus = propStatuses?.[fieldKey];
const canEditStatus =
propStatus?.status === 'static' ||
(propStatus?.status === 'keyframed' &&
propStatus.interpolationFunction === 'interpolate');
if (fieldSchema?.type !== 'number' || !canEditStatus) {
return null;
}
fields[fieldKey] = {
defaultValue: fieldSchema.default,
fieldSchema,
propStatus,
value: cropValues[fieldKey],
};
}
return fields as SelectedOutlineCropDragTarget['fields'];
};
type SelectableOutlines = Readonly<
ReturnType<typeof getCanvasSelectableOutlines>
>;
type CalculateOutlineTargetsOptions = {
readonly getCanvasLayoutTargets:
| (() => ReturnType<typeof getCanvasOutlineLayoutTargets>)
| null;
readonly mode: 'controls' | 'layout';
readonly runtimeValuesByStore: ReadonlyMap<
RuntimeValueStore,
Readonly<Record<string, unknown>>
>;
readonly selectableOutlines: SelectableOutlines;
readonly targetKey: string | null;
readonly targetTimelinePosition: number;
};
type CalculateOutlineTargets = (
options: CalculateOutlineTargetsOptions,
) => SelectedOutlineLayoutTarget[];
const calculateOutlineTargets = ({
connectedClientId,
editorShowOutlines,
getCanvasLayoutTargets,
getDragOverrides,
getScaleLockState,
isFullscreen,
manuallyEnabled3DTransformSequenceKeys,
mode,
previewSelectionAvailable,
propStatuses,
runtimeValuesByStore,
selectableOutlines,
selectedCropInfo,
selectedEffectsBySequenceKey,
selectedRotationInfo,
selectedSequenceKeys,
selectedTransformOriginInfo,
sequenceKeysContainingSelection,
studioInteractivityEnabled,
targetKey,
targetTimelinePosition,
}: CalculateOutlineTargetsOptions & {
readonly connectedClientId: string | null;
readonly editorShowOutlines: boolean;
readonly getDragOverrides: React.ContextType<
typeof Internals.VisualModeDragOverridesContext
>['getDragOverrides'];
readonly getScaleLockState: React.ContextType<
typeof ScaleLockContext
>['getScaleLockState'];
readonly isFullscreen: boolean;
readonly manuallyEnabled3DTransformSequenceKeys: ReadonlySet<string>;
readonly previewSelectionAvailable: boolean;
readonly propStatuses: React.ContextType<
typeof Internals.VisualModePropStatusesContext
>['propStatuses'];
readonly selectedCropInfo: ReturnType<typeof getSelectedCropInfo>;
readonly selectedEffectsBySequenceKey: ReturnType<
typeof getSelectedEffectFieldsBySequenceKey
>;
readonly selectedRotationInfo: ReturnType<typeof getSelectedRotationInfo>;
readonly selectedSequenceKeys: ReadonlySet<string>;
readonly selectedTransformOriginInfo: ReturnType<
typeof getSelectedTransformOriginInfo
>;
readonly sequenceKeysContainingSelection: ReadonlySet<string>;
readonly studioInteractivityEnabled: boolean;
}): SelectedOutlineLayoutTarget[] => {
if (
isFullscreen ||
!isStudioSelectionEnabled() ||
!previewSelectionAvailable ||
!editorShowOutlines
) {
return [];
}
const previewInteractive =
connectedClientId !== null && studioInteractivityEnabled;
const canvasLayoutTargets =
getCanvasLayoutTargets === null
? getCanvasOutlineLayoutTargets({
selectableOutlines,
selectedSequenceKeys,
sequenceKeysContainingSelection,
targetKey,
})
: getCanvasLayoutTargets();
return canvasLayoutTargets.flatMap((canvasLayoutTarget) => {
const {
key,
keyframeDisplayOffset,
keyframePlaybackRate,
nodePathInfo,
sequence,
} = canvasLayoutTarget;
const nodePath = nodePathInfo.sequenceSubscriptionKey;
const {controls} = sequence;
const nodePropStatuses = Internals.getPropStatusesCtx(
propStatuses,
nodePath,
);
const firstKeyframedStatus = Object.values(nodePropStatuses ?? {}).find(
(status) => status.status === 'keyframed',
);
const nodeKeyframeDisplayOffset = getKeyframeDisplayOffset({
propStatus: firstKeyframedStatus ?? null,
keyframeDisplayOffset,
keyframePlaybackRate,
});
const dragOverrides = getDragOverrides(nodePath) ?? {};
const runtimeValues = controls
? (runtimeValuesByStore.get(controls.runtimeValues) ??
controls.runtimeValues.getSnapshot())
: {};
const activeSchema = controls
? getSelectedOutlineActiveSchema({
schema: controls.schema,
currentRuntimeValueDotNotation: runtimeValues,
dragOverrides,
propStatus: nodePropStatuses,
frame:
(targetTimelinePosition - keyframeDisplayOffset) *
keyframePlaybackRate,
})
: null;
const cropValues = {
cropLeft: getEffectiveCropValue({
activeSchema,
dragOverrides,
fieldKey: cropFieldKeys.left,
frame:
(targetTimelinePosition - keyframeDisplayOffset) *
keyframePlaybackRate,
propStatuses: nodePropStatuses,
runtimeValues,
}),
cropRight: getEffectiveCropValue({
activeSchema,
dragOverrides,
fieldKey: cropFieldKeys.right,
frame:
(targetTimelinePosition - keyframeDisplayOffset) *
keyframePlaybackRate,
propStatuses: nodePropStatuses,
runtimeValues,
}),
cropTop: getEffectiveCropValue({
activeSchema,
dragOverrides,
fieldKey: cropFieldKeys.top,
frame:
(targetTimelinePosition - keyframeDisplayOffset) *
keyframePlaybackRate,
propStatuses: nodePropStatuses,
runtimeValues,
}),
cropBottom: getEffectiveCropValue({
activeSchema,
dragOverrides,
fieldKey: cropFieldKeys.bottom,
frame:
(targetTimelinePosition - keyframeDisplayOffset) *
keyframePlaybackRate,
propStatuses: nodePropStatuses,
runtimeValues,
}),
};
const crop = Internals.resolveSequenceCrop(cropValues);
const selectedForTransformOrigin =
selectedTransformOriginInfo?.sequenceKey === key;
const selectedForCrop = selectedCropInfo?.sequenceKey === key;
const selectedForRotation = selectedRotationInfo?.sequenceKey === key;
const selectedForUvHandles = selectedEffectsBySequenceKey.has(key);
const fieldSchema = activeSchema?.[translateFieldKey];
const pathFieldSchema = activeSchema?.d;
const pathPropStatus = nodePropStatuses?.d;
const propStatus = nodePropStatuses?.[translateFieldKey];
const scaleFieldSchema = activeSchema?.[scaleFieldKey];
const scalePropStatus = nodePropStatuses?.[scaleFieldKey];
const rotationFieldSchema = activeSchema?.[rotateFieldKey];
const rotationPropStatus = nodePropStatuses?.[rotateFieldKey];
const transformOriginFieldSchema = activeSchema?.[transformOriginFieldKey];
const transformOriginPropStatus =
nodePropStatuses?.[transformOriginFieldKey];
const transformOriginValueForRotation =
transformOriginFieldSchema?.type === 'transform-origin' &&
(transformOriginPropStatus?.status === 'static' ||
transformOriginPropStatus?.status === 'keyframed')
? String(
Internals.getEffectiveVisualModeValue({
propStatus: transformOriginPropStatus ?? null,
dragOverrideValue: dragOverrides[transformOriginFieldKey],
defaultValue: transformOriginFieldSchema.default,
frame:
(targetTimelinePosition - keyframeDisplayOffset) *
keyframePlaybackRate,
shouldResortToDefaultValueIfUndefined: true,
}) ?? transformOriginFieldSchema.default,
)
: '50% 50%';
const layoutTarget: SelectedOutlineLayoutTarget = {
...canvasLayoutTarget,
crop,
keyframeDisplayOffset: nodeKeyframeDisplayOffset,
selectedForCrop,
selectedForRotation,
selectedForTransformOrigin,
selectedForUvHandles,
transformOriginValue: transformOriginValueForRotation,
};
if (mode === 'layout') {
return [layoutTarget];
}
const cropFields = getCropDragFields({
activeSchema,
cropValues,
propStatuses: nodePropStatuses,
});
const canDragStatus =
propStatus?.status === 'static' ||
(propStatus?.status === 'keyframed' &&
propStatus.interpolationFunction === 'interpolate');
const canRotationDragStatus =
rotationPropStatus?.status === 'static' ||
(rotationPropStatus?.status === 'keyframed' &&
rotationPropStatus.interpolationFunction === 'interpolate');
const canDrag =
previewInteractive &&
controls !== null &&
fieldSchema?.type === 'translate' &&
canDragStatus;
const canScaleDragStatus =
scalePropStatus?.status === 'static' ||
(scalePropStatus?.status === 'keyframed' &&
scalePropStatus.interpolationFunction === 'interpolate');
const canScaleDrag =
previewInteractive &&
controls !== null &&
scaleFieldSchema?.type === 'scale' &&
canScaleDragStatus;
const canRotationDrag =
previewInteractive &&
controls !== null &&
rotationFieldSchema?.type === 'rotation-css' &&
canRotationDragStatus;
const transform3DMode =
manuallyEnabled3DTransformSequenceKeys.has(key) ||
[
'style.translate',
'style.scale',
'style.rotate',
'style.transformOrigin',
].some((fieldKey) =>
propStatusHas3DTransformValue({
fieldKey,
propStatus: nodePropStatuses?.[fieldKey],
runtimeValue: runtimeValues[fieldKey],
}),
);
const transformOriginLocalFrame =
((selectedTransformOriginInfo?.displayFrame ?? targetTimelinePosition) -
keyframeDisplayOffset) *
keyframePlaybackRate;
const canTransformOriginStatus =
transformOriginPropStatus?.status === 'static' ||
(transformOriginPropStatus?.status === 'keyframed' &&
transformOriginPropStatus.interpolationFunction === 'interpolate');
const canTransformOriginTranslateStatus =
propStatus?.status === 'static' ||
(propStatus?.status === 'keyframed' &&
propStatus.interpolationFunction === 'interpolate');
const canTransformOriginDrag =
previewInteractive &&
(selectedForTransformOrigin || selectedForRotation) &&
controls !== null &&
transformOriginFieldSchema?.type === 'transform-origin' &&
fieldSchema?.type === 'translate' &&
canTransformOriginStatus &&
canTransformOriginTranslateStatus;
const cropSourceFrame = {
displayFrame: selectedCropInfo?.displayFrame ?? targetTimelinePosition,
keyframeDisplayOffset: nodeKeyframeDisplayOffset,
keyframePlaybackRate,
};
const canCropDrag =
previewInteractive &&
selectedForCrop &&
controls !== null &&
cropFields !== null;
return [
{
...layoutTarget,
pathDrag:
previewInteractive &&
controls !== null &&
pathFieldSchema?.type === 'svg-path' &&
((pathPropStatus?.status === 'static' &&
typeof pathPropStatus.codeValue === 'string') ||
(pathPropStatus?.status === 'keyframed' &&
pathFieldSchema.keyframable !== false &&
pathPropStatus.interpolationFunction === 'interpolatePaths'))
? {
clientId: connectedClientId,
nodePath,
propStatus: pathPropStatus,
schema: controls.schema,
sourceFrame: {
displayFrame: targetTimelinePosition,
keyframeDisplayOffset: getKeyframeDisplayOffset({
propStatus: pathPropStatus,
keyframeDisplayOffset,
keyframePlaybackRate,
}),
keyframePlaybackRate,
},
}
: null,
canCrop: previewInteractive && controls !== null && cropFields !== null,
cropDrag: canCropDrag
? {
clientId: connectedClientId,
fields: cropFields,
nodePath,
schema: controls.schema,
sourceFrame: cropSourceFrame,
transformOrigin:
transformOriginFieldSchema?.type === 'transform-origin' &&
transformOriginPropStatus !== undefined
? {
defaultValue: transformOriginFieldSchema.default,
propStatus: transformOriginPropStatus ?? null,
value: transformOriginValueForRotation,
}
: null,
}
: null,
drag: canDrag
? {
propStatus,
clientId: connectedClientId,
fieldDefault: fieldSchema.default,
runtimeValue: runtimeValues[translateFieldKey],
keyframePlaybackRate,
keyframeDisplayOffset: getKeyframeDisplayOffset({
propStatus,
keyframeDisplayOffset,
keyframePlaybackRate,
}),
nodePath,
schema: controls.schema,
}
: null,
scaleDrag: canScaleDrag
? {
propStatus: scalePropStatus,
clientId: connectedClientId,
fieldDefault: scaleFieldSchema.default,
fieldSchema: scaleFieldSchema,
keyframePlaybackRate,
keyframeDisplayOffset: getKeyframeDisplayOffset({
propStatus: scalePropStatus,
keyframeDisplayOffset,
keyframePlaybackRate,
}),
linked: getScaleLockState({
nodePath,
fieldKey: scaleFieldKey,
defaultValue: (() => {
const dragOverrideValue = dragOverrides[scaleFieldKey];
const effectiveValue = Internals.getEffectiveVisualModeValue({
propStatus: scalePropStatus,
dragOverrideValue,
defaultValue: scaleFieldSchema.default,
shouldResortToDefaultValueIfUndefined: true,
});
const [x, y] =
NoReactInternals.parseScaleValue(effectiveValue);
return x === y;
})(),
}),
nodePath,
schema: controls.schema,
}
: null,
rotationDrag: canRotationDrag
? {
propStatus: rotationPropStatus,
clientId: connectedClientId,
fieldDefault: rotationFieldSchema.default,
fieldSchema: rotationFieldSchema,
keyframePlaybackRate,
keyframeDisplayOffset: getKeyframeDisplayOffset({
propStatus: rotationPropStatus,
keyframeDisplayOffset,
keyframePlaybackRate,
}),
nodePath,
schema: controls.schema,
transform3DMode,
transformOriginValue: transformOriginValueForRotation,
}
: null,
transformOriginDrag: canTransformOriginDrag
? {
clientId: connectedClientId,
keyframePlaybackRate,
keyframeDisplayOffset: getKeyframeDisplayOffset({
propStatus: transformOriginPropStatus ?? null,
keyframeDisplayOffset,
keyframePlaybackRate,
}),
nodePath,
originDefault: transformOriginFieldSchema.default,
originPropStatus: transformOriginPropStatus,
originValue: String(
Internals.getEffectiveVisualModeValue({
propStatus: transformOriginPropStatus ?? null,
dragOverrideValue: dragOverrides[transformOriginFieldKey],
defaultValue: transformOriginFieldSchema.default,
frame: transformOriginLocalFrame,
shouldResortToDefaultValueIfUndefined: true,
}) ?? transformOriginFieldSchema.default,
),
rotateValue: String(
rotationPropStatus?.status === 'static' ||
rotationPropStatus?.status === 'keyframed'
? (Internals.getEffectiveVisualModeValue({
propStatus: rotationPropStatus,
dragOverrideValue: dragOverrides[rotateFieldKey],
defaultValue:
rotationFieldSchema?.type === 'rotation-css'
? rotationFieldSchema.default
: '0deg',
frame: transformOriginLocalFrame,
shouldResortToDefaultValueIfUndefined: true,
}) ?? '0deg')
: '0deg',
),
scaleValue:
scalePropStatus?.status === 'static' ||
scalePropStatus?.status === 'keyframed'
? String(
Internals.getEffectiveVisualModeValue({
propStatus: scalePropStatus,
dragOverrideValue: dragOverrides[scaleFieldKey],
defaultValue:
scaleFieldSchema?.type === 'scale'
? scaleFieldSchema.default
: 1,
frame: transformOriginLocalFrame,
shouldResortToDefaultValueIfUndefined: true,
}) ?? 1,
)
: '1',
schema: controls.schema,
sourceFrame: {
displayFrame:
selectedTransformOriginInfo?.displayFrame ??
targetTimelinePosition,
keyframeDisplayOffset: getKeyframeDisplayOffset({
propStatus: transformOriginPropStatus,
keyframeDisplayOffset,
keyframePlaybackRate,
}),
keyframePlaybackRate,
},
translateDefault: fieldSchema.default,
translatePropStatus: propStatus,
translateValue: String(
Internals.getEffectiveVisualModeValue({
propStatus,
dragOverrideValue: dragOverrides[translateFieldKey],
defaultValue: fieldSchema.default,
frame: transformOriginLocalFrame,
shouldResortToDefaultValueIfUndefined: true,
}) ?? fieldSchema.default,
),
}
: null,
} satisfies SelectedOutlineTarget,
];
});
};
export type {
SelectedOutlineDragState,
SelectedOutlineRotationDragState,
SelectedOutlineScaleDragState,
} from './selected-outline-types';
type SelectedOutlineOverlayProps = {
readonly canvasHovered: boolean;
readonly compositionHeight: number;
readonly compositionWidth: number;
readonly scale: number;
};
type ActiveSelectedOutlineOverlayProps = Omit<
SelectedOutlineOverlayProps,
'canvasHovered'
> & {
readonly calculateOutlineTargetsForCurrentState: CalculateOutlineTargets;
readonly draggingOutline: boolean;
readonly getAllDragTargets: () => readonly SelectedOutlineDragTarget[];
readonly getLatestOutlineTargetByKey: (
key: string,
) => SelectedOutlineTarget | undefined;
readonly getSelectableOutlines: (
timelinePosition: number | null,
) => SelectableOutlines;
readonly hoveredTimelineNodePathKey: string | null;
readonly measureAllOutlines: boolean;
readonly onDraggingChange: (dragging: boolean) => void;
readonly onContextMenuOpenChange: (open: boolean) => void;
readonly onSelect: (
item: TimelineSelection,
interaction?: TimelineSelectionInteraction,
) => void;
readonly selectedSequenceKeys: ReadonlySet<string>;
readonly sequenceKeysContainingSelection: ReadonlySet<string>;
readonly sequences: TSequence[];
};
const ActiveSelectedOutlineOverlayUnmemoized: React.FC<
ActiveSelectedOutlineOverlayProps
> = ({
calculateOutlineTargetsForCurrentState,
compositionHeight,
compositionWidth,
draggingOutline,
getAllDragTargets,
getLatestOutlineTargetByKey,
getSelectableOutlines,
hoveredTimelineNodePathKey,
measureAllOutlines,
onDraggingChange,
onContextMenuOpenChange,
onSelect,
scale,
selectedSequenceKeys,
sequenceKeysContainingSelection,
sequences,
}) => {
const timelinePosition = Internals.Timeline.useTimelinePosition();
const selectableOutlines = useMemo(() => {
return getSelectableOutlines(null);
}, [getSelectableOutlines]);
const activeOutlineCandidates = useMemo(
() =>
getCanvasActiveOutlineTargets({
targets: selectableOutlines,
selectedSequenceKeys,
sequenceKeysContainingSelection,
hoveredNodePathKey: hoveredTimelineNodePathKey,
measureAll: measureAllOutlines,
}),
[
hoveredTimelineNodePathKey,
measureAllOutlines,
selectableOutlines,
selectedSequenceKeys,
sequenceKeysContainingSelection,
],
);
const selectableOutlinesForLayout = useMemo(
() =>
// A selected instance outside the current frame must not activate its
// visible siblings. Recheck only the cached active sources after visibility.
getCanvasActiveOutlineTargets({
targets: getCanvasVisibleOutlineTargets({
targets: activeOutlineCandidates,
timelinePosition,
}),
selectedSequenceKeys,
sequenceKeysContainingSelection,
hoveredNodePathKey: hoveredTimelineNodePathKey,
measureAll: measureAllOutlines,
}),
[
activeOutlineCandidates,
hoveredTimelineNodePathKey,
measureAllOutlines,
selectedSequenceKeys,
sequenceKeysContainingSelection,
timelinePosition,
],
);
const outlineRuntimeControls = useMemo(() => {
// Keep subscriptions stable while the playhead moves in and out of a layer.
return activeOutlineCandidates.flatMap(({key, sequence}) => {
if (
!selectedSequenceKeys.has(key) &&
!sequenceKeysContainingSelection.has(key)
) {
return [];
}
return sequence.controls ? [sequence.controls] : [];
});
}, [
activeOutlineCandidates,
selectedSequenceKeys,
sequenceKeysContainingSelection,
]);
const outlineRuntimeSnapshots = useRuntimeValueSnapshots(
outlineRuntimeControls,
);
const outlineRuntimeValuesByStore = useMemo(
() =>
new Map(
outlineRuntimeControls.map((controls, index) => [
controls.runtimeValues,
outlineRuntimeSnapshots[index],
]),
),
[outlineRuntimeControls, outlineRuntimeSnapshots],
);
const outlineTargets = useMemo(
() =>
calculateOutlineTargetsForCurrentState({
getCanvasLayoutTargets: null,
mode: 'layout',
runtimeValuesByStore: outlineRuntimeValuesByStore,
selectableOutlines: selectableOutlinesForLayout,
targetKey: null,
targetTimelinePosition: timelinePosition,
}),
[
calculateOutlineTargetsForCurrentState,
outlineRuntimeValuesByStore,
selectableOutlinesForLayout,
timelinePosition,
],
);
return (
<SelectedOutlineRenderer
compositionHeight={compositionHeight}
compositionWidth={compositionWidth}
dragging={draggingOutline}
getAllDragTargets={getAllDragTargets}
getLatestOutlineTargetByKey={getLatestOutlineTargetByKey}
outlineTargets={outlineTargets}
onDraggingChange={onDraggingChange}
onContextMenuOpenChange={onContextMenuOpenChange}
onSelect={onSelect}
scale={scale}
sequences={sequences}
/>
);
};
const ActiveSelectedOutlineOverlay = React.memo(
ActiveSelectedOutlineOverlayUnmemoized,
);
const SelectedOutlineOverlayUnmemoized: React.FC<
SelectedOutlineOverlayProps
> = ({canvasHovered, compositionHeight, compositionWidth, scale}) => {
const {selectedItems, selectItem} = useTimelineSelection();
const currentSelection = useCurrentTimelineSelectionStateAsRef();
const sequences = Internals.useSequenceManagerSequences();
const calculateTimeline = useTimelineCalculator();
const {compositions} = useContext(Internals.CompositionManager);
const {propStatuses} = useContext(Internals.VisualModePropStatusesContext);
const {previewServerState} = useContext(StudioServerConnectionCtx);
const {overrideIdToNodePathMappings} = useContext(
Internals.OverrideIdsToNodePathsGettersContext,
);
const {getDragOverrides} = useContext(
Internals.VisualModeDragOverridesContext,
);
const {getScaleLockState} = useContext(ScaleLockContext);
const {manuallyEnabledSequenceKeys} = useContext(Transform3DModeStateContext);
const {editorShowOutlines} = useContext(EditorShowOutlinesContext);
const setHoveredSequence = useSetTimelineSequenceHover();
const hoveredSequence = useTimelineSequenceHoverState();
const isFullscreen = useIsFullscreen();
const {getCurrentFrame} = PlayerInternals.usePlayerMethods();
const [draggingOutline, setDraggingOutline] = useState(false);
const [canvasContextMenuOpen, setCanvasContextMenuOpen] = useState(false);
const previewSelectionAvailable =
previewServerState.type === 'connected' || window.remotion_isReadOnlyStudio;
const selectedSequenceKeys = useMemo(
() => getSelectedSequenceKeys(selectedItems),
[selectedItems],
);
const sequenceKeysContainingSelection = useMemo(
() => getSequenceKeysContainingSelection(selectedItems),
[selectedItems],
);
const selectedEffectsBySequenceKey = useMemo(
() => getSelectedEffectFieldsBySequenceKey(selectedItems),
[selectedItems],
);
const selectedTransformOriginInfo = useMemo(
() => getSelectedTransformOriginInfo(selectedItems),
[selectedItems],
);
const selectedRotationInfo = useMemo(
() => getSelectedRotationInfo(selectedItems),
[selectedItems],
);
const selectedCropInfo = useMemo(
() => getSelectedCropInfo(selectedItems),
[selectedItems],
);
const getSelectableOutlines = useMemo(() => {
// Resolve source identities once per sequence snapshot, on first demand.
// Playback only filters the cached candidates by their visible range.
let selectableOutlines: ReturnType<
typeof getCanvasSelectableOutlines
> | null = null;
return (timelinePosition: number | null) => {
if (
isFullscreen ||
!isStudioSelectionEnabled() ||
!previewSelectionAvailable ||
!editorShowOutlines
) {
return [];
}
selectableOutlines ??= getCanvasSelectableOutlines({
tracks: calculateTimeline({
sequences,
overrideIdsToNodePaths: overrideIdToNodePathMappings,
compositions,
}).tracks,
timelinePosition: null,
resolveSequenceNodePathInfo: null,
});
return timelinePosition === null
? selectableOutlines
: getCanvasVisibleOutlineTargets({
targets: selectableOutlines,
timelinePosition,
});
};
}, [
calculateTimeline,
compositions,
editorShowOutlines,
isFullscreen,
overrideIdToNodePathMappings,
previewSelectionAvailable,
sequences,
]);
const selectedRotationKey = selectedRotationInfo?.sequenceKey ?? null;
const getSelectableOutlinesForCanvas = useMemo(() => {
if (selectedRotationKey === null) {
return getSelectableOutlines;
}
let candidates: SelectableOutlines | null = null;
return (timelinePosition: number | null) => {
if (candidates === null) {
const outlines = getSelectableOutlines(null);
const rotatingSequenceIds = new Set(
outlines
.filter((target) => target.key === selectedRotationKey)
.map((target) => target.sequence.id),
);
const parentBySequenceId = new Map(
sequences.map((sequence) => [sequence.id, sequence.parent]),
);
// Resolve ancestry on first demand, not on each frame or hover update.
candidates = outlines.filter((target) => {
let parentId = target.sequence.parent;
while (parentId !== null) {
if (rotatingSequenceIds.has(parentId)) {
return false;
}
parentId = parentBySequenceId.get(parentId) ?? null;
}
return true;
});
}
return timelinePosition === null
? candidates
: getCanvasVisibleOutlineTargets({
targets: candidates,
timelinePosition,
});
};
}, [getSelectableOutlines, selectedRotationKey, sequences]);
const calculateOutlineTargetsForCurrentState =
useCallback<CalculateOutlineTargets>(
(options) =>
calculateOutlineTargets({
...options,
connectedClientId:
previewServerState.type === 'connected'
? previewServerState.clientId
: null,
editorShowOutlines,
getDragOverrides,
getScaleLockState,
isFullscreen,
manuallyEnabled3DTransformSequenceKeys: manuallyEnabledSequenceKeys,
previewSelectionAvailable,
propStatuses,
selectedCropInfo,
selectedEffectsBySequenceKey,
selectedRotationInfo,
selectedSequenceKeys,
selectedTransformOriginInfo,
sequenceKeysContainingSelection,
studioInteractivityEnabled: isStudioInteractivityEnabled(),
}),
[
editorShowOutlines,
getDragOverrides,
getScaleLockState,
isFullscreen,
manuallyEnabledSequenceKeys,
previewSelectionAvailable,
previewServerState,
propStatuses,
selectedCropInfo,
selectedEffectsBySequenceKey,
selectedRotationInfo,
selectedSequenceKeys,
selectedTransformOriginInfo,
sequenceKeysContainingSelection,
],
);
const getSelectableOutlinesRef = useRef(getSelectableOutlines);
const selectableOutlinesCacheRef = useRef<{
readonly getSelectableOutlines: typeof getSelectableOutlines;
readonly selectableOutlines: ReturnType<typeof getCanvasSelectableOutlines>;
readonly timelinePosition: number;
} | null>(null);
useLayoutEffect(() => {
getSelectableOutlinesRef.current = getSelectableOutlines;
}, [getSelectableOutlines]);
const getSelectableOutlinesAtFrame = useCallback(
(timelinePosition: number) => {
const currentGetSelectableOutlines = getSelectableOutlinesRef.current;
const cached = selectableOutlinesCacheRef.current;
if (
cached?.timelinePosition === timelinePosition &&
cached.getSelectableOutlines === currentGetSelectableOutlines
) {
return cached.selectableOutlines;
}
const selectableOutlines = currentGetSelectableOutlines(timelinePosition);
selectableOutlinesCacheRef.current = {
getSelectableOutlines: currentGetSelectableOutlines,
selectableOutlines,
timelinePosition,
};
return selectableOutlines;
},
[],
);
const getLatestOutlineTargetByKey = useMemo(() => {
let cachedOutlines: SelectableOutlines | null = null;
let cachedLookup: ReturnType<
typeof createCanvasOutlineLayoutTargetLookup
> | null = null;
return (key: string) => {
const timelinePosition = getCurrentFrame();
const selectableOutlines = getSelectableOutlinesAtFrame(timelinePosition);
const target = calculateOutlineTargetsForCurrentState({
getCanvasLayoutTargets: () => {
// Share only source metadata; controls below still read live values.
if (cachedOutlines !== selectableOutlines || cachedLookup === null) {
cachedLookup = createCanvasOutlineLayoutTargetLookup({
selectableOutlines,
selectedSequenceKeys,
sequenceKeysContainingSelection,
});
cachedOutlines = selectableOutlines;
}
return cachedLookup(key);
},
mode: 'controls',
runtimeValuesByStore: new Map(),
selectableOutlines,
targetKey: key,
targetTimelinePosition: timelinePosition,
})[0];
return target as SelectedOutlineTarget | undefined;
};
}, [
calculateOutlineTargetsForCurrentState,
getCurrentFrame,
getSelectableOutlinesAtFrame,
selectedSequenceKeys,
sequenceKeysContainingSelection,
]);
const getAllDragTargets = useCallback((): SelectedOutlineDragTarget[] => {
// Selected layers can be outside the current frame and have no mounted DOM.
// Only outline measurement and snapping need to be restricted to visible layers.
const selectedKeys = getSequenceKeysContainingSelection(
currentSelection.current.selectedItems,
);
if (selectedKeys.size === 0) {
return [];
}
const selectableOutlines = getSelectableOutlines(null).filter(({key}) =>
selectedKeys.has(key),
);
const targets = calculateOutlineTargetsForCurrentState({
getCanvasLayoutTargets: null,
mode: 'controls',
runtimeValuesByStore: new Map(),
selectableOutlines,
targetKey: null,
targetTimelinePosition: getCurrentFrame(),
}) as SelectedOutlineTarget[];
const dragTargets = new Map<string, SelectedOutlineDragTarget>();
for (const {drag} of targets) {
if (drag === null) {
continue;
}
const sourceNodeKey = Internals.makeSequencePropsSubscriptionKey(
drag.nodePath,
);
if (!dragTargets.has(sourceNodeKey)) {
dragTargets.set(sourceNodeKey, drag);
}
}
return [...dragTargets.values()];
}, [
calculateOutlineTargetsForCurrentState,
currentSelection,
getCurrentFrame,
getSelectableOutlines,
]);
const onDraggingChange = useCallback(
(dragging: boolean) => {
setDraggingOutline(dragging);
if (dragging) {
setHoveredSequence((currentHover) =>
currentHover?.source === 'canvas' ? null : currentHover,
);
}
},
[setHoveredSequence],
);
const selectOutlineItem = useCallback(
(item: TimelineSelection, interaction?: TimelineSelectionInteraction) => {
selectItem(item, interaction, undefined, {reveal: true});
},
[selectItem],
);
const {measurementActive, measureAllOutlines, hoveredTimelineNodePathKey} =
getCanvasOutlineActivity({
canvasHovered,
dragging: draggingOutline,
contextMenuOpen: canvasContextMenuOpen,
hasSelection: sequenceKeysContainingSelection.size > 0,
hoveredSequence,
});
useLayoutEffect(() => {
if (measurementActive) {
return;
}
setHoveredSequence((currentHover) =>
currentHover?.source === 'canvas' ? null : currentHover,
);
}, [measurementActive, setHoveredSequence]);
return (
<>
<SelectedOutlineKeyboardControls getAllDragTargets={getAllDragTargets} />
{measurementActive ? (
<ActiveSelectedOutlineOverlay
calculateOutlineTargetsForCurrentState={
calculateOutlineTargetsForCurrentState
}
compositionHeight={compositionHeight}
compositionWidth={compositionWidth}
draggingOutline={draggingOutline}
getAllDragTargets={getAllDragTargets}
getLatestOutlineTargetByKey={getLatestOutlineTargetByKey}
getSelectableOutlines={getSelectableOutlinesForCanvas}
hoveredTimelineNodePathKey={hoveredTimelineNodePathKey}
measureAllOutlines={measureAllOutlines}
onDraggingChange={onDraggingChange}
onContextMenuOpenChange={setCanvasContextMenuOpen}
onSelect={selectOutlineItem}
scale={scale}
selectedSequenceKeys={selectedSequenceKeys}
sequenceKeysContainingSelection={sequenceKeysContainingSelection}
sequences={sequences}
/>
) : null}
</>
);
};
export const SelectedOutlineOverlay = React.memo(
SelectedOutlineOverlayUnmemoized,
);