Skip to content

Create polished demo videos without editing skills. Mac/Windows/Linux

13.3 KB
Raw Blame
import { type PointerEvent, useCallback, useEffect, useRef, useState } from "react";
import {
	canShowFloatingWebcamPreview,
	DEFAULT_WEBCAM_PREVIEW_SIZE,
	parseWebcamPreviewSize,
	resizeWebcamPreview,
	WEBCAM_PREVIEW_SIZE_STORAGE_KEY,
	type WebcamPreviewResizeHandle,
} from "../floatingWebcamPreview";
import { shouldRestoreHudMousePassthroughAfterDrag } from "../hudMousePassthrough";

const WEBCAM_PREVIEW_DRAG_THRESHOLD = 6;
const DEFAULT_WEBCAM_PREVIEW_OFFSET = { x: 0, y: 0 };

export function useWebcamPreviewOverlay({
	webcamEnabled,
	webcamDeviceId,
	showWebcamControls,
	webcamPopoverOpen,
	hudOverlayMousePassthroughSupported,
}: {
	webcamEnabled: boolean;
	webcamDeviceId?: string;
	showWebcamControls: boolean;
	webcamPopoverOpen: boolean;
	hudOverlayMousePassthroughSupported: boolean | null;
}) {
	const [editorMode, setEditorMode] = useState(true);
	useEffect(() => {
		let active = true;
		let receivedEvent = false;
		const unsubscribe = window.electronAPI.onEditorModeChanged((inEditor) => {
			receivedEvent = true;
			if (active) setEditorMode(inEditor);
		});
		void window.electronAPI
			.getEditorMode()
			.then((inEditor) => {
				if (active && !receivedEvent) setEditorMode(inEditor);
			})
			.catch(() => {
				/* Keep the camera off if editor mode is unknown. */
			});
		return () => {
			active = false;
			unsubscribe();
		};
	}, []);
	const [showFloatingWebcamPreview, setShowFloatingWebcamPreview] = useState(true);
	const [webcamPreviewOffset, setWebcamPreviewOffset] = useState(DEFAULT_WEBCAM_PREVIEW_OFFSET);
	const webcamPreviewOffsetRef = useRef(DEFAULT_WEBCAM_PREVIEW_OFFSET);
	const [webcamPreviewSize, setWebcamPreviewSize] = useState(() => {
		try {
			return parseWebcamPreviewSize(localStorage.getItem(WEBCAM_PREVIEW_SIZE_STORAGE_KEY));
		} catch {
			return DEFAULT_WEBCAM_PREVIEW_SIZE;
		}
	});
	const webcamPreviewResizeRef = useRef<{
		pointerId: number;
		handle: WebcamPreviewResizeHandle;
		startX: number;
		startY: number;
		startRect: DOMRect;
		startOffset: { x: number; y: number };
		size: { width: number; height: number };
	} | null>(null);
	const webcamPreviewRef = useRef<HTMLVideoElement | null>(null);
	const recordingWebcamPreviewRef = useRef<HTMLVideoElement | null>(null);
	const recordingWebcamPreviewContainerRef = useRef<HTMLDivElement | null>(null);
	const previewStreamRef = useRef<MediaStream | null>(null);
	const previewDragMoveRafRef = useRef<number | null>(null);
	const previewDragPendingPointerRef = useRef<{ clientX: number; clientY: number } | null>(null);
	const webcamPreviewDragStartRef = useRef<{
		pointerId: number;
		startX: number;
		startY: number;
		originX: number;
		originY: number;
		initialLeft: number;
		initialTop: number;
		previewWidth: number;
		previewHeight: number;
		dragging: boolean;
	} | null>(null);
	const isWebcamPreviewDraggingRef = useRef(false);
	const showRecordingWebcamPreview =
		webcamEnabled &&
		canShowFloatingWebcamPreview(
			showFloatingWebcamPreview,
			hudOverlayMousePassthroughSupported,
		);
	const shouldStreamWebcamPreview =
		!editorMode &&
		webcamEnabled &&
		(showRecordingWebcamPreview || (showWebcamControls && webcamPopoverOpen));

	useEffect(() => {
		if (!webcamEnabled) {
			webcamPreviewOffsetRef.current = DEFAULT_WEBCAM_PREVIEW_OFFSET;
			setWebcamPreviewOffset(DEFAULT_WEBCAM_PREVIEW_OFFSET);
			if (recordingWebcamPreviewContainerRef.current) {
				recordingWebcamPreviewContainerRef.current.style.transform = "translate(0px, 0px)";
			}
			webcamPreviewDragStartRef.current = null;
			isWebcamPreviewDraggingRef.current = false;
			setShowFloatingWebcamPreview(true);
		}
	}, [webcamEnabled]);

	const handleWebcamPreviewPointerDown = useCallback((event: PointerEvent<HTMLDivElement>) => {
		if (event.button !== 0) {
			return;
		}

		const previewRect = event.currentTarget.getBoundingClientRect();

		event.preventDefault();
		window.electronAPI?.hudOverlaySetIgnoreMouse?.(false);
		webcamPreviewDragStartRef.current = {
			pointerId: event.pointerId,
			startX: event.clientX,
			startY: event.clientY,
			originX: webcamPreviewOffsetRef.current.x,
			originY: webcamPreviewOffsetRef.current.y,
			initialLeft: previewRect.left,
			initialTop: previewRect.top,
			previewWidth: previewRect.width,
			previewHeight: previewRect.height,
			dragging: false,
		};
		event.currentTarget.setPointerCapture(event.pointerId);
	}, []);

	const handleWebcamPreviewPointerMove = useCallback((event: PointerEvent<HTMLDivElement>) => {
		const dragState = webcamPreviewDragStartRef.current;
		if (!dragState || dragState.pointerId !== event.pointerId) {
			return;
		}

		const deltaX = event.clientX - dragState.startX;
		const deltaY = event.clientY - dragState.startY;

		if (!dragState.dragging && Math.hypot(deltaX, deltaY) < WEBCAM_PREVIEW_DRAG_THRESHOLD) {
			return;
		}

		if (!dragState.dragging) {
			dragState.dragging = true;
			isWebcamPreviewDraggingRef.current = true;
		}

		previewDragPendingPointerRef.current = { clientX: event.clientX, clientY: event.clientY };
		if (previewDragMoveRafRef.current !== null) {
			return;
		}

		previewDragMoveRafRef.current = requestAnimationFrame(() => {
			previewDragMoveRafRef.current = null;
			const latestDragState = webcamPreviewDragStartRef.current;
			const pointer = previewDragPendingPointerRef.current;
			if (!latestDragState || !pointer) {
				return;
			}

			const latestDeltaX = pointer.clientX - latestDragState.startX;
			const latestDeltaY = pointer.clientY - latestDragState.startY;
			// Pointer coordinates and getBoundingClientRect() are relative to the HUD
			// viewport. `screen.width` can use a different display/DPI coordinate space.
			const viewportWidth = window.innerWidth;
			const viewportHeight = window.innerHeight;
			const unclampedLeft = latestDragState.initialLeft + latestDeltaX;
			const unclampedTop = latestDragState.initialTop + latestDeltaY;
			const clampedLeft = Math.min(
				Math.max(0, unclampedLeft),
				Math.max(0, viewportWidth - latestDragState.previewWidth),
			);
			const clampedTop = Math.min(
				Math.max(0, unclampedTop),
				Math.max(0, viewportHeight - latestDragState.previewHeight),
			);

			const nextOffset = {
				x: latestDragState.originX + (clampedLeft - latestDragState.initialLeft),
				y: latestDragState.originY + (clampedTop - latestDragState.initialTop),
			};
			webcamPreviewOffsetRef.current = nextOffset;
			if (recordingWebcamPreviewContainerRef.current) {
				recordingWebcamPreviewContainerRef.current.style.transform = `translate(${nextOffset.x}px, ${nextOffset.y}px)`;
			}
		});
	}, []);

	const handleWebcamPreviewPointerUp = useCallback((event: PointerEvent<HTMLDivElement>) => {
		const dragState = webcamPreviewDragStartRef.current;
		if (!dragState || dragState.pointerId !== event.pointerId) {
			return;
		}
		if (previewDragMoveRafRef.current !== null) {
			cancelAnimationFrame(previewDragMoveRafRef.current);
			previewDragMoveRafRef.current = null;
		}
		previewDragPendingPointerRef.current = null;

		const wasDragging = dragState.dragging;
		webcamPreviewDragStartRef.current = null;
		isWebcamPreviewDraggingRef.current = false;
		setWebcamPreviewOffset({ ...webcamPreviewOffsetRef.current });
		if (event.currentTarget.hasPointerCapture(event.pointerId)) {
			event.currentTarget.releasePointerCapture(event.pointerId);
		}
		if (wasDragging) {
			window.electronAPI?.hudOverlaySetIgnoreMouse?.(true);
		}
	}, []);

	const handleWebcamPreviewResizePointerDown = useCallback(
		(event: PointerEvent<HTMLDivElement>) => {
			const container = recordingWebcamPreviewContainerRef.current;
			if (event.button !== 0 || !container) {
				return;
			}

			// Keep the container's drag handler from treating this as a move.
			event.preventDefault();
			event.stopPropagation();
			window.electronAPI?.hudOverlaySetIgnoreMouse?.(false);
			isWebcamPreviewDraggingRef.current = true;
			webcamPreviewResizeRef.current = {
				pointerId: event.pointerId,
				handle: event.currentTarget.dataset.resizeHandle as WebcamPreviewResizeHandle,
				startX: event.clientX,
				startY: event.clientY,
				startRect: container.getBoundingClientRect(),
				startOffset: webcamPreviewOffsetRef.current,
				size: webcamPreviewSize,
			};
			event.currentTarget.setPointerCapture(event.pointerId);
		},
		[webcamPreviewSize],
	);

	const handleWebcamPreviewResizePointerMove = useCallback(
		(event: PointerEvent<HTMLDivElement>) => {
			const resizeState = webcamPreviewResizeRef.current;
			const container = recordingWebcamPreviewContainerRef.current;
			if (!resizeState || resizeState.pointerId !== event.pointerId || !container) {
				return;
			}

			const { width, height, shiftX, shiftY } = resizeWebcamPreview(
				resizeState.handle,
				resizeState.startRect,
				event.clientX - resizeState.startX,
				event.clientY - resizeState.startY,
				{ width: window.innerWidth, height: window.innerHeight },
			);
			resizeState.size = { width, height };
			webcamPreviewOffsetRef.current = {
				x: resizeState.startOffset.x + shiftX,
				y: resizeState.startOffset.y + shiftY,
			};
			container.style.width = `${width}px`;
			container.style.height = `${height}px`;
			container.style.transform = `translate(${webcamPreviewOffsetRef.current.x}px, ${webcamPreviewOffsetRef.current.y}px)`;
		},
		[],
	);

	const handleWebcamPreviewResizePointerUp = useCallback(
		(event: PointerEvent<HTMLDivElement>) => {
			const resizeState = webcamPreviewResizeRef.current;
			if (!resizeState || resizeState.pointerId !== event.pointerId) {
				return;
			}

			webcamPreviewResizeRef.current = null;
			isWebcamPreviewDraggingRef.current = false;
			setWebcamPreviewSize(resizeState.size);
			setWebcamPreviewOffset({ ...webcamPreviewOffsetRef.current });
			try {
				localStorage.setItem(
					WEBCAM_PREVIEW_SIZE_STORAGE_KEY,
					JSON.stringify(resizeState.size),
				);
			} catch {
				// Keep resizing and pointer cleanup working when preferences cannot be saved.
			}
			if (event.currentTarget.hasPointerCapture(event.pointerId)) {
				event.currentTarget.releasePointerCapture(event.pointerId);
			}
			const previewBounds =
				recordingWebcamPreviewContainerRef.current?.getBoundingClientRect();
			if (
				shouldRestoreHudMousePassthroughAfterDrag(
					previewBounds ?? null,
					event.clientX,
					event.clientY,
				)
			) {
				window.electronAPI?.hudOverlaySetIgnoreMouse?.(true);
			}
		},
		[],
	);

	const attachPreviewStreamToNode = useCallback((videoElement: HTMLVideoElement | null) => {
		const previewStream = previewStreamRef.current;
		if (!videoElement || !previewStream || videoElement.srcObject === previewStream) {
			return;
		}

		videoElement.srcObject = previewStream;
		const playPromise = videoElement.play();
		if (playPromise) {
			playPromise.catch(() => {
				// Ignore autoplay interruptions while the preview element mounts.
			});
		}
	}, []);

	const setWebcamPreviewNode = useCallback(
		(node: HTMLVideoElement | null) => {
			webcamPreviewRef.current = node;
			attachPreviewStreamToNode(node);
		},
		[attachPreviewStreamToNode],
	);

	const setRecordingWebcamPreviewNode = useCallback(
		(node: HTMLVideoElement | null) => {
			recordingWebcamPreviewRef.current = node;
			attachPreviewStreamToNode(node);
		},
		[attachPreviewStreamToNode],
	);

	useEffect(() => {
		return () => {
			if (previewDragMoveRafRef.current !== null) {
				cancelAnimationFrame(previewDragMoveRafRef.current);
			}
			previewDragMoveRafRef.current = null;
			previewDragPendingPointerRef.current = null;
		};
	}, []);

	useEffect(() => {
		let mounted = true;

		const startPreview = async () => {
			if (!shouldStreamWebcamPreview) {
				return;
			}

			try {
				const previewStream = await navigator.mediaDevices.getUserMedia({
					video: webcamDeviceId
						? {
								deviceId: { exact: webcamDeviceId },
								width: { ideal: 320 },
								height: { ideal: 320 },
								frameRate: { ideal: 24, max: 30 },
							}
						: {
								width: { ideal: 320 },
								height: { ideal: 320 },
								frameRate: { ideal: 24, max: 30 },
							},
					audio: false,
				});

				if (!mounted) {
					previewStream.getTracks().forEach((track) => track.stop());
					return;
				}

				previewStreamRef.current = previewStream;
				attachPreviewStreamToNode(webcamPreviewRef.current);
				attachPreviewStreamToNode(recordingWebcamPreviewRef.current);
			} catch (error) {
				console.warn("Failed to start live webcam preview:", error);
			}
		};

		void startPreview();

		return () => {
			mounted = false;
			const previewNode = webcamPreviewRef.current;
			const recordingPreviewNode = recordingWebcamPreviewRef.current;
			const previewStream = previewStreamRef.current;

			[previewNode, recordingPreviewNode]
				.filter((node): node is HTMLVideoElement => Boolean(node))
				.forEach((videoElement) => {
					videoElement.pause();
					videoElement.srcObject = null;
				});
			previewStream?.getTracks().forEach((track) => track.stop());
			if (previewStreamRef.current === previewStream) {
				previewStreamRef.current = null;
			}
		};
	}, [attachPreviewStreamToNode, shouldStreamWebcamPreview, webcamDeviceId]);

	return {
		showFloatingWebcamPreview,
		setShowFloatingWebcamPreview,
		webcamPreviewOffset,
		webcamPreviewSize,
		recordingWebcamPreviewContainerRef,
		isWebcamPreviewDraggingRef,
		webcamPreviewDragStartRef,
		handleWebcamPreviewPointerDown,
		handleWebcamPreviewPointerMove,
		handleWebcamPreviewPointerUp,
		handleWebcamPreviewResizePointerDown,
		handleWebcamPreviewResizePointerMove,
		handleWebcamPreviewResizePointerUp,
		setWebcamPreviewNode,
		setRecordingWebcamPreviewNode,
		showRecordingWebcamPreview,
	};
}