The VS Code of video editing, built for agents.
TypeScript
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
import { createEffect, createMemo, Index, onCleanup, onMount, Show } from 'solid-js';
import { toast } from 'somoto';
import { useTrait, useWorld } from '@diffusionstudio/koota-solid';
import { Sequence as SequenceElement } from '@diffusionstudio/reconciler';
import {
ClipHeight,
Computed,
FrameRate,
getNextName,
Playback,
Source,
togglePlayback,
} from '@diffusionstudio/runtime';
import { Button } from '@/components/ui/button';
import { Icon } from '@/components/ui/icon';
import {
DropdownMenu,
DropdownMenuCheckboxItem,
DropdownMenuContent,
DropdownMenuGroup,
DropdownMenuGroupLabel,
DropdownMenuItem,
DropdownMenuItemDetail,
DropdownMenuPortal,
DropdownMenuRadioGroup,
DropdownMenuRadioItem,
DropdownMenuSeparator,
DropdownMenuSub,
DropdownMenuSubContent,
DropdownMenuSubTrigger,
DropdownMenuTrigger,
} from '@/components/ui/dropdown-menu';
import { Tooltip, TooltipContent, TooltipPortal, TooltipTrigger } from '@/components/ui/tooltip';
import { CommandContextMenu, TIMELINE_HEADER_MENU } from '@/components/commands';
import { DEFAULT_CLIP_HEIGHT, RULER_HEIGHT } from '@/engine/timeline';
import { splitAtPlayhead } from '@/engine/split';
import { useDerived, useEditor, useTimelineIndex } from '@/engine/hooks';
import { useTimeline } from '@/context/timeline';
import { useLayout } from '@/context/layout';
import { store } from '@/init';
import { createStoredSignal } from '@/lib/store';
import { Layer } from './layer';
import { LayerContextProvider } from './context';
import { DropIndicator } from './drop-indicator';
import { formatFrames, TIME_FORMAT_OPTIONS, type TimeFormat } from '../time-format';
import type { TimelineNode } from '@diffusionstudio/runtime';
import type { Entity } from 'koota';
/** The row heights the height menu offers, tightest first. */
const HEIGHT_PRESETS = [
{ label: 'Tight', height: 28 },
{ label: 'Snug', height: 32 },
{ label: 'Normal', height: 40 },
{ label: 'Relaxed', height: 64 },
{ label: 'Loose', height: 116 },
];
export function Layers() {
const world = useWorld();
const editor = useEditor();
const timeline = useTimeline();
const index = useTimelineIndex();
const { timelineMinimized, toggleTimeline } = useLayout();
const layers = createMemo(() => index().layers);
const scene = createMemo(() => index().root);
const frameRate = useTrait(world, FrameRate);
const playback = useTrait(scene, Playback);
const now = useDerived(() => scene()?.get(Computed)?.localTime ?? 0);
const [timeFormat, setTimeFormat] = createStoredSignal(
store.define<TimeFormat>('timeline.timeFormat', 'standard'),
);
const clock = createMemo(() => formatFrames(now(), frameRate()?.value ?? 30, timeFormat()));
// What the height menu ticks: the height the rows share, or none of them if
// they differ.
const commonHeight = useDerived(() => {
let common: number | null = null;
for (const entity of geometryEntities(layers())) {
const height = entity.get(ClipHeight)?.value ?? DEFAULT_CLIP_HEIGHT;
if (common === null) common = height;
else if (common !== height) return null;
}
return common;
});
const setCommonHeight = (height: number) => {
for (const entity of geometryEntities(layers())) {
editor.editProperty(entity, 'clipHeight', height);
}
};
/**
* A new layer is an empty sequence: a row of its own whose clips share
* one line, laid end to end without overlapping.
*/
const addLayer = () => {
const parent = scene();
if (!parent?.get(Source)?.value) {
toast("Nothing to add a layer to", { description: "Open a scene first." });
return;
}
const [layer] = editor.insertElement(parent, () => (
<SequenceElement name={getNextName(world, 'Layer')} />
));
if (layer) editor.select(layer);
};
const toggleLooping = () => {
const entity = scene();
if (!entity) return;
entity.set(Playback, { loop: !playback()?.loop });
};
const handlePlay = () => {
const entity = scene();
if (entity) togglePlayback(world, entity);
};
// A press on the empty space below the rows, not on one of them.
const handlePointerDown = (e: PointerEvent) => {
if (e.button !== 0 || e.target !== e.currentTarget) return;
editor.clearSelection();
};
const handleHeaderDoubleClick = (e: MouseEvent) => {
if ((e.target as HTMLElement).closest('button')) return;
toggleTimeline();
};
createEffect(() => timeline.setMinimized(timelineMinimized()));
onMount(timeline.mount);
onCleanup(timeline.unmount);
return (
<div class="relative size-full">
<div
class="grid grid-cols-1 h-full absolute border-b border-border inset-0 overflow-hidden"
on:wheel={timeline.scroll}
style={{ 'grid-template-rows': `${RULER_HEIGHT}px 1fr` }}
data-timeline-layers-container
>
<CommandContextMenu
layout={TIMELINE_HEADER_MENU}
class="w-full z-10 flex flex-row gap-1 pl-2 pr-3 items-center text-muted-foreground select-none"
onDblClick={handleHeaderDoubleClick}
>
<Tooltip placement="top">
<TooltipTrigger<typeof Button>
as={(triggerProps) => (
<Button {...triggerProps} variant="ghost" size="icon" onClick={handlePlay}>
<Show when={playback()?.playing} fallback={<Icon name="play" />}>
<Icon name="pause" />
</Show>
</Button>
)}
/>
<TooltipPortal>
<TooltipContent shortcut="Space">
{playback()?.playing ? 'Pause' : 'Play'}
</TooltipContent>
</TooltipPortal>
</Tooltip>
<Tooltip placement="top">
<TooltipTrigger<typeof Button>
as={(triggerProps) => (
<Button {...triggerProps} variant="ghost" size="icon" onClick={toggleLooping}>
<Show when={playback()?.loop} fallback={<Icon name="controls-no-loop" />}>
<Icon name="controls-loop" />
</Show>
</Button>
)}
/>
<TooltipPortal>
<TooltipContent>
{playback()?.loop ? 'Disable loop' : 'Enable loop'}
</TooltipContent>
</TooltipPortal>
</Tooltip>
<Show when={!timelineMinimized()}>
<Tooltip placement="top">
<TooltipTrigger<typeof Button>
as={(triggerProps) => (
<Button {...triggerProps} variant="ghost" size="icon" onClick={() => splitAtPlayhead(world)}>
<Icon name="split" />
</Button>
)}
/>
<TooltipPortal>
<TooltipContent shortcut="⌘B">Split at playhead</TooltipContent>
</TooltipPortal>
</Tooltip>
<DropdownMenu>
<Tooltip placement="top">
<TooltipTrigger<typeof DropdownMenuTrigger>
as={(triggerProps: object) => (
<DropdownMenuTrigger<typeof Button>
{...triggerProps}
as={(buttonProps) => (
<Button {...buttonProps} variant="ghost" size="icon">
<Icon name="more-three-dots" />
</Button>
)}
/>
)}
/>
<TooltipPortal>
<TooltipContent>More options</TooltipContent>
</TooltipPortal>
</Tooltip>
<DropdownMenuPortal>
<DropdownMenuContent class="w-[180px]">
<DropdownMenuItem onSelect={addLayer}>Add layer</DropdownMenuItem>
<DropdownMenuSeparator />
<DropdownMenuGroup>
<DropdownMenuGroupLabel>View</DropdownMenuGroupLabel>
<DropdownMenuSub>
<DropdownMenuSubTrigger>Layer height</DropdownMenuSubTrigger>
<DropdownMenuPortal>
<DropdownMenuSubContent class="w-[160px]">
<DropdownMenuGroup>
<Index each={HEIGHT_PRESETS}>
{(preset) => (
<DropdownMenuCheckboxItem
onSelect={() => setCommonHeight(preset().height)}
checked={commonHeight() === preset().height}
>
{preset().label}
<DropdownMenuItemDetail class="ml-auto">{preset().height}</DropdownMenuItemDetail>
</DropdownMenuCheckboxItem>
)}
</Index>
</DropdownMenuGroup>
</DropdownMenuSubContent>
</DropdownMenuPortal>
</DropdownMenuSub>
<DropdownMenuSub>
<DropdownMenuSubTrigger>Time format</DropdownMenuSubTrigger>
<DropdownMenuPortal>
<DropdownMenuSubContent class="w-[200px]">
<DropdownMenuRadioGroup
value={timeFormat()}
onChange={(value) => setTimeFormat(value as TimeFormat)}
>
<Index each={TIME_FORMAT_OPTIONS}>
{(option) => (
<DropdownMenuRadioItem value={option().value}>
{option().label}
<DropdownMenuItemDetail class="ml-auto">{option().example}</DropdownMenuItemDetail>
</DropdownMenuRadioItem>
)}
</Index>
</DropdownMenuRadioGroup>
</DropdownMenuSubContent>
</DropdownMenuPortal>
</DropdownMenuSub>
</DropdownMenuGroup>
</DropdownMenuContent>
</DropdownMenuPortal>
</DropdownMenu>
</Show>
<span class="text-xs font-mono font-thin ml-auto select-none">
{clock()}
</span>
</CommandContextMenu>
<div data-timeline-layers-viewport class="relative h-full z-0 overflow-hidden">
<div
data-timeline-layers
class="min-h-full group/layers flex flex-col pb-0.5"
onPointerDown={handlePointerDown}
>
<LayerContextProvider>
<Index each={layers()}>
{(layer) => <Layer layer={layer()} />}
</Index>
<DropIndicator />
</LayerContextProvider>
</div>
</div>
</div>
</div>
);
}
/** Every clip row of the tree, expanded ones included. */
function* geometryEntities(nodes: TimelineNode[]): Generator<Entity> {
for (const node of nodes) {
if (node.kind === 'geometry') yield node.entity;
yield* geometryEntities(node.children);
}
}