Skip to content

🎥 Make videos programmatically with React

31.0 KB
Raw Blame
import React, {useContext, useMemo} from 'react';
import {Internals} from 'remotion';
import {StudioServerConnectionCtx} from '../helpers/client-id';
import {BLUE, SELECTED_OUTLINE_UV_DROP_SHADOW, WHITE} from '../helpers/colors';
import type {SequenceNodePathInfo} from '../helpers/get-timeline-sequence-sort-key';
import {startCapturedPointerSession} from '../helpers/pointer-session';
import {EditorSnappingContext} from '../state/editor-snapping';
import {
	forceSpecificCursor,
	stopForcingSpecificCursor,
} from './ForceSpecificCursor';
import {
	isSelectedOutlineDragPastThreshold,
	snapSelectedOutlineUv,
	selectedOutlineRotationSnapStepDegrees,
} from './selected-outline-drag';
import type {OutlinePoint, SelectedOutline} from './selected-outline-geometry';
import {
	getOutlineSelectionInteraction,
	getSelectedEffectFieldsBySequenceKey,
} from './selected-outline-measurement';
import {
	getAngleDegrees,
	getRotationCursor,
	getSelectedOutlineRotationDeltaDegrees,
} from './selected-outline-measurement';
import type {SelectedOutlineLayoutTarget} from './selected-outline-types';
import {
	constrainUv,
	getUvEllipseInteractiveControls,
	getUvHandleConnectionEllipses,
	getUvCoordinateForPoint,
	getUvHandleConnectionLines,
	getUvHandlePosition,
	getSelectedUvHandles,
	roundNumericUvEllipseValue,
	roundUvCoordinate,
	tuplesEqual,
	type SelectedOutlineUvHandle,
	type UvEllipseInteractiveControls,
	type UvEllipseResizeAxis,
	type UvEllipseControlField,
	type UvCoordinate,
} from './selected-outline-uv';
import {callAddEffectKeyframe} from './Timeline/call-add-keyframe';
import {
	resolveKeyframeSourceFrame,
	type KeyframeSourceFrame,
} from './Timeline/get-timeline-keyframes';
import {saveEffectProp} from './Timeline/save-effect-prop';
import type {
	TimelineSelection,
	TimelineSelectionInteraction,
} from './Timeline/TimelineSelection';
import {useTimelineSelection} from './Timeline/TimelineSelection';

const getSvgPointFromPointerEvent = ({
	event,
	rect,
}: {
	readonly event: Pick<PointerEvent, 'clientX' | 'clientY'>;
	readonly rect: DOMRect;
}): OutlinePoint => {
	return {
		x: event.clientX - rect.left,
		y: event.clientY - rect.top,
	};
};

const uvHandleRadius = 4.25;
const selectedUvHandleRadius = 6.8;
const ellipseControlRadius = 5.2;
const uvHandleStyle: React.CSSProperties = {
	filter: SELECTED_OUTLINE_UV_DROP_SHADOW,
};

export const getSelectedOutlineUvHandleTimelineSelection = ({
	effectIndex,
	fieldKey,
	nodePathInfo,
}: {
	readonly effectIndex: number;
	readonly fieldKey: string;
	readonly nodePathInfo: SequenceNodePathInfo;
}): TimelineSelection => {
	return {
		type: 'sequence-effect-prop',
		nodePathInfo: {
			...nodePathInfo,
			auxiliaryKeys: ['effects', String(effectIndex), fieldKey],
		},
		i: effectIndex,
		key: fieldKey,
	};
};

const SelectedUvHandleConnectionLines: React.FC<{
	readonly handles: readonly SelectedOutlineUvHandle[];
	readonly outline: SelectedOutline;
}> = ({handles, outline}) => {
	const lines = useMemo(
		() => getUvHandleConnectionLines({handles, points: outline.points}),
		[handles, outline.points],
	);
	const ellipses = useMemo(
		() =>
			getUvHandleConnectionEllipses({
				handles,
				dimensions: outline.dimensions,
				points: outline.points,
			}),
		[handles, outline.dimensions, outline.points],
	);

	return (
		<>
			{ellipses.map((ellipse) => (
				<polyline
					key={ellipse.key}
					points={ellipse.points
						.map((point) => `${point.x},${point.y}`)
						.join(' ')}
					fill="none"
					stroke={BLUE}
					strokeWidth={2}
					vectorEffect="non-scaling-stroke"
					pointerEvents="none"
				/>
			))}
			{lines.map((line) => (
				<line
					key={line.key}
					x1={line.from.x}
					y1={line.from.y}
					x2={line.to.x}
					y2={line.to.y}
					stroke={BLUE}
					strokeWidth={2}
					vectorEffect="non-scaling-stroke"
					pointerEvents="none"
				/>
			))}
		</>
	);
};

const fieldDefaultToString = (value: unknown): string | null =>
	value !== undefined ? JSON.stringify(value) : null;

const shouldSaveNumericEffectValue = ({
	defaultValue,
	field,
	value,
}: {
	readonly defaultValue: string | null;
	readonly field: UvEllipseControlField;
	readonly value: number | null;
}): boolean => {
	if (value === null) {
		return false;
	}

	if (field.propStatus.status === 'keyframed') {
		return field.value !== value;
	}

	const stringifiedValue = JSON.stringify(value);
	return (
		field.propStatus.codeValue !== value &&
		!(
			defaultValue === stringifiedValue &&
			field.propStatus.codeValue === undefined
		)
	);
};

const saveNumericEffectField = ({
	clearEffectDragOverrides,
	clientId,
	effectIndex,
	field,
	lastValue,
	nodePath,
	schema,
	setPropStatuses,
	sourceFrame,
}: {
	readonly clearEffectDragOverrides: React.ContextType<
		typeof Internals.VisualModeSettersContext
	>['clearEffectDragOverrides'];
	readonly clientId: string;
	readonly effectIndex: number;
	readonly field: UvEllipseControlField;
	readonly lastValue: number | null;
	readonly nodePath: SelectedOutlineUvHandle['nodePath'];
	readonly schema: SelectedOutlineUvHandle['schema'];
	readonly setPropStatuses: React.ContextType<
		typeof Internals.VisualModeSettersContext
	>['setPropStatuses'];
	readonly sourceFrame: KeyframeSourceFrame;
}): void => {
	const defaultValue = fieldDefaultToString(field.fieldDefault);
	if (
		!shouldSaveNumericEffectValue({
			defaultValue,
			field,
			value: lastValue,
		})
	) {
		clearEffectDragOverrides(nodePath, effectIndex);
		return;
	}

	(field.propStatus.status === 'keyframed'
		? callAddEffectKeyframe({
				fileName: nodePath.absolutePath,
				nodePath,
				effectIndex,
				fieldKey: field.fieldKey,
				sourceFrame: resolveKeyframeSourceFrame(sourceFrame, field.propStatus),
				value: lastValue,
				schema,
				setPropStatuses,
				clientId,
			})
		: saveEffectProp({
				type: 'value',
				fileName: nodePath.absolutePath,
				nodePath,
				effectIndex,
				fieldKey: field.fieldKey,
				value: lastValue,
				defaultValue,
				schema,
				setPropStatuses,
				clientId,
			})
	).finally(() => {
		clearEffectDragOverrides(nodePath, effectIndex);
	});
};

const getLocalEllipseAxisValue = ({
	axis,
	center,
	dimensions,
	point,
	rotation,
}: {
	readonly axis: UvEllipseResizeAxis;
	readonly center: UvCoordinate;
	readonly dimensions: SelectedOutline['dimensions'];
	readonly point: UvCoordinate;
	readonly rotation: number;
}): number => {
	const radians = (rotation / 180) * Math.PI;
	const deltaX = point[0] - center[0];
	const deltaY = point[1] - center[1];
	const axisX = axis === 'width' ? Math.cos(radians) : -Math.sin(radians);
	const axisY = axis === 'width' ? Math.sin(radians) : Math.cos(radians);

	if (dimensions !== null && dimensions.width > 0 && dimensions.height > 0) {
		const pixelDeltaX = deltaX * dimensions.width;
		const pixelDeltaY = deltaY * dimensions.height;
		const pixelAxisValue = pixelDeltaX * axisX + pixelDeltaY * axisY;

		return (
			pixelAxisValue / (axis === 'width' ? dimensions.width : dimensions.height)
		);
	}

	return deltaX * axisX + deltaY * axisY;
};

const getLocalEllipseWidthProgress = ({
	center,
	dimensions,
	point,
	rotation,
	width,
}: {
	readonly center: UvCoordinate;
	readonly dimensions: SelectedOutline['dimensions'];
	readonly point: UvCoordinate;
	readonly rotation: number;
	readonly width: number;
}): number => {
	if (width <= 0.000001) {
		return 0;
	}

	return (
		getLocalEllipseAxisValue({
			axis: 'width',
			center,
			dimensions,
			point,
			rotation,
		}) /
		(width / 2)
	);
};

const SelectedUvEllipseStartHandle: React.FC<{
	readonly control: UvEllipseInteractiveControls;
	readonly onDraggingChange: (dragging: boolean) => void;
	readonly outline: SelectedOutline;
}> = ({control, onDraggingChange, outline}) => {
	const {setEffectDragOverrides, clearEffectDragOverrides, setPropStatuses} =
		useContext(Internals.VisualModeSettersContext);
	const {startControl} = control;
	const field = startControl?.field;

	const onPointerDown = React.useCallback(
		(event: React.PointerEvent<SVGCircleElement>) => {
			if (startControl === null || field === undefined) {
				return;
			}

			if (event.button !== 0) {
				return;
			}

			event.preventDefault();
			event.stopPropagation();

			const svg = event.currentTarget.ownerSVGElement;
			if (svg === null) {
				return;
			}

			const svgRect = svg.getBoundingClientRect();
			const startPointerX = event.clientX;
			const startPointerY = event.clientY;
			let dragging = false;
			let lastValue: number | null = null;

			const updateFromPointerEvent = (pointerEvent: PointerEvent) => {
				const point = getSvgPointFromPointerEvent({
					event: pointerEvent,
					rect: svgRect,
				});
				const uv = getUvCoordinateForPoint(outline.points, point);
				const nextValue = roundNumericUvEllipseValue(
					getLocalEllipseWidthProgress({
						center: control.handle.value,
						dimensions: outline.dimensions,
						point: uv,
						rotation: control.rotation,
						width: control.width,
					}),
					field.fieldSchema,
				);
				lastValue = nextValue;
				setEffectDragOverrides(
					control.handle.nodePath,
					control.handle.effectIndex,
					field.fieldKey,
					field.propStatus.status === 'keyframed'
						? Internals.makeKeyframedDragOverride({
								status: field.propStatus,
								frame: resolveKeyframeSourceFrame(
									control.handle.sourceFrame,
									field.propStatus,
								),
								value: nextValue,
							})
						: Internals.makeStaticDragOverride(nextValue),
				);
			};

			const onPointerMove = (moveEvent: PointerEvent) => {
				moveEvent.preventDefault();
				const deltaX = moveEvent.clientX - startPointerX;
				const deltaY = moveEvent.clientY - startPointerY;
				if (!dragging) {
					if (!isSelectedOutlineDragPastThreshold({deltaX, deltaY})) {
						return;
					}

					dragging = true;
					forceSpecificCursor(startControl.cursor);
					onDraggingChange(true);
				}

				updateFromPointerEvent(moveEvent);
			};

			const onPointerUp = () => {
				if (dragging) {
					stopForcingSpecificCursor();
					onDraggingChange(false);
				}

				saveNumericEffectField({
					clearEffectDragOverrides,
					clientId: control.handle.clientId,
					effectIndex: control.handle.effectIndex,
					field,
					lastValue,
					nodePath: control.handle.nodePath,
					schema: control.handle.schema,
					setPropStatuses,
					sourceFrame: control.handle.sourceFrame,
				});
			};

			startCapturedPointerSession({
				event,
				captureTarget: event.currentTarget,
				onMove: onPointerMove,
				onEnd: onPointerUp,
			});
		},
		[
			clearEffectDragOverrides,
			control.handle,
			control.rotation,
			control.width,
			field,
			onDraggingChange,
			outline.dimensions,
			outline.points,
			setEffectDragOverrides,
			setPropStatuses,
			startControl,
		],
	);

	if (startControl === null || field === undefined) {
		return null;
	}

	return (
		<circle
			cx={startControl.position.x}
			cy={startControl.position.y}
			r={ellipseControlRadius}
			fill={WHITE}
			stroke={BLUE}
			strokeWidth={2}
			style={uvHandleStyle}
			vectorEffect="non-scaling-stroke"
			pointerEvents="all"
			cursor={startControl.cursor}
			onPointerDown={onPointerDown}
		/>
	);
};

const SelectedUvEllipseResizeHandle: React.FC<{
	readonly control: UvEllipseInteractiveControls;
	readonly axis: UvEllipseResizeAxis;
	readonly onDraggingChange: (dragging: boolean) => void;
	readonly outline: SelectedOutline;
}> = ({axis, control, onDraggingChange, outline}) => {
	const {setEffectDragOverrides, clearEffectDragOverrides, setPropStatuses} =
		useContext(Internals.VisualModeSettersContext);
	const resizeControl = control.resize.find((item) => item.axis === axis);
	const field = resizeControl?.field;

	const onPointerDown = React.useCallback(
		(event: React.PointerEvent<SVGCircleElement>) => {
			if (resizeControl === undefined || field === undefined) {
				return;
			}

			if (event.button !== 0) {
				return;
			}

			event.preventDefault();
			event.stopPropagation();

			const svg = event.currentTarget.ownerSVGElement;
			if (svg === null) {
				return;
			}

			const svgRect = svg.getBoundingClientRect();
			const startPointerX = event.clientX;
			const startPointerY = event.clientY;
			let dragging = false;
			let lastValue: number | null = null;

			const updateFromPointerEvent = (pointerEvent: PointerEvent) => {
				const point = getSvgPointFromPointerEvent({
					event: pointerEvent,
					rect: svgRect,
				});
				const uv = getUvCoordinateForPoint(outline.points, point);
				const axisValue = getLocalEllipseAxisValue({
					axis,
					center: control.handle.value,
					dimensions: outline.dimensions,
					point: uv,
					rotation: control.rotation,
				});
				const nextValue = roundNumericUvEllipseValue(
					Math.max(0, axisValue * 2),
					field.fieldSchema,
				);
				lastValue = nextValue;
				setEffectDragOverrides(
					control.handle.nodePath,
					control.handle.effectIndex,
					field.fieldKey,
					field.propStatus.status === 'keyframed'
						? Internals.makeKeyframedDragOverride({
								status: field.propStatus,
								frame: resolveKeyframeSourceFrame(
									control.handle.sourceFrame,
									field.propStatus,
								),
								value: nextValue,
							})
						: Internals.makeStaticDragOverride(nextValue),
				);
			};

			const onPointerMove = (moveEvent: PointerEvent) => {
				moveEvent.preventDefault();
				const deltaX = moveEvent.clientX - startPointerX;
				const deltaY = moveEvent.clientY - startPointerY;
				if (!dragging) {
					if (!isSelectedOutlineDragPastThreshold({deltaX, deltaY})) {
						return;
					}

					dragging = true;
					forceSpecificCursor(resizeControl.cursor);
					onDraggingChange(true);
				}

				updateFromPointerEvent(moveEvent);
			};

			const onPointerUp = () => {
				if (dragging) {
					stopForcingSpecificCursor();
					onDraggingChange(false);
				}

				saveNumericEffectField({
					clearEffectDragOverrides,
					clientId: control.handle.clientId,
					effectIndex: control.handle.effectIndex,
					field,
					lastValue,
					nodePath: control.handle.nodePath,
					schema: control.handle.schema,
					setPropStatuses,
					sourceFrame: control.handle.sourceFrame,
				});
			};

			startCapturedPointerSession({
				event,
				captureTarget: event.currentTarget,
				onMove: onPointerMove,
				onEnd: onPointerUp,
			});
		},
		[
			axis,
			clearEffectDragOverrides,
			control.handle,
			control.rotation,
			field,
			onDraggingChange,
			outline.dimensions,
			outline.points,
			resizeControl,
			setEffectDragOverrides,
			setPropStatuses,
		],
	);

	if (resizeControl === undefined || field === undefined) {
		return null;
	}

	return (
		<circle
			cx={resizeControl.position.x}
			cy={resizeControl.position.y}
			r={ellipseControlRadius}
			fill={WHITE}
			stroke={BLUE}
			strokeWidth={2}
			style={uvHandleStyle}
			vectorEffect="non-scaling-stroke"
			pointerEvents="all"
			cursor={resizeControl.cursor}
			onPointerDown={onPointerDown}
		/>
	);
};

const snapRotationDegrees = (value: number): number =>
	Math.round(value / selectedOutlineRotationSnapStepDegrees) *
	selectedOutlineRotationSnapStepDegrees;

const trimLineToCircleEdges = ({
	from,
	fromRadius,
	to,
	toRadius,
}: {
	readonly from: OutlinePoint;
	readonly fromRadius: number;
	readonly to: OutlinePoint;
	readonly toRadius: number;
}): {readonly from: OutlinePoint; readonly to: OutlinePoint} => {
	const deltaX = to.x - from.x;
	const deltaY = to.y - from.y;
	const distance = Math.hypot(deltaX, deltaY);
	if (distance <= fromRadius + toRadius || distance <= 0.000001) {
		const middle = {
			x: (from.x + to.x) / 2,
			y: (from.y + to.y) / 2,
		};
		return {from: middle, to: middle};
	}

	const unitX = deltaX / distance;
	const unitY = deltaY / distance;
	return {
		from: {
			x: from.x + unitX * fromRadius,
			y: from.y + unitY * fromRadius,
		},
		to: {
			x: to.x - unitX * toRadius,
			y: to.y - unitY * toRadius,
		},
	};
};

const SelectedUvEllipseRotationHandle: React.FC<{
	readonly control: UvEllipseInteractiveControls;
	readonly onDraggingChange: (dragging: boolean) => void;
}> = ({control, onDraggingChange}) => {
	const {setEffectDragOverrides, clearEffectDragOverrides, setPropStatuses} =
		useContext(Internals.VisualModeSettersContext);
	const {editorSnapping} = useContext(EditorSnappingContext);
	const {rotationControl} = control;
	const field = rotationControl?.field;

	const onPointerDown = React.useCallback(
		(event: React.PointerEvent<SVGCircleElement>) => {
			if (rotationControl === null || field === undefined) {
				return;
			}

			if (event.button !== 0) {
				return;
			}

			event.preventDefault();
			event.stopPropagation();

			const svg = event.currentTarget.ownerSVGElement;
			if (svg === null) {
				return;
			}

			const svgRect = svg.getBoundingClientRect();
			const {center} = control;
			const startPointer = {x: event.clientX, y: event.clientY};
			let previousAngle = getAngleDegrees(center, {
				x: event.clientX - svgRect.left,
				y: event.clientY - svgRect.top,
			});
			const startCursorDegrees = previousAngle;
			let accumulatedDelta = 0;
			let rotationLocked = event.shiftKey;
			let dragging = false;
			let lastValue: number | null = null;

			const updateRotationDragOverride = () => {
				const rawValue = control.rotation + accumulatedDelta;
				const snappedValue =
					rotationLocked && editorSnapping
						? snapRotationDegrees(rawValue)
						: rawValue;
				const nextValue = roundNumericUvEllipseValue(
					snappedValue,
					field.fieldSchema,
				);
				const cursorDelta = getSelectedOutlineRotationDeltaDegrees({
					from: control.rotation,
					to: nextValue,
				});
				lastValue = nextValue;
				forceSpecificCursor(
					getRotationCursor(startCursorDegrees + cursorDelta),
				);
				setEffectDragOverrides(
					control.handle.nodePath,
					control.handle.effectIndex,
					field.fieldKey,
					field.propStatus.status === 'keyframed'
						? Internals.makeKeyframedDragOverride({
								status: field.propStatus,
								frame: resolveKeyframeSourceFrame(
									control.handle.sourceFrame,
									field.propStatus,
								),
								value: nextValue,
							})
						: Internals.makeStaticDragOverride(nextValue),
				);
			};

			const onPointerMove = (moveEvent: PointerEvent) => {
				moveEvent.preventDefault();
				const deltaX = moveEvent.clientX - startPointer.x;
				const deltaY = moveEvent.clientY - startPointer.y;
				if (!dragging) {
					if (!isSelectedOutlineDragPastThreshold({deltaX, deltaY})) {
						return;
					}

					dragging = true;
					onDraggingChange(true);
				}

				const nextAngle = getAngleDegrees(center, {
					x: moveEvent.clientX - svgRect.left,
					y: moveEvent.clientY - svgRect.top,
				});
				accumulatedDelta += getSelectedOutlineRotationDeltaDegrees({
					from: previousAngle,
					to: nextAngle,
				});
				previousAngle = nextAngle;
				rotationLocked = moveEvent.shiftKey;
				updateRotationDragOverride();
			};

			const onKeyChange = (keyEvent: KeyboardEvent) => {
				if (keyEvent.key !== 'Shift') {
					return;
				}

				const nextRotationLocked = keyEvent.type === 'keydown';
				if (nextRotationLocked === rotationLocked) {
					return;
				}

				rotationLocked = nextRotationLocked;
				if (dragging) {
					updateRotationDragOverride();
				}
			};

			const onPointerUp = () => {
				window.removeEventListener('keydown', onKeyChange);
				window.removeEventListener('keyup', onKeyChange);
				if (dragging) {
					stopForcingSpecificCursor();
					onDraggingChange(false);
				}

				saveNumericEffectField({
					clearEffectDragOverrides,
					clientId: control.handle.clientId,
					effectIndex: control.handle.effectIndex,
					field,
					lastValue,
					nodePath: control.handle.nodePath,
					schema: control.handle.schema,
					setPropStatuses,
					sourceFrame: control.handle.sourceFrame,
				});
			};

			startCapturedPointerSession({
				event,
				captureTarget: event.currentTarget,
				onMove: onPointerMove,
				onEnd: onPointerUp,
			});
			window.addEventListener('keydown', onKeyChange);
			window.addEventListener('keyup', onKeyChange);
		},
		[
			clearEffectDragOverrides,
			control,
			editorSnapping,
			field,
			onDraggingChange,
			rotationControl,
			setEffectDragOverrides,
			setPropStatuses,
		],
	);

	if (rotationControl === null || field === undefined) {
		return null;
	}

	const heightControl = control.resize.find((item) => item.axis === 'height');
	if (heightControl === undefined) {
		return null;
	}

	const connector = trimLineToCircleEdges({
		from: heightControl.position,
		fromRadius: ellipseControlRadius,
		to: rotationControl.position,
		toRadius: ellipseControlRadius,
	});

	return (
		<>
			<line
				x1={connector.from.x}
				y1={connector.from.y}
				x2={connector.to.x}
				y2={connector.to.y}
				stroke={BLUE}
				strokeWidth={2}
				vectorEffect="non-scaling-stroke"
				pointerEvents="none"
			/>
			<circle
				cx={rotationControl.position.x}
				cy={rotationControl.position.y}
				r={ellipseControlRadius}
				fill={WHITE}
				stroke={BLUE}
				strokeWidth={2}
				style={uvHandleStyle}
				vectorEffect="non-scaling-stroke"
				pointerEvents="all"
				cursor={getRotationCursor(
					getAngleDegrees(control.center, rotationControl.position),
				)}
				onPointerDown={onPointerDown}
			/>
		</>
	);
};

const SelectedUvHandleCircle: React.FC<{
	readonly onDraggingChange: (dragging: boolean) => void;
	readonly onSelect: (
		item: TimelineSelection,
		interaction?: TimelineSelectionInteraction,
	) => void;
	readonly handle: SelectedOutlineUvHandle;
	readonly nodePathInfo: SequenceNodePathInfo;
	readonly outline: SelectedOutline;
}> = ({handle, nodePathInfo, onDraggingChange, onSelect, outline}) => {
	const {setEffectDragOverrides, clearEffectDragOverrides, setPropStatuses} =
		useContext(Internals.VisualModeSettersContext);
	const {editorSnapping} = useContext(EditorSnappingContext);
	const position = useMemo(
		() => getUvHandlePosition(outline.points, handle.value),
		[handle.value, outline.points],
	);

	const onPointerDown = React.useCallback(
		(event: React.PointerEvent<SVGCircleElement>) => {
			if (event.button !== 0) {
				return;
			}

			event.preventDefault();
			event.stopPropagation();

			const interaction = getOutlineSelectionInteraction(event);
			onSelect(
				getSelectedOutlineUvHandleTimelineSelection({
					effectIndex: handle.effectIndex,
					fieldKey: handle.fieldKey,
					nodePathInfo,
				}),
				interaction,
			);

			if (interaction.shiftKey || interaction.toggleKey) {
				return;
			}

			const svg = event.currentTarget.ownerSVGElement;
			if (svg === null) {
				return;
			}

			const svgRect = svg.getBoundingClientRect();
			const startPointerX = event.clientX;
			const startPointerY = event.clientY;
			let lastValue: UvCoordinate | null = null;
			let dragging = false;
			const defaultValue =
				handle.fieldDefault !== undefined
					? JSON.stringify(handle.fieldDefault)
					: null;

			const updateFromPointerEvent = (
				pointerEvent: PointerEvent | React.PointerEvent<SVGCircleElement>,
			) => {
				const point = getSvgPointFromPointerEvent({
					event: pointerEvent,
					rect: svgRect,
				});
				const rawUv = getUvCoordinateForPoint(outline.points, point);
				const snappedUv = editorSnapping
					? snapSelectedOutlineUv({
							point,
							points: outline.points,
							uv: rawUv,
						})
					: rawUv;
				const nextValue = roundUvCoordinate(
					constrainUv(snappedUv, handle.fieldSchema),
					handle.fieldSchema,
				);
				lastValue = nextValue;
				setEffectDragOverrides(
					handle.nodePath,
					handle.effectIndex,
					handle.fieldKey,
					handle.propStatus.status === 'keyframed'
						? Internals.makeKeyframedDragOverride({
								status: handle.propStatus,
								frame: resolveKeyframeSourceFrame(
									handle.sourceFrame,
									handle.propStatus,
								),
								value: nextValue,
							})
						: Internals.makeStaticDragOverride(nextValue),
				);
			};

			const updateDragFromPointerEvent = (pointerEvent: PointerEvent) => {
				if (!dragging) {
					const deltaX = pointerEvent.clientX - startPointerX;
					const deltaY = pointerEvent.clientY - startPointerY;
					if (!isSelectedOutlineDragPastThreshold({deltaX, deltaY})) {
						return;
					}

					dragging = true;
					forceSpecificCursor('default');
					onDraggingChange(true);
				}

				updateFromPointerEvent(pointerEvent);
			};

			const onPointerMove = (moveEvent: PointerEvent) => {
				moveEvent.preventDefault();
				updateDragFromPointerEvent(moveEvent);
			};

			const onPointerUp = () => {
				if (dragging) {
					stopForcingSpecificCursor();
					onDraggingChange(false);
				}

				const stringifiedValue =
					lastValue === null ? null : JSON.stringify(lastValue);
				const shouldSave = (() => {
					if (lastValue === null) {
						return false;
					}

					if (handle.propStatus.status === 'keyframed') {
						return !tuplesEqual(handle.value, lastValue);
					}

					return (
						!tuplesEqual(handle.propStatus.codeValue, lastValue) &&
						!(
							defaultValue === stringifiedValue &&
							handle.propStatus.codeValue === undefined
						)
					);
				})();

				if (!shouldSave) {
					clearEffectDragOverrides(handle.nodePath, handle.effectIndex);
					return;
				}

				(handle.propStatus.status === 'keyframed'
					? callAddEffectKeyframe({
							fileName: handle.nodePath.absolutePath,
							nodePath: handle.nodePath,
							effectIndex: handle.effectIndex,
							fieldKey: handle.fieldKey,
							sourceFrame: resolveKeyframeSourceFrame(
								handle.sourceFrame,
								handle.propStatus,
							),
							value: lastValue,
							schema: handle.schema,
							setPropStatuses,
							clientId: handle.clientId,
						})
					: saveEffectProp({
							type: 'value',
							fileName: handle.nodePath.absolutePath,
							nodePath: handle.nodePath,
							effectIndex: handle.effectIndex,
							fieldKey: handle.fieldKey,
							value: lastValue,
							defaultValue,
							schema: handle.schema,
							setPropStatuses,
							clientId: handle.clientId,
						})
				).finally(() => {
					clearEffectDragOverrides(handle.nodePath, handle.effectIndex);
				});
			};

			startCapturedPointerSession({
				event,
				captureTarget: event.currentTarget,
				onMove: onPointerMove,
				onEnd: onPointerUp,
			});
		},
		[
			clearEffectDragOverrides,
			editorSnapping,
			handle,
			nodePathInfo,
			onDraggingChange,
			onSelect,
			outline.points,
			setPropStatuses,
			setEffectDragOverrides,
		],
	);

	return (
		<circle
			cx={position.x}
			cy={position.y}
			r={handle.isSelected ? selectedUvHandleRadius : uvHandleRadius}
			fill={WHITE}
			stroke={BLUE}
			strokeWidth={2}
			style={uvHandleStyle}
			vectorEffect="non-scaling-stroke"
			pointerEvents="all"
			cursor="default"
			onPointerDown={onPointerDown}
		/>
	);
};

type UvTarget = {
	readonly containsSelection: boolean;
	readonly nodePathInfo: SequenceNodePathInfo;
	readonly uvHandles: readonly SelectedOutlineUvHandle[];
};

const useSelectedOutlineUvTarget = (
	layoutTarget: SelectedOutlineLayoutTarget,
): UvTarget => {
	const timelinePosition = Internals.Timeline.useTimelinePosition();
	const {selectedItems} = useTimelineSelection();
	const {propStatuses} = useContext(Internals.VisualModePropStatusesContext);
	const {getEffectDragOverrides} = useContext(
		Internals.VisualModeDragOverridesContext,
	);
	const {previewServerState} = useContext(StudioServerConnectionCtx);
	const selectedEffectsBySequenceKey = useMemo(
		() => getSelectedEffectFieldsBySequenceKey(selectedItems),
		[selectedItems],
	);

	return useMemo(() => {
		return {
			containsSelection: layoutTarget.containsSelection,
			nodePathInfo: layoutTarget.nodePathInfo,
			uvHandles: getSelectedUvHandles({
				propStatuses,
				clientId:
					previewServerState.type === 'connected'
						? previewServerState.clientId
						: null,
				getEffectDragOverrides,
				nodePath: layoutTarget.nodePathInfo.sequenceSubscriptionKey,
				selectedEffects: selectedEffectsBySequenceKey.get(layoutTarget.key),
				sequence: layoutTarget.sequence,
				sourceFrame: {
					displayFrame: timelinePosition,
					keyframeDisplayOffset: layoutTarget.keyframeDisplayOffset,
					keyframePlaybackRate: layoutTarget.keyframePlaybackRate,
				},
			}),
		};
	}, [
		getEffectDragOverrides,
		layoutTarget,
		previewServerState,
		propStatuses,
		selectedEffectsBySequenceKey,
		timelinePosition,
	]);
};

const SelectedOutlineUvHandleConnectionLayerActive: React.FC<{
	readonly layoutTarget: SelectedOutlineLayoutTarget;
	readonly outline: SelectedOutline;
}> = ({layoutTarget, outline}) => {
	const target = useSelectedOutlineUvTarget(layoutTarget);
	if (!target.containsSelection || target.uvHandles.length === 0) {
		return null;
	}

	return (
		<SelectedUvHandleConnectionLines
			handles={target.uvHandles}
			outline={outline}
		/>
	);
};

export const SelectedOutlineUvHandleConnectionLayer: React.FC<{
	readonly layoutTarget: SelectedOutlineLayoutTarget | undefined;
	readonly outline: SelectedOutline;
}> = ({layoutTarget, outline}) => {
	if (layoutTarget?.selectedForUvHandles !== true) {
		return null;
	}

	return (
		<SelectedOutlineUvHandleConnectionLayerActive
			layoutTarget={layoutTarget}
			outline={outline}
		/>
	);
};

const SelectedOutlineUvHandleCircleLayerActive: React.FC<{
	readonly layoutTarget: SelectedOutlineLayoutTarget;
	readonly onDraggingChange: (dragging: boolean) => void;
	readonly onSelect: (
		item: TimelineSelection,
		interaction?: TimelineSelectionInteraction,
	) => void;
	readonly outline: SelectedOutline;
}> = ({layoutTarget, onDraggingChange, onSelect, outline}) => {
	const target = useSelectedOutlineUvTarget(layoutTarget);
	const ellipseControls = useMemo(
		() =>
			getUvEllipseInteractiveControls({
				handles: target.uvHandles,
				dimensions: outline.dimensions,
				points: outline.points,
			}),
		[outline.dimensions, outline.points, target.uvHandles],
	);

	if (!target.containsSelection || target.uvHandles.length === 0) {
		return null;
	}

	return (
		<>
			{ellipseControls.map((control) => (
				<React.Fragment
					key={`${control.handle.effectIndex}-${control.handle.fieldKey}-ellipse-controls`}
				>
					<SelectedUvEllipseStartHandle
						control={control}
						onDraggingChange={onDraggingChange}
						outline={outline}
					/>
					<SelectedUvEllipseResizeHandle
						axis="width"
						control={control}
						onDraggingChange={onDraggingChange}
						outline={outline}
					/>
					<SelectedUvEllipseResizeHandle
						axis="height"
						control={control}
						onDraggingChange={onDraggingChange}
						outline={outline}
					/>
					<SelectedUvEllipseRotationHandle
						control={control}
						onDraggingChange={onDraggingChange}
					/>
				</React.Fragment>
			))}
			{target.uvHandles.map((handle) => (
				<SelectedUvHandleCircle
					key={`${handle.effectIndex}-${handle.fieldKey}`}
					handle={handle}
					nodePathInfo={target.nodePathInfo}
					onDraggingChange={onDraggingChange}
					onSelect={onSelect}
					outline={outline}
				/>
			))}
		</>
	);
};

export const SelectedOutlineUvHandleCircleLayer: React.FC<{
	readonly layoutTarget: SelectedOutlineLayoutTarget | undefined;
	readonly onDraggingChange: (dragging: boolean) => void;
	readonly onSelect: (
		item: TimelineSelection,
		interaction?: TimelineSelectionInteraction,
	) => void;
	readonly outline: SelectedOutline;
}> = ({layoutTarget, onDraggingChange, onSelect, outline}) => {
	if (layoutTarget?.selectedForUvHandles !== true) {
		return null;
	}

	return (
		<SelectedOutlineUvHandleCircleLayerActive
			layoutTarget={layoutTarget}
			onDraggingChange={onDraggingChange}
			onSelect={onSelect}
			outline={outline}
		/>
	);
};