Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
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}
/>
);
}