Skip to content

🎥 Make videos programmatically with React

16.2 KB
Raw Blame
import {CanvasInternals} from '@remotion/sdk';
import {
	canMoveKeyframesWithoutCollisions,
	moveKeyframesInPropStatus,
} from '@remotion/studio-shared';
import React, {
	useCallback,
	useContext,
	useEffect,
	useMemo,
	useState,
} from 'react';
import type {
	CanUpdateSequencePropStatusKeyframed,
	DragOverrideValue,
	InteractivitySchema,
	SequencePropsSubscriptionKey,
} from 'remotion';
import {Internals, useVideoConfig} from 'remotion';
import type {CodePosition} from '../../error-overlay/react-overlay/utils/get-source-map';
import {StudioServerConnectionCtx} from '../../helpers/client-id';
import {
	getEffectFieldsToShow,
	getFieldsToShow,
	type EffectSchemaFieldInfo,
	type SchemaFieldInfo,
} from '../../helpers/timeline-layout';
import {useRuntimeValues} from '../../helpers/use-runtime-values';
import {VERTICAL_SCROLLBAR_CLASSNAME} from '../Menu/is-menu-item';
import {InputDragger} from '../NewComposition/InputDragger';
import {
	callDeleteEffectKeyframe,
	callDeleteSequenceKeyframe,
} from '../Timeline/call-delete-keyframe';
import {callMoveKeyframes} from '../Timeline/call-move-keyframe';
import {
	getKeyframeDisplayOffset,
	getKeyframePlaybackRate,
	getKeyframeSourceFrame,
} from '../Timeline/get-timeline-keyframes';
import {parseKeyframeFieldFromNodePath} from '../Timeline/parse-keyframe-field-from-node-path';
import {TimelineEffectPropValue} from '../Timeline/TimelineEffectPropItem';
import {
	getTimelineSelectionFromNodePathInfo,
	useTimelineSelection,
	type TimelineSelection,
} from '../Timeline/TimelineSelection';
import {TimelineSequenceKeyframedValue} from '../Timeline/TimelineSequencePropItem';
import {
	InspectorBackAction,
	InspectorDetailRow,
	InspectorMessage,
	InspectorQuickAction,
	InspectorQuickActionsSection,
} from './common';
import {clampInspectorKeyframeDisplayFrame} from './keyframe-inspector-frame';
import {KeyframeEasingNavigator} from './KeyframeEasingNavigator';
import {SequenceInspectorSections} from './SequenceInspectorHeader';
import {
	detailsBeforeInlineAction,
	detailsWithInlineAction,
	keyframeEditorRow,
	keyframeEditorValue,
	selectedContainer,
} from './styles';
import {useTrackForSelection} from './use-track-for-selection';

const {canEditKeyframeEasing} = CanvasInternals;

type KeyframeEditorDetails =
	| {
			readonly type: 'sequence';
			readonly field: SchemaFieldInfo;
			readonly fieldLabel: string;
			readonly fileName: string;
			readonly nodePath: SequencePropsSubscriptionKey;
			readonly propStatus: CanUpdateSequencePropStatusKeyframed;
			readonly schema: InteractivitySchema;
			readonly keyframeDisplayOffset: number;
			readonly keyframePlaybackRate: number;
			readonly sourceFrame: number;
	  }
	| {
			readonly type: 'effect';
			readonly effectIndex: number;
			readonly field: EffectSchemaFieldInfo;
			readonly fieldLabel: string;
			readonly fileName: string;
			readonly nodePath: SequencePropsSubscriptionKey;
			readonly propStatus: CanUpdateSequencePropStatusKeyframed;
			readonly schema: InteractivitySchema;
			readonly keyframeDisplayOffset: number;
			readonly keyframePlaybackRate: number;
			readonly sourceFrame: number;
			readonly validatedLocation: CodePosition;
	  };

const makeMovedKeyframedDragOverride = ({
	details,
	toFrame,
}: {
	readonly details: KeyframeEditorDetails;
	readonly toFrame: number;
}): DragOverrideValue | null => {
	if (
		!canMoveKeyframesWithoutCollisions({
			status: details.propStatus,
			moves: [{fromFrame: details.sourceFrame, toFrame}],
		})
	) {
		return null;
	}

	const movedStatus = moveKeyframesInPropStatus({
		status: details.propStatus,
		moves: [{fromFrame: details.sourceFrame, toFrame}],
	});

	if (movedStatus.status !== 'keyframed') {
		return null;
	}

	return {
		type: 'keyframed',
		status: movedStatus,
	};
};

const removeKeyframeIcon: React.CSSProperties = {
	display: 'block',
	flexShrink: 0,
	height: 16,
	width: 16,
};

const TrashIcon: React.FC<{readonly color: string}> = ({color}) => {
	return (
		<svg viewBox="0 0 448 512" style={removeKeyframeIcon}>
			<path
				fill={color}
				d="M160.5 27.4c2-6.8 8.3-11.4 15.3-11.4l96.4 0c7.1 0 13.3 4.6 15.3 11.4l11 36.6-149 0 11-36.6zM116.1 64L16 64C7.2 64 0 71.2 0 80S7.2 96 16 96l416 0c8.8 0 16-7.2 16-16s-7.2-16-16-16l-100.1 0-13.7-45.8C312.1-2.1 293.4-16 272.2-16l-96.4 0c-21.2 0-39.9 13.9-46 34.2L116.1 64zM28.7 144L51.6 452.7c2.5 33.4 30.3 59.3 63.8 59.3l217.1 0c33.5 0 61.3-25.9 63.8-59.3l22.9-308.7-32.1 0-22.7 306.4c-1.2 16.7-15.2 29.6-31.9 29.6l-217.1 0c-16.8 0-30.7-12.9-31.9-29.6L60.8 144 28.7 144z"
			/>
		</svg>
	);
};

export const KeyframeInspector: React.FC<{
	readonly selection: Extract<TimelineSelection, {type: 'keyframe'}>;
}> = ({selection}) => {
	const track = useTrackForSelection(selection);
	const runtimeValues = useRuntimeValues(track?.sequence.controls ?? null);
	const videoConfig = useVideoConfig();
	const {propStatuses} = useContext(Internals.VisualModePropStatusesContext);
	const {
		clearDragOverrides,
		clearEffectDragOverrides,
		setDragOverrides,
		setEffectDragOverrides,
		setPropStatuses,
	} = useContext(Internals.VisualModeSettersContext);
	const {getDragOverrides, getEffectDragOverrides} = useContext(
		Internals.VisualModeDragOverridesContext,
	);
	const {previewServerState} = useContext(StudioServerConnectionCtx);
	const {selectItems} = useTimelineSelection();
	const [draftFrame, setDraftFrame] = useState(selection.frame);
	const parentSelection = useMemo(
		() => getTimelineSelectionFromNodePathInfo(selection.nodePathInfo),
		[selection.nodePathInfo],
	);

	useEffect(() => {
		setDraftFrame(selection.frame);
	}, [selection.frame]);

	const details = useMemo<KeyframeEditorDetails | null>(() => {
		if (!track || !track.sequence.controls) {
			return null;
		}

		const keyframeField = parseKeyframeFieldFromNodePath(
			selection.nodePathInfo.auxiliaryKeys,
		);
		if (keyframeField === null) {
			return null;
		}

		const nodePath = {
			...selection.nodePathInfo.sequenceSubscriptionKey,
			videoConfigValues: track.sequence.controls.videoConfigValues,
		};
		const {keyframeDisplayOffset, keyframePlaybackRate} = track;

		if (keyframeField.type === 'sequence') {
			const sequenceFields = getFieldsToShow({
				schema: track.sequence.controls.schema,
				currentRuntimeValueDotNotation: runtimeValues,
				getDragOverrides,
				propStatuses,
				nodePath,
				includeTextContent: false,
			});
			const sequenceField =
				sequenceFields?.find(
					(candidate) => candidate.key === keyframeField.fieldKey,
				) ?? null;
			const sequencePropStatus =
				Internals.getPropStatusesCtx(propStatuses, nodePath)?.[
					keyframeField.fieldKey
				] ?? null;

			if (!sequenceField || sequencePropStatus?.status !== 'keyframed') {
				return null;
			}

			return {
				type: 'sequence',
				field: sequenceField,
				fieldLabel: sequenceField.description ?? sequenceField.key,
				fileName: nodePath.absolutePath,
				keyframePlaybackRate,
				keyframeDisplayOffset: getKeyframeDisplayOffset({
					propStatus: sequencePropStatus,
					keyframeDisplayOffset,
					keyframePlaybackRate,
				}),
				nodePath,
				propStatus: sequencePropStatus,
				schema: track.sequence.controls.schema,
				sourceFrame: getKeyframeSourceFrame({
					displayFrame: selection.frame,
					propStatus: sequencePropStatus,
					keyframeDisplayOffset: getKeyframeDisplayOffset({
						propStatus: sequencePropStatus,
						keyframeDisplayOffset,
						keyframePlaybackRate,
					}),
					keyframePlaybackRate,
				}),
			};
		}

		const effect = track.sequence.effects[keyframeField.effectIndex];
		if (!effect) {
			return null;
		}

		const effectFields = getEffectFieldsToShow({
			effect,
			effectIndex: keyframeField.effectIndex,
			nodePath,
			propStatuses,
			getEffectDragOverrides,
		});
		const effectField =
			effectFields.find(
				(candidate) => candidate.key === keyframeField.fieldKey,
			) ?? null;
		const effectStatus = Internals.getEffectPropStatusesCtx({
			propStatuses,
			nodePath,
			effectIndex: keyframeField.effectIndex,
		});
		const effectPropStatus =
			effectStatus.type === 'can-update-effect'
				? (effectStatus.props[keyframeField.fieldKey] ?? null)
				: null;

		if (!effectField || effectPropStatus?.status !== 'keyframed') {
			return null;
		}

		return {
			type: 'effect',
			effectIndex: keyframeField.effectIndex,
			field: effectField,
			fieldLabel: effectField.description ?? effectField.key,
			fileName: nodePath.absolutePath,
			keyframePlaybackRate,
			keyframeDisplayOffset: getKeyframeDisplayOffset({
				propStatus: effectPropStatus,
				keyframeDisplayOffset,
				keyframePlaybackRate,
			}),
			nodePath,
			propStatus: effectPropStatus,
			schema: effect.schema,
			sourceFrame: getKeyframeSourceFrame({
				displayFrame: selection.frame,
				propStatus: effectPropStatus,
				keyframeDisplayOffset: getKeyframeDisplayOffset({
					propStatus: effectPropStatus,
					keyframeDisplayOffset,
					keyframePlaybackRate,
				}),
				keyframePlaybackRate,
			}),
			validatedLocation: {
				source: nodePath.absolutePath,
				line: 1,
				column: 0,
			},
		};
	}, [
		getDragOverrides,
		getEffectDragOverrides,
		propStatuses,
		runtimeValues,
		selection,
		track,
	]);

	const clearFrameDragOverride = useCallback(
		(detailsToClear: KeyframeEditorDetails | null) => {
			if (detailsToClear === null) {
				return;
			}

			if (detailsToClear.type === 'sequence') {
				clearDragOverrides(detailsToClear.nodePath);
				return;
			}

			clearEffectDragOverrides(
				detailsToClear.nodePath,
				detailsToClear.effectIndex,
			);
		},
		[clearDragOverrides, clearEffectDragOverrides],
	);

	const onFrameChange = useCallback(
		(value: number) => {
			const displayFrame = clampInspectorKeyframeDisplayFrame({
				durationInFrames: videoConfig.durationInFrames,
				frame: value,
			});

			setDraftFrame(displayFrame);

			if (details === null) {
				return;
			}

			const toFrame = getKeyframeSourceFrame({
				displayFrame,
				keyframeDisplayOffset: details.keyframeDisplayOffset,
				keyframePlaybackRate: details.keyframePlaybackRate,
				propStatus: details.propStatus,
			});

			if (displayFrame === selection.frame || toFrame === details.sourceFrame) {
				clearFrameDragOverride(details);
				return;
			}

			const dragOverrideValue = makeMovedKeyframedDragOverride({
				details,
				toFrame,
			});

			if (dragOverrideValue === null) {
				clearFrameDragOverride(details);
				return;
			}

			if (details.type === 'sequence') {
				setDragOverrides(
					details.nodePath,
					details.field.key,
					dragOverrideValue,
				);
				return;
			}

			setEffectDragOverrides(
				details.nodePath,
				details.effectIndex,
				details.field.key,
				dragOverrideValue,
			);
		},
		[
			clearFrameDragOverride,
			details,
			selection.frame,
			setDragOverrides,
			setEffectDragOverrides,
			videoConfig.durationInFrames,
		],
	);

	const onFrameChangeEnd = useCallback(
		(value: number) => {
			if (details === null || previewServerState.type !== 'connected') {
				clearFrameDragOverride(details);
				setDraftFrame(selection.frame);
				return;
			}

			const displayFrame = clampInspectorKeyframeDisplayFrame({
				durationInFrames: videoConfig.durationInFrames,
				frame: value,
			});
			const toFrame = getKeyframeSourceFrame({
				displayFrame,
				keyframeDisplayOffset: details.keyframeDisplayOffset,
				keyframePlaybackRate: details.keyframePlaybackRate,
				propStatus: details.propStatus,
			});

			setDraftFrame(displayFrame);
			clearFrameDragOverride(details);

			if (displayFrame === selection.frame || toFrame === details.sourceFrame) {
				return;
			}

			if (makeMovedKeyframedDragOverride({details, toFrame}) === null) {
				setDraftFrame(selection.frame);
				return;
			}

			selectItems(
				[
					{
						...selection,
						frame: displayFrame,
					},
				],
				{reveal: true},
			);

			const move = {
				fileName: details.fileName,
				nodePath: details.nodePath,
				fieldKey: details.field.key,
				fromFrame: details.sourceFrame,
				toFrame,
				schema: details.schema,
			};

			callMoveKeyframes({
				sequenceKeyframes: details.type === 'sequence' ? [move] : [],
				effectKeyframes:
					details.type === 'effect'
						? [
								{
									...move,
									effectIndex: details.effectIndex,
								},
							]
						: [],
				setPropStatuses,
				clientId: previewServerState.clientId,
			}).catch(() => undefined);
		},
		[
			clearFrameDragOverride,
			details,
			previewServerState,
			selection,
			selectItems,
			setPropStatuses,
			videoConfig.durationInFrames,
		],
	);

	const onSelectParent = useCallback<
		React.MouseEventHandler<HTMLButtonElement>
	>(
		(event) => {
			event.stopPropagation();
			if (parentSelection === null) {
				return;
			}

			selectItems([parentSelection], {reveal: true});
		},
		[parentSelection, selectItems],
	);

	const removeDisabled = previewServerState.type !== 'connected';
	const onRemoveKeyframe = useCallback<
		React.MouseEventHandler<HTMLButtonElement>
	>(
		(event) => {
			event.stopPropagation();
			if (details === null || previewServerState.type !== 'connected') {
				return;
			}

			if (parentSelection !== null) {
				selectItems([parentSelection], {reveal: true});
			}

			if (details.type === 'sequence') {
				callDeleteSequenceKeyframe({
					fileName: details.fileName,
					nodePath: details.nodePath,
					fieldKey: details.field.key,
					sourceFrame: details.sourceFrame,
					schema: details.schema,
					setPropStatuses,
					clientId: previewServerState.clientId,
				}).catch(() => undefined);
				return;
			}

			callDeleteEffectKeyframe({
				fileName: details.fileName,
				nodePath: details.nodePath,
				effectIndex: details.effectIndex,
				fieldKey: details.field.key,
				sourceFrame: details.sourceFrame,
				schema: details.schema,
				setPropStatuses,
				clientId: previewServerState.clientId,
			}).catch(() => undefined);
		},
		[
			details,
			parentSelection,
			previewServerState,
			selectItems,
			setPropStatuses,
		],
	);

	if (details === null || track === null) {
		return <InspectorMessage>Keyframe unavailable</InspectorMessage>;
	}

	return (
		<div style={selectedContainer} className={VERTICAL_SCROLLBAR_CLASSNAME}>
			<SequenceInspectorSections track={track} />
			<InspectorBackAction
				disabled={parentSelection === null}
				onClick={onSelectParent}
				aria-label="Back to property"
			>
				{details.fieldLabel}
			</InspectorBackAction>
			<KeyframeEasingNavigator
				currentSelection={selection}
				includeEasings={canEditKeyframeEasing({
					field: details.field.fieldSchema,
					propStatus: details.propStatus,
				})}
				keyframes={details.propStatus.keyframes.map((keyframe) => ({
					...keyframe,
					frame:
						keyframe.frame /
							getKeyframePlaybackRate(
								details.propStatus,
								details.keyframePlaybackRate,
							) +
						details.keyframeDisplayOffset,
				}))}
				nodePathInfo={selection.nodePathInfo}
			/>
			<div style={detailsWithInlineAction}>
				<div style={detailsBeforeInlineAction}>
					<InspectorDetailRow label="Frame">
						<InputDragger
							type="number"
							value={draftFrame}
							status="ok"
							onValueChange={onFrameChange}
							onValueChangeEnd={onFrameChangeEnd}
							onTextChange={() => undefined}
							min={0}
							max={Math.max(0, videoConfig.durationInFrames - 1)}
							step={1}
							formatter={(value) => String(Math.round(Number(value)))}
							rightAlign
							small
						/>
					</InspectorDetailRow>
					<div style={keyframeEditorRow}>
						<InspectorDetailRow label={details.fieldLabel}>
							<div style={keyframeEditorValue}>
								{details.type === 'sequence' ? (
									<TimelineSequenceKeyframedValue
										field={details.field}
										fileName={details.fileName}
										nodePath={details.nodePath}
										schema={details.schema}
										propStatus={details.propStatus}
										sourceFrame={details.sourceFrame}
									/>
								) : (
									<TimelineEffectPropValue
										field={details.field}
										nodePath={details.nodePath}
										validatedLocation={details.validatedLocation}
										sourceFrame={details.sourceFrame}
										runtimeValueStore={null}
									/>
								)}
							</div>
						</InspectorDetailRow>
					</div>
				</div>
				<InspectorQuickActionsSection>
					<InspectorQuickAction
						disabled={removeDisabled}
						onClick={onRemoveKeyframe}
						renderIcon={(color) => <TrashIcon color={color} />}
					>
						Remove keyframe
					</InspectorQuickAction>
				</InspectorQuickActionsSection>
			</div>
		</div>
	);
};