Skip to content

🎥 Make videos programmatically with React

12.9 KB
Raw Blame
import React, {useCallback, useContext, useMemo, useRef, useState} from 'react';
import type {
	CanUpdateSequencePropStatusStatic,
	SequencePropsSubscriptionKey,
} from 'remotion';
import {NoReactInternals} from 'remotion/no-react';
import {CURRENT_COLOR_LOWERCASE, LIGHT_COLOR} from '../../helpers/colors';
import type {
	SchemaFieldInfo,
	TimelineFieldOnDragValueChange,
	TimelineFieldOnSave,
} from '../../helpers/timeline-layout';
import {ScaleLockContext} from '../../state/scale-lock';
import {ActionTooltip} from '../ActionTooltip';
import {InputDragger} from '../NewComposition/InputDragger';
import {formatTimelineFieldValueForDisplay} from './timeline-field-display-utils';
import {normalizeTimelineNumber} from './timeline-field-utils';
import {timelineLayerIconContainer} from './TimelineLayerEye';
import {Transform3DModeContext} from './Transform3DModeContext';

const leftDraggerStyle: React.CSSProperties = {
	paddingLeft: 0,
	textAlign: 'left',
	width: 40,
};

const rightDraggerStyle: React.CSSProperties = {
	paddingRight: 0,
	textAlign: 'left',
	width: 40,
};

const containerStyle: React.CSSProperties = {
	alignItems: 'center',
	display: 'flex',
	gap: 4,
};

const toggleStyle: React.CSSProperties = {
	...timelineLayerIconContainer,
	border: 'none',
	color: LIGHT_COLOR,
	cursor: 'default',
	marginRight: 0,
	padding: 0,
};

const linkIconStyle: React.CSSProperties = {
	width: 14,
	height: 14,
	pointerEvents: 'none',
};

const gapStyle: React.CSSProperties = {
	marginLeft: -6,
	marginRight: -6,
};

const clamp = (value: number, min: number, max: number): number => {
	return Math.min(max, Math.max(min, value));
};

export const getLinkedScale = ({
	axis,
	newValue,
	baseX,
	baseY,
	min,
	max,
}: {
	readonly axis: 'x' | 'y';
	readonly newValue: number;
	readonly baseX: number;
	readonly baseY: number;
	readonly min: number;
	readonly max: number;
}): [number, number] => {
	const drivingBase = axis === 'x' ? baseX : baseY;
	const linkedBase = axis === 'x' ? baseY : baseX;

	if (drivingBase === 0 || linkedBase === 0) {
		const clamped = normalizeTimelineNumber(clamp(newValue, min, max));
		return [clamped, clamped];
	}

	let factor = newValue / drivingBase;
	let driving = newValue;
	let linked = linkedBase * factor;
	const clampedLinked = clamp(linked, min, max);

	if (clampedLinked !== linked) {
		factor = clampedLinked / linkedBase;
		linked = clampedLinked;
		driving = drivingBase * factor;
	}

	const clampedDriving = clamp(driving, min, max);
	const normalizedDriving = normalizeTimelineNumber(clampedDriving);
	const normalizedLinked = normalizeTimelineNumber(linked);

	return axis === 'x'
		? [normalizedDriving, normalizedLinked]
		: [normalizedLinked, normalizedDriving];
};

const valuesEqual = (left: unknown, right: unknown): boolean => {
	return JSON.stringify(left) === JSON.stringify(right);
};

const LinkToggle: React.FC<{
	readonly linked: boolean;
	readonly onToggle: () => void;
}> = ({linked, onToggle}) => {
	const label = linked ? 'Unlink scale axes' : 'Link scale axes';
	const onPointerDown = useCallback(
		(e: React.PointerEvent<HTMLButtonElement>) => {
			if (e.button !== 0) {
				return;
			}

			e.stopPropagation();
			onToggle();
		},
		[onToggle],
	);

	return (
		<ActionTooltip label={label} shortcut={null} delay={800} dismissOnClick>
			<button
				type="button"
				style={toggleStyle}
				onPointerDown={onPointerDown}
				aria-label={label}
			>
				{linked ? (
					<svg
						xmlns="http://www.w3.org/2000/svg"
						viewBox="0 0 640 640"
						style={linkIconStyle}
					>
						<path
							fill={CURRENT_COLOR_LOWERCASE}
							d="M32 320C32 214 118 128 224 128L288 128L288 192L224 192C153.3 192 96 249.3 96 320C96 390.7 153.3 448 224 448L288 448L288 512L224 512C118 512 32 426 32 320zM608 320C608 426 522 512 416 512L352 512L352 448L416 448C486.7 448 544 390.7 544 320C544 249.3 486.7 192 416 192L352 192L352 128L416 128C522 128 608 214 608 320zM224 288L448 288L448 352L192 352L192 288L224 288z"
						/>
					</svg>
				) : null}
			</button>
		</ActionTooltip>
	);
};

export const TimelineScaleField: React.FC<{
	readonly field: SchemaFieldInfo;
	readonly propStatus: CanUpdateSequencePropStatusStatic;
	readonly effectiveValue: unknown;
	readonly onSave: TimelineFieldOnSave;
	readonly onDragValueChange: TimelineFieldOnDragValueChange;
	readonly onDragEnd: () => void;
	readonly scaleLockNodePath: SequencePropsSubscriptionKey;
}> = ({
	field,
	propStatus,
	effectiveValue,
	onSave,
	onDragValueChange,
	onDragEnd,
	scaleLockNodePath,
}) => {
	const [dragX, setDragX] = useState<number | null>(null);
	const [dragY, setDragY] = useState<number | null>(null);
	const [dragZ, setDragZ] = useState<number | null>(null);
	const dragStartRef = useRef<readonly [number, number] | null>(null);
	const {getScaleLockState, setScaleLockState} = useContext(ScaleLockContext);
	const transform3DMode = useContext(Transform3DModeContext);

	const [codeX, codeY, codeZ] = useMemo(
		() => NoReactInternals.parseScaleValue(effectiveValue),
		[effectiveValue],
	);
	const show3D = transform3DMode || codeZ !== 1;

	const defaultLinked = codeX === codeY;
	const linked = getScaleLockState({
		nodePath: scaleLockNodePath,
		fieldKey: field.key,
		defaultValue: defaultLinked,
	});

	const configuredStep =
		field.fieldSchema.type === 'scale' ? field.fieldSchema.step : undefined;
	const step = configuredStep ?? 0.01;
	const min =
		field.fieldSchema.type === 'scale'
			? (field.fieldSchema.min ?? -Infinity)
			: -Infinity;
	const max =
		field.fieldSchema.type === 'scale'
			? (field.fieldSchema.max ?? Infinity)
			: Infinity;

	const formatter = useCallback(
		(v: number | string) => {
			return formatTimelineFieldValueForDisplay({
				fieldSchema: field.fieldSchema,
				value: v,
			});
		},
		[field.fieldSchema],
	);

	const getDragStart = useCallback((): readonly [number, number] => {
		if (dragStartRef.current === null) {
			dragStartRef.current = [dragX ?? codeX, dragY ?? codeY];
		}

		return dragStartRef.current;
	}, [codeX, codeY, dragX, dragY]);

	const serialize = useCallback(
		(x: number, y: number, z = dragZ ?? codeZ) => {
			return NoReactInternals.serializeScaleValue([x, y, z]);
		},
		[codeZ, dragZ],
	);

	const onXChange = useCallback(
		(newVal: number) => {
			if (linked) {
				const [baseX, baseY] = getDragStart();
				const [newX, newY] = getLinkedScale({
					axis: 'x',
					newValue: newVal,
					baseX,
					baseY,
					min,
					max,
				});
				setDragX(newX);
				setDragY(newY);
				onDragValueChange(serialize(newX, newY));
				return;
			}

			setDragX(newVal);
			const currentY = dragY ?? codeY;
			onDragValueChange(serialize(newVal, currentY));
		},
		[
			codeY,
			dragY,
			getDragStart,
			linked,
			max,
			min,
			onDragValueChange,
			serialize,
		],
	);

	const onXChangeEnd = useCallback(
		(newVal: number) => {
			const [newX, newY] = linked
				? getLinkedScale({
						axis: 'x',
						newValue: newVal,
						baseX: dragStartRef.current?.[0] ?? codeX,
						baseY: dragStartRef.current?.[1] ?? codeY,
						min,
						max,
					})
				: [newVal, dragY ?? codeY];
			const newScale = serialize(newX, newY);

			const clearDragState = () => {
				dragStartRef.current = null;
				setDragX(null);
				setDragY(null);
				setDragZ(null);
				onDragEnd();
			};

			if (!valuesEqual(newScale, propStatus.codeValue)) {
				onSave(newScale).finally(clearDragState);
			} else {
				clearDragState();
			}
		},
		[
			codeX,
			codeY,
			dragY,
			linked,
			max,
			min,
			onDragEnd,
			onSave,
			propStatus,
			serialize,
		],
	);

	const onXTextChange = useCallback(
		(newVal: string) => {
			const parsed = Number(newVal);
			if (Number.isNaN(parsed)) {
				return;
			}

			const [newX, newY] = linked
				? getLinkedScale({
						axis: 'x',
						newValue: parsed,
						baseX: codeX,
						baseY: codeY,
						min,
						max,
					})
				: [parsed, dragY ?? codeY];
			const newScale = serialize(newX, newY);
			if (!valuesEqual(newScale, propStatus.codeValue)) {
				setDragX(newX);
				setDragY(newY);
				onSave(newScale).finally(() => {
					dragStartRef.current = null;
					setDragX(null);
					setDragY(null);
					setDragZ(null);
				});
			}
		},
		[codeX, codeY, dragY, linked, max, min, onSave, propStatus, serialize],
	);

	const onYChange = useCallback(
		(newVal: number) => {
			if (linked) {
				const [baseX, baseY] = getDragStart();
				const [newX, newY] = getLinkedScale({
					axis: 'y',
					newValue: newVal,
					baseX,
					baseY,
					min,
					max,
				});
				setDragX(newX);
				setDragY(newY);
				onDragValueChange(serialize(newX, newY));
				return;
			}

			setDragY(newVal);
			const currentX = dragX ?? codeX;
			onDragValueChange(serialize(currentX, newVal));
		},
		[
			codeX,
			dragX,
			getDragStart,
			linked,
			max,
			min,
			onDragValueChange,
			serialize,
		],
	);

	const onYChangeEnd = useCallback(
		(newVal: number) => {
			const [newX, newY] = linked
				? getLinkedScale({
						axis: 'y',
						newValue: newVal,
						baseX: dragStartRef.current?.[0] ?? codeX,
						baseY: dragStartRef.current?.[1] ?? codeY,
						min,
						max,
					})
				: [dragX ?? codeX, newVal];
			const newScale = serialize(newX, newY);

			const clearDragState = () => {
				dragStartRef.current = null;
				setDragX(null);
				setDragY(null);
				setDragZ(null);
				onDragEnd();
			};

			if (!valuesEqual(newScale, propStatus.codeValue)) {
				onSave(newScale).finally(clearDragState);
			} else {
				clearDragState();
			}
		},
		[
			codeX,
			codeY,
			dragX,
			linked,
			max,
			min,
			onDragEnd,
			onSave,
			propStatus,
			serialize,
		],
	);

	const onYTextChange = useCallback(
		(newVal: string) => {
			const parsed = Number(newVal);
			if (Number.isNaN(parsed)) {
				return;
			}

			const [newX, newY] = linked
				? getLinkedScale({
						axis: 'y',
						newValue: parsed,
						baseX: codeX,
						baseY: codeY,
						min,
						max,
					})
				: [dragX ?? codeX, parsed];
			const newScale = serialize(newX, newY);
			if (!valuesEqual(newScale, propStatus.codeValue)) {
				setDragX(newX);
				setDragY(newY);
				onSave(newScale).finally(() => {
					dragStartRef.current = null;
					setDragX(null);
					setDragY(null);
					setDragZ(null);
				});
			}
		},
		[codeX, codeY, dragX, linked, max, min, onSave, propStatus, serialize],
	);

	const onToggleLink = useCallback(() => {
		setScaleLockState({
			nodePath: scaleLockNodePath,
			fieldKey: field.key,
			linked: !linked,
		});
	}, [field.key, linked, scaleLockNodePath, setScaleLockState]);

	const onZChange = useCallback(
		(newVal: number) => {
			setDragZ(newVal);
			onDragValueChange(serialize(dragX ?? codeX, dragY ?? codeY, newVal));
		},
		[codeX, codeY, dragX, dragY, onDragValueChange, serialize],
	);

	const onZChangeEnd = useCallback(
		(newVal: number) => {
			const newScale = serialize(dragX ?? codeX, dragY ?? codeY, newVal);
			const clearDragState = () => {
				dragStartRef.current = null;
				setDragX(null);
				setDragY(null);
				setDragZ(null);
				onDragEnd();
			};

			if (!valuesEqual(newScale, propStatus.codeValue)) {
				onSave(newScale).finally(clearDragState);
			} else {
				clearDragState();
			}
		},
		[
			codeX,
			codeY,
			dragX,
			dragY,
			onDragEnd,
			onSave,
			propStatus.codeValue,
			serialize,
		],
	);

	const onZTextChange = useCallback(
		(newVal: string) => {
			const parsed = Number(newVal);
			if (Number.isNaN(parsed)) {
				return;
			}

			const newScale = serialize(dragX ?? codeX, dragY ?? codeY, parsed);
			if (!valuesEqual(newScale, propStatus.codeValue)) {
				setDragZ(parsed);
				onSave(newScale).finally(() => setDragZ(null));
			}
		},
		[codeX, codeY, dragX, dragY, onSave, propStatus.codeValue, serialize],
	);

	return (
		<span style={containerStyle}>
			<InputDragger
				type="number"
				value={dragX ?? codeX}
				buttonStyle={leftDraggerStyle}
				style={leftDraggerStyle}
				status="ok"
				small
				onValueChange={onXChange}
				onValueChangeEnd={onXChangeEnd}
				onTextChange={onXTextChange}
				min={min}
				max={max}
				step={step}
				formatter={formatter}
				rightAlign={false}
				allowStepMismatch
				aria-label="Scale X"
			/>
			<div style={gapStyle} />
			<InputDragger
				type="number"
				value={dragY ?? codeY}
				buttonStyle={rightDraggerStyle}
				style={rightDraggerStyle}
				status="ok"
				small
				onValueChange={onYChange}
				onValueChangeEnd={onYChangeEnd}
				onTextChange={onYTextChange}
				min={min}
				max={max}
				step={step}
				formatter={formatter}
				rightAlign={false}
				allowStepMismatch
				aria-label="Scale Y"
			/>
			{show3D ? (
				<>
					<div style={gapStyle} />
					<InputDragger
						type="number"
						value={dragZ ?? codeZ}
						buttonStyle={rightDraggerStyle}
						style={rightDraggerStyle}
						status="ok"
						small
						onValueChange={onZChange}
						onValueChangeEnd={onZChangeEnd}
						onTextChange={onZTextChange}
						min={min}
						max={max}
						step={step}
						formatter={formatter}
						rightAlign={false}
						allowStepMismatch
						aria-label="Scale Z"
					/>
				</>
			) : null}
			<LinkToggle linked={linked} onToggle={onToggleLink} />
		</span>
	);
};