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 { trait, type Entity, type World } from 'koota';
import type { FontSource } from '../fonts/types';
import type { AssetLibrary } from '@diffusionstudio/assets';
import type { Quad } from '../math/aabb';
export const Project = trait({ id: '' });
// Tag on the single stage entity every runtime world owns.
export const Stage = trait();
// World-level pointer to the stage entity
export const Root = trait(() => null as Entity | null);
/**
* 2D affine camera transform in CSS pixel space (before DPR scaling), on the
* stage. The render system multiplies this by RenderSurface.resolution
* to derive the canvas transform.
*/
export const Camera = trait({ a: 0.3, b: 0, c: 0, d: 0.3, e: 85, f: 150 });
export type Camera2D = { a: number; b: number; c: number; d: number; e: number; f: number };
export const DEFAULT_BACKGROUND = 0x161616;
// Stage background color, on the stage entity.
export const Background = trait({ value: DEFAULT_BACKGROUND });
export type RuntimeMode = 'realtime' | 'offline-video' | 'offline-audio';
export const Mode = trait({ value: 'realtime' as RuntimeMode });
// On the world: nothing in this render is to be heard, so no audio decoder is
// ever opened (a frame capture draws pictures and never mixes). A rendering
// concern, kept apart from `Muted`, which is the composition's own — a clip
// the project muted. What is silenced here is still audio the scene has.
export const Silent = trait();
// Frame clock (was timestamp).
export const Time = trait({ now: 0, delta: 0 });
// Project frame rate (frames per second).
export const FrameRate = trait({ value: 30 });
// Render target injected by the host. Capture uses an HTML canvas too so HTML
// paint roots can live in its layout subtree. resolution is the pixel ratio.
export const RenderSurface = trait({
canvas: () => null as HTMLCanvasElement | OffscreenCanvas | null,
ctx: () => null as CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null,
resolution: 1,
});
// Audio output injected by the host: a realtime AudioContext in the editor,
// an OfflineAudioContext during capture.
export const AudioEngine = trait({
context: () => null as AudioContext | OfflineAudioContext | null,
});
// Fonts registered for text layout.
export const Fonts = trait({ list: () => [] as FontSource[] });
// The project's asset library, once the host has attached one (it needs the
// project's file system): every asset an entity's AssetId can name, library
// and transient alike. Null in a world without a project.
export const Library = trait(() => null as AssetLibrary | null);
// Per-tick callbacks. A mounted project adds one to feed its `useTicker`
// clock; the playback system fires the set once per tick, after playheads
// advance. Held on the world so anything that runs the systems (the editor
// loop, the encoder) drives the mounts without knowing them.
export const Tickers = trait(() => new Set<() => void>());
// Async barrier for offline capture: systems push decoder/host readiness
// promises here; the encoder awaits and clears them before sampling a frame.
// null in realtime mode (nothing collects).
export const FramePromises = trait({
list: () => null as (Promise<unknown> | null)[] | null,
});
export type EntityTarget = {
kind: 'entity';
id: Entity;
};
export type HudTarget = {
kind: 'hud';
id: string;
quad: Quad;
entity?: Entity;
};
export type PointerEventType =
| 'pointermove'
| 'pointerdown'
| 'pointerup'
| 'pointerenter'
| 'pointerleave'
| 'dragstart'
| 'drag'
| 'dragend'
| 'click'
| 'dblclick';
/**
* A pointer event in canvas device pixels (CSS pixels x resolution), which is
* the space WorldTransform and the hit region quads are in. Not a DOM event:
* the app's input layer distills one of these per DOM event, and adds the
* gesture types (drag*, pointerenter/leave) the DOM has no equivalent for.
*/
export type CanvasPointerEvent = {
type: PointerEventType;
clientX: number;
clientY: number;
button: number; // 0: left, 1: middle, 2: right
};
export type DispatchedPointerEvent = CanvasPointerEvent & {
target: EntityTarget | HudTarget;
};
// Paint-order hit regions collected during a render pass (topmost last). The
// render system pushes callback-less entries for Interactive entities and the
// stage canvas; the app's input system clears the list each frame, pushes its
// HUD controls with handlers attached, and maps callback-less targets to its
// default interaction handlers.
export type HitRegion = {
target: EntityTarget | HudTarget;
callback?: (world: World, event: DispatchedPointerEvent) => void;
};
export const HitRegions = trait({ list: () => [] as HitRegion[] });