Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

10.7 KB
Raw Blame
import { createEventListenerMap } from "@solid-primitives/event-listener";
import { cx } from "cva";
import { createMemo, createRoot, For, Show } from "solid-js";
import { produce } from "solid-js/store";

import { useCanvasSnapTargets } from "./CanvasElementsOverlay";
import { useEditorContext } from "./context";
import { evaluateMask, type MaskSegment } from "./masks";
import { createOverlaySegments } from "./overlay-segments";
import { SNAP_PX, snapMovingRect } from "./snapping";
import { getOverlayZIndex } from "./timelineTracks";

type MaskOverlayProps = {
	size: { width: number; height: number };
};

export function MaskOverlay(props: MaskOverlayProps) {
	const { project, setProject, editorState, setEditorState, projectHistory } =
		useEditorContext();

	const currentAbsoluteTime = () =>
		editorState.previewTime ?? editorState.playbackTime ?? 0;

	const { indexed: maskSegments, visible: visibleMaskSegments } =
		createOverlaySegments(
			() => project.timeline?.maskSegments ?? [],
			currentAbsoluteTime,
		);

	const selectedMaskIndex = createMemo(() => {
		const selection = editorState.timeline.selection;
		if (!selection || selection.type !== "mask") return null;
		return selection.indices[0] ?? null;
	});

	const hoveredMaskIndex = createMemo(
		() => editorState.timeline.hoveredMaskIndex,
	);
	const hoveredMaskTime = createMemo(
		() => editorState.timeline.hoveredMaskTime,
	);

	const selectedMask = createMemo(() => {
		const index = selectedMaskIndex();
		if (index === null) return;
		const segment = project.timeline?.maskSegments?.[index];
		if (!segment) return;
		return { index, segment };
	});

	const hoveredMask = createMemo(() => {
		const index = hoveredMaskIndex();
		if (index === null) return null;
		const segment = project.timeline?.maskSegments?.[index];
		if (!segment) return null;
		return { index, segment };
	});

	const updateSegment = (fn: (segment: MaskSegment) => void) => {
		const index = selectedMask()?.index;
		if (index === undefined) return;
		setProject(
			"timeline",
			"maskSegments",
			index,
			produce((segment) => {
				segment.keyframes ??= { position: [], size: [], intensity: [] };
				segment.keyframes.position = [];
				segment.keyframes.size = [];
				fn(segment);
			}),
		);
	};

	const handleSelectSegment = (index: number, e: MouseEvent) => {
		e.preventDefault();
		e.stopPropagation();
		setEditorState("timeline", "selection", {
			type: "mask",
			indices: [index],
		});
	};

	const displayedMaskSegments = createMemo(() => {
		const visible = visibleMaskSegments();
		const hoveredIndex = hoveredMaskIndex();
		if (
			hoveredIndex === null ||
			visible.some(({ index }) => index === hoveredIndex)
		) {
			return visible;
		}
		const hovered = maskSegments()[hoveredIndex];
		if (!hovered) return visible;
		return [...visible, hovered];
	});

	const getMaskTime = (index: number) => {
		const time = hoveredMaskTime();
		return hoveredMaskIndex() === index && time !== null
			? time
			: currentAbsoluteTime();
	};

	const getMaskRectAtTime = (segment: MaskSegment, time: number) => {
		const state = evaluateMask(segment, time);
		const width = state.size.x * props.size.width;
		const height = state.size.y * props.size.height;
		const left = state.position.x * props.size.width - width / 2;
		const top = state.position.y * props.size.height - height / 2;
		return { width, height, left, top };
	};

	const shouldRenderHoveredMask = () => {
		const hovered = hoveredMask();
		return (
			hovered !== null &&
			selectedMaskIndex() !== hovered.index &&
			hoveredMaskTime() !== null
		);
	};

	return (
		<div
			class="absolute inset-0 pointer-events-none"
			style={{ opacity: "var(--preview-controls-opacity, 1)" }}
		>
			<Show when={shouldRenderHoveredMask() ? hoveredMask() : null}>
				{(hovered) => {
					const rect = () =>
						getMaskRectAtTime(hovered().segment, getMaskTime(hovered().index));
					return (
						<div
							class="absolute z-20 pointer-events-none rounded-md border-2 border-gray-11/65 shadow-[0_0_0_1px_rgba(255,255,255,0.03)]"
							style={{
								"z-index": getOverlayZIndex(
									project,
									"mask",
									hovered().segment.track ?? 0,
								),
								left: `${rect().left}px`,
								top: `${rect().top}px`,
								width: `${rect().width}px`,
								height: `${rect().height}px`,
							}}
						/>
					);
				}}
			</Show>
			<For each={displayedMaskSegments()}>
				{({ segment, index }) => {
					const isSelected = () => selectedMaskIndex() === index;
					const isHovered = () => hoveredMaskIndex() === index;
					const rect = () => getMaskRectAtTime(segment, getMaskTime(index));
					const maskState = () => evaluateMask(segment, getMaskTime(index));
					const overlayClass = () =>
						cx(
							"border-transparent bg-transparent hover:border-gray-11/65",
							isHovered() && "border-gray-11/65",
						);

					return (
						<Show
							when={isSelected() && selectedMask()}
							fallback={
								<div
									class={cx(
										"absolute pointer-events-auto rounded-md border-2 transition-colors",
										overlayClass(),
									)}
									style={{
										"z-index": getOverlayZIndex(
											project,
											"mask",
											segment.track ?? 0,
										),
										left: `${rect().left}px`,
										top: `${rect().top}px`,
										width: `${rect().width}px`,
										height: `${rect().height}px`,
									}}
									onMouseDown={(e) => handleSelectSegment(index, e)}
								/>
							}
						>
							<MaskOverlayContent
								size={props.size}
								maskIndex={index}
								zIndex={getOverlayZIndex(project, "mask", segment.track ?? 0)}
								maskState={maskState}
								updateSegment={updateSegment}
								projectHistory={projectHistory}
							/>
						</Show>
					);
				}}
			</For>
		</div>
	);
}

function MaskOverlayContent(props: {
	size: { width: number; height: number };
	maskIndex: number;
	zIndex: number;
	maskState: () => ReturnType<typeof evaluateMask>;
	updateSegment: (fn: (segment: MaskSegment) => void) => void;
	projectHistory: ReturnType<typeof useEditorContext>["projectHistory"];
}) {
	const { projectHistory, updateSegment } = props;
	const { setSnapGuides } = useEditorContext();
	const snapTargetsFor = useCanvasSnapTargets();

	function createMouseDownDrag<T>(
		setup: () => T,
		update: (
			e: MouseEvent,
			value: T,
			initialMouse: { x: number; y: number },
		) => void,
	) {
		return (downEvent: MouseEvent) => {
			downEvent.preventDefault();
			downEvent.stopPropagation();

			const initial = setup();
			const initialMouse = { x: downEvent.clientX, y: downEvent.clientY };
			const resumeHistory = projectHistory.pause();

			function handleUpdate(event: MouseEvent) {
				update(event, initial, initialMouse);
			}

			function finish() {
				resumeHistory();
				setSnapGuides([]);
				dispose();
			}

			const dispose = createRoot((dispose) => {
				createEventListenerMap(window, {
					mousemove: handleUpdate,
					mouseup: () => {
						finish();
					},
				});
				return dispose;
			});
		};
	}

	const state = () => props.maskState();
	const rect = () => {
		const width = state().size.x * props.size.width;
		const height = state().size.y * props.size.height;
		const left = state().position.x * props.size.width - width / 2;
		const top = state().position.y * props.size.height - height / 2;
		return { width, height, left, top };
	};

	const onMove = createMouseDownDrag(
		() => ({
			startPos: { ...state().position },
			startSize: { ...state().size },
			targets: snapTargetsFor({ mask: props.maskIndex }),
		}),
		(e, { startPos, startSize, targets }, initialMouse) => {
			const dx = (e.clientX - initialMouse.x) / props.size.width;
			const dy = (e.clientY - initialMouse.y) / props.size.height;

			let snapDx = 0;
			let snapDy = 0;
			if (e.shiftKey) {
				setSnapGuides([]);
			} else {
				const snap = snapMovingRect(
					{
						x: startPos.x + dx - startSize.x / 2,
						y: startPos.y + dy - startSize.y / 2,
						w: startSize.x,
						h: startSize.y,
					},
					targets,
					SNAP_PX / props.size.width,
					SNAP_PX / props.size.height,
				);
				snapDx = snap.dx;
				snapDy = snap.dy;
				setSnapGuides(snap.guides);
			}

			updateSegment((s) => {
				s.center.x = Math.max(0, Math.min(1, startPos.x + dx + snapDx));
				s.center.y = Math.max(0, Math.min(1, startPos.y + dy + snapDy));
			});
		},
	);

	const createResizeHandler = (dirX: -1 | 0 | 1, dirY: -1 | 0 | 1) => {
		return createMouseDownDrag(
			() => ({
				startPos: { ...state().position },
				startSize: { ...state().size },
			}),
			(e, { startPos, startSize }, initialMouse) => {
				const dx = (e.clientX - initialMouse.x) / props.size.width;
				const dy = (e.clientY - initialMouse.y) / props.size.height;

				updateSegment((s) => {
					if (dirX !== 0) {
						const newWidth = Math.max(0.01, startSize.x + dx * dirX);
						s.size.x = newWidth;
						s.center.x = startPos.x + dx / 2;
					}

					if (dirY !== 0) {
						const newHeight = Math.max(0.01, startSize.y + dy * dirY);
						s.size.y = newHeight;
						s.center.y = startPos.y + dy / 2;
					}
				});
			},
		);
	};

	return (
		<div
			class="absolute pointer-events-auto group z-10"
			style={{
				"z-index": props.zIndex,
				left: `${rect().left}px`,
				top: `${rect().top}px`,
				width: `${rect().width}px`,
				height: `${rect().height}px`,
			}}
			onMouseDown={onMove}
		>
			<div class="absolute inset-0 rounded-md border-2 border-gray-12 cursor-move" />

			<ResizeHandle
				class="top-0 left-0 -translate-x-1/2 -translate-y-1/2 cursor-nw-resize"
				onMouseDown={createResizeHandler(-1, -1)}
			/>
			<ResizeHandle
				class="top-0 right-0 translate-x-1/2 -translate-y-1/2 cursor-ne-resize"
				onMouseDown={createResizeHandler(1, -1)}
			/>
			<ResizeHandle
				class="bottom-0 left-0 -translate-x-1/2 translate-y-1/2 cursor-sw-resize"
				onMouseDown={createResizeHandler(-1, 1)}
			/>
			<ResizeHandle
				class="bottom-0 right-0 translate-x-1/2 translate-y-1/2 cursor-se-resize"
				onMouseDown={createResizeHandler(1, 1)}
			/>

			<ResizeHandle
				class="top-0 left-1/2 -translate-x-1/2 -translate-y-1/2 cursor-n-resize"
				onMouseDown={createResizeHandler(0, -1)}
			/>
			<ResizeHandle
				class="bottom-0 left-1/2 -translate-x-1/2 translate-y-1/2 cursor-s-resize"
				onMouseDown={createResizeHandler(0, 1)}
			/>
			<ResizeHandle
				class="left-0 top-1/2 -translate-x-1/2 -translate-y-1/2 cursor-w-resize"
				onMouseDown={createResizeHandler(-1, 0)}
			/>
			<ResizeHandle
				class="right-0 top-1/2 translate-x-1/2 -translate-y-1/2 cursor-e-resize"
				onMouseDown={createResizeHandler(1, 0)}
			/>
		</div>
	);
}

function ResizeHandle(props: {
	class?: string;
	onMouseDown: (e: MouseEvent) => void;
}) {
	return (
		<div
			class={cx(
				"absolute w-3 h-3 bg-gray-12 border border-white rounded-full shadow-xs transition-transform hover:scale-125",
				props.class,
			)}
			onMouseDown={props.onMouseDown}
		/>
	);
}