Visualize Your Ideas With Code
feat: new playback architecture (#402)
Jacobbbe3e2a24de0
diff --git a/package.json b/package.jsonindex b621929f..0c2ef167 100644--- a/package.json+++ b/package.json@@ -14,6 +14,7 @@"ui:build": "npm run build -w packages/ui","ui:serve": "npm run dev -w packages/ui","ui:showcase": "npm run showcase -w packages/ui",+ "ui:type": "npm run type -w packages/ui","template:serve": "npm run serve -w packages/template","template:build": "npm run build -w packages/template","examples:serve": "npm run serve -w packages/examples",diff --git a/packages/2d/src/components/Layout.ts b/packages/2d/src/components/Layout.tsindex 5cf788ae..8b34d80f 100644--- a/packages/2d/src/components/Layout.ts+++ b/packages/2d/src/components/Layout.ts@@ -578,7 +578,7 @@ export class Layout extends Node {protected appendedToView() {const root = this.isLayoutRoot();if (root) {- this.view()?.element.append(this.element);+ this.view().element.append(this.element);}return root;diff --git a/packages/2d/src/components/Node.ts b/packages/2d/src/components/Node.tsindex 73258ab8..40996bde 100644--- a/packages/2d/src/components/Node.ts+++ b/packages/2d/src/components/Node.ts@@ -549,7 +549,7 @@ export class Node implements Promisable<Node> {return new DOMMatrix();}- public view(): View2D | null {+ public view(): View2D {return this.view2D;}diff --git a/packages/2d/src/components/Video.ts b/packages/2d/src/components/Video.tsindex 461b5266..a7dc4202 100644--- a/packages/2d/src/components/Video.ts+++ b/packages/2d/src/components/Video.ts@@ -4,7 +4,7 @@ import {} from '@motion-canvas/core/lib/types';import {drawImage} from '../utils';import {computed, initial, signal} from '../decorators';-import {useProject, useThread} from '@motion-canvas/core/lib/utils';+import {useThread} from '@motion-canvas/core/lib/utils';import {PlaybackState} from '@motion-canvas/core';import {clamp} from '@motion-canvas/core/lib/tweening';import {Rect, RectProps} from './Rect';@@ -162,7 +162,7 @@ export class Video extends Rect {const alpha = this.alpha();if (alpha > 0) {const video =- useProject().playbackState() === PlaybackState.Playing+ this.view().playbackState() === PlaybackState.Playing? this.fastSeekedVideo(): this.seekedVideo();diff --git a/packages/2d/src/components/View2D.ts b/packages/2d/src/components/View2D.tsindex f70fedfd..82aed82c 100644--- a/packages/2d/src/components/View2D.ts+++ b/packages/2d/src/components/View2D.ts@@ -1,9 +1,16 @@import {Rect, RectProps} from './Rect';+import {initial, signal} from '../decorators';+import {PlaybackState} from '@motion-canvas/core';+import {SimpleSignal} from '@motion-canvas/core/lib/signals';export class View2D extends Rect {public static frameID = 'motion-canvas-2d-frame';public static shadowRoot: ShadowRoot;+ @initial(PlaybackState.Paused)+ @signal()+ public declare readonly playbackState: SimpleSignal<PlaybackState, this>;+static {let frame = document.querySelector<HTMLDivElement>(`#${View2D.frameID}`);if (!frame) {@@ -55,7 +62,7 @@ export class View2D extends Rect {this.updateLayout();}- public override view(): View2D | null {+ public override view(): View2D {return this;}}diff --git a/packages/2d/src/scenes/Scene2D.ts b/packages/2d/src/scenes/Scene2D.tsindex 0df216a8..7085d5f5 100644--- a/packages/2d/src/scenes/Scene2D.ts+++ b/packages/2d/src/scenes/Scene2D.ts@@ -1,10 +1,12 @@import {+ FullSceneDescription,GeneratorScene,Inspectable,InspectedAttributes,InspectedElement,Scene,SceneRenderEvent,+ ThreadGeneratorFactory,} from '@motion-canvas/core/lib/scenes';import {endScene, startScene} from '@motion-canvas/core/lib/utils';import {Vector2} from '@motion-canvas/core/lib/types';@@ -15,15 +17,28 @@ export class Scene2D extends GeneratorScene<View2D> implements Inspectable {private registeredNodes: Record<string, Node> = {};private nodeCounters: Record<string, number> = {};+ public constructor(+ description: FullSceneDescription<ThreadGeneratorFactory<View2D>>,+ ) {+ super(description);+ this.recreateView();+ }+public getView(): View2D {return this.view!;}+ public override next(): Promise<void> {+ this.getView()?.playbackState(this.playback.state);+ return super.next();+ }+public draw(context: CanvasRenderingContext2D) {context.save();this.renderLifecycle.dispatch([SceneRenderEvent.BeforeRender, context]);context.save();this.renderLifecycle.dispatch([SceneRenderEvent.BeginRender, context]);+ this.getView().playbackState(this.playback.state);this.getView().render(context);this.renderLifecycle.dispatch([SceneRenderEvent.FinishRender, context]);context.restore();@@ -37,14 +52,7 @@ export class Scene2D extends GeneratorScene<View2D> implements Inspectable {}this.registeredNodes = {};this.nodeCounters = {};-- startScene(this);- const size = this.getSize();- this.view = new View2D({- position: size.scale(0.5),- size,- });- endScene(this);+ this.recreateView();return super.reset(previousScene);}@@ -105,4 +113,14 @@ export class Scene2D extends GeneratorScene<View2D> implements Inspectable {if (typeof key !== 'string') return null;return this.registeredNodes[key] ?? null;}++ protected recreateView() {+ startScene(this);+ const size = this.getSize();+ this.view = new View2D({+ position: size.scale(0.5),+ size,+ });+ endScene(this);+ }}diff --git a/packages/2d/src/scenes/makeScene2D.ts b/packages/2d/src/scenes/makeScene2D.tsindex 890c9ba9..4fa69644 100644--- a/packages/2d/src/scenes/makeScene2D.ts+++ b/packages/2d/src/scenes/makeScene2D.ts@@ -1,4 +1,5 @@import {+ createSceneMetadata,DescriptionOf,ThreadGeneratorFactory,} from '@motion-canvas/core/lib/scenes';@@ -12,5 +13,6 @@ export function makeScene2D(klass: Scene2D,config: runner,stack: new Error().stack,+ meta: createSceneMetadata(),};}diff --git a/packages/core/package.json b/packages/core/package.jsonindex 68d80fb1..f6235171 100644--- a/packages/core/package.json+++ b/packages/core/package.json@@ -2,7 +2,7 @@"name": "@motion-canvas/core","version": "2.6.0","description": "Web-based tool for creating animations programmatically",- "main": "lib/index.js",+ "main": "lib/app/index.js","author": "motion-canvas","homepage": "https://motioncanvas.io/","bugs": "https://github.com/motion-canvas/motion-canvas/issues",diff --git a/packages/core/src/Meta.ts b/packages/core/src/Meta.tsdeleted file mode 100644index f913d41f..00000000--- a/packages/core/src/Meta.ts+++ /dev/null@@ -1,111 +0,0 @@-import {ValueDispatcher} from './events';-import {useLogger} from './utils';--const META_VERSION = 1;--/**- * Represents the contents of a meta file.- */-export interface Metadata {- version: number;-}--/**- * Represents the meta file of a given entity.- *- * @typeParam T - The type of the data stored in the meta file.- */-export class Meta<T extends Metadata = Metadata> {- /**- * Triggered when metadata changes.- *- * @eventProperty- */- public get onDataChanged() {- return this.data.subscribable;- }- private readonly data = new ValueDispatcher(<T>{version: META_VERSION});-- public constructor(- private readonly name: string,- private source: string | false = false,- ) {}-- public getData() {- return this.data.current;- }-- /**- * Set data without waiting for confirmation.- *- * @remarks- * Any possible errors will be logged to the console.- *- * @param data - New data.- */- public setDataSync(data: Partial<T>) {- this.setData(data).catch(error => useLogger().error(error));- }-- public async setData(data: Partial<T>) {- this.data.current = {- ...this.data.current,- ...data,- };-- if (import.meta.hot) {- if (this.source === false) {- return;- }-- if (!this.source) {- useLogger().warn(- `The meta file for ${this.name} is missing.\n` +- `Make sure the file containing your scene is called "${this.name}.ts" to match the generator function name.`,- );- return;- }-- if (Meta.sourceLookup[this.source]) {- useLogger().warn(`Metadata for ${this.name} is already being updated`);- return;- }-- const source = this.source;- await new Promise<void>((resolve, reject) => {- setTimeout(() => {- delete Meta.sourceLookup[source];- reject(`Connection timeout when updating metadata for ${this.name}`);- }, 1000);- Meta.sourceLookup[source] = () => {- delete Meta.sourceLookup[source];- resolve();- };- import.meta.hot!.send('motion-canvas:meta', {- source,- data: this.data.current,- });- });- }- }-- /**- * Load new metadata from a file.- *- * @param data - New metadata.- */- public async loadData(data: T) {- data.version ||= META_VERSION;- this.data.current = data;- }-- private static sourceLookup: Record<string, Callback> = {};-- static {- if (import.meta.hot) {- import.meta.hot.on('motion-canvas:meta-ack', ({source}) => {- this.sourceLookup[source]?.();- });- }- }-}diff --git a/packages/core/src/Project.ts b/packages/core/src/Project.tsdeleted file mode 100644index 93c69737..00000000--- a/packages/core/src/Project.ts+++ /dev/null@@ -1,462 +0,0 @@-import {FullSceneDescription, Scene} from './scenes';-import {Meta, Metadata} from './Meta';-import {EventDispatcher, ValueDispatcher} from './events';-import {- CanvasColorSpace,- CanvasOutputMimeType,- PossibleVector2,- Vector2,-} from './types';-import {AudioManager} from './media';-import {getContext} from './utils';-import {Logger} from './Logger';-import {createSignal} from './signals';--const EXPORT_FRAME_LIMIT = 256;-const EXPORT_RETRY_DELAY = 1000;--export const ProjectSize: Record<string, Vector2> = {- FullHD: new Vector2(1920, 1080),-};--export interface ProjectConfig {- name?: string;- scenes: FullSceneDescription[];- audio?: string;- audioOffset?: number;- canvas?: HTMLCanvasElement;- size?: Vector2;- background?: string | false;- variables?: Record<string, unknown>;-}--export enum PlaybackState {- Playing,- Rendering,- Paused,- Seeking,-}--export type ProjectMetadata = Metadata;--export function makeProject(config: ProjectConfig) {- return config;-}--export class Project {- /**- * Triggered after the scenes were recalculated.- */- public get onScenesChanged() {- return this.scenes.subscribable;- }- private readonly scenes = new ValueDispatcher<Scene[]>([]);-- /**- * Triggered when the current scene changes.- */- public get onCurrentSceneChanged() {- return this.currentScene.subscribable;- }- private readonly currentScene = new ValueDispatcher<Scene | null>(null);-- /**- * Triggered after any of the scenes were reloaded.- */- public get onReloaded() {- return this.reloaded;- }- private readonly reloaded = new EventDispatcher<void>();-- public readonly meta: Meta<ProjectMetadata>;- public frame = 0;-- public get time(): number {- return this.framesToSeconds(this.frame);- }-- public get framerate(): number {- return this.framesPerSeconds / this._speed;- }-- public set framerate(value: number) {- this.framesPerSeconds = value;- this.reloadAll();- }-- public set resolutionScale(value: number) {- this._resolutionScale = value;- this.updateCanvas();- }-- public set colorSpace(value: CanvasColorSpace) {- this._colorSpace = value;- this.updateCanvas();- }-- public set fileType(value: CanvasOutputMimeType) {- this._fileType = value;- }-- public set quality(value: number) {- this._quality = value;- }-- public set speed(value: number) {- this._speed = value;- this.reloadAll();- }-- private updateCanvas() {- if (!this.canvas) {- return;- }-- this.bufferContext = this.buffer.getContext('2d', {- colorSpace: this._colorSpace,- });- this.previousBufferContext = this.previousBuffer.getContext('2d', {- colorSpace: this._colorSpace,- });- this.context = this.canvas.getContext('2d', {- colorSpace: this._colorSpace,- });-- this.canvas.width =- this.buffer.width =- this.previousBuffer.width =- this.size.x * this._resolutionScale;- this.canvas.height =- this.buffer.height =- this.previousBuffer.height =- this.size.y * this._resolutionScale;-- this.render();- }-- public setCanvas(value: HTMLCanvasElement | null = null) {- this.canvas = value;- this.updateCanvas();- }-- public setSize(size: PossibleVector2): void {- this.size = new Vector2(size);- this.updateCanvas();- this.reloadAll();- }-- public getSize(): Vector2 {- return this.size;- }-- public setVariables(variables: Record<string, unknown>) {- this.variables = variables;- this.currentScene.current?.variables.updateSignals();- }-- public getVariables(): {[key: string]: any} {- return this.variables;- }-- public readonly name: string;- public readonly audio = new AudioManager();- public readonly logger = new Logger();- public readonly background: string | false;- public readonly creationStack: string;- public playbackState = createSignal(PlaybackState.Paused);- private readonly renderLookup: Record<number, Callback> = {};- private _resolutionScale = 1;- private _colorSpace: CanvasColorSpace = 'srgb';- private _fileType: CanvasOutputMimeType = 'image/png';- private _quality = 1;- private _speed = 1;- private framesPerSeconds = 30;- private previousScene: Scene | null = null;- private canvas: HTMLCanvasElement | null = null;- private context: CanvasRenderingContext2D | null = null;- private buffer = document.createElement('canvas');- private bufferContext: CanvasRenderingContext2D | null = null;- private previousBuffer = document.createElement('canvas');- private previousBufferContext: CanvasRenderingContext2D | null = null;- private exportCounter = 0;- private size = Vector2.zero;- private variables: Record<string, unknown> = {};-- /**- * @deprecated Use {@link makeProject} instead.- *- * @param config - The project configuration.- */- public constructor(config: ProjectConfig);- public constructor(- name: string,- meta: Meta<ProjectMetadata>,- config: ProjectConfig,- );- public constructor(- name: string | ProjectConfig,- meta?: Meta<ProjectMetadata>,- config?: ProjectConfig,- ) {- const {- scenes,- audio,- audioOffset,- canvas,- size = ProjectSize.FullHD,- background = false,- variables = {},- } = typeof name === 'string' ? config! : name;-- this.name = typeof name === 'string' ? name : '';- this.meta = meta!;-- this.creationStack = new Error().stack ?? '';- this.setCanvas(canvas);- this.setSize(size);- this.setVariables(variables);- this.background = background;-- if (audio) {- this.audio.setSource(audio);- }- if (audioOffset) {- this.audio.setOffset(audioOffset);- }-- const instances: Scene[] = [];- for (const description of scenes) {- const scene = new description.klass({- ...description,- project: this,- });- description.onReplaced?.subscribe(description => {- scene.creationStack = description.stack;- scene.reload(description.config);- }, false);- scene.onReloaded.subscribe(() => this.reloaded.dispatch());- instances.push(scene);- }- this.scenes.current = instances;-- if (import.meta.hot) {- import.meta.hot.on('motion-canvas:export-ack', ({frame}) => {- this.renderLookup[frame]?.();- });- }- }-- public transformCanvas(context: CanvasRenderingContext2D) {- context.setTransform(- this._resolutionScale,- 0,- 0,- this._resolutionScale,- (this.size.x * this._resolutionScale) / 2,- (this.size.y * this._resolutionScale) / 2,- );- }-- public async render() {- if (!this.canvas || !this.context) return;-- if (this.previousScene) {- this.previousBufferContext ??= getContext(this.previousBuffer);- this.transformCanvas(this.previousBufferContext);- await this.previousScene.render(this.previousBufferContext);- }-- this.bufferContext ??= getContext(this.buffer);- this.transformCanvas(this.bufferContext);- await this.currentScene.current?.render(this.bufferContext);-- this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);- if (this.background) {- this.context.save();- this.context.fillStyle = this.background;- this.context.fillRect(0, 0, this.canvas.width, this.canvas.height);- this.context.restore();- }-- if (this.previousScene) {- this.context.drawImage(this.previousBuffer, 0, 0);- }-- this.context.drawImage(this.buffer, 0, 0);- }-- private reloadAll() {- for (const scene of this.scenes.current) {- scene.reload();- }- }-- public async next(): Promise<boolean> {- if (this.previousScene) {- await this.previousScene.next();- if (!this.currentScene.current) {- this.previousScene = null;- }- }-- this.frame += this._speed;-- if (this.currentScene.current) {- await this.currentScene.current.next();- if (- this.previousScene &&- this.currentScene.current.isAfterTransitionIn()- ) {- this.previousScene = null;- }- if (this.currentScene.current.canTransitionOut()) {- this.previousScene = this.currentScene.current;- this.currentScene.current = this.getNextScene(this.previousScene);- if (this.currentScene.current) {- await this.currentScene.current.reset(this.previousScene);- }- if (- !this.currentScene.current ||- this.currentScene.current.isAfterTransitionIn()- ) {- this.previousScene = null;- }- }- }-- return !this.currentScene.current || this.currentScene.current.isFinished();- }-- public async recalculate() {- this.previousScene = null;-- const speed = this._speed;- this.frame = 0;- const scenes = [...this.scenes.current];-- try {- this._speed = 1;- for (const scene of scenes) {- await scene.recalculate();- }- } finally {- this._speed = speed;- }-- this.scenes.current = scenes;- }-- public async seek(frame: number): Promise<boolean> {- if (this.currentScene.current && !this.currentScene.current.isCached()) {- this.logger.warn(- `Attempting to seek a project with an invalidated scene: ${this.currentScene.current.name}`,- );- }-- if (- frame <= this.frame ||- !this.currentScene.current ||- (this.currentScene.current.isCached() &&- this.currentScene.current.lastFrame < frame)- ) {- const scene = this.findBestScene(frame);- if (scene !== this.currentScene.current) {- this.previousScene = null;- this.currentScene.current = scene;-- this.frame = this.currentScene.current.firstFrame;- await this.currentScene.current.reset();- } else if (this.frame >= frame) {- this.previousScene = null;- this.frame = this.currentScene.current.firstFrame;- await this.currentScene.current.reset();- }- }-- let finished = false;- while (this.frame < frame && !finished) {- finished = await this.next();- }-- return finished;- }-- public async export(isStill = false) {- const frame = this.frame;-- if (this.renderLookup[frame]) {- this.logger.warn(`Frame no. ${frame} is already being exported.`);- return;- }- if (import.meta.hot) {- while (this.exportCounter > EXPORT_FRAME_LIMIT) {- await new Promise(resolve => setTimeout(resolve, EXPORT_RETRY_DELAY));- }- if (!this.canvas) {- return;- }-- this.exportCounter++;- this.renderLookup[frame] = () => {- this.exportCounter--;- delete this.renderLookup[frame];- };- import.meta.hot!.send('motion-canvas:export', {- frame,- isStill,- data: this.canvas.toDataURL(this._fileType, this._quality),- mimeType: this._fileType,- project: this.name,- });- }- }-- public async finishExport() {- while (this.exportCounter > 0) {- await new Promise(resolve => setTimeout(resolve, EXPORT_RETRY_DELAY));- }- }-- public syncAudio(frameOffset = 0) {- this.audio.setTime(this.framesToSeconds(this.frame + frameOffset));- }-- private findBestScene(frame: number): Scene {- let lastScene = this.scenes.current[0];- for (const scene of this.scenes.current) {- if (!scene.isCached()) {- this.logger.warn(- `Attempting to seek a project with an invalidated scene: ${scene.name}`,- );- return scene;- }- if (scene.lastFrame > frame) {- return scene;- }- lastScene = scene;- }-- return lastScene;- }-- private getNextScene(scene?: Scene): Scene | null {- const scenes = this.scenes.current;- if (!scene) {- return scenes[0];- }-- const index = scenes.findIndex(s => s === scene);- if (index < 0) {- return null;- }- return scenes[index + 1] ?? null;- }-- public secondsToFrames(seconds: number) {- return Math.ceil(seconds * this.framesPerSeconds);- }-- public framesToSeconds(frames: number) {- return frames / this.framesPerSeconds;- }-}diff --git a/packages/core/src/app/Exporter.ts b/packages/core/src/app/Exporter.tsnew file mode 100644index 00000000..af2c3138--- /dev/null+++ b/packages/core/src/app/Exporter.ts@@ -0,0 +1,57 @@+import {RendererResult, RendererSettings} from './Renderer';++/**+ * The main interface for implementing custom exporters.+ */+export interface Exporter {+ /**+ * Prepare the rendering configuration.+ *+ * @remarks+ * Called at the beginning of the rendering process, before anything else has+ * been set up. The returned value can be used to override the rendering+ * settings provided by the user.+ *+ * @param settings - Rendering settings provided by the user.+ */+ configure(settings: RendererSettings): Promise<RendererSettings | void>;++ /**+ * Begin the rendering process.+ *+ * @remarks+ * Called after the rendering has been set up, right before the first frame+ * is rendered. Once `start()` is called, it is guaranteed that the `stop()`+ * method will be called as well. Can be used to initialize any resources that+ * require clean-up.+ */+ start(): Promise<void>;++ /**+ * Export a frame.+ *+ * @remarks+ * Called each time after a frame is rendered.+ *+ * @param canvas - A canvas containing the rendered frame.+ * @param frame - The frame number.+ * @param signal - An abort signal triggered if the user aborts the rendering.+ */+ handleFrame(+ canvas: HTMLCanvasElement,+ frame: number,+ signal: AbortSignal,+ ): Promise<void>;++ /**+ * Finish the rendering process.+ *+ * @remarks+ * Guaranteed to be called after the rendering has finished - no matter the+ * result. Can be used to finalize the exporting and perform any necessary+ * clean up.+ *+ * @param result - The result of the rendering.+ */+ stop(result: RendererResult): Promise<void>;+}diff --git a/packages/core/src/app/ImageExporter.ts b/packages/core/src/app/ImageExporter.tsnew file mode 100644index 00000000..4e890121--- /dev/null+++ b/packages/core/src/app/ImageExporter.ts@@ -0,0 +1,74 @@+import {CanvasOutputMimeType} from '../types';+import {Exporter} from './Exporter';+import {Logger} from './Logger';+import {RendererSettings} from './Renderer';++const EXPORT_FRAME_LIMIT = 256;+const EXPORT_RETRY_DELAY = 1000;++/**+ * Image sequence exporter.+ */+export class ImageExporter implements Exporter {+ private readonly frameLookup = new Map<number, Callback>();+ private frameCounter = 0;+ private name = 'unknown';+ private quality = 1;+ private fileType: CanvasOutputMimeType = 'image/png';++ public constructor(private readonly logger: Logger) {+ if (import.meta.hot) {+ import.meta.hot.on('motion-canvas:export-ack', ({frame}) => {+ this.frameLookup.get(frame)?.();+ });+ }+ }++ public async configure(settings: RendererSettings) {+ this.name = settings.name;+ this.quality = settings.quality;+ this.fileType = settings.fileType;+ }++ public async start() {+ this.frameLookup.clear();+ }++ public async handleFrame(+ canvas: HTMLCanvasElement,+ frame: number,+ signal: AbortSignal,+ ) {+ if (this.frameLookup.has(frame)) {+ this.logger.warn(`Frame no. ${frame} is already being exported.`);+ return;+ }+ if (import.meta.hot) {+ while (this.frameCounter > EXPORT_FRAME_LIMIT) {+ await new Promise(resolve => setTimeout(resolve, EXPORT_RETRY_DELAY));+ if (signal.aborted) {+ return;+ }+ }++ this.frameCounter++;+ this.frameLookup.set(frame, () => {+ this.frameCounter--;+ this.frameLookup.delete(frame);+ });+ import.meta.hot!.send('motion-canvas:export', {+ frame,+ isStill: false,+ data: canvas.toDataURL(this.fileType, this.quality),+ mimeType: this.fileType,+ project: this.name,+ });+ }+ }++ public async stop() {+ while (this.frameCounter > 0) {+ await new Promise(resolve => setTimeout(resolve, EXPORT_RETRY_DELAY));+ }+ }+}diff --git a/packages/core/src/Logger.ts b/packages/core/src/app/Logger.tssimilarity index 97%rename from packages/core/src/Logger.tsrename to packages/core/src/app/Logger.tsindex 36cd04f7..977925de 100644--- a/packages/core/src/Logger.ts+++ b/packages/core/src/app/Logger.ts@@ -1,4 +1,4 @@-import {EventDispatcher} from './events';+import {EventDispatcher} from '../events';export enum LogLevel {Error = 'error',diff --git a/packages/core/src/app/PlaybackManager.ts b/packages/core/src/app/PlaybackManager.tsnew file mode 100644index 00000000..bb213148--- /dev/null+++ b/packages/core/src/app/PlaybackManager.ts@@ -0,0 +1,195 @@+import {Scene, SceneDescriptionReload} from '../scenes';+import {ValueDispatcher} from '../events';++export enum PlaybackState {+ Playing,+ Rendering,+ Paused,+}++/**+ * A general class for managing a sequence of scenes.+ *+ * @remarks+ * This class provides primitive operations that can be executed on a scene+ * sequence, such as {@link progress} or {@link seek}.+ */+export class PlaybackManager {+ /**+ * Triggered when the active scene changes.+ *+ * @eventProperty+ */+ public get onSceneChanged() {+ if (this.currentSceneReference === null) {+ throw new Error('PlaybackManager has not been properly initialized');+ }+ return this.currentSceneReference.subscribable;+ }++ /**+ * Triggered when the scenes get recalculated.+ *+ * @remarks+ * This event indicates that the timing of at least one scene has changed.+ *+ * @eventProperty+ */+ public get onScenesRecalculated() {+ return this.scenes.subscribable;+ }++ public frame = 0;+ public speed = 1;+ public fps = 30;+ public duration = 0;+ public finished = false;++ public previousScene: Scene | null = null;+ public state = PlaybackState.Paused;++ public get currentScene(): Scene {+ if (this.currentSceneReference === null) {+ throw new Error('PlaybackManager has not been properly initialized');+ }+ return this.currentSceneReference.current;+ }++ public set currentScene(scene: Scene) {+ this.currentSceneReference ??= new ValueDispatcher<Scene>(scene);+ this.currentSceneReference.current = scene;+ }++ private currentSceneReference: ValueDispatcher<Scene> | null = null;+ private scenes = new ValueDispatcher<Scene[]>([]);++ public setup(scenes: Scene[]) {+ this.scenes.current = scenes;+ this.currentScene = scenes[0];+ }++ public async progress() {+ this.finished = await this.next();+ return this.finished;+ }++ public async seek(frame: number): Promise<boolean> {+ if (+ frame <= this.frame ||+ (this.currentScene.isCached() && this.currentScene.lastFrame < frame)+ ) {+ const scene = this.findBestScene(frame);+ if (scene !== this.currentScene) {+ this.previousScene = null;+ this.currentScene = scene;++ this.frame = this.currentScene.firstFrame;+ await this.currentScene.reset();+ } else if (this.frame >= frame) {+ this.previousScene = null;+ this.frame = this.currentScene.firstFrame;+ await this.currentScene.reset();+ }+ }++ this.finished = false;+ while (this.frame < frame && !this.finished) {+ this.finished = await this.next();+ }++ return this.finished;+ }++ public async reset() {+ this.previousScene = null;+ this.currentScene = this.scenes.current[0];+ this.frame = 0;+ await this.currentScene.reset();+ }++ public reload(description?: SceneDescriptionReload<never>) {+ this.scenes.current.forEach(scene => scene.reload(description));+ }++ public async recalculate() {+ this.previousScene = null;++ const speed = this.speed;+ this.frame = 0;+ this.speed = 1;++ const scenes: Scene[] = [];+ try {+ for (const scene of this.scenes.current) {+ await scene.recalculate(frame => {+ this.frame = frame;+ });+ scenes.push(scene);+ }+ } finally {+ this.speed = speed;+ }++ this.scenes.current = scenes;+ this.duration = this.frame;+ }++ private async next(): Promise<boolean> {+ if (this.previousScene) {+ await this.previousScene.next();+ if (this.currentScene.isFinished()) {+ this.previousScene = null;+ }+ }++ this.frame += this.speed;++ if (this.currentScene.isFinished()) {+ return false;+ }++ await this.currentScene.next();+ if (this.previousScene && this.currentScene.isAfterTransitionIn()) {+ this.previousScene = null;+ }++ if (this.currentScene.canTransitionOut()) {+ this.previousScene = this.currentScene;+ const nextScene = this.getNextScene(this.previousScene);+ if (nextScene) {+ this.currentScene = nextScene;+ await this.currentScene.reset(this.previousScene);+ }+ if (!nextScene || this.currentScene.isAfterTransitionIn()) {+ this.previousScene = null;+ }+ }++ return this.currentScene.isFinished();+ }++ private findBestScene(frame: number): Scene {+ let lastScene = this.scenes.current[0];+ for (const scene of this.scenes.current) {+ if (!scene.isCached() || scene.lastFrame > frame) {+ return scene;+ }+ lastScene = scene;+ }++ return lastScene;+ }++ private getNextScene(scene?: Scene): Scene | null {+ const scenes = this.scenes.current;+ if (!scene) {+ return scenes[0];+ }++ const index = scenes.findIndex(s => s === scene);+ if (index < 0) {+ return null;+ }+ return scenes[index + 1] ?? null;+ }+}diff --git a/packages/core/src/app/PlaybackStatus.ts b/packages/core/src/app/PlaybackStatus.tsnew file mode 100644index 00000000..dd432ac2--- /dev/null+++ b/packages/core/src/app/PlaybackStatus.ts@@ -0,0 +1,46 @@+import {PlaybackManager, PlaybackState} from './PlaybackManager';++/**+ * A read-only representation of the playback.+ */+export class PlaybackStatus {+ public constructor(private readonly playback: PlaybackManager) {}++ /**+ * Convert seconds to frames using the current framerate.+ *+ * @param seconds - The seconds to convert.+ */+ public secondsToFrames(seconds: number) {+ return Math.ceil(seconds * this.playback.fps);+ }++ /**+ * Convert frames to seconds using the current framerate.+ *+ * @param seconds - The frames to convert.+ */+ public framesToSeconds(frames: number) {+ return frames / this.playback.fps;+ }++ public get time(): number {+ return this.framesToSeconds(this.playback.frame);+ }++ public get frame(): number {+ return this.playback.frame;+ }++ public get speed(): number {+ return this.playback.speed;+ }++ public get fps(): number {+ return this.playback.fps;+ }++ public get state(): PlaybackState {+ return this.playback.state;+ }+}diff --git a/packages/core/src/app/Player.ts b/packages/core/src/app/Player.tsnew file mode 100644index 00000000..a41f52bc--- /dev/null+++ b/packages/core/src/app/Player.ts@@ -0,0 +1,456 @@+import {Project} from './Project';+import {PlaybackManager, PlaybackState} from './PlaybackManager';+import {AudioManager} from '../media';+import {clamp} from '../tweening';+import {Logger} from './Logger';+import {+ AsyncEventDispatcher,+ EventDispatcher,+ ValueDispatcher,+} from '../events';+import {Scene} from '../scenes';+import {Vector2} from '../types';+import {PlaybackStatus} from './PlaybackStatus';+import {Semaphore} from '../utils';++export interface PlayerState extends Record<string, unknown> {+ paused: boolean;+ loop: boolean;+ muted: boolean;+ speed: number;+}++export interface PlayerSettings {+ range: [number, number];+ fps: number;+ size: Vector2;+ audioOffset: number;+}++const MAX_AUDIO_DESYNC = 1 / 50;++/**+ * The player logic used by the editor and embeddable player.+ *+ * @remarks+ * This class builds on top of the {@link PlaybackManager} to provide a simple+ * interface similar to other media players. It plays through the animation+ * using a real-time update loop and optionally synchronises it with audio.+ */+export class Player {+ /**+ * Triggered during each iteration of the update loop when the frame is ready+ * to be rendered.+ *+ * @remarks+ * Player does not perform any rendering on its own. For the animation to be+ * visible, another class must subscribe to this event and perform the+ * rendering itself. {@link Stage} can be used to display the animation.+ *+ * @eventProperty+ */+ public get onRender() {+ return this.render.subscribable;+ }+ private readonly render = new AsyncEventDispatcher<void>();++ public get onStateChanged() {+ return this.playerState.subscribable;+ }+ private readonly playerState: ValueDispatcher<PlayerState>;++ public get onFrameChanged() {+ return this.frame.subscribable;+ }+ private readonly frame = new ValueDispatcher(0);++ public get onDurationChanged() {+ return this.duration.subscribable;+ }+ private readonly duration = new ValueDispatcher(0);++ /**+ * Triggered right after recalculation finishes.+ *+ * @remarks+ * Can be used to provide visual feedback.+ *+ * @eventProperty+ */+ public get onRecalculated() {+ return this.recalculated.subscribable;+ }+ private readonly recalculated = new EventDispatcher<void>();++ public readonly playback: PlaybackManager;+ public readonly status: PlaybackStatus;+ public readonly audio: AudioManager;+ public readonly logger: Logger;++ private readonly lock = new Semaphore();+ private startTime = 0;+ private endTime = Infinity;+ private requestId: number | null = null;+ private renderTime = 0;+ private requestedSeek = -1;+ private requestedRecalculation = true;+ private size: Vector2;+ private active = false;++ private get startFrame() {+ return Math.min(+ this.playback.duration,+ this.status.secondsToFrames(this.startTime),+ );+ }++ private get endFrame() {+ return Math.min(+ this.playback.duration,+ this.status.secondsToFrames(this.endTime),+ );+ }++ private get finished() {+ return this.playback.finished || this.playback.frame >= this.endFrame;+ }++ public constructor(+ private project: Project,+ private settings: Partial<PlayerSettings> = {},+ private initialState: Partial<PlayerState> = {},+ private initialFrame = -1,+ ) {+ this.playerState = new ValueDispatcher<PlayerState>({+ loop: true,+ muted: true,+ speed: 1,+ ...initialState,+ paused: true,+ });++ this.requestedSeek = initialFrame;+ this.logger = this.project.logger;+ this.playback = new PlaybackManager();+ this.status = new PlaybackStatus(this.playback);+ this.audio = new AudioManager(this.logger);+ this.size = settings.size ?? new Vector2(1920, 1080);+ this.startTime = settings.range?.[0] ?? 0;+ this.endTime = settings.range?.[1] ?? Infinity;+ this.playback.fps = settings.fps ?? 60;+ this.audio.setOffset(settings.audioOffset ?? 0);++ if (project.audio) {+ this.audio.setSource(project.audio);+ }++ const scenes: Scene[] = [];+ for (const description of project.scenes) {+ const scene = new description.klass({+ ...description,+ playback: this.status,+ logger: this.project.logger,+ size: this.size,+ });+ description.onReplaced?.subscribe(description => {+ scene.reload(description);+ }, false);+ scene.onReloaded.subscribe(() => this.requestRecalculation());+ scene.variables.updateSignals(project.variables ?? {});+ scenes.push(scene);+ }+ this.playback.setup(scenes);+ this.activate();+ }++ public async configure(settings: PlayerSettings) {+ await this.lock.acquire();+ let frame = this.playback.frame;+ let recalculate = false;+ this.startTime = settings.range[0];+ this.endTime = settings.range[1];+ if (this.playback.fps !== settings.fps) {+ const ratio = settings.fps / this.playback.fps;+ this.playback.fps = settings.fps;+ frame = Math.floor(frame * ratio);+ recalculate = true;+ }+ if (!settings.size.exactlyEquals(this.size)) {+ this.size = settings.size;+ this.playback.reload({size: this.size});+ }+ if (settings.audioOffset !== undefined) {+ this.audio.setOffset(settings.audioOffset);+ }++ this.lock.release();+ if (recalculate) {+ this.playback.reload();+ this.frame.current = frame;+ await this.requestRecalculation();+ this.requestSeek(frame);+ }+ }++ public requestSeek(value: number): void {+ this.requestedSeek = this.clampRange(value);+ }++ public requestPreviousFrame(): void {+ this.requestedSeek = this.frame.current - this.playback.speed;+ }++ public requestNextFrame(): void {+ this.requestedSeek = this.frame.current + this.playback.speed;+ }++ public requestReset(): void {+ this.requestedSeek = 0;+ }++ public toggleLoop(value = !this.playerState.current.loop) {+ if (value !== this.playerState.current.loop) {+ this.playerState.current = {+ ...this.playerState.current,+ loop: value,+ };+ }+ }++ public togglePlayback(+ value: boolean = this.playerState.current.paused,+ ): void {+ if (value === this.playerState.current.paused) {+ this.playerState.current = {+ ...this.playerState.current,+ paused: !value,+ };++ // hitting play after the animation has finished should reset the+ // playback, even if looping is disabled.+ if (+ value &&+ !this.playerState.current.loop &&+ this.playback.frame === this.playback.duration+ ) {+ this.requestReset();+ }+ }+ }++ public toggleAudio(value: boolean = this.playerState.current.muted): void {+ if (value === this.playerState.current.muted) {+ this.playerState.current = {+ ...this.playerState.current,+ muted: !value,+ };+ }+ }++ public setSpeed(value: number) {+ if (value !== this.playerState.current.speed) {+ this.playback.speed = value;+ this.playback.reload();+ this.playerState.current = {+ ...this.playerState.current,+ speed: value,+ };+ this.requestRecalculation();+ }+ }++ public setVariables(variables: Record<string, unknown>) {+ for (const scene of this.playback.onScenesRecalculated.current) {+ scene.variables.updateSignals(variables);+ }+ }++ /**+ * Activate the player.+ *+ * @remarks+ * A player needs to be active in order for the update loop to run. Each+ * player is active by default.+ */+ public activate() {+ this.active = true;+ this.request();+ }++ /**+ * Deactivate the player.+ *+ * @remarks+ * Deactivating the player prevents its update loop from running. This should+ * be done before disposing the player, to prevent it from running in the+ * background.+ *+ * Just pausing the player does not stop the loop.+ */+ public deactivate() {+ this.active = false;+ if (this.requestId !== null) {+ cancelAnimationFrame(this.requestId);+ this.requestId = null;+ }+ }++ private requestRecalculation() {+ this.requestedRecalculation = true;+ this.request();+ }++ private async prepare(): Promise<PlayerState & {seek: number}> {+ const state = {+ ...this.playerState.current,+ seek: this.requestedSeek,+ };+ this.requestedSeek = -1;++ // Recalculate the project if necessary+ if (this.requestedRecalculation) {+ if (state.seek < 0) {+ state.seek = this.playback.frame;+ }+ try {+ await this.playback.recalculate();+ this.duration.current = this.playback.frame;+ this.recalculated.dispatch();+ } catch (e) {+ this.requestSeek(state.seek);+ throw e;+ } finally {+ this.requestedRecalculation = false;+ }+ }++ // Pause if reached the end or the range is 0+ if (+ (!state.loop && this.finished && !state.paused && state.seek < 0) ||+ this.endFrame === this.startFrame+ ) {+ this.togglePlayback(false);+ state.paused = true;+ }++ // Seek to the beginning if looping is enabled+ if (+ state.loop &&+ (state.seek > this.endFrame || (this.finished && !state.paused)) &&+ this.startFrame !== this.endTime+ ) {+ state.seek = this.startFrame;+ }++ // Pause / play audio.+ const audioPaused =+ state.paused || this.finished || !this.audio.isInRange(this.status.time);+ if (await this.audio.setPaused(audioPaused)) {+ this.syncAudio(-3);+ }+ this.audio.setMuted(state.muted);++ return state;+ }++ private async run() {+ const state = await this.prepare();+ const previousState = this.playback.state;+ this.playback.state = state.paused+ ? PlaybackState.Paused+ : PlaybackState.Playing;++ // Seek to the given frame+ if (state.seek >= 0 || !this.isInRange(this.status.frame)) {+ const seekFrame = state.seek < 0 ? this.status.frame : state.seek;+ const clampedFrame = this.clampRange(seekFrame);+ this.logger.profile('seek time');+ await this.playback.seek(clampedFrame);+ this.logger.profile('seek time');+ this.syncAudio(-3);+ }+ // Do nothing if paused or is ahead of the audio.+ else if (+ state.paused ||+ (state.speed === 1 &&+ this.audio.isReady() &&+ this.audio.isInRange(this.status.time) &&+ this.audio.getTime() < this.status.time)+ ) {+ if (state.paused && previousState !== PlaybackState.Paused) {+ await this.render.dispatch();+ }++ // Sync the audio if the animation is too far ahead.+ if (+ !state.paused &&+ this.status.time > this.audio.getTime() + MAX_AUDIO_DESYNC+ ) {+ this.syncAudio();+ }++ this.request();+ return;+ }+ // Seek to synchronize animation with audio.+ else if (+ this.audio.isReady() &&+ state.speed === 1 &&+ this.audio.isInRange(this.status.time) &&+ this.status.framesToSeconds(this.playback.frame + 1) <+ this.audio.getTime() - MAX_AUDIO_DESYNC+ ) {+ const seekFrame = this.status.secondsToFrames(this.audio.getTime());+ await this.playback.seek(seekFrame);+ }+ // Simply move forward one frame+ else if (this.status.frame < this.endFrame) {+ await this.playback.progress();++ if (state.speed !== 1) {+ this.syncAudio();+ }+ }++ // Draw the project+ await this.render.dispatch();++ this.frame.current = this.playback.frame;++ this.request();+ }++ private request() {+ if (!this.active) return;++ this.requestId ??= requestAnimationFrame(async time => {+ this.requestId = null;+ if (time - this.renderTime >= 1000 / (this.status.fps + 5)) {+ this.renderTime = time;+ await this.lock.acquire();+ try {+ await this.run();+ } catch (e: any) {+ this.logger.error(e);+ }+ this.lock.release();+ } else {+ this.request();+ }+ });+ }++ private clampRange(frame: number): number {+ return clamp(this.startFrame, this.endFrame, frame);+ }++ private isInRange(frame: number): boolean {+ return frame >= this.startFrame && frame <= this.endFrame;+ }++ private syncAudio(frameOffset = 0) {+ this.audio.setTime(+ this.status.framesToSeconds(this.playback.frame + frameOffset),+ );+ }+}diff --git a/packages/core/src/app/Project.ts b/packages/core/src/app/Project.tsnew file mode 100644index 00000000..9ff78965--- /dev/null+++ b/packages/core/src/app/Project.ts@@ -0,0 +1,30 @@+import {FullSceneDescription} from '../scenes';+import {Logger} from './Logger';+import {ProjectMetadata} from './ProjectMetadata';++export interface ProjectSettings {+ name?: string;+ scenes: FullSceneDescription[];+ logger?: Logger;+ audio?: string;+ audioOffset?: number;+ variables?: Record<string, unknown>;+}++export interface Project {+ name: string;+ scenes: FullSceneDescription[];+ logger: Logger;+ meta: ProjectMetadata;+ audio?: string;+ audioOffset?: number;+ variables?: Record<string, unknown>;+}++export function makeProject(settings: ProjectSettings) {+ return {+ logger: new Logger(),+ meta: new ProjectMetadata(),+ ...settings,+ };+}diff --git a/packages/core/src/app/ProjectMetadata.ts b/packages/core/src/app/ProjectMetadata.tsnew file mode 100644index 00000000..16eaa209--- /dev/null+++ b/packages/core/src/app/ProjectMetadata.ts@@ -0,0 +1,70 @@+import {+ ColorMetaField,+ MetaField,+ ObjectMetaField,+ RangeMetaField,+ Vector2MetaField,+} from '../meta';+import {CanvasColorSpace, Color, CanvasOutputMimeType, Vector2} from '../types';++function createProjectMetadata() {+ return {+ version: new MetaField('version', 1),+ shared: new ObjectMetaField('shared', {+ background: new ColorMetaField('background', null),+ range: new RangeMetaField('range', [0, Infinity]),+ size: new Vector2MetaField('size', new Vector2(1920, 1080)),+ audioOffset: new MetaField('audioOffset', 0),+ }),+ preview: new ObjectMetaField('preview', {+ fps: new MetaField('fps', 30),+ resolutionScale: new MetaField('scale', 1),+ }),+ rendering: new ObjectMetaField('rendering', {+ fps: new MetaField('fps', 60),+ resolutionScale: new MetaField('scale', 2),+ colorSpace: new MetaField('color space', 'srgb' as CanvasColorSpace),+ fileType: new MetaField('file type', 'image/png' as CanvasOutputMimeType),+ quality: new MetaField('quality', 1),+ }),+ };+}++export class ProjectMetadata extends ObjectMetaField<+ ReturnType<typeof createProjectMetadata>+> {+ public constructor() {+ super('project', createProjectMetadata());+ }++ public getFullPreviewSettings(): {+ fps: number;+ resolutionScale: number;+ background: Color | null;+ range: [number, number];+ size: Vector2;+ audioOffset: number;+ } {+ return {+ ...this.shared.get(),+ ...this.preview.get(),+ };+ }++ public getFullRenderingSettings(): {+ fps: number;+ resolutionScale: number;+ colorSpace: CanvasColorSpace;+ fileType: CanvasOutputMimeType;+ quality: number;+ background: Color | null;+ range: [number, number];+ size: Vector2;+ audioOffset: number;+ } {+ return {+ ...this.shared.get(),+ ...this.rendering.get(),+ };+ }+}diff --git a/packages/core/src/app/Renderer.ts b/packages/core/src/app/Renderer.tsnew file mode 100644index 00000000..6ee958b4--- /dev/null+++ b/packages/core/src/app/Renderer.ts@@ -0,0 +1,236 @@+import {Project} from './Project';+import {PlaybackManager, PlaybackState} from './PlaybackManager';+import {Stage, StageSettings} from './Stage';+import {Scene} from '../scenes';+import {EventDispatcher, ValueDispatcher} from '../events';+import {ImageExporter} from './ImageExporter';+import {Exporter} from './Exporter';+import {CanvasOutputMimeType, Vector2} from '../types';+import {PlaybackStatus} from './PlaybackStatus';+import {Semaphore} from '../utils';++export interface RendererSettings extends StageSettings {+ name: string;+ range: [number, number];+ fps: number;+ fileType: CanvasOutputMimeType;+ quality: number;+}++export enum RendererState {+ Initial,+ Working,+ Aborting,+}++export enum RendererResult {+ Success,+ Error,+ Aborted,+}++/**+ * The rendering logic used by the editor to export animations.+ *+ * @remarks+ * This class uses the {@link PlaybackManager} to render animations.+ * In contrast to a player, a renderer does not use an update loop.+ * It plays through the animation as fast as it can, occasionally pausing+ * to keep the UI responsive.+ *+ * The actual exporting is outsourced to an {@link Exporter}.+ */+export class Renderer {+ public get onStateChanged() {+ return this.state.subscribable;+ }+ private readonly state = new ValueDispatcher(RendererState.Initial);++ public get onFinished() {+ return this.finished.subscribable;+ }+ private readonly finished = new EventDispatcher<RendererResult>();++ public get onFrameChanged() {+ return this.frame.subscribable;+ }+ private readonly frame = new ValueDispatcher(0);++ public readonly stage = new Stage();++ private readonly lock = new Semaphore();+ private readonly playback: PlaybackManager;+ private readonly status: PlaybackStatus;+ private readonly exporter: Exporter = new ImageExporter(this.project.logger);+ private abortController: AbortController | null = null;++ public constructor(private project: Project) {+ this.playback = new PlaybackManager();+ this.status = new PlaybackStatus(this.playback);+ const scenes: Scene[] = [];+ for (const description of project.scenes) {+ const scene = new description.klass({+ ...description,+ meta: description.meta.clone(),+ logger: this.project.logger,+ playback: this.status,+ size: new Vector2(1920, 1080),+ });+ scenes.push(scene);+ }+ this.playback.setup(scenes);+ }++ /**+ * Render the animation using the provided settings.+ *+ * @param settings - The rendering settings.+ */+ public async render(settings: RendererSettings) {+ if (this.state.current !== RendererState.Initial) return;+ await this.lock.acquire();+ this.state.current = RendererState.Working;+ let result: RendererResult;+ try {+ this.abortController = new AbortController();+ result = await this.run(settings, this.abortController.signal);+ } catch (e: any) {+ this.project.logger.error(e);+ result = RendererResult.Error;+ }++ this.state.current = RendererState.Initial;+ this.finished.dispatch(result);+ this.lock.release();+ }++ /**+ * Abort the ongoing render process.+ */+ public abort() {+ if (this.state.current !== RendererState.Working) return;+ this.abortController?.abort();+ this.state.current = RendererState.Aborting;+ }++ /**+ * Export an individual frame.+ *+ * @remarks+ * This method always uses the default {@link ImageExporter}.+ *+ * @param settings - The rendering settings.+ * @param frame - The frame to export.+ */+ public async renderFrame(settings: RendererSettings, frame: number) {+ await this.lock.acquire();++ try {+ this.stage.configure(settings);+ this.playback.fps = settings.fps;+ this.playback.state = PlaybackState.Rendering;++ await this.reloadScenes(settings.size);+ await this.playback.reset();+ await this.playback.seek(this.status.secondsToFrames(settings.range[0]));+ await this.stage.render(+ this.playback.currentScene!,+ this.playback.previousScene,+ );++ if (import.meta.hot) {+ import.meta.hot!.send('motion-canvas:export', {+ frame,+ isStill: true,+ data: this.stage.finalBuffer.toDataURL(+ settings.fileType,+ settings.quality,+ ),+ mimeType: settings.fileType,+ project: this.project.name,+ });+ }+ } catch (e: any) {+ this.project.logger.error(e);+ }++ this.lock.release();+ }++ private async run(+ settings: RendererSettings,+ signal: AbortSignal,+ ): Promise<RendererResult> {+ settings = (await this.exporter.configure(settings)) ?? settings;+ this.stage.configure(settings);+ this.playback.fps = settings.fps;+ const from = this.status.secondsToFrames(settings.range[0]);+ const to = this.status.secondsToFrames(settings.range[1]);++ await this.reloadScenes(settings.size);+ if (signal.aborted) return RendererResult.Aborted;+ await this.playback.reset();+ if (signal.aborted) return RendererResult.Aborted;+ await this.playback.seek(from);+ if (signal.aborted) return RendererResult.Aborted;++ await this.exporter.start();++ let lastRefresh = performance.now();+ let result = RendererResult.Success;+ try {+ await this.exportFrame(signal);+ if (signal.aborted) {+ result = RendererResult.Aborted;+ } else {+ let finished = false;+ while (!finished) {+ await this.playback.progress();+ await this.exportFrame(signal);+ if (performance.now() - lastRefresh > 1 / 30) {+ lastRefresh = performance.now();+ await new Promise(resolve => setTimeout(resolve, 0));+ }+ if (this.playback.finished || this.playback.frame > to) {+ finished = true;+ }+ if (signal.aborted) {+ result = RendererResult.Aborted;+ finished = true;+ }+ }+ }+ } catch (e: any) {+ this.project.logger.error(e);+ result = RendererResult.Error;+ }++ await this.exporter.stop(result);+ return result;+ }++ private async reloadScenes(size: Vector2) {+ for (let i = 0; i < this.project.scenes.length; i++) {+ const description = this.project.scenes[i];+ const scene = this.playback.onScenesRecalculated.current[i];+ scene.reload({+ config: description.onReplaced.current.config,+ size: size,+ });+ scene.meta.set(description.meta.get());+ }+ }++ private async exportFrame(signal: AbortSignal) {+ this.frame.current = this.playback.frame;+ await this.stage.render(+ this.playback.currentScene!,+ this.playback.previousScene,+ );+ await this.exporter.handleFrame(+ this.stage.finalBuffer,+ this.playback.frame,+ signal,+ );+ }+}diff --git a/packages/core/src/app/Stage.ts b/packages/core/src/app/Stage.tsnew file mode 100644index 00000000..e68d90e7--- /dev/null+++ b/packages/core/src/app/Stage.ts@@ -0,0 +1,118 @@+import {getContext} from '../utils';+import {Scene} from '../scenes';+import {CanvasColorSpace, Vector2} from '../types';+import type {Color} from '../types';++export interface StageSettings {+ size: Vector2;+ resolutionScale: number;+ colorSpace: CanvasColorSpace;+ background: Color | string | null;+}++/**+ * Manages canvases on which an animation can be displayed.+ */+export class Stage {+ // TODO Consider adding pooling for canvases.++ private background: string | null = null;+ private resolutionScale = 1;+ private colorSpace: CanvasColorSpace = 'srgb';+ private size = new Vector2(1920, 1080);++ public readonly finalBuffer: HTMLCanvasElement;+ private readonly currentBuffer: HTMLCanvasElement;+ private readonly previousBuffer: HTMLCanvasElement;++ private context: CanvasRenderingContext2D;+ private currentContext: CanvasRenderingContext2D;+ private previousContext: CanvasRenderingContext2D;++ private get canvasSize() {+ return this.size.scale(this.resolutionScale);+ }++ public constructor() {+ this.finalBuffer = document.createElement('canvas');+ this.currentBuffer = document.createElement('canvas');+ this.previousBuffer = document.createElement('canvas');++ const colorSpace = this.colorSpace;+ this.context = getContext({colorSpace}, this.finalBuffer);+ this.currentContext = getContext({colorSpace}, this.currentBuffer);+ this.previousContext = getContext({colorSpace}, this.previousBuffer);+ }++ public configure({+ colorSpace = this.colorSpace,+ size = this.size,+ resolutionScale = this.resolutionScale,+ background = this.background,+ }: Partial<StageSettings>) {+ if (colorSpace !== this.colorSpace) {+ this.colorSpace = colorSpace;+ this.context = getContext({colorSpace}, this.finalBuffer);+ this.currentContext = getContext({colorSpace}, this.currentBuffer);+ this.previousContext = getContext({colorSpace}, this.previousBuffer);+ }++ if (+ !size.exactlyEquals(this.size) ||+ resolutionScale !== this.resolutionScale+ ) {+ this.resolutionScale = resolutionScale;+ this.size = size;+ this.resizeCanvas(this.context);+ this.resizeCanvas(this.currentContext);+ this.resizeCanvas(this.previousContext);+ }++ this.background =+ typeof background === 'string'+ ? background+ : background?.serialize() ?? null;+ }++ public async render(currentScene: Scene, previousScene: Scene | null) {+ if (previousScene) {+ this.transformCanvas(this.previousContext);+ await previousScene.render(this.previousContext);+ }++ this.transformCanvas(this.currentContext);+ await currentScene.render(this.currentContext);++ const size = this.canvasSize;+ this.context.clearRect(0, 0, size.width, size.height);+ if (this.background) {+ this.context.save();+ this.context.fillStyle = this.background;+ this.context.fillRect(0, 0, size.width, size.height);+ this.context.restore();+ }++ if (previousScene) {+ this.context.drawImage(this.previousBuffer, 0, 0);+ }+ this.context.drawImage(this.currentBuffer, 0, 0);+ }++ public transformCanvas(context: CanvasRenderingContext2D) {+ const offset = this.canvasSize.scale(0.5);+ context.setTransform(+ this.resolutionScale,+ 0,+ 0,+ this.resolutionScale,+ offset.x,+ offset.y,+ );+ }++ public resizeCanvas(context: CanvasRenderingContext2D) {+ const size = this.canvasSize;+ context.canvas.width = size.width;+ context.canvas.height = size.height;+ }+}diff --git a/packages/core/src/app/index.ts b/packages/core/src/app/index.tsnew file mode 100644index 00000000..f960e49c--- /dev/null+++ b/packages/core/src/app/index.ts@@ -0,0 +1,16 @@+/**+ * Main Motion Canvas classes.+ *+ * @packageDocumentation+ */++export * from './Exporter';+export * from './ImageExporter';+export * from './Logger';+export * from './PlaybackManager';+export * from './PlaybackStatus';+export * from './Player';+export * from './Project';+export * from './ProjectMetadata';+export * from './Renderer';+export * from './Stage';diff --git a/packages/core/src/flow/every.ts b/packages/core/src/flow/every.tsindex 4d61ae2f..ed435825 100644--- a/packages/core/src/flow/every.ts+++ b/packages/core/src/flow/every.ts@@ -1,6 +1,6 @@import {ThreadGenerator} from '../threading';import {decorate, threadable} from '../decorators';-import {useProject} from '../utils';+import {usePlayback} from '../utils';/*** A callback called by {@link EveryTimer} every N seconds.@@ -48,7 +48,7 @@ export function every(interval: number, callback: EveryCallback): EveryTimer {let changed = false;decorate(everyRunner, threadable('every'));function* everyRunner(): ThreadGenerator {- const project = useProject();+ const project = usePlayback();let acc = 0;let tick = 0;callback(tick);diff --git a/packages/core/src/flow/scheduling.test.ts b/packages/core/src/flow/scheduling.test.tsindex b8e543c0..e5bad612 100644--- a/packages/core/src/flow/scheduling.test.ts+++ b/packages/core/src/flow/scheduling.test.ts@@ -1,19 +1,18 @@/* eslint-disable @typescript-eslint/no-unused-vars */-import {describe, test, beforeEach, expect} from 'vitest';-import {Project} from '../Project';-import {setProject, useProject, useTime} from '../utils';+import {describe, test, expect, beforeAll, afterAll} from 'vitest';+import {endPlayback, startPlayback, useTime} from '../utils';import {threads} from '../threading';import {waitFor} from './scheduling';+import {PlaybackManager, PlaybackStatus} from '../app';describe('waitFor()', () => {- beforeEach(() => {- setProject(new Project({name: 'tests', scenes: []}));- });+ const playback = new PlaybackManager();+ const status = new PlaybackStatus(playback);+ beforeAll(() => startPlayback(status));+ afterAll(() => endPlayback(status));test('Framerate-independent wait duration', () => {- const project = useProject();-let time60;const task60 = threads(function* () {yield* waitFor(3.1415);@@ -26,16 +25,16 @@ describe('waitFor()', () => {time24 = useTime();});- project.framerate = 60;- project.frame = 0;+ playback.fps = 60;+ playback.frame = 0;for (const _ of task60) {- project.frame++;+ playback.frame++;}- project.framerate = 24;- project.frame = 0;+ playback.fps = 24;+ playback.frame = 0;for (const _ of task24) {- project.frame++;+ playback.frame++;}expect(time60).toBeCloseTo(3.1415);@@ -43,9 +42,7 @@ describe('waitFor()', () => {});test('Accumulated time offset', () => {- const project = useProject();-- let time: number;+ let time = NaN;const task = threads(function* () {yield* waitFor(0.15);yield* waitFor(0.15);@@ -53,13 +50,13 @@ describe('waitFor()', () => {time = useTime();});- project.framerate = 10;- project.frame = 0;+ playback.fps = 10;+ playback.frame = 0;for (const _ of task) {- project.frame++;+ playback.frame++;}- expect(project.frame).toBe(4);+ expect(playback.frame).toBe(4);expect(time).toBeCloseTo(0.45);});});diff --git a/packages/core/src/flow/scheduling.ts b/packages/core/src/flow/scheduling.tsindex 0298af51..0d007ce3 100644--- a/packages/core/src/flow/scheduling.ts+++ b/packages/core/src/flow/scheduling.ts@@ -1,6 +1,6 @@import {decorate, threadable} from '../decorators';import {ThreadGenerator} from '../threading';-import {useProject, useScene, useThread} from '../utils';+import {usePlayback, useScene, useThread} from '../utils';decorate(waitUntil, threadable());/**@@ -25,7 +25,7 @@ export function* waitUntil(const scene = useScene();const frames = scene.timeEvents.register(event);- while (scene.project.frame < frames) {+ while (scene.playback.frame < frames) {yield;}@@ -54,7 +54,7 @@ export function* waitFor(seconds = 0,after?: ThreadGenerator,): ThreadGenerator {- const project = useProject();+ const project = usePlayback();const thread = useThread();const step = project.framesToSeconds(1);diff --git a/packages/core/src/index.ts b/packages/core/src/index.tsdeleted file mode 100644index 7246402d..00000000--- a/packages/core/src/index.ts+++ /dev/null@@ -1,9 +0,0 @@-/**- * Main Motion Canvas classes.- *- * @packageDocumentation- */--export * from './Logger';-export * from './Meta';-export * from './Project';diff --git a/packages/core/src/media/AudioManager.ts b/packages/core/src/media/AudioManager.tsindex db94c194..90f2cb2e 100644--- a/packages/core/src/media/AudioManager.ts+++ b/packages/core/src/media/AudioManager.ts@@ -1,6 +1,7 @@import {AudioData} from './AudioData';import {ValueDispatcher} from '../events';import {useLogger} from '../utils';+import {Logger} from '../app';export class AudioManager {public get onDataChanged() {@@ -8,18 +9,14 @@ export class AudioManager {}private readonly data = new ValueDispatcher<AudioData | null>(null);- public get onOffsetChanged() {- return this.offset.subscribable;- }- private readonly offset = new ValueDispatcher(0);-private static readonly context = new AudioContext();private readonly audioElement: HTMLAudioElement = new Audio();private source: string | null = null;private error = false;private abortController: AbortController | null = null;+ private offset = 0;- public constructor() {+ public constructor(private readonly logger: Logger) {if (import.meta.hot) {import.meta.hot.on('motion-canvas:assets', ({urls}) => {if (this.source && urls.includes(this.source)) {@@ -38,7 +35,7 @@ export class AudioManager {}public setOffset(value: number) {- this.offset.current = value;+ this.offset = value;}public setMuted(isMuted: boolean) {@@ -52,21 +49,21 @@ export class AudioManager {this.abortController = new AbortController();this.loadData(this.abortController.signal).catch(e => {if (e.name !== 'AbortError') {- useLogger().error(e);+ this.logger.error(e);}});}public isInRange(time: number) {- return time >= this.offset.current && time < this.audioElement.duration;+ return time >= this.offset && time < this.audioElement.duration;}public toRelativeTime(time: number) {- return Math.max(0, time - this.offset.current);+ return Math.max(0, time - this.offset);}public toAbsoluteTime(time: number) {- return time + this.offset.current;+ return time + this.offset;}public isReady() {diff --git a/packages/core/src/media/loadImage.ts b/packages/core/src/media/loadImage.tsindex af1f855a..ee05fc66 100644--- a/packages/core/src/media/loadImage.ts+++ b/packages/core/src/media/loadImage.ts@@ -27,7 +27,7 @@ export function loadAnimation(sources: string[]): Promise<HTMLImageElement[]> {export function getImageData(image: ImageDataSource) {canvas ??= document.createElement('canvas');- context ??= getContext(canvas);+ context ??= getContext({willReadFrequently: true}, canvas);canvas.width = image.width;canvas.height = image.height;diff --git a/packages/core/src/meta/ColorMetaField.ts b/packages/core/src/meta/ColorMetaField.tsnew file mode 100644index 00000000..58ee982f--- /dev/null+++ b/packages/core/src/meta/ColorMetaField.ts@@ -0,0 +1,18 @@+import {MetaField} from './MetaField';+import {Color, PossibleColor} from '../types';++/**+ * Represents a color stored in a meta file.+ */+export class ColorMetaField extends MetaField<+ PossibleColor | null,+ Color | null+> {+ public override parse(value: PossibleColor | null): Color | null {+ return value === null ? null : new Color(value);+ }++ public override serialize(): PossibleColor | null {+ return this.value.current?.serialize() ?? null;+ }+}diff --git a/packages/core/src/meta/MetaField.ts b/packages/core/src/meta/MetaField.tsnew file mode 100644index 00000000..8933f9de--- /dev/null+++ b/packages/core/src/meta/MetaField.ts@@ -0,0 +1,71 @@+import {ValueDispatcher} from '../events';++/**+ * Represents an entry in the meta file.+ *+ * @typeParam TSerializedValue - The type used to store this field in the meta+ * file.+ * @typeParam TValue - The runtime type of this field.+ */+export class MetaField<+ TSerializedValue,+ TValue extends TSerializedValue = TSerializedValue,+> {+ /**+ * Triggered when the data of this field changes.+ *+ * @eventProperty+ */+ public get onChanged() {+ return this.value.subscribable;+ }++ protected readonly value: ValueDispatcher<TValue>;++ /**+ * @param name - The name of this field displayed in the editor.+ * @param value - The initial value of this field.+ */+ public constructor(public readonly name: string, value: TValue) {+ this.value = new ValueDispatcher(value);+ }++ /**+ * Get the current value.+ */+ public get(): TValue {+ return this.value.current;+ }++ /**+ * Set the current value.+ *+ * @param value - The new value.+ */+ public set(value: TSerializedValue) {+ this.value.current = this.parse(value);+ }++ /**+ * Convert a serialized value into a runtime type.+ *+ * @param value - The serialized value.+ */+ public parse(value: TSerializedValue): TValue {+ return value as TValue;+ }++ /**+ * Serialize the value of this field.+ */+ public serialize(): TSerializedValue {+ return this.value.current;+ }++ /**+ * Create a clone of this field.+ */+ public clone(): this {+ return new (<any>this.constructor)(this.name, this.get());+ }+}diff --git a/packages/core/src/meta/MetaFile.ts b/packages/core/src/meta/MetaFile.tsnew file mode 100644index 00000000..da59a472--- /dev/null+++ b/packages/core/src/meta/MetaFile.ts@@ -0,0 +1,103 @@+import {Semaphore, useLogger} from '../utils';+import {MetaField} from './MetaField';++/**+ * Represents the meta file of a given entity.+ *+ * @remarks+ * This class is used exclusively by our Vite plugin as a bridge between+ * physical files and their runtime representation.+ *+ * @typeParam T - The type of the data stored in the meta file.+ *+ * @internal+ */+export class MetaFile<T> {+ private readonly lock = new Semaphore();+ private ignoreChange = false;+ private cache: T | null = null;+ private metaField: MetaField<T> | null = null;++ public constructor(+ private readonly name: string,+ private source: string | false = false,+ ) {}++ public attach(field: MetaField<T>) {+ if (this.metaField) return;+ this.metaField = field;+ if (this.cache) {+ this.metaField.set(this.cache);+ }+ this.metaField?.onChanged.subscribe(this.handleChanged);+ }++ protected handleChanged = async () => {+ if (import.meta.hot && this.metaField && !this.ignoreChange) {+ const data = this.metaField.serialize();+ await this.lock.acquire();+ try {+ // TODO Consider debouncing saving the meta file.+ await this.saveData(data);+ } catch (e: any) {+ useLogger().error(e);+ }+ this.lock.release();+ }+ };++ private async saveData(data: T) {+ if (this.source === false) {+ return;+ }++ if (!this.source) {+ throw new Error(`The meta file for ${this.name} is missing.`);+ }++ if (MetaFile.sourceLookup[this.source]) {+ throw new Error(`Metadata for ${this.name} is already being updated`);+ }++ const source = this.source;+ await new Promise<void>((resolve, reject) => {+ setTimeout(() => {+ delete MetaFile.sourceLookup[source];+ reject(`Connection timeout when updating metadata for ${this.name}`);+ }, 1000);+ MetaFile.sourceLookup[source] = () => {+ delete MetaFile.sourceLookup[source];+ resolve();+ };+ import.meta.hot!.send('motion-canvas:meta', {+ source,+ data,+ });+ });+ }++ /**+ * Load new metadata from a file.+ *+ * @remarks+ * This method is called during hot module replacement.+ *+ * @param data - New metadata.+ */+ public loadData(data: T) {+ this.ignoreChange = true;+ this.cache = data;+ this.metaField?.set(data);+ this.ignoreChange = false;+ }++ private static sourceLookup: Record<string, Callback> = {};++ static {+ if (import.meta.hot) {+ import.meta.hot.on('motion-canvas:meta-ack', ({source}) => {+ this.sourceLookup[source]?.();+ });+ }+ }+}diff --git a/packages/core/src/meta/ObjectMetaField.ts b/packages/core/src/meta/ObjectMetaField.tsnew file mode 100644index 00000000..f4f1571e--- /dev/null+++ b/packages/core/src/meta/ObjectMetaField.ts@@ -0,0 +1,83 @@+import {MetaField} from './MetaField';++type ValueOf<T extends Record<string, any>> = {+ [K in keyof T]: T[K] extends MetaField<any, infer P> ? P : never;+};++/**+ * Represents an object with nested meta-fields.+ */+class ObjectMetaFieldInternal<+ T extends Record<string, MetaField<any>>,+> extends MetaField<ValueOf<T>> {+ protected ignoreChange = false;++ public constructor(name: string, protected readonly fields: T) {+ const entries = Object.entries(fields);+ super(+ name,+ Object.fromEntries(+ entries.map(([name, field]) => [name, field.get()]),+ ) as ValueOf<T>,+ );++ for (const [key, field] of entries) {+ Object.defineProperty(this, key, {value: field});+ field.onChanged.subscribe(this.handleChange);+ }+ }++ public override set(value: ValueOf<T>) {+ this.ignoreChange = true;+ for (const [key, fieldValue] of Object.entries(value)) {+ this.fields[key]?.set(fieldValue);+ }+ this.ignoreChange = false;+ this.handleChange();+ }++ public override serialize(): ValueOf<T> {+ return Object.fromEntries(+ Object.entries(this.fields).map(([name, field]) => [+ name,+ field.serialize(),+ ]),+ ) as ValueOf<T>;+ }++ protected handleChange = () => {+ if (this.ignoreChange) return;++ this.value.current = Object.fromEntries(+ Object.entries(this.fields).map(([name, field]) => [name, field.get()]),+ ) as ValueOf<T>;+ };++ public override clone(): this {+ return new (<any>this.constructor)(+ this.name,+ Object.fromEntries(+ Object.entries(this.fields).map(([name, field]) => [+ name,+ field.clone(),+ ]),+ ),+ );+ }+}++/**+ * {@inheritDoc ObjectMetaFieldInternal}+ */+export type ObjectMetaField<T extends Record<string, MetaField<any>>> =+ ObjectMetaFieldInternal<T> & T;++/**+ * {@inheritDoc ObjectMetaFieldInternal}+ */+export const ObjectMetaField = ObjectMetaFieldInternal as {+ new <T extends Record<string, MetaField<any>>>(+ name: string,+ data: T,+ ): ObjectMetaField<T>;+};diff --git a/packages/core/src/meta/RangeMetaField.ts b/packages/core/src/meta/RangeMetaField.tsnew file mode 100644index 00000000..ca7a2a00--- /dev/null+++ b/packages/core/src/meta/RangeMetaField.ts@@ -0,0 +1,63 @@+import {MetaField} from './MetaField';+import {EPSILON} from '../types';+import {clamp} from '../tweening';++/**+ * Represents a range stored in a meta file.+ *+ * @remarks+ * Range is an array with two elements denoting the beginning and end of a+ * range, respectively.+ */+export class RangeMetaField extends MetaField<+ [number, number | null],+ [number, number]+> {+ public override parse(value: [number, number | null]): [number, number] {+ return this.parseRange(Infinity, value[0], value[1] ?? Infinity);+ }++ /**+ * Convert the given range from frames to seconds and update this field.+ *+ * @remarks+ * This helper method applies additional validation to the range, preventing+ * it from overflowing the timeline.+ *+ * @param startFrame - The beginning of the range.+ * @param endFrame - The end of the range.+ * @param duration - The current duration in frames.+ * @param fps - The current framerate.+ */+ public update(+ startFrame: number,+ endFrame: number,+ duration: number,+ fps: number,+ ) {+ this.value.current = this.parseRange(+ duration / fps - EPSILON,+ startFrame / fps - EPSILON,+ endFrame / fps - EPSILON,+ );+ }++ protected parseRange(+ duration: number,+ startFrame: number = this.value.current[0],+ endFrame: number = this.value.current[1],+ ): [number, number] {+ startFrame = clamp(0, duration, startFrame);+ endFrame = clamp(0, duration, endFrame ?? Infinity);++ if (startFrame > endFrame) {+ [startFrame, endFrame] = [endFrame, startFrame];+ }++ if (endFrame >= duration) {+ endFrame = Infinity;+ }++ return [startFrame, endFrame];+ }+}diff --git a/packages/core/src/meta/Vector2MetaField.ts b/packages/core/src/meta/Vector2MetaField.tsnew file mode 100644index 00000000..07e2d5ee--- /dev/null+++ b/packages/core/src/meta/Vector2MetaField.ts@@ -0,0 +1,15 @@+import {MetaField} from './MetaField';+import {PossibleVector2, Vector2} from '../types';++/**+ * Represents a two-dimensional vector stored in a meta file.+ */+export class Vector2MetaField extends MetaField<PossibleVector2, Vector2> {+ public override parse(value: PossibleVector2): Vector2 {+ return new Vector2(value);+ }++ public override serialize(): PossibleVector2 {+ return this.value.current.serialize();+ }+}diff --git a/packages/core/src/meta/index.ts b/packages/core/src/meta/index.tsnew file mode 100644index 00000000..5cd82d66--- /dev/null+++ b/packages/core/src/meta/index.ts@@ -0,0 +1,12 @@+/**+ * The runtime representation of meta files.+ *+ * @packageDocumentation+ */++export * from './ColorMetaField';+export * from './MetaField';+export * from './MetaFile';+export * from './ObjectMetaField';+export * from './RangeMetaField';+export * from './Vector2MetaField';diff --git a/packages/core/src/player/Player.ts b/packages/core/src/player/Player.tsdeleted file mode 100644index 00d236c4..00000000--- a/packages/core/src/player/Player.ts+++ /dev/null@@ -1,415 +0,0 @@-import type {Project} from '../Project';-import {PlaybackState} from '../Project';-import {EventDispatcher, ValueDispatcher} from '../events';-import type {CanvasColorSpace, CanvasOutputMimeType} from '../types';-import {Logger} from '../Logger';--const MAX_AUDIO_DESYNC = 1 / 50;--export interface PlayerState extends Record<string, unknown> {- duration: number;- startFrame: number;- endFrame: number;- paused: boolean;- loading: boolean;- finished: boolean;- loop: boolean;- speed: number;- render: boolean;- muted: boolean;- fps: number;- scale: number;- colorSpace: CanvasColorSpace;- fileType: CanvasOutputMimeType;- quality: number;-}--interface PlayerCommands {- seek: number;- recalculate: boolean;-}--export class Player {- public get onStateChanged() {- return this.state.subscribable;- }- private readonly state = new ValueDispatcher<PlayerState>({- duration: Infinity,- startFrame: 0,- endFrame: Infinity,- paused: true,- loading: false,- finished: false,- loop: true,- speed: 1,- render: false,- muted: true,- fps: 30,- scale: 1,- colorSpace: 'srgb',- fileType: 'image/png',- quality: 1,- });-- public get onFrameChanged() {- return this.frame.subscribable;- }- private readonly frame = new ValueDispatcher(0);-- public get onReloaded() {- return this.reloaded.subscribable;- }- private readonly reloaded = new EventDispatcher<number>();-- private startTime: number;- private renderTime = 0;- private requestId: number | null = null;-- private commands: PlayerCommands = {- seek: -1,- recalculate: true,- };-- private readonly logger: Logger;-- public constructor(public readonly project: Project) {- this.startTime = performance.now();- this.logger = this.project.logger;- this.project.framerate = this.state.current.fps;- this.project.resolutionScale = this.state.current.scale;- this.project.colorSpace = this.state.current.colorSpace;- // TODO Recalculation should be handled by the project.- this.project.onReloaded.subscribe(() => this.reload());-- this.request();- }-- public loadState(state: Partial<PlayerState>) {- this.updateState(state);- this.project.speed = this.state.current.speed;- this.project.framerate = this.state.current.fps;- this.project.resolutionScale = this.state.current.scale;- this.project.colorSpace = this.state.current.colorSpace;- this.setRange(this.state.current.startFrame, this.state.current.endFrame);- }-- private updateState(newState: Partial<PlayerState>) {- let changed = false;- for (const prop in newState) {- if (newState[prop] !== this.state.current[prop]) {- changed = true;- break;- }- }-- if (changed) {- this.state.current = {- ...this.state.current,- ...newState,- };- }- }-- private consumeCommands(): PlayerCommands {- const commands = {...this.commands};- this.commands.seek = -1;- this.commands.recalculate = false;-- return commands;- }-- private reload() {- this.commands.recalculate = true;- if (this.requestId === null) {- this.request();- }- }-- public setRange(- startFrame = this.state.current.startFrame,- endFrame = this.state.current.endFrame,- ) {- if (endFrame >= this.state.current.duration || !endFrame) {- endFrame = Infinity;- }-- if (startFrame < 0) {- startFrame = 0;- }-- if (startFrame > endFrame) {- [startFrame, endFrame] = [endFrame, startFrame];- }-- if (endFrame - startFrame < 1) {- if (startFrame !== 0) {- startFrame--;- } else {- endFrame++;- }- }-- this.updateState({startFrame, endFrame});- }-- public setSpeed(value: number) {- this.project.speed = value;- this.updateState({speed: value});- this.reload();- }-- public setFramerate(fps: number) {- const ratio = fps / this.state.current.fps;- this.project.framerate = fps;- this.updateState({- fps,- startFrame: Math.floor(this.state.current.startFrame * ratio),- endFrame: Math.floor(this.state.current.endFrame * ratio),- duration: Math.floor(this.state.current.duration * ratio),- });- this.requestSeek(Math.floor(this.frame.current * ratio));- this.reload();- }-- public setScale(scale: number) {- this.project.resolutionScale = scale;- this.updateState({scale});- }-- public setColorSpace(colorSpace: CanvasColorSpace) {- this.project.colorSpace = colorSpace;- this.updateState({colorSpace});- }-- public setFileType(fileType: CanvasOutputMimeType) {- this.project.fileType = fileType;- this.updateState({fileType});- }-- public setQuality(quality: number) {- this.project.quality = quality;- this.updateState({quality});- }-- public requestPreviousFrame(): void {- this.commands.seek = this.frame.current - this.state.current.speed;- }-- public requestNextFrame(): void {- this.commands.seek = this.frame.current + this.state.current.speed;- }-- public requestReset(): void {- this.commands.seek = 0;- }-- public requestSeek(value: number): void {- this.commands.seek = this.clampRange(value, this.state.current);- }-- public toggleLoop(value = !this.state.current.loop) {- this.updateState({loop: value});- }-- public togglePlayback(value: boolean = this.state.current.paused): void {- this.updateState({paused: !value});- }-- public toggleRendering(value = !this.state.current.render): void {- if (value) {- this.requestSeek(0);- this.reload();- }- this.updateState({render: value});- }-- public toggleAudio(value: boolean = this.state.current.muted): void {- this.updateState({muted: !value});- }-- public async exportCurrentFrame() {- await this.project.export(true);- }-- private async run() {- const commands = this.consumeCommands();- const state = {...this.state.current};- // if (state.finished && commands.seek < 0 && !state.loop && !state.paused) {- // this.togglePlayback(false);- // this.request();- // return;- // }-- const previousState = this.project.playbackState();- this.project.playbackState(- state.paused ? PlaybackState.Paused : PlaybackState.Playing,- );-- // Recalculate- if (commands.recalculate) {- const startTime = performance.now();- await this.project.recalculate();- const duration = this.project.frame;- const frame = commands.seek < 0 ? this.frame.current : commands.seek;- const finished = await this.project.seek(frame);- await this.project.render();- this.updateState({- duration,- finished,- endFrame:- state.endFrame !== Infinity && state.endFrame > duration- ? duration- : state.endFrame,- });- if (this.frame.current + 1 !== this.project.frame) {- this.frame.current = this.project.frame;- }- this.request();- this.reloaded.dispatch(performance.now() - startTime);- return;- }-- // Pause / play audio.- const audioPaused =- state.paused ||- state.finished ||- state.render ||- !this.project.audio.isInRange(this.project.time);- if (await this.project.audio.setPaused(audioPaused)) {- this.project.syncAudio(-3);- }- this.project.audio.setMuted(state.muted);-- // Rendering- if (state.render) {- this.project.playbackState(PlaybackState.Rendering);- state.finished = await this.project.next();- await this.project.render();- try {- await this.project.export();- } catch (e: any) {- this.logger.error(e);- this.toggleRendering(false);- }-- if (state.finished || this.project.frame >= state.endFrame) {- await this.project.finishExport();- this.toggleRendering(false);- }-- this.updateState({- finished: state.finished,- });- this.frame.current = this.project.frame;- this.request();- return;- }-- // Seek to the given frame- if (commands.seek >= 0 || !this.isInRange(this.project.frame, state)) {- const seekFrame = commands.seek < 0 ? this.project.frame : commands.seek;- const clampedFrame = this.clampRange(seekFrame, state);- this.logger.profile('seek time');- state.finished = await this.project.seek(clampedFrame);- this.logger.profile('seek time');- this.project.syncAudio(-3);- }- // Do nothing if paused or is ahead of the audio.- else if (- state.paused ||- (state.speed === 1 &&- this.project.audio.isReady() &&- this.project.audio.isInRange(this.project.time) &&- this.project.audio.getTime() < this.project.time)- ) {- if (state.paused && previousState !== PlaybackState.Paused) {- await this.project.render();- }-- // Sync the audio if the animation is too far ahead.- if (this.project.time > this.project.audio.getTime() + MAX_AUDIO_DESYNC) {- this.project.syncAudio();- }-- this.request();- return;- }- // Seek to synchronize animation with audio.- else if (- this.project.audio.isReady() &&- state.speed === 1 &&- this.project.audio.isInRange(this.project.time) &&- this.project.time < this.project.audio.getTime() - MAX_AUDIO_DESYNC- ) {- const seekFrame = this.project.secondsToFrames(- this.project.audio.getTime(),- );- state.finished = await this.project.seek(seekFrame);- }- // Simply move forward one frame- else if (this.project.frame < state.endFrame) {- state.finished = await this.project.next();-- // Synchronize audio.- if (state.speed !== 1) {- this.project.syncAudio();- }- }-- // Draw the project- await this.project.render();-- // Loop back at the end if looping is enabled- if (- state.loop &&- (commands.seek > Math.min(state.duration, state.endFrame) ||- (state.finished && !state.paused))- ) {- this.requestSeek(state.startFrame);- }- // Otherwise pause at the end- if (!state.loop && state.finished && !state.paused) {- this.togglePlayback(false);- this.request();- return;- }-- this.updateState({- finished:- state.finished ||- this.project.frame >= Math.min(state.duration, state.endFrame),- });- this.frame.current = this.project.frame;-- this.request();- }-- private clampRange(frame: number, state: PlayerState): number {- const endFrame = Math.min(state.endFrame, state.duration);- return frame > endFrame- ? endFrame- : frame < state.startFrame- ? state.startFrame- : frame;- }-- private isInRange(frame: number, state: PlayerState): boolean {- return frame >= state.startFrame && frame <= state.endFrame;- }-- private request() {- this.requestId = requestAnimationFrame(async time => {- if (time - this.renderTime >= 1000 / (this.state.current.fps + 5)) {- this.renderTime = time;- try {- await this.run();- } catch (e: any) {- this.requestId = null;- this.logger.error(e);- }- } else {- this.request();- }- });- }-}diff --git a/packages/core/src/player/index.ts b/packages/core/src/player/index.tsdeleted file mode 100644index acb7e481..00000000--- a/packages/core/src/player/index.ts+++ /dev/null@@ -1,7 +0,0 @@-/**- * Playback control.- *- * @packageDocumentation- */--export * from './Player';diff --git a/packages/core/src/scenes/GeneratorScene.ts b/packages/core/src/scenes/GeneratorScene.tsindex 5cfe9685..fbe4e4ef 100644--- a/packages/core/src/scenes/GeneratorScene.ts+++ b/packages/core/src/scenes/GeneratorScene.ts@@ -5,18 +5,17 @@ import {ThreadGenerator,threads,} from '../threading';-import {Meta} from '../Meta';+import {Logger, PlaybackStatus} from '../app';import {TimeEvents} from './TimeEvents';import {Variables} from './Variables';import {EventDispatcher, ValueDispatcher} from '../events';-import {Project} from '../Project';import {decorate, threadable} from '../decorators';-import {endScene, setProject, startScene} from '../utils';+import {endPlayback, endScene, startPlayback, startScene} from '../utils';import {CachedSceneData,FullSceneDescription,Scene,- SceneMetadata,+ SceneDescriptionReload,SceneRenderEvent,} from './Scene';import {LifecycleEvents} from './LifecycleEvents';@@ -25,6 +24,7 @@ import {Rect, Vector2} from '../types';import {SceneState} from './SceneState';import {Random} from './Random';import {DependencyContext} from '../signals';+import {SceneMetadata} from './SceneMetadata';export interface ThreadGeneratorFactory<T> {(view: T): ThreadGenerator;@@ -39,8 +39,9 @@ export abstract class GeneratorScene<T>implements Scene<ThreadGeneratorFactory<T>>, Threadable{public readonly name: string;- public readonly project: Project;- public readonly meta: Meta<SceneMetadata>;+ public readonly playback: PlaybackStatus;+ public readonly logger: Logger;+ public readonly meta: SceneMetadata;public readonly timeEvents: TimeEvents;public readonly variables: Variables;public random: Random;@@ -103,12 +104,15 @@ export abstract class GeneratorScene<T>private state: SceneState = SceneState.Initial;private cached = false;private counters: Record<string, number> = {};+ private size: Vector2;public constructor(description: FullSceneDescription<ThreadGeneratorFactory<T>>,) {this.name = description.name;- this.project = description.project;+ this.size = description.size;+ this.logger = description.logger;+ this.playback = description.playback;this.meta = description.meta;this.runnerFactory = description.config;this.creationStack = description.stack;@@ -117,13 +121,7 @@ export abstract class GeneratorScene<T>this.timeEvents = new TimeEvents(this);this.variables = new Variables(this);- let seed = this.meta.getData().seed;- if (typeof seed !== 'number') {- seed = Random.createSeed();- this.meta.setDataSync({seed});- }-- this.random = new Random(seed);+ this.random = new Random(this.meta.seed.get());}public abstract getView(): T;@@ -158,27 +156,37 @@ export abstract class GeneratorScene<T>endScene(this);if (iterations > 1) {- this.project.logger.debug(`render iterations: ${iterations}`);+ this.logger.debug(`render iterations: ${iterations}`);}}protected abstract draw(context: CanvasRenderingContext2D): void;- public reload(runnerFactory?: ThreadGeneratorFactory<T>) {- if (runnerFactory) {- this.runnerFactory = runnerFactory;+ public reload({+ config,+ size,+ stack,+ }: SceneDescriptionReload<ThreadGeneratorFactory<T>> = {}) {+ if (config) {+ this.runnerFactory = config;+ }+ if (size) {+ this.size = size;+ }+ if (stack) {+ this.creationStack = stack;}this.cached = false;this.reloaded.dispatch();}- public async recalculate() {+ public async recalculate(setFrame: (frame: number) => void) {const cached = this.cache.current;- cached.firstFrame = this.project.frame;+ cached.firstFrame = this.playback.frame;cached.lastFrame = cached.firstFrame + cached.duration;if (this.isCached()) {- this.project.frame = cached.lastFrame;+ setFrame(cached.lastFrame);this.cache.current = {...cached};return;}@@ -190,9 +198,9 @@ export abstract class GeneratorScene<T>cached.transitionDuration < 0 &&this.state === SceneState.AfterTransitionIn) {- cached.transitionDuration = this.project.frame - cached.firstFrame;+ cached.transitionDuration = this.playback.frame - cached.firstFrame;}- this.project.frame++;+ setFrame(this.playback.frame + 1);await this.next();}@@ -200,7 +208,7 @@ export abstract class GeneratorScene<T>cached.transitionDuration = 0;}- cached.lastFrame = this.project.frame;+ cached.lastFrame = this.playback.frame;cached.duration = cached.lastFrame - cached.firstFrame;// Prevent the page from becoming unresponsive.await new Promise(resolve => setTimeout(resolve, 0));@@ -215,29 +223,35 @@ export abstract class GeneratorScene<T>}startScene(this);- setProject(this.project);- let result = this.runner.next();- this.update();- while (result.value) {- if (isPromisable(result.value)) {- result = this.runner.next(await result.value.toPromise());- } else if (isPromise(result.value)) {- result = this.runner.next(await result.value);- } else {- this.project.logger.warn({- message: 'Invalid value yielded by the scene.',- object: result.value,- });- result = this.runner.next(result.value);- }+ startPlayback(this.playback);+ let done = false;+ try {+ let result = this.runner.next();this.update();+ while (result.value) {+ if (isPromisable(result.value)) {+ result = this.runner.next(await result.value.toPromise());+ } else if (isPromise(result.value)) {+ result = this.runner.next(await result.value);+ } else {+ this.logger.warn({+ message: 'Invalid value yielded by the scene.',+ object: result.value,+ });+ result = this.runner.next(result.value);+ }+ this.update();+ }+ done = !!result.done;+ } finally {+ endPlayback(this.playback);+ endScene(this);}- endScene(this);const promises = DependencyContext.consumePromises();if (promises.length > 0) {await Promise.all(promises.map(handle => handle.promise));- this.project.logger.error({+ this.logger.error({message:'Tried to access an asynchronous property before the node was ready. ' +'Make sure to yield the node before accessing the property.',@@ -246,32 +260,34 @@ export abstract class GeneratorScene<T>});}- if (result.done) {+ if (done) {this.state = SceneState.Finished;}}public async reset(previousScene: Scene | null = null) {+ if (this.cache.current.firstFrame !== this.playback.frame) {+ this.cache.current = {+ ...this.cache.current,+ firstFrame: this.playback.frame,+ };+ }this.counters = {};this.previousScene = previousScene;- this.random = new Random(this.meta.getData().seed!);+ this.random = new Random(this.meta.seed.get());this.runner = threads(() => this.runnerFactory(this.getView()),thread => {this.thread.current = thread;},);- if (this.cache.current.transitionDuration === 0) {- this.state = SceneState.AfterTransitionIn;- } else {- this.state = SceneState.Initial;- }+ this.state = SceneState.AfterTransitionIn;this.afterReset.dispatch();await this.next();}public getSize(): Vector2 {- return this.project.getSize();+ return this.size;}public isAfterTransitionIn(): boolean {@@ -289,11 +305,21 @@ export abstract class GeneratorScene<T>return this.state === SceneState.Finished;}+ public enterInitial() {+ if (this.state === SceneState.AfterTransitionIn) {+ this.state = SceneState.Initial;+ } else {+ this.logger.warn(+ `Scene ${this.name} entered initial in an unexpected state: ${this.state}`,+ );+ }+ }+public enterAfterTransitionIn() {if (this.state === SceneState.Initial) {this.state = SceneState.AfterTransitionIn;} else {- this.project.logger.warn(+ this.logger.warn(`Scene ${this.name} transitioned in an unexpected state: ${this.state}`,);}@@ -306,7 +332,7 @@ export abstract class GeneratorScene<T>) {this.state = SceneState.CanTransitionOut;} else {- this.project.logger.warn(+ this.logger.warn(`Scene ${this.name} was marked as finished in an unexpected state: ${this.state}`,);}diff --git a/packages/core/src/scenes/Scene.ts b/packages/core/src/scenes/Scene.tsindex 7aef4499..c6e53e7e 100644--- a/packages/core/src/scenes/Scene.ts+++ b/packages/core/src/scenes/Scene.ts@@ -1,6 +1,5 @@-import type {Project} from '../Project';-import {Meta, Metadata} from '../Meta';-import {SavedTimeEvent, TimeEvents} from './TimeEvents';+import {Logger, PlaybackStatus} from '../app';+import {TimeEvents} from './TimeEvents';import {Variables} from './Variables';import {SubscribableEvent,@@ -10,11 +9,7 @@ import {import {Vector2} from '../types';import {LifecycleEvents} from './LifecycleEvents';import {Random} from './Random';--export interface SceneMetadata extends Metadata {- timeEvents: SavedTimeEvent[];- seed: number;-}+import {SceneMetadata} from './SceneMetadata';/*** The constructor used when creating new scenes.@@ -49,6 +44,7 @@ export interface SceneDescription<T = unknown> {* The stack trace at the moment of creation.*/stack?: string;+ meta: SceneMetadata;}/**@@ -58,11 +54,24 @@ export interface SceneDescription<T = unknown> {*/export interface FullSceneDescription<T = unknown> extends SceneDescription<T> {name: string;- meta: Meta<SceneMetadata>;- project: Project;+ size: Vector2;+ variables: Variables;+ playback: PlaybackStatus;+ logger: Logger;onReplaced: ValueDispatcher<FullSceneDescription<T>>;}+/**+ * A part of the {@link SceneDescription} that can be updated during reload.+ *+ * @typeParam T - The type of the configuration object.+ */+export interface SceneDescriptionReload<T = unknown> {+ size?: Vector2;+ config?: T;+ stack?: string;+}+export type DescriptionOf<TScene> = TScene extends Scene<infer TConfig>? SceneDescription<TConfig>: never;@@ -121,11 +130,12 @@ export interface Scene<T = unknown> {/*** Reference to the project.*/- readonly project: Project;+ readonly playback: PlaybackStatus;readonly timeEvents: TimeEvents;+ readonly logger: Logger;readonly variables: Variables;readonly random: Random;- readonly meta: Meta<SceneMetadata>;+ readonly meta: SceneMetadata;creationStack?: string;/**@@ -201,9 +211,9 @@ export interface Scene<T = unknown> {** Should trigger {@link onReloaded}.*- * @param config - If present, a new configuration object.+ * @param description - If present, an updated version of the description.*/- reload(config?: T): void;+ reload(description?: SceneDescriptionReload<T>): void;/*** Recalculate the scene.@@ -218,7 +228,7 @@ export interface Scene<T = unknown> {** Should trigger {@link onRecalculated}.*/- recalculate(): Promise<void>;+ recalculate(setFrame: (frame: number) => void): Promise<void>;/*** Progress this scene one frame forward.@@ -254,6 +264,11 @@ export interface Scene<T = unknown> {*/isFinished(): boolean;+ /**+ * Enter the {@link SceneState.Initial} state.+ */+ enterInitial(): void;+/*** Enter the {@link SceneState.AfterTransitionIn} state.*/diff --git a/packages/core/src/scenes/SceneMetadata.ts b/packages/core/src/scenes/SceneMetadata.tsnew file mode 100644index 00000000..7a14bd73--- /dev/null+++ b/packages/core/src/scenes/SceneMetadata.ts@@ -0,0 +1,19 @@+import {MetaField, ObjectMetaField} from '../meta';+import {SavedTimeEvent} from './TimeEvents';+import {Random} from './Random';++/**+ * Create a runtime representation of the scene metadata.+ */+export function createSceneMetadata() {+ return new ObjectMetaField('scene', {+ version: new MetaField('version', 1),+ timeEvents: new MetaField<SavedTimeEvent[]>('time events', []),+ seed: new MetaField('seed', Random.createSeed()),+ });+}++/**+ * A runtime representation of the scene metadata.+ */+export type SceneMetadata = ReturnType<typeof createSceneMetadata>;diff --git a/packages/core/src/scenes/TimeEvents.ts b/packages/core/src/scenes/TimeEvents.tsindex c813854d..59a8be02 100644--- a/packages/core/src/scenes/TimeEvents.ts+++ b/packages/core/src/scenes/TimeEvents.ts@@ -1,4 +1,4 @@-import type {Scene, SceneMetadata} from './Scene';+import type {Scene} from './Scene';import {ValueDispatcher} from '../events';/**@@ -58,18 +58,18 @@ export class TimeEvents {private registeredEvents: Record<string, TimeEvent> = {};private lookup: Record<string, TimeEvent> = {};private collisionLookup = new Set<string>();- private previousReference: SavedTimeEvent[] | undefined = [];+ private previousReference: SavedTimeEvent[] = [];private didEventsChange = false;private preserveTiming = true;public constructor(private readonly scene: Scene) {- this.previousReference = scene.meta.getData().timeEvents ?? [];+ this.previousReference = scene.meta.timeEvents.get();this.load(this.previousReference);scene.onReloaded.subscribe(this.handleReload);scene.onRecalculated.subscribe(this.handleRecalculated);scene.onReset.subscribe(this.handleReset);- scene.meta.onDataChanged.subscribe(this.handleMetaChanged, false);+ scene.meta.timeEvents.onChanged.subscribe(this.handleMetaChanged, false);}public get(name: string) {@@ -112,7 +112,7 @@ export class TimeEvents {*/public register(name: string): number {if (this.collisionLookup.has(name)) {- this.scene.project.logger.error({+ this.scene.logger.error({message: `name "${name}" has already been used for another event name.`,stack: new Error().stack,});@@ -121,8 +121,8 @@ export class TimeEvents {this.collisionLookup.add(name);- const initialTime = this.scene.project.framesToSeconds(- this.scene.project.frame - this.scene.firstFrame,+ const initialTime = this.scene.playback.framesToSeconds(+ this.scene.playback.frame - this.scene.firstFrame,);if (!this.lookup[name]) {this.didEventsChange = true;@@ -170,7 +170,7 @@ export class TimeEvents {return (this.scene.firstFrame +- this.scene.project.secondsToFrames(this.lookup[name].targetTime)+ this.scene.playback.secondsToFrames(this.lookup[name].targetTime));}@@ -200,9 +200,7 @@ export class TimeEvents {targetTime: event.targetTime,}),);- this.scene.meta.setDataSync({- timeEvents: this.previousReference,- });+ this.scene.meta.timeEvents.set(this.previousReference);}};@@ -213,13 +211,13 @@ export class TimeEvents {/*** Called when the meta of the parent scene changes.*/- private handleMetaChanged = (data: SceneMetadata) => {+ private handleMetaChanged = (data: SavedTimeEvent[]) => {// Ignore the event if `timeEvents` hasn't changed.// This may happen when another part of metadata has changed triggering// this event.- if (data.timeEvents === this.previousReference) return;- this.previousReference = data.timeEvents;- this.load(data.timeEvents ?? []);+ if (data === this.previousReference) return;+ this.previousReference = data;+ this.load(data);this.scene.reload();};diff --git a/packages/core/src/scenes/Variables.ts b/packages/core/src/scenes/Variables.tsindex 63e319c8..c1c48c1c 100644--- a/packages/core/src/scenes/Variables.ts+++ b/packages/core/src/scenes/Variables.ts@@ -3,6 +3,7 @@ import {createSignal, SimpleSignal} from '../signals';export class Variables {private signals: {[key: string]: SimpleSignal<any>} = {};+ private variables: Record<string, unknown> = {};public constructor(private readonly scene: Scene) {scene.onReset.subscribe(this.handleReset);@@ -12,33 +13,25 @@ export class Variables {* Get variable signal if exists or create signal if not** @param name - The name of the variable.+ * @param initial - The initial value of the variable. It will be used if the+ * variable was not configured from the outside.*/- public get<T>(name: string, initial: T): SimpleSignal<T> {- const variables = this.scene.project.getVariables();- if (!(name in variables)) {- this.scene.project.logger.warn(- `Variable ${name} has not been set in project ${this.scene.project.name}`,- );- this.signals[name] = createSignal(initial);- }- if (!(name in this.signals)) {- this.signals[name] = createSignal(variables[name]);- }-- return this.signals[name];+ public get<T>(name: string, initial: T): () => T {+ this.signals[name] ??= createSignal(this.variables[name] ?? initial);+ return () => this.signals[name]();}/*** Update all signals with new project variable values.*/- public updateSignals = () => {- const variables = this.scene.project.getVariables();+ public updateSignals(variables: Record<string, unknown>) {+ this.variables = variables;Object.keys(variables).map(variableName => {if (variableName in this.signals) {this.signals[variableName](variables[variableName]);}});- };+ }/*** Reset all stored signals.diff --git a/packages/core/src/scenes/index.ts b/packages/core/src/scenes/index.tsindex d138e8b3..452948d1 100644--- a/packages/core/src/scenes/index.ts+++ b/packages/core/src/scenes/index.ts@@ -8,6 +8,7 @@ export * from './GeneratorScene';export * from './Inspectable';export * from './Random';export * from './Scene';+export * from './SceneMetadata';export * from './SceneState';export * from './Threadable';export * from './TimeEvents';diff --git a/packages/core/src/signals/DependencyContext.ts b/packages/core/src/signals/DependencyContext.tsindex 3d1db981..be184347 100644--- a/packages/core/src/signals/DependencyContext.ts+++ b/packages/core/src/signals/DependencyContext.ts@@ -107,6 +107,7 @@ export class DependencyContext<TOwner = void>public dispose() {this.clearDependencies();+ this.event.clear();this.owner = null as TOwner;}diff --git a/packages/core/src/threading/Thread.ts b/packages/core/src/threading/Thread.tsindex 5456fbd1..2ea0ead4 100644--- a/packages/core/src/threading/Thread.ts+++ b/packages/core/src/threading/Thread.ts@@ -1,5 +1,5 @@import {ThreadGenerator} from './ThreadGenerator';-import {endThread, startThread, useProject} from '../utils';+import {endThread, startThread, usePlayback} from '../utils';import {createSignal} from '../signals';import {setTaskName} from './names';@@ -45,9 +45,9 @@ export class Thread {*/public readonly runner: ThreadGenerator,) {- const project = useProject();- this.frameDuration = project.framesToSeconds(1);- this.time(project.time);+ const playback = usePlayback();+ this.frameDuration = playback.framesToSeconds(1);+ this.time(playback.time);}/**@@ -65,7 +65,8 @@ export class Thread {* Prepare the thread for the next update cycle.*/public update() {- this.time(this.time() + useProject().framesToSeconds(1));+ const playback = usePlayback();+ this.time(this.time() + playback.framesToSeconds(1) * playback.speed);this.children = this.children.filter(child => !child.canceled);}diff --git a/packages/core/src/threading/cancel.test.ts b/packages/core/src/threading/cancel.test.tsindex 8b7f6616..3cc2e5d2 100644--- a/packages/core/src/threading/cancel.test.ts+++ b/packages/core/src/threading/cancel.test.ts@@ -1,22 +1,21 @@/* eslint-disable @typescript-eslint/no-unused-vars */-import {describe, test, beforeEach, expect} from 'vitest';-import {Project} from '../Project';-import {setProject, useProject, useTime} from '../utils';+import {describe, test, expect, beforeAll, afterAll} from 'vitest';+import {PlaybackManager, PlaybackStatus} from '../app';+import {endPlayback, startPlayback, useTime} from '../utils';import {waitFor} from '../flow';import {threads} from './threads';import {join} from './join';import {cancel} from './cancel';describe('cancel()', () => {- beforeEach(() => {- setProject(new Project({name: 'tests', scenes: []}));- });+ const playback = new PlaybackManager();+ const status = new PlaybackStatus(playback);+ beforeAll(() => startPlayback(status));+ afterAll(() => endPlayback(status));test('Elapsed time when canceling a thread', () => {- const project = useProject();-- let time: number;+ let time = NaN;const task = threads(function* () {const waitTask = yield waitFor(2);cancel(waitTask);@@ -24,10 +23,10 @@ describe('cancel()', () => {time = useTime();});- project.framerate = 10;- project.frame = 0;+ playback.fps = 10;+ playback.frame = 0;for (const _ of task) {- project.frame++;+ playback.frame++;}expect(time).toBeCloseTo(0);diff --git a/packages/core/src/threading/join.test.ts b/packages/core/src/threading/join.test.tsindex e0cb4e64..7f688695 100644--- a/packages/core/src/threading/join.test.ts+++ b/packages/core/src/threading/join.test.ts@@ -1,21 +1,20 @@/* eslint-disable @typescript-eslint/no-unused-vars */-import {describe, test, beforeEach, expect} from 'vitest';-import {Project} from '../Project';-import {setProject, useProject, useTime} from '../utils';+import {describe, test, expect, beforeAll, afterAll} from 'vitest';+import {endPlayback, startPlayback, useTime} from '../utils';import {waitFor} from '../flow';import {threads} from './threads';import {join} from './join';+import {PlaybackManager, PlaybackStatus} from '../app';describe('join()', () => {- beforeEach(() => {- setProject(new Project({name: 'tests', scenes: []}));- });+ const playback = new PlaybackManager();+ const status = new PlaybackStatus(playback);+ beforeAll(() => startPlayback(status));+ afterAll(() => endPlayback(status));test('Elapsed time when joining all threads', () => {- const project = useProject();-- let time: number;+ let time = NaN;const task = threads(function* () {const taskA = yield waitFor(0.15);const taskB = yield waitFor(0.17);@@ -23,19 +22,17 @@ describe('join()', () => {time = useTime();});- project.framerate = 10;- project.frame = 0;+ playback.fps = 10;+ playback.frame = 0;for (const _ of task) {- project.frame++;+ playback.frame++;}expect(time).toBeCloseTo(0.17);});test('Elapsed time when joining any thread', () => {- const project = useProject();-- let time: number;+ let time = NaN;const task = threads(function* () {const taskA = yield waitFor(0.15);const taskB = yield waitFor(0.17);@@ -43,19 +40,17 @@ describe('join()', () => {time = useTime();});- project.framerate = 10;- project.frame = 0;+ playback.fps = 10;+ playback.frame = 0;for (const _ of task) {- project.frame++;+ playback.frame++;}expect(time).toBeCloseTo(0.15);});test('Elapsed time when joining an already canceled thread', () => {- const project = useProject();-- let time: number;+ let time = NaN;const task = threads(function* () {const waitTask = yield waitFor(0.15);yield* waitFor(0.2);@@ -63,29 +58,27 @@ describe('join()', () => {time = useTime();});- project.framerate = 10;- project.frame = 0;+ playback.fps = 10;+ playback.frame = 0;for (const _ of task) {- project.frame++;+ playback.frame++;}expect(time).toBeCloseTo(0.2);});test('Elapsed time when joining a thread right after cancellation', () => {- const project = useProject();-- let time: number;+ let time = NaN;const task = threads(function* () {const waitTask = yield waitFor(0.05);yield* join(waitTask);time = useTime();});- project.framerate = 10;- project.frame = 0;+ playback.fps = 10;+ playback.frame = 0;for (const _ of task) {- project.frame++;+ playback.frame++;}expect(time).toBeCloseTo(0.05);diff --git a/packages/core/src/threading/threads.test.ts b/packages/core/src/threading/threads.test.tsindex 381a6c6d..35dee719 100644--- a/packages/core/src/threading/threads.test.ts+++ b/packages/core/src/threading/threads.test.ts@@ -1,13 +1,13 @@-import {describe, test, beforeEach, expect} from 'vitest';+import {describe, test, expect, beforeAll, afterAll} from 'vitest';import {threads} from './threads';import {noop, run} from '../flow';-import {setProject} from '../utils';-import {Project} from '../Project';+import {endPlayback, startPlayback} from '../utils';+import {PlaybackManager, PlaybackStatus} from '../app';describe('threads()', () => {- beforeEach(() => {- setProject(new Project({name: 'tests', scenes: []}));- });+ const status = new PlaybackStatus(new PlaybackManager());+ beforeAll(() => startPlayback(status));+ afterAll(() => endPlayback(status));test('Execution order', () => {const order: number[] = [];diff --git a/packages/core/src/transitions/useTransition.ts b/packages/core/src/transitions/useTransition.tsindex 0d541e76..3d770ff3 100644--- a/packages/core/src/transitions/useTransition.ts+++ b/packages/core/src/transitions/useTransition.ts@@ -22,6 +22,8 @@ export function useTransition(const unsubPrev = prior?.LifecycleEvents.onBeforeRender.subscribe(previous);const unsubNext = scene.LifecycleEvents.onBeforeRender.subscribe(current);+ scene.enterInitial();+return () => {scene.enterAfterTransitionIn();unsubPrev?.();diff --git a/packages/core/src/tweening/spring.test.ts b/packages/core/src/tweening/spring.test.tsindex acb4b89d..86300b58 100644--- a/packages/core/src/tweening/spring.test.ts+++ b/packages/core/src/tweening/spring.test.ts@@ -1,19 +1,18 @@/* eslint-disable @typescript-eslint/no-unused-vars */-import {describe, test, beforeEach, expect} from 'vitest';-import {Project} from '../Project';-import {setProject, useProject, useTime} from '../utils';+import {describe, test, expect, beforeAll, afterAll} from 'vitest';+import {endPlayback, startPlayback, useTime} from '../utils';import {threads} from '../threading';-import {spring, Spring} from './spring';+import {spring} from './spring';+import {PlaybackManager, PlaybackStatus} from '../app';describe('spring()', () => {- beforeEach(() => {- setProject(new Project({name: 'tests', scenes: []}));- });+ const playback = new PlaybackManager();+ const status = new PlaybackStatus(playback);+ beforeAll(() => startPlayback(status));+ afterAll(() => endPlayback(status));test('Framerate-independent spring duration', () => {- const project = useProject();-let timeA;// should be around 1.13333333 secondsconst taskA = threads(function* () {@@ -66,22 +65,22 @@ describe('spring()', () => {timeC = useTime();});- project.framerate = 60;- project.frame = 0;+ playback.fps = 60;+ playback.frame = 0;for (const _ of taskA) {- project.frame++;+ playback.frame++;}- project.framerate = 24;- project.frame = 0;+ playback.fps = 24;+ playback.frame = 0;for (const _ of taskB) {- project.frame++;+ playback.frame++;}- project.framerate = 120;- project.frame = 0;+ playback.fps = 120;+ playback.frame = 0;for (const _ of taskC) {- project.frame++;+ playback.frame++;}expect(timeA).toBeCloseTo(1.5, 0);@@ -90,8 +89,6 @@ describe('spring()', () => {});test('Accumulated time offset', () => {- const project = useProject();-let time;const task = threads(function* () {yield* spring(@@ -109,13 +106,13 @@ describe('spring()', () => {time = useTime();});- project.framerate = 10;- project.frame = 0;+ playback.fps = 10;+ playback.frame = 0;for (const _ of task) {- project.frame++;+ playback.frame++;}- expect(project.frame).toBe(18);+ expect(playback.frame).toBe(18);expect(time).toBeCloseTo(1.5, 0);});});diff --git a/packages/core/src/tweening/spring.ts b/packages/core/src/tweening/spring.tsindex 3cc220dd..952ac33a 100644--- a/packages/core/src/tweening/spring.ts+++ b/packages/core/src/tweening/spring.ts@@ -1,6 +1,6 @@import {decorate, threadable} from '../decorators';import {ThreadGenerator} from '../threading';-import {useProject, useThread, useLogger} from '../utils';+import {usePlayback, useThread, useLogger} from '../utils';type ProgressFunction = (value: number, time: number) => void;@@ -69,7 +69,7 @@ export function* spring(return;}- const project = useProject();+ const project = usePlayback();const thread = useThread();let position = from;diff --git a/packages/core/src/tweening/tween.test.ts b/packages/core/src/tweening/tween.test.tsindex ab3fff40..afb8949a 100644--- a/packages/core/src/tweening/tween.test.ts+++ b/packages/core/src/tweening/tween.test.ts@@ -1,20 +1,19 @@/* eslint-disable @typescript-eslint/no-unused-vars */-import {describe, test, beforeEach, expect} from 'vitest';-import {Project} from '../Project';-import {setProject, useProject, useTime} from '../utils';+import {describe, test, expect, beforeAll, afterAll} from 'vitest';+import {endPlayback, startPlayback, useTime} from '../utils';import {threads} from '../threading';import {tween} from './tween';+import {PlaybackManager, PlaybackStatus} from '../app';describe('tween()', () => {- beforeEach(() => {- setProject(new Project({name: 'tests', scenes: []}));- });+ const playback = new PlaybackManager();+ const status = new PlaybackStatus(playback);+ beforeAll(() => startPlayback(status));+ afterAll(() => endPlayback(status));test('Framerate-independent tween duration', () => {- const project = useProject();-- let time60;+ let time60 = NaN;const task60 = threads(function* () {yield* tween(3.1415, () => {// do nothing@@ -22,7 +21,7 @@ describe('tween()', () => {time60 = useTime();});- let time24;+ let time24 = NaN;const task24 = threads(function* () {yield* tween(3.1415, () => {// do nothing@@ -30,16 +29,16 @@ describe('tween()', () => {time24 = useTime();});- project.framerate = 60;- project.frame = 0;+ playback.fps = 60;+ playback.frame = 0;for (const _ of task60) {- project.frame++;+ playback.frame++;}- project.framerate = 24;- project.frame = 0;+ playback.fps = 24;+ playback.frame = 0;for (const _ of task24) {- project.frame++;+ playback.frame++;}expect(time60).toBeCloseTo(3.1415);@@ -47,9 +46,7 @@ describe('tween()', () => {});test('Accumulated time offset', () => {- const project = useProject();-- let time: number;+ let time = NaN;const task = threads(function* () {yield* tween(0.45, () => {// do nothing@@ -57,13 +54,13 @@ describe('tween()', () => {time = useTime();});- project.framerate = 10;- project.frame = 0;+ playback.fps = 10;+ playback.frame = 0;for (const _ of task) {- project.frame++;+ playback.frame++;}- expect(project.frame).toBe(5);+ expect(playback.frame).toBe(5);expect(time).toBeCloseTo(0.45);});});diff --git a/packages/core/src/tweening/tween.ts b/packages/core/src/tweening/tween.tsindex bd60acac..d532800e 100644--- a/packages/core/src/tweening/tween.ts+++ b/packages/core/src/tweening/tween.ts@@ -1,6 +1,6 @@import {decorate, threadable} from '../decorators';import {ThreadGenerator} from '../threading';-import {useProject, useThread} from '../utils';+import {usePlayback, useThread} from '../utils';decorate(tween, threadable());export function* tween(@@ -8,7 +8,7 @@ export function* tween(onProgress: (value: number, time: number) => void,onEnd?: (value: number, time: number) => void,): ThreadGenerator {- const project = useProject();+ const project = usePlayback();const thread = useThread();const startTime = thread.time();diff --git a/packages/core/src/types/Vector.ts b/packages/core/src/types/Vector.tsindex e7e6ab7d..fc385240 100644--- a/packages/core/src/types/Vector.ts+++ b/packages/core/src/types/Vector.ts@@ -264,4 +264,8 @@ export class Vector2 implements Type {public serialize(): SerializedVector2 {return {x: this.x, y: this.y};}++ public exactlyEquals(other: Vector2): boolean {+ return this.y === other.y && this.x === other.y;+ }}diff --git a/packages/core/src/utils/Semaphore.ts b/packages/core/src/utils/Semaphore.tsnew file mode 100644index 00000000..6251ecd0--- /dev/null+++ b/packages/core/src/utils/Semaphore.ts@@ -0,0 +1,24 @@+/**+ * A simple semaphore implementation with a capacity of 1.+ *+ * @internal+ */+export class Semaphore {+ private resolveCurrent: (() => void) | null = null;+ private current: Promise<void> | null = null;++ public async acquire() {+ while (this.current) {+ await this.current;+ }+ this.current = new Promise(resolve => {+ this.resolveCurrent = resolve;+ });+ }++ public release() {+ this.current = null;+ this.resolveCurrent?.();+ this.resolveCurrent = null;+ }+}diff --git a/packages/core/src/utils/debug.test.ts b/packages/core/src/utils/debug.test.tsindex 4a4d4f56..673fea71 100644--- a/packages/core/src/utils/debug.test.ts+++ b/packages/core/src/utils/debug.test.ts@@ -1,12 +1,12 @@import {describe, test, beforeEach, expect, vi} from 'vitest';-import {setProject, useLogger, debug} from '../utils';-import {Project} from '../Project';-import {LogLevel} from '../Logger';+import {useLogger, debug, startScene} from '../utils';import {Rect, Vector2} from '../types';+import {Logger, LogLevel} from '../app';+import {Scene} from '../scenes';describe('debug()', () => {beforeEach(() => {- setProject(new Project({name: 'test', scenes: []}));+ startScene({logger: new Logger()} as Scene);});test.each([@@ -38,7 +38,7 @@ describe('debug()', () => {['Empty Objects', {}, {message: '{}', object: {}}],])('log: %s', (_, payload, expected) => {const spy = vi.fn();- useLogger().onLogged.subscribe(spy);+ (useLogger() as Logger).onLogged.subscribe(spy);debug(payload);diff --git a/packages/core/src/utils/debug.ts b/packages/core/src/utils/debug.tsindex 18f9b5af..b3b22720 100644--- a/packages/core/src/utils/debug.ts+++ b/packages/core/src/utils/debug.ts@@ -1,5 +1,5 @@-import {useLogger} from '.';-import {LogPayload} from '../Logger';+import {useLogger} from './useScene';+import {LogPayload} from '../app';function stringify(value: any): string {switch (typeof value) {diff --git a/packages/core/src/utils/deprecate.ts b/packages/core/src/utils/deprecate.tsindex 8052548a..672256f9 100644--- a/packages/core/src/utils/deprecate.ts+++ b/packages/core/src/utils/deprecate.ts@@ -1,4 +1,4 @@-import {useLogger} from './useProject';+import {useLogger} from './useScene';/*** Mark the given function as deprecated.diff --git a/packages/core/src/utils/errorToLog.ts b/packages/core/src/utils/errorToLog.tsindex 7e6c7898..3e497509 100644--- a/packages/core/src/utils/errorToLog.ts+++ b/packages/core/src/utils/errorToLog.ts@@ -1,4 +1,4 @@-import {LogPayload} from '../Logger';+import type {LogPayload} from '../app';export function errorToLog(error: any): LogPayload {return {diff --git a/packages/core/src/utils/getContext.ts b/packages/core/src/utils/getContext.tsindex c78152f8..f093ae6d 100644--- a/packages/core/src/utils/getContext.ts+++ b/packages/core/src/utils/getContext.ts@@ -1,7 +1,8 @@export function getContext(- canvas: HTMLCanvasElement,+ options?: CanvasRenderingContext2DSettings,+ canvas: HTMLCanvasElement = document.createElement('canvas'),): CanvasRenderingContext2D {- const context = canvas.getContext('2d');+ const context = canvas.getContext('2d', options);if (!context) {throw new Error('Could not create a 2D context.');}diff --git a/packages/core/src/utils/index.ts b/packages/core/src/utils/index.tsindex c016688a..44d1bbdc 100644--- a/packages/core/src/utils/index.ts+++ b/packages/core/src/utils/index.ts@@ -11,7 +11,8 @@ export * from './DetailedError';export * from './errorToLog';export * from './getContext';export * from './range';-export * from './useProject';+export * from './Semaphore';+export * from './usePlayback';export * from './useRandom';export * from './createRef';export * from './useScene';diff --git a/packages/core/src/utils/proxyUtils.ts b/packages/core/src/utils/proxyUtils.tsindex 35239de2..9907c20b 100644--- a/packages/core/src/utils/proxyUtils.ts+++ b/packages/core/src/utils/proxyUtils.ts@@ -5,7 +5,7 @@* the Proxy instead.*/-import {useLogger} from './useProject';+import {useLogger} from './useScene';/*** Route the given url through a local proxy.diff --git a/packages/core/src/utils/usePlayback.ts b/packages/core/src/utils/usePlayback.tsnew file mode 100644index 00000000..64f2630c--- /dev/null+++ b/packages/core/src/utils/usePlayback.ts@@ -0,0 +1,24 @@+import {PlaybackStatus} from '../app';++const playbackStack: PlaybackStatus[] = [];++/**+ * Get a reference to the playback status.+ */+export function usePlayback() {+ const playback = playbackStack.at(-1);+ if (!playback) {+ throw new Error('The playback is not available in the current context.');+ }+ return playback;+}++export function startPlayback(playback: PlaybackStatus) {+ playbackStack.push(playback);+}++export function endPlayback(playback: PlaybackStatus) {+ if (playbackStack.pop() !== playback) {+ throw new Error('startPlayback/endPlayback were called out of order.');+ }+}diff --git a/packages/core/src/utils/useProject.ts b/packages/core/src/utils/useProject.tsdeleted file mode 100644index 81d7a2a9..00000000--- a/packages/core/src/utils/useProject.ts+++ /dev/null@@ -1,18 +0,0 @@-import type {Project} from '../Project';--let currentProject: Project;--/**- * Get a reference to the current project.- */-export function useProject() {- return currentProject;-}--export function useLogger() {- return currentProject?.logger ?? console;-}--export function setProject(project: Project) {- currentProject = project;-}diff --git a/packages/core/src/utils/useRandom.ts b/packages/core/src/utils/useRandom.tsindex 4da56306..8a8d7bd8 100644--- a/packages/core/src/utils/useRandom.ts+++ b/packages/core/src/utils/useRandom.ts@@ -15,6 +15,6 @@ export function useRandom(): Random;export function useRandom(seed: number, fixed?: boolean): Random;export function useRandom(seed?: number, fixed = true): Random {return typeof seed === 'number'- ? new Random(fixed ? seed : seed + useScene().meta.getData().seed)+ ? new Random(fixed ? seed : seed + useScene().meta.seed.get()): useScene().random;}diff --git a/packages/core/src/utils/useScene.ts b/packages/core/src/utils/useScene.tsindex e441dd15..4e97e55e 100644--- a/packages/core/src/utils/useScene.ts+++ b/packages/core/src/utils/useScene.ts@@ -19,10 +19,14 @@ export function startScene(scene: Scene) {export function endScene(scene: Scene) {if (sceneStack.pop() !== scene) {- throw new Error('startScene/endScene was called out of order.');+ throw new Error('startScene/endScene were called out of order.');}}+export function useLogger() {+ return sceneStack.at(-1)?.logger ?? console;+}+/*** Mark the current scene as ready to transition out.*diff --git a/packages/core/src/vite-env.d.ts b/packages/core/src/vite-env.d.tsindex c776d726..fb307abd 100644--- a/packages/core/src/vite-env.d.ts+++ b/packages/core/src/vite-env.d.ts@@ -4,7 +4,7 @@ import 'vite/types/customEvent';declare module 'vite/types/customEvent' {interface CustomEventMap {- 'motion-canvas:meta': {source: string; data: import('./Meta').Metadata};+ 'motion-canvas:meta': {source: string; data: any};'motion-canvas:meta-ack': {source: string};'motion-canvas:export': {frame: number;diff --git a/packages/examples/src/code-block.meta b/packages/examples/src/code-block.metaindex 5dfe44db..af6756e0 100644--- a/packages/examples/src/code-block.meta+++ b/packages/examples/src/code-block.meta@@ -1,3 +1,26 @@{- "version": 0-}+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }+}\ No newline at end of filediff --git a/packages/examples/src/components.meta b/packages/examples/src/components.metaindex 0e33e3fe..8fe8c9c9 100644--- a/packages/examples/src/components.meta+++ b/packages/examples/src/components.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 960,+ "y": 540+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/components.ts b/packages/examples/src/components.tsindex 8d47a987..24a5b1c7 100644--- a/packages/examples/src/components.ts+++ b/packages/examples/src/components.ts@@ -1,9 +1,7 @@import {makeProject} from '@motion-canvas/core';import scene from './scenes/components?scene';-import {Vector2} from '@motion-canvas/core/lib/types';export default makeProject({scenes: [scene],- size: new Vector2(960, 540),});diff --git a/packages/examples/src/layout-group.meta b/packages/examples/src/layout-group.metaindex 0e33e3fe..af6756e0 100644--- a/packages/examples/src/layout-group.meta+++ b/packages/examples/src/layout-group.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/layout.meta b/packages/examples/src/layout.metaindex 0e33e3fe..27044d5e 100644--- a/packages/examples/src/layout.meta+++ b/packages/examples/src/layout.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": "rgb(36,36,36)",+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 960,+ "y": 540+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/layout.ts b/packages/examples/src/layout.tsindex fa0335bd..ce7bf7e4 100644--- a/packages/examples/src/layout.ts+++ b/packages/examples/src/layout.ts@@ -1,10 +1,7 @@-import {Project} from '@motion-canvas/core/lib';+import {makeProject} from '@motion-canvas/core';import layout from './scenes/layout?scene';-import {Vector2} from '@motion-canvas/core/lib/types';-export default new Project({+export default makeProject({scenes: [layout],- size: new Vector2(960, 540),- background: '#141414',});diff --git a/packages/examples/src/logging.meta b/packages/examples/src/logging.metaindex 0e33e3fe..af6756e0 100644--- a/packages/examples/src/logging.meta+++ b/packages/examples/src/logging.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/media-image.meta b/packages/examples/src/media-image.metaindex 0e33e3fe..af6756e0 100644--- a/packages/examples/src/media-image.meta+++ b/packages/examples/src/media-image.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/media-video.meta b/packages/examples/src/media-video.metaindex 0e33e3fe..d41358b6 100644--- a/packages/examples/src/media-video.meta+++ b/packages/examples/src/media-video.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": "rgb(36,36,36)",+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/node-signal.meta b/packages/examples/src/node-signal.metaindex 0e33e3fe..af6756e0 100644--- a/packages/examples/src/node-signal.meta+++ b/packages/examples/src/node-signal.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/positioning.meta b/packages/examples/src/positioning.metaindex 0e33e3fe..3b168145 100644--- a/packages/examples/src/positioning.meta+++ b/packages/examples/src/positioning.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": "rgb(20,20,20)",+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 960,+ "y": 540+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/positioning.ts b/packages/examples/src/positioning.tsindex d16d0081..15267c63 100644--- a/packages/examples/src/positioning.ts+++ b/packages/examples/src/positioning.ts@@ -1,10 +1,7 @@-import {Project} from '@motion-canvas/core/lib';+import {makeProject} from '@motion-canvas/core';import node from './scenes/positioning?scene';-import {Vector2} from '@motion-canvas/core/lib/types';-export default new Project({+export default makeProject({scenes: [node],- size: new Vector2(960, 540),- background: '#141414',});diff --git a/packages/examples/src/quickstart.meta b/packages/examples/src/quickstart.metaindex 0e33e3fe..af6756e0 100644--- a/packages/examples/src/quickstart.meta+++ b/packages/examples/src/quickstart.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/random.meta b/packages/examples/src/random.metaindex 0e33e3fe..8fe8c9c9 100644--- a/packages/examples/src/random.meta+++ b/packages/examples/src/random.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 960,+ "y": 540+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/random.ts b/packages/examples/src/random.tsindex b8dc0427..a2a3eb44 100644--- a/packages/examples/src/random.ts+++ b/packages/examples/src/random.ts@@ -1,9 +1,7 @@import {makeProject} from '@motion-canvas/core';import scene from './scenes/random?scene';-import {Vector2} from '@motion-canvas/core/lib/types';export default makeProject({scenes: [scene],- size: new Vector2(960, 540),});diff --git a/packages/examples/src/scenes/code-block.meta b/packages/examples/src/scenes/code-block.metaindex 61a2092b..26889c72 100644--- a/packages/examples/src/scenes/code-block.meta+++ b/packages/examples/src/scenes/code-block.meta@@ -1,3 +1,5 @@{- "version": 1-}+ "version": 1,+ "timeEvents": [],+ "seed": 4275731031+}\ No newline at end of filediff --git a/packages/examples/src/scenes/components.meta b/packages/examples/src/scenes/components.metaindex 0e33e3fe..fa9bf279 100644--- a/packages/examples/src/scenes/components.meta+++ b/packages/examples/src/scenes/components.meta@@ -1,3 +1,5 @@{- "version": 0+ "version": 0,+ "timeEvents": [],+ "seed": 1216764715}\ No newline at end of filediff --git a/packages/examples/src/scenes/layout-group.meta b/packages/examples/src/scenes/layout-group.metaindex 44ec0647..3cd16b9d 100644--- a/packages/examples/src/scenes/layout-group.meta+++ b/packages/examples/src/scenes/layout-group.meta@@ -1,4 +1,5 @@{"version": 1,+ "timeEvents": [],"seed": 2413678884}\ No newline at end of filediff --git a/packages/examples/src/scenes/layout.meta b/packages/examples/src/scenes/layout.metaindex c9164b55..822e230f 100644--- a/packages/examples/src/scenes/layout.meta+++ b/packages/examples/src/scenes/layout.meta@@ -1,4 +1,5 @@{"version": 1,+ "timeEvents": [],"seed": 2835047788}\ No newline at end of filediff --git a/packages/examples/src/scenes/logging.meta b/packages/examples/src/scenes/logging.metaindex b1593984..c4d94cd8 100644--- a/packages/examples/src/scenes/logging.meta+++ b/packages/examples/src/scenes/logging.meta@@ -1,6 +1,5 @@{"version": 1,- "seed": 1707918003,"timeEvents": [{"name": "basic logging",@@ -14,5 +13,6 @@"name": "profiling","targetTime": 2.985234375}- ]+ ],+ "seed": 1707918003}\ No newline at end of filediff --git a/packages/examples/src/scenes/media-image.meta b/packages/examples/src/scenes/media-image.metaindex 857af9b8..61408465 100644--- a/packages/examples/src/scenes/media-image.meta+++ b/packages/examples/src/scenes/media-image.meta@@ -1,4 +1,5 @@{"version": 1,+ "timeEvents": [],"seed": 3374664546}\ No newline at end of filediff --git a/packages/examples/src/scenes/media-image.tsx b/packages/examples/src/scenes/media-image.tsxindex 0cf1c6b0..14b42698 100644--- a/packages/examples/src/scenes/media-image.tsx+++ b/packages/examples/src/scenes/media-image.tsx@@ -8,7 +8,7 @@ import logoSvg from '@motion-canvas/examples/assets/logo.svg';export default makeScene2D(function* (view) {const imageRef = createRef<Image>();- view.add(<Image ref={imageRef} src={logoSvg} scale={2} />);+ yield view.add(<Image ref={imageRef} src={logoSvg} scale={2} />);yield* all(imageRef().scale(2.5, 1.5).to(2, 1.5),diff --git a/packages/examples/src/scenes/media-video.meta b/packages/examples/src/scenes/media-video.metaindex 857af9b8..61408465 100644--- a/packages/examples/src/scenes/media-video.meta+++ b/packages/examples/src/scenes/media-video.meta@@ -1,4 +1,5 @@{"version": 1,+ "timeEvents": [],"seed": 3374664546}\ No newline at end of filediff --git a/packages/examples/src/scenes/node-signal.meta b/packages/examples/src/scenes/node-signal.metaindex 14f24862..f5d46f28 100644--- a/packages/examples/src/scenes/node-signal.meta+++ b/packages/examples/src/scenes/node-signal.meta@@ -1,4 +1,5 @@{"version": 1,+ "timeEvents": [],"seed": 1826074633}\ No newline at end of filediff --git a/packages/examples/src/scenes/positioning.meta b/packages/examples/src/scenes/positioning.metaindex 0972fdbb..93b4ad33 100644--- a/packages/examples/src/scenes/positioning.meta+++ b/packages/examples/src/scenes/positioning.meta@@ -1,4 +1,5 @@{"version": 1,+ "timeEvents": [],"seed": 3423079105}\ No newline at end of filediff --git a/packages/examples/src/scenes/quickstart.meta b/packages/examples/src/scenes/quickstart.metaindex 2faa114b..92b47b37 100644--- a/packages/examples/src/scenes/quickstart.meta+++ b/packages/examples/src/scenes/quickstart.meta@@ -1,4 +1,5 @@{"version": 1,+ "timeEvents": [],"seed": 2953611296}\ No newline at end of filediff --git a/packages/examples/src/scenes/random.meta b/packages/examples/src/scenes/random.metaindex 98fdd4c6..183f0544 100644--- a/packages/examples/src/scenes/random.meta+++ b/packages/examples/src/scenes/random.meta@@ -1,4 +1,5 @@{"version": 1,+ "timeEvents": [],"seed": 1456280284}\ No newline at end of filediff --git a/packages/examples/src/scenes/tex.meta b/packages/examples/src/scenes/tex.metaindex 0e33e3fe..8ad2dda3 100644--- a/packages/examples/src/scenes/tex.meta+++ b/packages/examples/src/scenes/tex.meta@@ -1,3 +1,5 @@{- "version": 0+ "version": 0,+ "timeEvents": [],+ "seed": 422106947}\ No newline at end of filediff --git a/packages/examples/src/scenes/transitions-first.meta b/packages/examples/src/scenes/transitions-first.metaindex d9d4e789..9e95f2ff 100644--- a/packages/examples/src/scenes/transitions-first.meta+++ b/packages/examples/src/scenes/transitions-first.meta@@ -1,4 +1,5 @@{"version": 1,+ "timeEvents": [],"seed": 2868148813}\ No newline at end of filediff --git a/packages/examples/src/scenes/transitions-second.meta b/packages/examples/src/scenes/transitions-second.metaindex b337a552..bc6ef1f5 100644--- a/packages/examples/src/scenes/transitions-second.meta+++ b/packages/examples/src/scenes/transitions-second.meta@@ -1,4 +1,5 @@{"version": 1,+ "timeEvents": [],"seed": 1065746214}\ No newline at end of filediff --git a/packages/examples/src/scenes/tweening-color.meta b/packages/examples/src/scenes/tweening-color.metaindex 0e33e3fe..4417b801 100644--- a/packages/examples/src/scenes/tweening-color.meta+++ b/packages/examples/src/scenes/tweening-color.meta@@ -1,3 +1,5 @@{- "version": 0+ "version": 0,+ "timeEvents": [],+ "seed": 177802521}\ No newline at end of filediff --git a/packages/examples/src/scenes/tweening-cubic.meta b/packages/examples/src/scenes/tweening-cubic.metaindex 0e33e3fe..9eb3ac4a 100644--- a/packages/examples/src/scenes/tweening-cubic.meta+++ b/packages/examples/src/scenes/tweening-cubic.meta@@ -1,3 +1,5 @@{- "version": 0+ "version": 0,+ "timeEvents": [],+ "seed": 3083903239}\ No newline at end of filediff --git a/packages/examples/src/scenes/tweening-linear.meta b/packages/examples/src/scenes/tweening-linear.metaindex 1a98a9c1..960a1648 100644--- a/packages/examples/src/scenes/tweening-linear.meta+++ b/packages/examples/src/scenes/tweening-linear.meta@@ -1,4 +1,5 @@{"version": 1,+ "timeEvents": [],"seed": 1564249406}\ No newline at end of filediff --git a/packages/examples/src/scenes/tweening-spring.meta b/packages/examples/src/scenes/tweening-spring.metaindex efb61818..3322e21d 100644--- a/packages/examples/src/scenes/tweening-spring.meta+++ b/packages/examples/src/scenes/tweening-spring.meta@@ -1,4 +1,5 @@{"version": 1,+ "timeEvents": [],"seed": 3566829446}\ No newline at end of filediff --git a/packages/examples/src/scenes/tweening-vector.meta b/packages/examples/src/scenes/tweening-vector.metaindex 0e33e3fe..fef1e3b0 100644--- a/packages/examples/src/scenes/tweening-vector.meta+++ b/packages/examples/src/scenes/tweening-vector.meta@@ -1,3 +1,5 @@{- "version": 0+ "version": 0,+ "timeEvents": [],+ "seed": 3538592294}\ No newline at end of filediff --git a/packages/examples/src/scenes/tweening-visualiser.meta b/packages/examples/src/scenes/tweening-visualiser.metaindex 0e33e3fe..833e1990 100644--- a/packages/examples/src/scenes/tweening-visualiser.meta+++ b/packages/examples/src/scenes/tweening-visualiser.meta@@ -1,3 +1,5 @@{- "version": 0+ "version": 0,+ "timeEvents": [],+ "seed": 579161267}\ No newline at end of filediff --git a/packages/examples/src/tex.meta b/packages/examples/src/tex.metaindex 0e33e3fe..8fe8c9c9 100644--- a/packages/examples/src/tex.meta+++ b/packages/examples/src/tex.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 960,+ "y": 540+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/tex.ts b/packages/examples/src/tex.tsindex a55205c8..8c06c0f0 100644--- a/packages/examples/src/tex.ts+++ b/packages/examples/src/tex.ts@@ -1,9 +1,7 @@import {makeProject} from '@motion-canvas/core';import scene from './scenes/tex?scene';-import {Vector2} from '@motion-canvas/core/lib/types';export default makeProject({scenes: [scene],- size: new Vector2(960, 540),});diff --git a/packages/examples/src/transitions.meta b/packages/examples/src/transitions.metaindex 0e33e3fe..af6756e0 100644--- a/packages/examples/src/transitions.meta+++ b/packages/examples/src/transitions.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/tweening-color.meta b/packages/examples/src/tweening-color.metaindex 0e33e3fe..af6756e0 100644--- a/packages/examples/src/tweening-color.meta+++ b/packages/examples/src/tweening-color.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/tweening-cubic.meta b/packages/examples/src/tweening-cubic.metaindex 0e33e3fe..af6756e0 100644--- a/packages/examples/src/tweening-cubic.meta+++ b/packages/examples/src/tweening-cubic.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/tweening-linear.meta b/packages/examples/src/tweening-linear.metaindex 0e33e3fe..af6756e0 100644--- a/packages/examples/src/tweening-linear.meta+++ b/packages/examples/src/tweening-linear.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/tweening-spring.meta b/packages/examples/src/tweening-spring.metaindex 0e33e3fe..af6756e0 100644--- a/packages/examples/src/tweening-spring.meta+++ b/packages/examples/src/tweening-spring.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/tweening-vector.meta b/packages/examples/src/tweening-vector.metaindex 0e33e3fe..af6756e0 100644--- a/packages/examples/src/tweening-vector.meta+++ b/packages/examples/src/tweening-vector.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/examples/src/tweening-visualiser.meta b/packages/examples/src/tweening-visualiser.metaindex 0e33e3fe..af6756e0 100644--- a/packages/examples/src/tweening-visualiser.meta+++ b/packages/examples/src/tweening-visualiser.meta@@ -1,3 +1,26 @@{- "version": 0+ "version": 0,+ "shared": {+ "background": null,+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 60,+ "resolutionScale": 2,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/player/src/global.d.ts b/packages/player/src/global.d.tsindex 6707d8d5..78b5c479 100644--- a/packages/player/src/global.d.ts+++ b/packages/player/src/global.d.ts@@ -1,3 +1,5 @@+/// <reference types="vite/client" />+declare module '*.scss?inline' {const value: string;export = value;diff --git a/packages/player/src/main.ts b/packages/player/src/main.tsindex 54cb39c0..e99d5e8a 100644--- a/packages/player/src/main.ts+++ b/packages/player/src/main.ts@@ -1,7 +1,9 @@-import type {Project} from '@motion-canvas/core';+import {Stage, Player} from '@motion-canvas/core';+import type {PlayerSettings, Project, StageSettings} from '@motion-canvas/core';import styles from './styles.scss?inline';import html from './template.html?raw';+import {Vector2} from '@motion-canvas/core/lib/types';const TEMPLATE = `<style>${styles}</style>${html}`;const ID = 'motion-canvas-player';@@ -29,17 +31,17 @@ class MotionCanvasPlayer extends HTMLElement {private get quality() {const attr = this.getAttribute('quality');- return attr ? parseFloat(attr) : 1;+ return attr ? parseFloat(attr) : this.defaultSettings.resolutionScale;}private get width() {const attr = this.getAttribute('width');- return attr ? parseFloat(attr) : this.defaultWidth;+ return attr ? parseFloat(attr) : this.defaultSettings.size.width;}private get height() {const attr = this.getAttribute('height');- return attr ? parseFloat(attr) : this.defaultHeight;+ return attr ? parseFloat(attr) : this.defaultSettings.size.height;}private get variables() {@@ -58,24 +60,26 @@ class MotionCanvasPlayer extends HTMLElement {private readonly button: HTMLDivElement;private state = State.Initial;- private defaultWidth = 1920;- private defaultHeight = 1080;private project: Project | null = null;+ private player: Player | null = null;+ private defaultSettings: PlayerSettings & StageSettings;private abortController: AbortController | null = null;- private runId: number | null = null;private mouseMoveId: number | null = null;- private renderTime = 0;private finished = false;private playing = false;private connected = false;+ private stage = new Stage();public constructor() {super();this.root = this.attachShadow({mode: 'open'});this.root.innerHTML = TEMPLATE;- this.canvas = this.root.querySelector('.canvas');+this.overlay = this.root.querySelector('.overlay');this.button = this.root.querySelector('.button');+ this.canvas = this.stage.finalBuffer;+ this.canvas.classList.add('canvas');+ this.root.prepend(this.canvas);this.overlay.addEventListener('click', this.handleClick);this.overlay.addEventListener('mousemove', this.handleMouseMove);@@ -138,9 +142,10 @@ class MotionCanvasPlayer extends HTMLElement {private setPlaying(value: boolean) {if (this.state === State.Ready && (value || (this.auto && !this.hover))) {+ this.player?.togglePlayback(true);this.playing = true;- this.request();} else {+ this.player?.togglePlayback(false);this.playing = false;}this.updateClass();@@ -162,10 +167,6 @@ class MotionCanvasPlayer extends HTMLElement {}}- private shouldPlay() {- return this.state === State.Ready && this.playing && this.connected;- }-private async updateSource(source: string) {this.setState(State.Initial);@@ -180,62 +181,31 @@ class MotionCanvasPlayer extends HTMLElement {const delay = new Promise(resolve => setTimeout(resolve, 200));await Promise.any([delay, promise]);this.setState(State.Loading);- project = (await promise).default();- project.setVariables(this.variables);+ project = (await promise).default;} catch (e) {+ console.error(e);this.setState(State.Error);return;}- if (this.abortController.signal.aborted) return;- project.framerate = 60;- await project.recalculate();+ this.defaultSettings = project.meta.getFullRenderingSettings();+ const player = new Player(project);+ player.setVariables(this.variables);- if (this.abortController.signal.aborted) return;- await project.seek(0);-- if (this.abortController.signal.aborted) return;- const size = project.getSize();- this.defaultWidth = size.width;- this.defaultHeight = size.height;this.finished = false;+ this.player?.onRender.unsubscribe(this.render);+ this.player?.togglePlayback(false);+ this.player?.deactivate();this.project = project;- this.project.resolutionScale = this.quality;- this.project.setSize([this.width, this.height]);- this.project.logger.onLogged.subscribe(console.log);- this.project.setCanvas(this.canvas);-- this.setState(State.Ready);- }-- private async run() {- if (this.finished) {- await this.project.seek(0);+ this.player = player;+ this.updateSettings();+ this.player.onRender.subscribe(this.render);+ this.player.togglePlayback(this.playing);+ if (import.meta.env.DEV) {+ this.player.logger.onLogged.subscribe(console.log);}- if (!this.shouldPlay()) return;- this.finished = await this.project.next();-- if (!this.shouldPlay()) return;- await this.project.render();- }-- private request() {- this.runId ??= requestAnimationFrame(async time => {- this.runId = null;- if (!this.shouldPlay()) return;- if (time - this.renderTime >= 1000 / (this.project.framerate + 5)) {- this.renderTime = time;- try {- await this.run();- } catch (e) {- this.setState(State.Error);- return;- }- }-- this.request();- });+ this.setState(State.Ready);}private attributeChangedCallback(name: string, oldValue: any, newValue: any) {@@ -247,30 +217,44 @@ class MotionCanvasPlayer extends HTMLElement {this.updateSource(newValue);break;case 'quality':- if (this.project) {- this.project.resolutionScale = this.quality;- }- break;case 'width':case 'height':- if (this.project) {- this.project.setSize([this.width, this.height]);- }+ this.updateSettings();break;case 'variables':- if (this.project) {- this.project.setVariables(this.variables);- }+ this.player?.setVariables(this.variables);}}private disconnectedCallback() {this.connected = false;+ this.player?.deactivate();+ this.player?.onRender.unsubscribe(this.render);}private connectedCallback() {this.connected = true;- this.request();+ this.player?.activate();+ this.player?.onRender.subscribe(this.render);+ }++ private render = async () => {+ if (this.player) {+ await this.stage.render(+ this.player.playback.currentScene,+ this.player.playback.previousScene,+ );+ }+ };++ private updateSettings() {+ const settings = {+ ...this.defaultSettings,+ size: new Vector2(this.width, this.height),+ resolutionScale: this.quality,+ };+ this.stage.configure(settings);+ this.player.configure(settings);}}diff --git a/packages/player/src/template.html b/packages/player/src/template.htmlindex 00ccdeb5..eae64d9e 100644--- a/packages/player/src/template.html+++ b/packages/player/src/template.html@@ -1,4 +1,3 @@-<canvas class="canvas"></canvas><div class="overlay"><button title="Play / Pause" class="button ready" tabindex="0"></button><div class="message error">diff --git a/packages/player/types/main.d.ts b/packages/player/types/main.d.tsindex b8422619..3898ef47 100644--- a/packages/player/types/main.d.ts+++ b/packages/player/types/main.d.ts@@ -1,5 +1,8 @@export interface MotionCanvasPlayerProps {src: string;+ width?: number;+ height?: number;auto?: boolean;quality?: number;+ variables?: string;}diff --git a/packages/template/src/project.meta b/packages/template/src/project.metaindex 81745113..992720b2 100644--- a/packages/template/src/project.meta+++ b/packages/template/src/project.meta@@ -1,3 +1,26 @@{- "version": 1+ "version": 1,+ "shared": {+ "background": "rgb(20,20,20)",+ "range": [+ 0,+ null+ ],+ "size": {+ "x": 1920,+ "y": 1080+ },+ "audioOffset": 0+ },+ "preview": {+ "fps": 30,+ "resolutionScale": 1+ },+ "rendering": {+ "fps": 30,+ "resolutionScale": 1,+ "colorSpace": "srgb",+ "fileType": "image/png",+ "quality": 1+ }}\ No newline at end of filediff --git a/packages/template/src/project.ts b/packages/template/src/project.tsindex 0c181a65..ecfbbeb6 100644--- a/packages/template/src/project.ts+++ b/packages/template/src/project.ts@@ -4,5 +4,4 @@ import example from './scenes/example?scene';export default makeProject({scenes: [example],- background: '#141414',});diff --git a/packages/ui/package.json b/packages/ui/package.jsonindex 31b739ec..b8a8880d 100644--- a/packages/ui/package.json+++ b/packages/ui/package.json@@ -12,6 +12,7 @@"scripts": {"dev": "vite","build": "tsc && vite build",+ "type": "tsc -w","showcase": "tsc && vite build -c vite.showcase.ts","preview": "vite preview"},diff --git a/packages/ui/src/components/console/Console.tsx b/packages/ui/src/components/console/Console.tsxindex a6c584e5..a51b790f 100644--- a/packages/ui/src/components/console/Console.tsx+++ b/packages/ui/src/components/console/Console.tsx@@ -1,6 +1,6 @@import styles from './Console.module.scss';-import {LogLevel} from '@motion-canvas/core/lib';+import {LogLevel} from '@motion-canvas/core';import {capitalize} from '@motion-canvas/core/lib/utils';import {Pane} from '../tabs';import {useLogs} from '../../contexts';diff --git a/packages/ui/src/components/controls/ColorInput.tsx b/packages/ui/src/components/controls/ColorInput.tsxnew file mode 100644index 00000000..52855a61--- /dev/null+++ b/packages/ui/src/components/controls/ColorInput.tsx@@ -0,0 +1,23 @@+import styles from './Controls.module.scss';+import clsx from 'clsx';+import {ColorPreview} from './ColorPreview';+import {Color} from '@motion-canvas/core/lib/types';++export interface ColorInputProps {+ value: Color | null;+ onChange: (value: string) => void;+}++export function ColorInput({value, onChange}: ColorInputProps) {+ return (+ <div className={clsx(styles.input, styles.color)}>+ <input+ onChange={event => onChange((event.target as HTMLInputElement).value)}+ placeholder="none"+ type="text"+ value={value?.serialize() ?? ''}+ />+ <ColorPreview color={value?.hex() ?? '#00000000'} />+ </div>+ );+}diff --git a/packages/ui/src/components/controls/Controls.module.scss b/packages/ui/src/components/controls/Controls.module.scssindex 9e1af4c5..0a77c33d 100644--- a/packages/ui/src/components/controls/Controls.module.scss+++ b/packages/ui/src/components/controls/Controls.module.scss@@ -109,6 +109,24 @@-moz-appearance: textfield;}+.color {+ display: flex;+ padding-left: 0;+ align-items: center;++ input {+ width: 0;+ flex-shrink: 1;+ flex-grow: 1;+ margin: 0 8px 0 0;+ padding-left: 8px;+ appearance: none;+ border: 0;+ background-color: transparent;+ color: inherit;+ }+}+.colorPreview {width: 16px;height: 16px;diff --git a/packages/ui/src/components/controls/Toggle.tsx b/packages/ui/src/components/controls/Toggle.tsxindex 0854e9ff..1a836b53 100644--- a/packages/ui/src/components/controls/Toggle.tsx+++ b/packages/ui/src/components/controls/Toggle.tsx@@ -4,14 +4,14 @@ import {ChevronRight} from '../icons/ChevronRight';export interface ToggleProps {open?: boolean;- onToggle: (value: boolean) => void;+ onToggle?: (value: boolean) => void;}export function Toggle({open, onToggle}: ToggleProps) {return (<buttonclassName={clsx(styles.toggle, open && styles.open)}- onClick={() => onToggle(!open)}+ onClick={() => onToggle?.(!open)}><ChevronRight /></button>diff --git a/packages/ui/src/components/controls/index.ts b/packages/ui/src/components/controls/index.tsindex a454532b..32c7f10b 100644--- a/packages/ui/src/components/controls/index.ts+++ b/packages/ui/src/components/controls/index.ts@@ -1,4 +1,5 @@export * from './Button';+export * from './ColorInput';export * from './InputSelect';export * from './Group';export * from './Input';diff --git a/packages/ui/src/components/fields/Expandable.module.scss b/packages/ui/src/components/fields/Expandable.module.scssnew file mode 100644index 00000000..b7879201--- /dev/null+++ b/packages/ui/src/components/fields/Expandable.module.scss@@ -0,0 +1,17 @@+.root {+ border-top: 1px solid var(--background-color);+}++.title {+ padding: 8px 0;+ line-height: 24px;+ user-select: none;+ cursor: pointer;++ display: flex;+ align-items: center;+}++.content {+ padding-bottom: 16px;+}diff --git a/packages/ui/src/components/fields/Expandable.tsx b/packages/ui/src/components/fields/Expandable.tsxnew file mode 100644index 00000000..facb8df6--- /dev/null+++ b/packages/ui/src/components/fields/Expandable.tsx@@ -0,0 +1,26 @@+import {ComponentChildren} from 'preact';++import {useStorage} from '../../hooks';+import {Toggle} from '../controls';++import styles from './Expandable.module.scss';++export interface ExpandableProps {+ title: string;+ children: ComponentChildren;+ open?: boolean;+}++export function Expandable({title, children, open}: ExpandableProps) {+ const [isOpen, setOpen] = useStorage(`expandable-${title}`, open);++ return (+ <div className={styles.root}>+ <div className={styles.title} onClick={() => setOpen(!isOpen)}>+ <Toggle open={isOpen} />+ {title}+ </div>+ {isOpen && <div className={styles.content}>{children}</div>}+ </div>+ );+}diff --git a/packages/ui/src/components/fields/index.ts b/packages/ui/src/components/fields/index.tsindex 79bdd044..e9d849ac 100644--- a/packages/ui/src/components/fields/index.ts+++ b/packages/ui/src/components/fields/index.ts@@ -1,5 +1,6 @@export * from './AutoField';export * from './ColorField';+export * from './Expandable';export * from './Layout';export * from './NumberField';export * from './SpacingField';diff --git a/packages/ui/src/components/icons/AccountTree.tsx b/packages/ui/src/components/icons/AccountTree.tsxnew file mode 100644index 00000000..5220636e--- /dev/null+++ b/packages/ui/src/components/icons/AccountTree.tsx@@ -0,0 +1,11 @@+export function AccountTree() {+ return (+ <svg+ viewBox="0 0 24 24"+ fill="currentColor"+ style={{rotate: '90deg', scale: '1 -1'}}+ >+ <path d="M22,11V3h-7v3H9V3H2v8h7V8h2v10h4v3h7v-8h-7v3h-2V8h2v3H22z M7,9H4V5h3V9z M17,15h3v4h-3V15z M17,5h3v4h-3V5z" />+ </svg>+ );+}diff --git a/packages/ui/src/components/icons/Videocam.tsx b/packages/ui/src/components/icons/Videocam.tsxnew file mode 100644index 00000000..8812bef7--- /dev/null+++ b/packages/ui/src/components/icons/Videocam.tsx@@ -0,0 +1,7 @@+export function Videocam() {+ return (+ <svg viewBox="0 0 24 24" fill="currentColor">+ <path d="M15 8v8H5V8h10m1-2H4c-.55 0-1 .45-1 1v10c0 .55.45 1 1 1h12c.55 0 1-.45 1-1v-3.5l4 4v-11l-4 4V7c0-.55-.45-1-1-1z" />+ </svg>+ );+}diff --git a/packages/ui/src/components/icons/ViewTimeline.tsx b/packages/ui/src/components/icons/ViewTimeline.tsxnew file mode 100644index 00000000..6aab7f48--- /dev/null+++ b/packages/ui/src/components/icons/ViewTimeline.tsx@@ -0,0 +1,10 @@+export function ViewTimeline() {+ return (+ <svg viewBox="0 0 24 24" fill="currentColor">+ <rect height="2" width="6" x="6" y="15" />+ <rect height="2" width="6" x="12" y="7" />+ <rect height="2" width="6" x="9" y="11" />+ <path d="M19,3H5C3.9,3,3,3.9,3,5v14c0,1.1,0.9,2,2,2h14c1.1,0,2-0.9,2-2V5C21,3.9,20.1,3,19,3z M19,19H5V5h14V19z" />+ </svg>+ );+}diff --git a/packages/ui/src/components/icons/index.ts b/packages/ui/src/components/icons/index.tsindex db2a779f..07c824f2 100644--- a/packages/ui/src/components/icons/index.ts+++ b/packages/ui/src/components/icons/index.ts@@ -1,3 +1,4 @@+export * from './AccountTree';export * from './Add';export * from './Bug';export * from './Clear';@@ -14,6 +15,7 @@ export * from './SkipNext';export * from './SkipPrevious';export * from './Tune';export * from './UnfoldMore';+export * from './Videocam';export * from './VideoSettings';export * from './VolumeOff';export * from './VolumeOn';diff --git a/packages/ui/src/components/playback/Playback.module.scss b/packages/ui/src/components/playback/Playback.module.scssindex 28cc90d2..9cea1246 100644--- a/packages/ui/src/components/playback/Playback.module.scss+++ b/packages/ui/src/components/playback/Playback.module.scss@@ -20,6 +20,6 @@select,input {- width: 70px;+ width: 100px;}}diff --git a/packages/ui/src/components/playback/PlaybackControls.tsx b/packages/ui/src/components/playback/PlaybackControls.tsxindex 5c90620e..664d1ad5 100644--- a/packages/ui/src/components/playback/PlaybackControls.tsx+++ b/packages/ui/src/components/playback/PlaybackControls.tsx@@ -1,11 +1,10 @@import styles from './Playback.module.scss';-import {IconButton, IconCheckbox} from '../controls';-import {useDocumentEvent, usePlayerState} from '../../hooks';-import {Select, Input} from '../controls';+import {IconButton, IconCheckbox, Input, Select} from '../controls';+import {useDocumentEvent, usePlayerState, useRendererState} from '../../hooks';import {Framerate} from './Framerate';import {useCallback} from 'preact/hooks';-import {usePlayer} from '../../contexts';+import {useApplication} from '../../contexts';import clsx from 'clsx';import React from 'react';import {@@ -18,10 +17,12 @@ import {VolumeOff,VolumeOn,} from '../icons';+import {RendererState} from '@motion-canvas/core';export function PlaybackControls() {- const player = usePlayer();+ const {player, renderer, meta, project} = useApplication();const state = usePlayerState();+ const rendererState = useRendererState();useDocumentEvent('keydown',@@ -47,7 +48,7 @@ export function PlaybackControls() {case 'ArrowRight':event.preventDefault();if (event.shiftKey) {- player.requestSeek(state.endFrame);+ player.requestSeek(Infinity);return;}@@ -61,12 +62,17 @@ export function PlaybackControls() {break;}},- [state],+ [player],),);return (- <div className={clsx(styles.controls, state.render && styles.disabled)}>+ <div+ className={clsx(+ styles.controls,+ rendererState === RendererState.Working && styles.disabled,+ )}+ ><Selecttitle="Playback speed"options={[@@ -118,13 +124,27 @@ export function PlaybackControls() {<Inputtitle="Current framerate"readOnly- value={paused ? 'PAUSED' : `${framerate} FPS`}+ value={+ rendererState === RendererState.Working+ ? 'RENDERING'+ : paused+ ? 'PAUSED'+ : `${framerate} FPS`+ }/>)}/><IconButtontitle="Save snapshot"- onClick={() => player.exportCurrentFrame()}+ onClick={() =>+ renderer.renderFrame(+ {+ ...meta.getFullRenderingSettings(),+ name: project.name,+ },+ player.playback.frame,+ )+ }><PhotoCamera /></IconButton>diff --git a/packages/ui/src/components/settings/PreviewSettings.tsx b/packages/ui/src/components/settings/PreviewSettings.tsxnew file mode 100644index 00000000..cb131eeb--- /dev/null+++ b/packages/ui/src/components/settings/PreviewSettings.tsx@@ -0,0 +1,34 @@+import {usePreviewSettings} from '../../hooks';+import {Group, InputSelect, Label, Select} from '../controls';+import {useApplication} from '../../contexts';+import {FrameRates, Scales} from './options';++export function PreviewSettings() {+ const {meta} = useApplication();+ const state = usePreviewSettings();++ return (+ <>+ <Group>+ <Label>frame rate</Label>+ <InputSelect+ type="number"+ min={1}+ value={state.fps.toString()}+ onChange={value => {+ meta.preview.fps.set(parseInt(value));+ }}+ options={FrameRates}+ />+ </Group>+ <Group>+ <Label>scale</Label>+ <Select+ options={Scales}+ value={state.resolutionScale}+ onChange={value => meta.preview.resolutionScale.set(value)}+ />+ </Group>+ </>+ );+}diff --git a/packages/ui/src/components/settings/RenderingSettings.tsx b/packages/ui/src/components/settings/RenderingSettings.tsxnew file mode 100644index 00000000..71fe10c4--- /dev/null+++ b/packages/ui/src/components/settings/RenderingSettings.tsx@@ -0,0 +1,74 @@+import {useRenderingSettings} from '../../hooks';+import {Group, Input, InputSelect, Label, Select} from '../controls';+import {useApplication} from '../../contexts';+import type {+ CanvasColorSpace,+ CanvasOutputMimeType,+} from '@motion-canvas/core/lib/types';+import {ColorSpaces, FileTypes, FrameRates, Scales} from './options';++export function RenderingSettings() {+ const {meta} = useApplication();+ const state = useRenderingSettings();++ return (+ <>+ <Group>+ <Label>frame rate</Label>+ <InputSelect+ type="number"+ min={1}+ value={state.fps.toString()}+ onChange={value => {+ meta.rendering.fps.set(parseInt(value));+ }}+ options={FrameRates}+ />+ </Group>+ <Group>+ <Label>scale</Label>+ <Select+ options={Scales}+ value={state.resolutionScale}+ onChange={value => meta.rendering.resolutionScale.set(value)}+ />+ </Group>+ <Group>+ <Label>color space</Label>+ <Select+ options={ColorSpaces}+ value={state.colorSpace}+ onChange={value =>+ meta.rendering.colorSpace.set(value as CanvasColorSpace)+ }+ />+ </Group>+ <Group>+ <Label>file type</Label>+ <Select+ options={FileTypes}+ value={state.fileType}+ onChange={value =>+ meta.rendering.fileType.set(value as CanvasOutputMimeType)+ }+ />+ </Group>+ {state.fileType !== 'image/png' && (+ <Group>+ <Label>quality (%)</Label>+ <Input+ type="number"+ min={0}+ max={100}+ value={state.quality * 100}+ onChange={event => {+ meta.rendering.quality.set(+ parseFloat((event.target as HTMLInputElement).value) / 100,+ );+ }}+ />+ </Group>+ )}+ </>+ );+}diff --git a/packages/ui/src/components/settings/SharedSettings.tsx b/packages/ui/src/components/settings/SharedSettings.tsxnew file mode 100644index 00000000..479a0987--- /dev/null+++ b/packages/ui/src/components/settings/SharedSettings.tsx@@ -0,0 +1,100 @@+import {useApplication} from '../../contexts';+import {useDuration, usePreviewSettings, useSharedSettings} from '../../hooks';+import {ColorInput, Group, Input, Label} from '../controls';+import {Add} from '../icons';+import styles from '../sidebar/Sidebar.module.scss';++export function SharedSettings() {+ const {player, project, meta} = useApplication();+ const duration = useDuration();+ const state = useSharedSettings();+ // We use the preview framerate for all editing purposes.+ const {fps} = usePreviewSettings();++ const startFrame = player.status.secondsToFrames(state.range[0]);+ const endFrame = player.status.secondsToFrames(state.range[1]);++ return (+ <>+ <Group>+ <Label>background</Label>+ <ColorInput+ value={state.background}+ onChange={value => {+ meta.shared.background.set(value ? value : null);+ }}+ />+ </Group>+ <Group>+ <Label>range</Label>+ <Input+ min={0}+ max={endFrame}+ type={'number'}+ value={startFrame}+ onChange={event => {+ let start = parseInt((event.target as HTMLInputElement).value);+ if (isNaN(start)) {+ start = 0;+ }+ meta.shared.range.update(start, endFrame, duration, fps);+ }}+ />+ <Input+ min={startFrame}+ max={duration}+ type={'number'}+ placeholder="end"+ value={endFrame >= Infinity ? '' : endFrame}+ onChange={event => {+ let end = parseInt((event.target as HTMLInputElement).value);+ if (isNaN(end)) {+ end = Infinity;+ }+ meta.shared.range.update(startFrame, end, duration, fps);+ }}+ />+ </Group>+ <Group>+ <Label>resolution</Label>+ <Input+ type="number"+ min={1}+ value={state.size.width}+ onChange={event => {+ const value = parseInt((event.target as HTMLInputElement).value);+ meta.shared.size.set([value, state.size.height]);+ }}+ />+ <Add className={styles.times} />+ <Input+ type="number"+ min={1}+ value={state.size.height}+ onChange={event => {+ const value = parseInt((event.target as HTMLInputElement).value);+ meta.shared.size.set([state.size.width, value]);+ }}+ />+ </Group>{' '}+ {project.audio && (+ <Group>+ <Label>audio offset</Label>+ <Input+ type={'number'}+ value={state.audioOffset.toFixed(4)}+ onChange={event => {+ let audioOffset = parseFloat(+ (event.target as HTMLInputElement).value,+ );+ if (isNaN(audioOffset)) {+ audioOffset = 0;+ }+ meta.shared.audioOffset.set(audioOffset);+ }}+ />+ </Group>+ )}+ </>+ );+}diff --git a/packages/ui/src/components/settings/index.ts b/packages/ui/src/components/settings/index.tsnew file mode 100644index 00000000..9596477c--- /dev/null+++ b/packages/ui/src/components/settings/index.ts@@ -0,0 +1,3 @@+export * from './PreviewSettings';+export * from './RenderingSettings';+export * from './SharedSettings';diff --git a/packages/ui/src/components/settings/options.ts b/packages/ui/src/components/settings/options.tsnew file mode 100644index 00000000..96cb9c21--- /dev/null+++ b/packages/ui/src/components/settings/options.ts@@ -0,0 +1,22 @@+export const Scales = [+ {value: 0.25, text: '0.25x (Quarter)'},+ {value: 0.5, text: `0.5x (Half)`},+ {value: 1, text: `1.0x (Full)`},+ {value: 2, text: `2.0x (Double)`},+];++export const ColorSpaces = [+ {value: 'srgb', text: 'sRGB'},+ {value: 'display-p3', text: 'DCI-P3'},+];++export const FileTypes = [+ {value: 'image/png', text: 'png'},+ {value: 'image/jpeg', text: 'jpeg'},+ {value: 'image/webp', text: 'webp'},+];++export const FrameRates = [+ {value: '30', text: '30 FPS'},+ {value: '60', text: '60 FPS'},+];diff --git a/packages/ui/src/components/sidebar/Rendering.tsx b/packages/ui/src/components/sidebar/Rendering.tsxdeleted file mode 100644index 60efe4c0..00000000--- a/packages/ui/src/components/sidebar/Rendering.tsx+++ /dev/null@@ -1,155 +0,0 @@-import styles from './Sidebar.module.scss';--import {usePlayerState} from '../../hooks';-import {Button, Group, Input, InputSelect, Label, Select} from '../controls';-import {Pane} from '../tabs';-import {usePlayer} from '../../contexts';-import type {- CanvasColorSpace,- CanvasOutputMimeType,-} from '@motion-canvas/core/lib/types';-import {Add} from '../icons';--export function Rendering() {- const player = usePlayer();- const state = usePlayerState();- const {width, height} = player.project.getSize();-- const scales = [- {value: 0.25, text: '0.25x (Quarter)'},- {value: 0.5, text: `0.5x (Half)`},- {value: 1, text: `1.0x (Full)`},- {value: 2, text: `2.0x (Double)`},- ];-- const colorSpaces = [- {value: 'srgb', text: 'sRGB'},- {value: 'display-p3', text: 'DCI-P3'},- ];-- const fileTypes = [- {value: 'image/png', text: 'png'},- {value: 'image/jpeg', text: 'jpeg'},- {value: 'image/webp', text: 'webp'},- ];-- const frameRates = [- {value: '30', text: '30 FPS'},- {value: '60', text: '60 FPS'},- ];-- return (- <Pane title="Rendering" id="rendering-pane">- <Group>- <Label>range</Label>- <Input- min={0}- max={state.endFrame}- type={'number'}- value={state.startFrame}- onChange={event => {- player.setRange(parseInt((event.target as HTMLInputElement).value));- }}- />- <Input- min={state.startFrame}- max={state.duration}- type={'number'}- value={Math.min(state.duration, state.endFrame)}- onChange={event => {- const value = parseInt((event.target as HTMLInputElement).value);- player.setRange(undefined, value);- }}- />- </Group>- <Group>- <Label>frame rate</Label>- <InputSelect- type="number"- min={1}- value={state.fps.toString()}- onChange={value => {- player.setFramerate(parseInt(value));- }}- options={frameRates}- />- </Group>- <Group>- <Label>resolution</Label>- <Input- type="number"- min={1}- value={width}- onChange={event => {- const value = parseInt((event.target as HTMLInputElement).value);- const {height} = player.project.getSize();- player.project.setSize([value, height]);- }}- />- <Add className={styles.times} />- <Input- type="number"- min={1}- value={height}- onChange={event => {- const value = parseInt((event.target as HTMLInputElement).value);- const {width} = player.project.getSize();- player.project.setSize([width, value]);- }}- />- </Group>- <Group>- <Label>scale</Label>- <Select- options={scales}- value={state.scale}- onChange={value => player.setScale(value)}- />- </Group>- <Group>- <Label>color space</Label>- <Select- options={colorSpaces}- value={state.colorSpace}- onChange={value => player.setColorSpace(value as CanvasColorSpace)}- />- </Group>- <Group>- <Label>file type</Label>- <Select- options={fileTypes}- value={state.fileType}- onChange={value => player.setFileType(value as CanvasOutputMimeType)}- />- </Group>- {state.fileType !== 'image/png' && (- <Group>- <Label>quality (%)</Label>- <Input- type="number"- min={0}- max={100}- value={state.quality * 100}- onChange={event => {- const value = parseFloat(- (event.target as HTMLInputElement).value,- );- player.setQuality(value / 100);- }}- />- </Group>- )}- <Group>- <Label />- <Button- main- id="render"- data-rendering={state.render}- onClick={() => player.toggleRendering()}- >- {state.render ? 'STOP RENDERING' : 'RENDER'}- </Button>- </Group>- </Pane>- );-}diff --git a/packages/ui/src/components/sidebar/Sidebar.tsx b/packages/ui/src/components/sidebar/Sidebar.tsxindex 24579827..a6160ab9 100644--- a/packages/ui/src/components/sidebar/Sidebar.tsx+++ b/packages/ui/src/components/sidebar/Sidebar.tsx@@ -1,14 +1,15 @@import {Badge, Tabs, TabType} from '../tabs';import {Properties} from './Properties';-import {Rendering} from './Rendering';+import {VideoSettings} from './VideoSettings';import {Threads} from './Threads';import {Console} from '../console';import {useInspection, useLogger} from '../../contexts';import {useEffect, useRef, useState} from 'preact/hooks';import {shake} from '../animations';import {useStorage} from '../../hooks';-import {MotionCanvas, Bug, Tune, VideoSettings, Schedule} from '../icons';+import {MotionCanvas, Bug, Videocam, AccountTree} from '../icons';import {Docs} from '../icons/Docs';+import {ViewTimeline} from '../icons/ViewTimeline';interface SidebarProps {setOpen?: (value: boolean) => void;@@ -33,7 +34,7 @@ export function Sidebar({setOpen}: SidebarProps) {useEffect(() => {if (inspectedElement && tab !== -1) {- setTab(3);+ setTab(4);}}, [!inspectedElement]);@@ -64,24 +65,24 @@ export function Sidebar({setOpen}: SidebarProps) {type: TabType.Space,}}{{- title: 'Inspector',- id: 'inspector-tab',+ title: 'Video Settings',+ id: 'rendering-tab',type: TabType.Pane,- icon: <Tune />,- pane: <Properties />,+ icon: <Videocam />,+ pane: <VideoSettings />,}}{{- title: 'Video Settings',- id: 'rendering-tab',+ title: 'Inspector',+ id: 'inspector-tab',type: TabType.Pane,- icon: <VideoSettings />,- pane: <Rendering />,+ icon: <AccountTree />,+ pane: <Properties />,}}{{title: 'Thread Debugger',id: 'threads-tab',type: TabType.Pane,- icon: <Schedule />,+ icon: <ViewTimeline />,pane: <Threads />,}}{{diff --git a/packages/ui/src/components/sidebar/VideoSettings.tsx b/packages/ui/src/components/sidebar/VideoSettings.tsxnew file mode 100644index 00000000..eb64902c--- /dev/null+++ b/packages/ui/src/components/sidebar/VideoSettings.tsx@@ -0,0 +1,50 @@+import {useRendererState} from '../../hooks';+import {Button, Group, Label} from '../controls';+import {Pane} from '../tabs';+import {useApplication} from '../../contexts';+import {PreviewSettings, RenderingSettings, SharedSettings} from '../settings';+import {Expandable} from '../fields';+import {RendererState} from '@motion-canvas/core';++export function VideoSettings() {+ const {renderer, project, meta} = useApplication();+ const state = useRendererState();++ return (+ <Pane title="Video Settings" id="settings-pane">+ <Expandable title="General" open>+ <SharedSettings />+ </Expandable>+ <Expandable title="Preview">+ <PreviewSettings />+ </Expandable>+ <Expandable title="Rendering">+ <RenderingSettings />+ </Expandable>+ <Group>+ <Label />+ <Button+ main+ id="render"+ data-rendering={state !== RendererState.Initial}+ onClick={() => {+ if (state === RendererState.Initial) {+ renderer.render({+ ...meta.getFullRenderingSettings(),+ name: project.name,+ });+ } else {+ renderer.abort();+ }+ }}+ >+ {state === RendererState.Initial+ ? 'RENDER'+ : state === RendererState.Working+ ? 'STOP RENDERING'+ : 'ABORTING...'}+ </Button>+ </Group>+ </Pane>+ );+}diff --git a/packages/ui/src/components/timeline/AudioTrack.tsx b/packages/ui/src/components/timeline/AudioTrack.tsxindex e2a40646..a8157140 100644--- a/packages/ui/src/components/timeline/AudioTrack.tsx+++ b/packages/ui/src/components/timeline/AudioTrack.tsx@@ -1,14 +1,30 @@import styles from './Timeline.module.scss';-import {useLayoutEffect, useMemo, useRef} from 'preact/hooks';-import {useSubscribableValue} from '../../hooks';-import {useProject, useTimelineContext} from '../../contexts';+import {+ useCallback,+ useLayoutEffect,+ useMemo,+ useRef,+ useState,+} from 'preact/hooks';+import {+ useDrag,+ useKeyHold,+ useSharedSettings,+ useSubscribableValue,+} from '../../hooks';+import {useApplication, useTimelineContext} from '../../contexts';+import clsx from 'clsx';const HEIGHT = 48;export function AudioTrack() {const ref = useRef<HTMLCanvasElement>();- const project = useProject();+ const {player, meta} = useApplication();+ const {audioOffset} = useSharedSettings();+ const [hover, setHover] = useState(false);+ const shiftHeld = useKeyHold('Shift');+ const [editingOffset, setEditingOffset] = useState(0);const context = useMemo(() => ref.current?.getContext('2d'), [ref.current]);const {viewLength,@@ -16,26 +32,41 @@ export function AudioTrack() {lastVisibleFrame,density,framesToPercents,+ pixelsToFrames,} = useTimelineContext();- const audioData = useSubscribableValue(project.audio.onDataChanged);+ const audioData = useSubscribableValue(player.audio.onDataChanged);+ const fullOffset = audioOffset + editingOffset;++ const [handleDrag, isDragging] = useDrag(+ useCallback(+ dx => {+ setEditingOffset(+ editingOffset + player.status.framesToSeconds(pixelsToFrames(dx)),+ );+ },+ [editingOffset, pixelsToFrames],+ ),+ useCallback(() => {+ meta.shared.audioOffset.set(audioOffset);+ }, [fullOffset]),+ );++ const isActive = (hover && shiftHeld) || isDragging;useLayoutEffect(() => {if (!context) return;context.clearRect(0, 0, viewLength, HEIGHT * 2);if (!audioData) return;- context.strokeStyle = '#444';- context.lineWidth = 1;context.beginPath();context.moveTo(0, HEIGHT);const start =- (project.framesToSeconds(firstVisibleFrame) -- project.audio.onOffsetChanged.current) *+ (player.status.framesToSeconds(firstVisibleFrame) - fullOffset) *audioData.sampleRate;const end =- project.audio.toRelativeTime(project.framesToSeconds(lastVisibleFrame)) *+ (player.status.framesToSeconds(lastVisibleFrame) - fullOffset) *audioData.sampleRate;const flooredStart = Math.floor(start);@@ -44,7 +75,7 @@ export function AudioTrack() {const step = Math.ceil(density);for (let index = start; index < end; index += step * 2) {const offset = index - start;- const sample = flooredStart + offset;+ const sample = Math.round(flooredStart + offset);if (sample >= audioData.peaks.length) break;context.lineTo(@@ -57,8 +88,12 @@ export function AudioTrack() {);}+ context.lineWidth = 2;+ context.lineJoin = 'round';+ context.strokeStyle = '#444';context.stroke();}, [+ fullOffset,context,audioData,density,@@ -67,6 +102,10 @@ export function AudioTrack() {lastVisibleFrame,]);+ useLayoutEffect(() => {+ setEditingOffset(0);+ }, [audioOffset]);+const style = useMemo(() => ({marginLeft: `${framesToPercents(firstVisibleFrame)}%`,@@ -78,11 +117,22 @@ export function AudioTrack() {return (<canvas+ ref={ref}+ className={clsx(+ styles.audioTrack,+ isActive && styles.active,+ audioData && styles.show,+ )}style={style}width={viewLength}height={HEIGHT * 2}- ref={ref}- className={styles.audioTrack}+ onMouseEnter={() => setHover(true)}+ onMouseLeave={() => setHover(false)}+ onMouseDown={event => {+ if (event.shiftKey) {+ handleDrag(event);+ }+ }}/>);}diff --git a/packages/ui/src/components/timeline/Label.tsx b/packages/ui/src/components/timeline/Label.tsxindex d01f4c0c..cd629724 100644--- a/packages/ui/src/components/timeline/Label.tsx+++ b/packages/ui/src/components/timeline/Label.tsx@@ -3,7 +3,7 @@ import styles from './Timeline.module.scss';import type {Scene, TimeEvent} from '@motion-canvas/core/lib/scenes';import {useDrag} from '../../hooks';import {useCallback, useLayoutEffect, useState} from 'preact/hooks';-import {usePlayer, useProject, useTimelineContext} from '../../contexts';+import {useApplication, useTimelineContext} from '../../contexts';import {findAndOpenFirstUserFile} from '../../utils';interface LabelProps {@@ -13,15 +13,16 @@ interface LabelProps {export function Label({event, scene}: LabelProps) {const {framesToPercents, pixelsToFrames} = useTimelineContext();- const player = usePlayer();- const project = useProject();+ const {player} = useApplication();const [eventTime, setEventTime] = useState(event.offset);const [handleDrag] = useDrag(useCallback(dx => {- setEventTime(eventTime + project.framesToSeconds(pixelsToFrames(dx)));+ setEventTime(+ eventTime + player.status.framesToSeconds(pixelsToFrames(dx)),+ );},- [eventTime, project, pixelsToFrames],+ [eventTime, player, pixelsToFrames],),useCallback(e => {@@ -51,9 +52,7 @@ export function Label({event, scene}: LabelProps) {e.preventDefault();player.requestSeek(scene.firstFrame +- player.project.secondsToFrames(- event.initialTime + event.offset,- ),+ player.status.secondsToFrames(event.initialTime + event.offset),);} else {handleDrag(e);@@ -64,7 +63,7 @@ export function Label({event, scene}: LabelProps) {style={{left: `${framesToPercents(scene.firstFrame +- scene.project.secondsToFrames(+ scene.playback.secondsToFrames(event.initialTime + Math.max(0, eventTime),),)}%`,@@ -74,7 +73,7 @@ export function Label({event, scene}: LabelProps) {className={styles.labelClipTarget}style={{left: `${framesToPercents(- scene.firstFrame + scene.project.secondsToFrames(event.targetTime),+ scene.firstFrame + scene.playback.secondsToFrames(event.targetTime),)}%`,}}/>@@ -82,11 +81,12 @@ export function Label({event, scene}: LabelProps) {className={styles.labelClipStart}style={{left: `${framesToPercents(- scene.firstFrame + scene.project.secondsToFrames(event.initialTime),+ scene.firstFrame ++ scene.playback.secondsToFrames(event.initialTime),)}%`,width: `${Math.max(0,- framesToPercents(scene.project.secondsToFrames(eventTime)),+ framesToPercents(scene.playback.secondsToFrames(eventTime)),)}%`,}}/>diff --git a/packages/ui/src/components/timeline/Playhead.tsx b/packages/ui/src/components/timeline/Playhead.tsxindex c437c19c..7c9559c4 100644--- a/packages/ui/src/components/timeline/Playhead.tsx+++ b/packages/ui/src/components/timeline/Playhead.tsx@@ -1,18 +1,28 @@import styles from './Timeline.module.scss';-import {usePlayerTime} from '../../hooks';+import {usePlayerState, usePlayerTime} from '../../hooks';import {useTimelineContext} from '../../contexts';export function Playhead() {const {framesToPixels} = useTimelineContext();+ const {speed} = usePlayerState();const time = usePlayerTime();return (<divclassName={styles.playhead}- data-frame={time.frame}+ data-frame={formatFrames(time.frame, speed)}style={{left: `${framesToPixels(time.frame)}px`,}}/>);}++function formatFrames(frames: number, speed: number) {+ const round = speed % 1 === 0;+ if (round) {+ return frames;+ } else {+ return frames.toFixed(2);+ }+}diff --git a/packages/ui/src/components/timeline/RangeSelector.tsx b/packages/ui/src/components/timeline/RangeSelector.tsxindex b5ecf2a9..b22e85cd 100644--- a/packages/ui/src/components/timeline/RangeSelector.tsx+++ b/packages/ui/src/components/timeline/RangeSelector.tsx@@ -1,21 +1,30 @@import styles from './Timeline.module.scss';-import {useDrag, usePlayerState} from '../../hooks';+import {+ useDrag,+ useDuration,+ usePreviewSettings,+ useSharedSettings,+} from '../../hooks';import {useCallback, useEffect, useState} from 'preact/hooks';-import {usePlayer, useTimelineContext} from '../../contexts';+import {useApplication, useTimelineContext} from '../../contexts';import {DragIndicator} from '../icons';export function RangeSelector() {const {pixelsToFrames, framesToPercents} = useTimelineContext();- const player = usePlayer();- const state = usePlayerState();- const [start, setStart] = useState(state.startFrame);- const [end, setEnd] = useState(state.endFrame);+ const {player, meta} = useApplication();+ const {range} = useSharedSettings();+ const {fps} = usePreviewSettings();+ const duration = useDuration();+ const startFrame = player.status.secondsToFrames(range[0]);+ const endFrame = Math.min(player.status.secondsToFrames(range[1]), duration);+ const [start, setStart] = useState(startFrame);+ const [end, setEnd] = useState(endFrame);const onDrop = useCallback(() => {- player.setRange(Math.floor(start), Math.floor(end));- }, [start, end, state.duration]);+ meta.shared.range.update(start, end, duration, fps);+ }, [start, end, duration, fps]);const [handleDragStart] = useDrag(useCallback(@@ -30,9 +39,9 @@ export function RangeSelector() {const [handleDragEnd] = useDrag(useCallback(dx => {- setEnd(Math.min(state.duration, end) + pixelsToFrames(dx));+ setEnd(end + pixelsToFrames(dx));},- [end, pixelsToFrames, state.duration],+ [end, pixelsToFrames, duration],),onDrop,);@@ -41,17 +50,17 @@ export function RangeSelector() {useCallback(dx => {setStart(start + pixelsToFrames(dx));- setEnd(Math.min(state.duration, end) + pixelsToFrames(dx));+ setEnd(end + pixelsToFrames(dx));},- [start, end, state.duration, pixelsToFrames],+ [start, end, duration, pixelsToFrames],),onDrop,);useEffect(() => {- setStart(state.startFrame);- setEnd(state.endFrame);- }, [state.startFrame, state.endFrame]);+ setStart(startFrame);+ setEnd(endFrame);+ }, [startFrame, endFrame, range[0], range[1]]);let normalizedStart = start;let normalizedEnd = end;@@ -65,15 +74,13 @@ export function RangeSelector() {style={{flexDirection: start > end ? 'row-reverse' : 'row',left: `${framesToPercents(Math.max(0, normalizedStart))}%`,- right: `${- 100 - framesToPercents(Math.min(state.duration, normalizedEnd + 1))- }%`,+ right: `${100 - framesToPercents(Math.min(duration, normalizedEnd))}%`,}}className={styles.range}onMouseDown={event => {if (event.button === 1) {event.preventDefault();- player.setRange(0, Infinity);+ meta.shared.range.update(0, Infinity, duration, fps);} else {handleDrag(event);}diff --git a/packages/ui/src/components/timeline/SceneTrack.tsx b/packages/ui/src/components/timeline/SceneTrack.tsxindex 5ad98958..80ba1e25 100644--- a/packages/ui/src/components/timeline/SceneTrack.tsx+++ b/packages/ui/src/components/timeline/SceneTrack.tsx@@ -2,7 +2,7 @@ import styles from './Timeline.module.scss';import type {Scene} from '@motion-canvas/core/lib/scenes';import {useScenes, useSubscribableValue} from '../../hooks';-import {usePlayer, useTimelineContext} from '../../contexts';+import {useApplication, useTimelineContext} from '../../contexts';import {useMemo} from 'preact/hooks';import {findAndOpenFirstUserFile} from '../../utils';@@ -23,7 +23,7 @@ interface SceneClipProps {}function SceneClip({scene}: SceneClipProps) {- const player = usePlayer();+ const {player, meta} = useApplication();const {framesToPercents, framesToPixels, offset} = useTimelineContext();const cachedData = useSubscribableValue(scene.onCacheChanged);@@ -49,7 +49,10 @@ function SceneClip({scene}: SceneClipProps) {onMouseUp={event => {if (event.button === 1) {event.stopPropagation();- player.setRange(cachedData.firstFrame, cachedData.lastFrame - 1);+ meta.shared.range.set([+ player.status.framesToSeconds(cachedData.firstFrame),+ player.status.framesToSeconds(cachedData.lastFrame),+ ]);}}}>diff --git a/packages/ui/src/components/timeline/Timeline.module.scss b/packages/ui/src/components/timeline/Timeline.module.scssindex c19746fb..488b5c08 100644--- a/packages/ui/src/components/timeline/Timeline.module.scss+++ b/packages/ui/src/components/timeline/Timeline.module.scss@@ -2,10 +2,16 @@background-color: var(--surface-color);width: 100%;height: 100%;-+ padding-top: 1px;+ opacity: 0;+ transition: opacity 0.2s;display: flex;align-items: stretch;position: relative;++ &.show {+ opacity: 1;+ }}.sidebar {@@ -220,7 +226,7 @@.playheadPreview {position: absolute;- width: 1px;+ width: 2px;top: 0;bottom: 0;background-color: white;@@ -228,7 +234,7 @@pointer-events: none;.root:hover & {- opacity: 0.24;+ opacity: 0.16;}}@@ -237,8 +243,8 @@cursor: move;position: absolute;height: 32px;- background-color: var(--theme-overlay);- border-bottom: 2px solid var(--theme);+ background-color: var(--surface-color);+ border: 2px solid var(--surface-color-light);display: flex;align-items: center;justify-content: center;@@ -268,4 +274,15 @@position: relative;width: 100%;margin: 24px 0;+ opacity: 0;+ transition: opacity 0.2s;++ &.show {+ opacity: 1;+ }++ &.active {+ cursor: move;+ filter: brightness(0.9);+ }}diff --git a/packages/ui/src/components/timeline/Timeline.tsx b/packages/ui/src/components/timeline/Timeline.tsxindex e35de238..97d72ef8 100644--- a/packages/ui/src/components/timeline/Timeline.tsx+++ b/packages/ui/src/components/timeline/Timeline.tsx@@ -2,16 +2,18 @@ import styles from './Timeline.module.scss';import {useCallback,+ useEffect,useLayoutEffect,useMemo,useRef,- useState,} from 'preact/hooks';import {useDocumentEvent,- usePlayerState,+ useDuration,+ usePreviewSettings,useSize,useStateChange,+ useStorage,} from '../../hooks';import {Playhead} from './Playhead';import {Timestamps} from './Timestamps';@@ -21,10 +23,11 @@ import {RangeSelector} from './RangeSelector';import {clamp} from '@motion-canvas/core/lib/tweening';import {AudioTrack} from './AudioTrack';import {- usePlayer,+ useApplication,TimelineContextProvider,TimelineState,} from '../../contexts';+import clsx from 'clsx';const ZOOM_SPEED = 0.1;const ZOOM_MIN = 0.5;@@ -32,13 +35,19 @@ const TIMESTAMP_SPACING = 32;const MAX_FRAME_SIZE = 128;export function Timeline() {- const player = usePlayer();+ const {player} = useApplication();const containerRef = useRef<HTMLDivElement>();const playheadRef = useRef<HTMLDivElement>();- const {duration, fps} = usePlayerState();+ const duration = useDuration();+ const {fps} = usePreviewSettings();const rect = useSize(containerRef);- const [offset, setOffset] = useState(0);- const [scale, setScale] = useState(1);+ const [offset, setOffset] = useStorage('timeline-offset', 0);+ const [scale, setScale] = useStorage('timeline-scale', 1);+ const isReady = duration > 0;++ useEffect(() => {+ containerRef.current.scrollLeft = offset;+ }, [rect.width > 0 && isReady]);const sizes = useMemo(() => ({@@ -103,7 +112,7 @@ export function Timeline() {if (prevWidth !== 0 && rect.width !== 0) {newScale *= prevWidth / rect.width;}- if (!isNaN(newScale)) {+ if (!isNaN(newScale) && duration > 0) {setScale(clamp(ZOOM_MIN, ZOOM_MAX, newScale));}},@@ -132,7 +141,7 @@ export function Timeline() {return (<TimelineContextProvider state={state}>- <div className={styles.root}>+ <div className={clsx(styles.root, isReady && styles.show)}><divclassName={styles.timelineWrapper}ref={containerRef}diff --git a/packages/ui/src/components/viewport/Debug.tsx b/packages/ui/src/components/viewport/Debug.tsxindex 5bc7b001..c78ed91c 100644--- a/packages/ui/src/components/viewport/Debug.tsx+++ b/packages/ui/src/components/viewport/Debug.tsx@@ -2,8 +2,9 @@ import styles from './Viewport.module.scss';import {useCurrentScene,- usePlayerState,usePlayerTime,+ usePreviewSettings,+ useSharedSettings,useSubscribable,} from '../../hooks';import {@@ -15,19 +16,19 @@ import {} from 'preact/hooks';import {ViewportContext} from './ViewportContext';import {isInspectable} from '@motion-canvas/core/lib/scenes/Inspectable';-import {useInspection, usePlayer} from '../../contexts';+import {useInspection, useApplication} from '../../contexts';export function Debug() {const time = usePlayerTime();const scene = useCurrentScene();- const player = usePlayer();- const {scale} = usePlayerState();+ const {player} = useApplication();+ const {resolutionScale} = usePreviewSettings();+ const {size} = useSharedSettings();const canvasRef = useRef<HTMLCanvasElement>();const contextRef = useRef<CanvasRenderingContext2D>();const state = useContext(ViewportContext);const {inspectedElement, setInspectedElement} = useInspection();const [renderCount, setRenderCount] = useState(0);- const size = player.project.getSize();const matrix = useMemo(() => {const matrix = new DOMMatrix();@@ -37,15 +38,20 @@ export function Debug() {const offset = size.scale(-0.5);matrix.translateSelf(state.x + state.width / 2, state.y + state.height / 2);- matrix.scaleSelf(state.zoom * scale, state.zoom * scale);+ matrix.scaleSelf(+ state.zoom * resolutionScale,+ state.zoom * resolutionScale,+ );matrix.translateSelf(offset.width, offset.height);return matrix;- }, [size, state, scale]);+ }, [size, state, resolutionScale]);- useSubscribable(player.onReloaded, () => setRenderCount(renderCount + 1), [- renderCount,- ]);+ useSubscribable(+ player.onRecalculated,+ () => setRenderCount(renderCount + 1),+ [renderCount],+ );useLayoutEffect(() => {contextRef.current ??= canvasRef.current.getContext('2d');diff --git a/packages/ui/src/components/viewport/View.tsx b/packages/ui/src/components/viewport/EditorPreview.tsxsimilarity index 80%rename from packages/ui/src/components/viewport/View.tsxrename to packages/ui/src/components/viewport/EditorPreview.tsxindex 69ec26b0..c52edfc2 100644--- a/packages/ui/src/components/viewport/View.tsx+++ b/packages/ui/src/components/viewport/EditorPreview.tsx@@ -4,30 +4,34 @@ import {useCurrentScene,useDocumentEvent,useDrag,+ usePreviewSettings,+ useSharedSettings,useSize,+ useStateChange,useStorage,useSubscribable,- usePlayerState,- useStateChange,} from '../../hooks';import {Debug} from './Debug';import {Grid} from './Grid';import styles from './Viewport.module.scss';import {ViewportContext, ViewportState} from './ViewportContext';import {isInspectable} from '@motion-canvas/core/lib/scenes/Inspectable';-import {useInspection, usePlayer} from '../../contexts';+import {useApplication, useInspection} from '../../contexts';import {highlight} from '../animations';+import {PreviewStage} from './PreviewStage';const ZOOM_SPEED = 0.1;-export function View() {- const player = usePlayer();+export function EditorPreview() {+ const {player} = useApplication();const scene = useCurrentScene();const containerRef = useRef<HTMLDivElement>();- const viewportRef = useRef<HTMLCanvasElement>();const overlayRef = useRef<HTMLDivElement>();const size = useSize(containerRef);- const playerState = usePlayerState();+ const settings = {+ ...useSharedSettings(),+ ...usePreviewSettings(),+ };const [state, setState, wasStateLoaded] = useStorage<ViewportState>('viewport',@@ -44,14 +48,16 @@ export function View() {const resetZoom = useCallback(() => {const rect = containerRef.current.getBoundingClientRect();- const {width, height} = player.project.getSize();+ const {width, height} = size;let zoom = rect.height / height;if (width * zoom > rect.width) {zoom = rect.width / width;}- zoom /= playerState.scale;- setState({...state, zoom, x: 0, y: 0});- }, [state, player, playerState.scale]);+ zoom /= settings.resolutionScale;+ if (!isNaN(zoom) && zoom > 0 && zoom < Infinity) {+ setState({...state, zoom, x: 0, y: 0});+ }+ }, [state, player, settings.resolutionScale]);const [handleDrag, isDragging] = useDrag(useCallback(@@ -81,22 +87,18 @@ export function View() {}}, [wasStateLoaded]);- useEffect(() => {- player.project.setCanvas(viewportRef.current);- }, [playerState.colorSpace]);-useStateChange(([scale]) => {- const zoom = (state.zoom * scale) / playerState.scale;+ const zoom = (state.zoom * scale) / settings.resolutionScale;if (!isNaN(zoom) && zoom > 0) {setState({...state, zoom});}},- [playerState.scale],+ [settings.resolutionScale],);useSubscribable(- player.onReloaded,+ player.onRecalculated,() => overlayRef.current.animate(highlight(), {duration: 300}),[],);@@ -152,13 +154,12 @@ export function View() {y: event.y - size.y,};- const projectSize = player.project.getSize();position.x -= state.x + size.width / 2;position.y -= state.y + size.height / 2;- position.x /= state.zoom * playerState.scale;- position.y /= state.zoom * playerState.scale;- position.x += projectSize.width / 2;- position.y += projectSize.height / 2;+ position.x /= state.zoom * settings.resolutionScale;+ position.y /= state.zoom * settings.resolutionScale;+ position.x += settings.size.width / 2;+ position.y += settings.size.height / 2;setInspectedElement(scene.inspectPosition(position.x, position.y));} else {@@ -184,7 +185,7 @@ export function View() {><divclassName={- player.project.background+ settings.background?.alpha() === 1? styles.canvasOutline: styles.alphaBackground}@@ -193,11 +194,7 @@ export function View() {outlineWidth: `${1 / state.zoom}px`,}}>- <canvas- className={styles.preview}- key={playerState.colorSpace}- ref={viewportRef}- />+ <PreviewStage /></div><Grid /><Debug />diff --git a/packages/ui/src/components/viewport/PreviewStage.tsx b/packages/ui/src/components/viewport/PreviewStage.tsxnew file mode 100644index 00000000..be9d65d3--- /dev/null+++ b/packages/ui/src/components/viewport/PreviewStage.tsx@@ -0,0 +1,39 @@+import {useEffect, useRef, useState} from 'preact/hooks';+import {Stage} from '@motion-canvas/core';+import {useApplication} from '../../contexts';+import {+ usePreviewSettings,+ useSharedSettings,+ useSubscribable,+} from '../../hooks';++export function PreviewStage() {+ const [stage] = useState(() => new Stage());+ const ref = useRef<HTMLDivElement>();+ const {player} = useApplication();+ const {size, background} = useSharedSettings();+ const {resolutionScale} = usePreviewSettings();++ useSubscribable(+ player.onRender,+ async () => {+ await stage.render(+ player.playback.currentScene,+ player.playback.previousScene,+ );+ },+ [],+ );++ useEffect(() => {+ stage.configure({resolutionScale, size, background});+ stage.render(player.playback.currentScene, player.playback.previousScene);+ }, [resolutionScale, size, background]);++ useEffect(() => {+ ref.current.append(stage.finalBuffer);+ return () => stage.finalBuffer.remove();+ }, []);++ return <div ref={ref} />;+}diff --git a/packages/ui/src/components/viewport/RenderingPreview.tsx b/packages/ui/src/components/viewport/RenderingPreview.tsxnew file mode 100644index 00000000..7e2f6fa6--- /dev/null+++ b/packages/ui/src/components/viewport/RenderingPreview.tsx@@ -0,0 +1,28 @@+import {useApplication} from '../../contexts';+import {useLayoutEffect, useRef} from 'preact/hooks';+import {useSharedSettings} from '../../hooks';++import styles from './Viewport.module.scss';+import clsx from 'clsx';++export function RenderingPreview() {+ const {renderer} = useApplication();+ const ref = useRef<HTMLDivElement>();+ const settings = useSharedSettings();++ useLayoutEffect(() => {+ ref.current.append(renderer.stage.finalBuffer);+ return () => renderer.stage.finalBuffer.remove();+ }, []);++ return (+ <div+ className={clsx(+ styles.viewport,+ styles.renderingPreview,+ settings.background ? styles.canvasOutline : styles.alphaBackground,+ )}+ ref={ref}+ />+ );+}diff --git a/packages/ui/src/components/viewport/Viewport.module.scss b/packages/ui/src/components/viewport/Viewport.module.scssindex 7192f198..94fbe3f3 100644--- a/packages/ui/src/components/viewport/Viewport.module.scss+++ b/packages/ui/src/components/viewport/Viewport.module.scss@@ -16,23 +16,30 @@flex-grow: 1;background-color: #000000;++ canvas {+ display: block;+ }+}++.renderingPreview {+ canvas {+ max-width: 100%;+ max-height: 100%;+ }}-.alphaBackground {+.alphaBackground canvas {background-color: rgba(0, 0, 0, 0.16);background-size: 80px;background-position: center;background-image: url('../../img/grid.svg');}-.canvasOutline {+.canvasOutline canvas {outline: 1px solid var(--surface-color);}-.preview {- display: block;-}-.overlay {position: absolute;top: 0;diff --git a/packages/ui/src/components/viewport/Viewport.tsx b/packages/ui/src/components/viewport/Viewport.tsxindex 6ca027ce..1abc489e 100644--- a/packages/ui/src/components/viewport/Viewport.tsx+++ b/packages/ui/src/components/viewport/Viewport.tsx@@ -1,40 +1,52 @@-import {usePlayerState} from '../../hooks';+import {useDuration, usePlayerState, useRendererState} from '../../hooks';import {PlaybackControls, PlaybackProgress} from '../playback';import {CurrentTime} from '../playback/CurrentTime';-import {View} from './View';+import {EditorPreview} from './EditorPreview';import styles from './Viewport.module.scss';-import {usePlayer} from '../../contexts';+import {useApplication} from '../../contexts';+import {RenderingPreview} from './RenderingPreview';+import {RendererState} from '@motion-canvas/core';export function Viewport() {- const player = usePlayer();- const state = usePlayerState();+ const {player} = useApplication();+ const duration = useDuration();+ const {speed} = usePlayerState();+ const state = useRendererState();return (<div className={styles.root}>- <View />+ {state === RendererState.Working ? (+ <RenderingPreview />+ ) : (+ <EditorPreview />+ )}<PlaybackProgress /><div className={styles.playback}><CurrentTimerender={time => {return (<div className={styles.time} title="Current time">- {formatFrames(player.project.framesToSeconds(time))}- <span className={styles.frames}>[{time}]</span>+ {formatDuration(player.status.framesToSeconds(time))}+ <span className={styles.frames}>+ [{formatFrames(time, speed)}]+ </span></div>);}}/><PlaybackControls /><div className={styles.duration} title="Duration">- <span className={styles.frames}>[{state.duration}]</span>- {formatFrames(player.project.framesToSeconds(state.duration))}+ <span className={styles.frames}>+ [{formatFrames(duration, speed)}]+ </span>+ {formatDuration(player.status.framesToSeconds(duration))}</div></div></div>);}-function formatFrames(duration: number) {+function formatDuration(duration: number) {const minutes = Math.floor(duration / 60) % 60;const seconds = Math.floor(duration % 60);@@ -42,3 +54,12 @@ function formatFrames(duration: number) {.toString().padStart(2, '0')}`;}++function formatFrames(frames: number, speed: number) {+ const round = speed % 1 === 0;+ if (round) {+ return frames;+ } else {+ return frames.toFixed(2);+ }+}diff --git a/packages/ui/src/components/viewport/index.ts b/packages/ui/src/components/viewport/index.tsindex a0a706a1..f3e6b530 100644--- a/packages/ui/src/components/viewport/index.ts+++ b/packages/ui/src/components/viewport/index.ts@@ -1,2 +1 @@-export * from './View';export * from './Viewport';diff --git a/packages/ui/src/contexts/application.tsx b/packages/ui/src/contexts/application.tsxnew file mode 100644index 00000000..cbfe5e5a--- /dev/null+++ b/packages/ui/src/contexts/application.tsx@@ -0,0 +1,30 @@+import {ComponentChildren, createContext} from 'preact';+import {useContext} from 'preact/hooks';+import {Player, Renderer, Project, ProjectMetadata} from '@motion-canvas/core';++interface Application {+ project: Project;+ player: Player;+ renderer: Renderer;+ meta: ProjectMetadata;+}++const ApplicationContext = createContext<Application | null>(null);++export function useApplication(): Application {+ return useContext(ApplicationContext);+}++export function ApplicationProvider({+ application,+ children,+}: {+ application: Application;+ children: ComponentChildren;+}) {+ return (+ <ApplicationContext.Provider value={application}>+ {children}+ </ApplicationContext.Provider>+ );+}diff --git a/packages/ui/src/contexts/index.ts b/packages/ui/src/contexts/index.tsindex 446ee0c2..266e72fa 100644--- a/packages/ui/src/contexts/index.ts+++ b/packages/ui/src/contexts/index.ts@@ -1,5 +1,4 @@+export * from './application';export * from './inspection';export * from './logger';-export * from './player';-export * from './project';export * from './timeline';diff --git a/packages/ui/src/contexts/logger.tsx b/packages/ui/src/contexts/logger.tsxindex a4e391a6..2bb4a8da 100644--- a/packages/ui/src/contexts/logger.tsx+++ b/packages/ui/src/contexts/logger.tsx@@ -1,9 +1,9 @@+import {LogLevel, LogPayload, Logger} from '@motion-canvas/core';import {ComponentChildren, createContext} from 'preact';import {useContext, useRef} from 'preact/hooks';-import {LogLevel, LogPayload, Project} from '@motion-canvas/core/lib';import {ValueDispatcher} from '@motion-canvas/core/lib/events';-import {useProject} from './project';-import {useSubscribableValue} from '../hooks';+import {useSubscribable, useSubscribableValue} from '../hooks';+import {useApplication} from './application';export class LoggerManager {public get onErrorLogged() {@@ -16,13 +16,9 @@ export class LoggerManager {}private readonly logs = new ValueDispatcher<LogPayload[]>([]);- private readonly logger;-- public constructor(project: Project) {- this.logger = project.logger;- this.logs.current = project.logger.history;+ public constructor(private readonly logger: Logger) {+ this.logs.current = logger.history;this.logger.onLogged.subscribe(this.handleLog);- project.onReloaded.subscribe(this.clear);}public readonly clear = () => {@@ -54,9 +50,10 @@ export interface LoggerProviderProps {children: ComponentChildren;}export function LoggerProvider({children}: LoggerProviderProps) {- const project = useProject();+ const {project, player} = useApplication();const manager = useRef<LoggerManager | null>(null);- manager.current ??= new LoggerManager(project);+ manager.current ??= new LoggerManager(project.logger);+ useSubscribable(player.onRecalculated, () => manager.current.clear(), []);return (<LoggerContext.Provider value={manager.current}>diff --git a/packages/ui/src/contexts/player.tsx b/packages/ui/src/contexts/player.tsxdeleted file mode 100644index a1f04899..00000000--- a/packages/ui/src/contexts/player.tsx+++ /dev/null@@ -1,21 +0,0 @@-import {ComponentChildren, createContext} from 'preact';-import {useContext} from 'preact/hooks';-import type {Player} from '@motion-canvas/core/lib/player';--const PlayerContext = createContext<Player | null>(null);--export function usePlayer() {- return useContext(PlayerContext);-}--export function PlayerProvider({- player,- children,-}: {- player: Player;- children: ComponentChildren;-}) {- return (- <PlayerContext.Provider value={player}>{children}</PlayerContext.Provider>- );-}diff --git a/packages/ui/src/contexts/project.tsx b/packages/ui/src/contexts/project.tsxdeleted file mode 100644index c3350163..00000000--- a/packages/ui/src/contexts/project.tsx+++ /dev/null@@ -1,23 +0,0 @@-import {ComponentChildren, createContext} from 'preact';-import {useContext} from 'preact/hooks';-import type {Project} from '@motion-canvas/core/lib';--const ProjectContext = createContext<Project | null>(null);--export function useProject() {- return useContext(ProjectContext);-}--export function ProjectProvider({- project,- children,-}: {- project: Project;- children: ComponentChildren;-}) {- return (- <ProjectContext.Provider value={project}>- {children}- </ProjectContext.Provider>- );-}diff --git a/packages/ui/src/hooks/index.ts b/packages/ui/src/hooks/index.tsindex 22475ecc..b3a91d19 100644--- a/packages/ui/src/hooks/index.ts+++ b/packages/ui/src/hooks/index.ts@@ -1,11 +1,14 @@export * from './useCurrentFrame';export * from './useDocumentEvent';export * from './useDrag';+export * from './useDuration';export * from './useFormattedNumber';-export * from './useMeta';+export * from './useKeyHold';export * from './usePlayerState';export * from './usePlayerTime';+export * from './useRendererState';export * from './useScenes';+export * from './useSettings';export * from './useSize';export * from './useStateChange';export * from './useStorage';diff --git a/packages/ui/src/hooks/useCurrentFrame.ts b/packages/ui/src/hooks/useCurrentFrame.tsindex d0e5f8d4..283ac40f 100644--- a/packages/ui/src/hooks/useCurrentFrame.ts+++ b/packages/ui/src/hooks/useCurrentFrame.ts@@ -1,7 +1,18 @@import {useSubscribableValue} from './useSubscribable';-import {usePlayer} from '../contexts';+import {useApplication} from '../contexts';+import {RendererState} from '@motion-canvas/core';+import {usePreviewSettings, useRenderingSettings} from './useSettings';+import {useRendererState} from './useRendererState';export function useCurrentFrame() {- const player = usePlayer();- return useSubscribableValue(player.onFrameChanged);+ const {player, renderer} = useApplication();+ const playerFrame = useSubscribableValue(player.onFrameChanged);+ const rendererFrame = useSubscribableValue(renderer.onFrameChanged);+ const rendererState = useRendererState();+ const preview = usePreviewSettings();+ const rendering = useRenderingSettings();++ return rendererState === RendererState.Working+ ? Math.floor((rendererFrame / rendering.fps) * preview.fps)+ : playerFrame;}diff --git a/packages/ui/src/hooks/useDuration.ts b/packages/ui/src/hooks/useDuration.tsnew file mode 100644index 00000000..c14d75a7--- /dev/null+++ b/packages/ui/src/hooks/useDuration.ts@@ -0,0 +1,7 @@+import {useApplication} from '../contexts';+import {useSubscribableValue} from './useSubscribable';++export function useDuration() {+ const {player} = useApplication();+ return useSubscribableValue(player.onDurationChanged);+}diff --git a/packages/ui/src/hooks/useKeyHold.ts b/packages/ui/src/hooks/useKeyHold.tsnew file mode 100644index 00000000..af7fbff9--- /dev/null+++ b/packages/ui/src/hooks/useKeyHold.ts@@ -0,0 +1,28 @@+import {useEffect, useState} from 'preact/hooks';++export function useKeyHold(key: string) {+ const [isHeld, setHeld] = useState(false);++ useEffect(() => {+ const handleDown = (event: KeyboardEvent) => {+ if (event.key === key) {+ setHeld(true);+ }+ };+ const handleUp = (event: KeyboardEvent) => {+ if (event.key === key) {+ setHeld(false);+ }+ };++ document.addEventListener('keydown', handleDown, true);+ document.addEventListener('keyup', handleUp, true);++ return () => {+ document.removeEventListener('keydown', handleDown, true);+ document.removeEventListener('keyup', handleUp, true);+ };+ }, [key]);++ return isHeld;+}diff --git a/packages/ui/src/hooks/useMeta.ts b/packages/ui/src/hooks/useMeta.tsdeleted file mode 100644index 671c0ff5..00000000--- a/packages/ui/src/hooks/useMeta.ts+++ /dev/null@@ -1,31 +0,0 @@-import type {Meta, Metadata} from '@motion-canvas/core/lib';-import {useCallback} from 'preact/hooks';-import {useSubscribableValue} from './useSubscribable';-import {usePlayer} from '../contexts';--/**- * Get a stateful value representing the contents of the given meta file and- * a function to update it.- *- * @param meta - The meta object to extract data from.- */-export function useMeta<T extends Metadata>(- meta: Meta<T>,-): [T, (value: Partial<T>) => void] {- const data = useSubscribableValue(meta.onDataChanged);- const setter = useCallback(- (value: Partial<T>) => meta.setDataSync(value),- [meta],- );-- return [data, setter];-}--/**- * Get a stateful value representing the contents of the project's meta file and- * a function to update it.- */-export function useProjectMeta() {- const {project} = usePlayer();- return useMeta(project.meta);-}diff --git a/packages/ui/src/hooks/usePlayerState.ts b/packages/ui/src/hooks/usePlayerState.tsindex d3ec865b..0f95b523 100644--- a/packages/ui/src/hooks/usePlayerState.ts+++ b/packages/ui/src/hooks/usePlayerState.ts@@ -1,7 +1,7 @@-import {usePlayer} from '../contexts';+import {useApplication} from '../contexts';import {useSubscribableValue} from './useSubscribable';export function usePlayerState() {- const player = usePlayer();+ const {player} = useApplication();return useSubscribableValue(player.onStateChanged);}diff --git a/packages/ui/src/hooks/usePlayerTime.ts b/packages/ui/src/hooks/usePlayerTime.tsindex 056cd217..5e0bfc3e 100644--- a/packages/ui/src/hooks/usePlayerTime.ts+++ b/packages/ui/src/hooks/usePlayerTime.ts@@ -1,19 +1,21 @@import {useMemo} from 'preact/hooks';-import {usePlayerState} from './usePlayerState';import {useCurrentFrame} from './useCurrentFrame';+import {usePreviewSettings} from './useSettings';+import {useDuration} from './useDuration';export function usePlayerTime() {- const state = usePlayerState();+ const {fps} = usePreviewSettings();const frame = useCurrentFrame();+ const duration = useDuration();return useMemo(() => ({frame,- time: frame / state.fps,- duration: state.duration,- durationTime: state.duration / state.fps,- completion: frame / state.duration,+ time: frame / fps,+ duration: duration,+ durationTime: duration / fps,+ completion: frame / duration,}),- [state, frame],+ [frame, duration, fps],);}diff --git a/packages/ui/src/hooks/useRendererState.ts b/packages/ui/src/hooks/useRendererState.tsnew file mode 100644index 00000000..72d2dbc7--- /dev/null+++ b/packages/ui/src/hooks/useRendererState.ts@@ -0,0 +1,7 @@+import {useSubscribableValue} from './useSubscribable';+import {useApplication} from '../contexts';++export function useRendererState() {+ const {renderer} = useApplication();+ return useSubscribableValue(renderer.onStateChanged);+}diff --git a/packages/ui/src/hooks/useScenes.ts b/packages/ui/src/hooks/useScenes.tsindex d8b74741..c27cb4d6 100644--- a/packages/ui/src/hooks/useScenes.ts+++ b/packages/ui/src/hooks/useScenes.ts@@ -1,12 +1,12 @@import {useSubscribableValue} from './useSubscribable';-import {usePlayer} from '../contexts';+import {useApplication} from '../contexts';export function useScenes() {- const player = usePlayer();- return useSubscribableValue(player.project.onScenesChanged);+ const {player} = useApplication();+ return useSubscribableValue(player.playback.onScenesRecalculated);}export function useCurrentScene() {- const player = usePlayer();- return useSubscribableValue(player.project.onCurrentSceneChanged);+ const {player} = useApplication();+ return useSubscribableValue(player.playback.onSceneChanged);}diff --git a/packages/ui/src/hooks/useSettings.ts b/packages/ui/src/hooks/useSettings.tsnew file mode 100644index 00000000..580af87c--- /dev/null+++ b/packages/ui/src/hooks/useSettings.ts@@ -0,0 +1,17 @@+import {useApplication} from '../contexts';+import {useSubscribableValue} from './useSubscribable';++export function useSharedSettings() {+ const {meta} = useApplication();+ return useSubscribableValue(meta.shared.onChanged);+}++export function usePreviewSettings() {+ const {meta} = useApplication();+ return useSubscribableValue(meta.preview.onChanged);+}++export function useRenderingSettings() {+ const {meta} = useApplication();+ return useSubscribableValue(meta.rendering.onChanged);+}diff --git a/packages/ui/src/hooks/useStorage.ts b/packages/ui/src/hooks/useStorage.tsindex bdd75455..fec90e90 100644--- a/packages/ui/src/hooks/useStorage.ts+++ b/packages/ui/src/hooks/useStorage.ts@@ -1,11 +1,11 @@import {useCallback, useMemo, useState} from 'preact/hooks';-import {usePlayer} from '../contexts';+import {useApplication} from '../contexts';export function useStorage<T>(id: string,initialState: T = null,): [T, (newState: T) => void, boolean] {- const name = usePlayer().project.name;+ const name = useApplication().project.name;const key = `${name}-${id}`;const [savedState, wasLoaded] = useMemo(() => {const savedState = localStorage.getItem(key);diff --git a/packages/ui/src/main.tsx b/packages/ui/src/main.tsxindex 458cfa72..ed15f990 100644--- a/packages/ui/src/main.tsx+++ b/packages/ui/src/main.tsx@@ -1,16 +1,16 @@import './index.scss';-import type {Project} from '@motion-canvas/core/lib';-import {Player} from '@motion-canvas/core/lib/player';+import type {Project} from '@motion-canvas/core';+import {Player, Renderer} from '@motion-canvas/core';import {ComponentChild, render} from 'preact';import {Editor} from './Editor';import {Index, ProjectData} from './Index';import {InspectionProvider,LoggerProvider,- PlayerProvider,- ProjectProvider,+ ApplicationProvider,} from './contexts';+import {getItem, setItem} from './utils';function renderRoot(vnode: ComponentChild) {const root = document.createElement('main');@@ -18,8 +18,7 @@ function renderRoot(vnode: ComponentChild) {render(vnode, root);}-export function editor(factory: () => Project) {- const project = factory();+export function editor(project: Project) {Error.stackTraceLimit = Infinity;project.logger.onLogged.subscribe(log => {@@ -31,35 +30,47 @@ export function editor(factory: () => Project) {}});- const player = new Player(project);+ const renderer = new Renderer(project);++ const meta = project.meta;const playerKey = `${project.name}/player`;const frameKey = `${project.name}/frame`;- const state = localStorage.getItem(playerKey);- const frame = localStorage.getItem(frameKey);- if (state) {- player.loadState(JSON.parse(state));- }- if (frame) {- player.requestSeek(parseInt(frame));- }+ const player = new Player(+ project,+ meta.getFullPreviewSettings(),+ getItem(playerKey, {}),+ getItem(frameKey, -1),+ );+player.onStateChanged.subscribe(state => {- localStorage.setItem(playerKey, JSON.stringify(state));+ setItem(playerKey, state);});player.onFrameChanged.subscribe(frame => {- localStorage.setItem(frameKey, frame.toString());+ setItem(frameKey, frame);});+ const updatePlayer = () => {+ player.configure(meta.getFullPreviewSettings());+ };+ meta.shared.onChanged.subscribe(updatePlayer);+ meta.preview.onChanged.subscribe(updatePlayer);+document.title = `${project.name} | Motion Canvas`;renderRoot(- <PlayerProvider player={player}>- <ProjectProvider project={project}>- <LoggerProvider>- <InspectionProvider>- <Editor />- </InspectionProvider>- </LoggerProvider>- </ProjectProvider>- </PlayerProvider>,+ <ApplicationProvider+ application={{+ player,+ renderer,+ project,+ meta,+ }}+ >+ <LoggerProvider>+ <InspectionProvider>+ <Editor />+ </InspectionProvider>+ </LoggerProvider>+ </ApplicationProvider>,);}diff --git a/packages/ui/src/utils/index.ts b/packages/ui/src/utils/index.tsindex 6b4cf4b3..0646a189 100644--- a/packages/ui/src/utils/index.ts+++ b/packages/ui/src/utils/index.ts@@ -1,2 +1,3 @@+export * from './localStorage';export * from './sourceMaps';export * from './withLoader';diff --git a/packages/ui/src/utils/localStorage.ts b/packages/ui/src/utils/localStorage.tsnew file mode 100644index 00000000..03b806dd--- /dev/null+++ b/packages/ui/src/utils/localStorage.ts@@ -0,0 +1,11 @@+export function getItem<T>(key: string, initial: T): T {+ try {+ return JSON.parse(localStorage.getItem(key));+ } catch (_) {+ return initial;+ }+}++export function setItem(key: string, value: unknown) {+ localStorage.setItem(key, JSON.stringify(value));+}diff --git a/packages/vite-plugin/src/__logs__/project-instance.md b/packages/vite-plugin/src/__logs__/project-instance.mddeleted file mode 100644index ce61eac1..00000000--- a/packages/vite-plugin/src/__logs__/project-instance.md+++ /dev/null@@ -1,8 +0,0 @@-Use the `makeProject()` function instead:--```ts-import {makeProject} from '@motion-canvas/core';-export default makeProject({- // Configuration and scenes go here.-});-```diff --git a/packages/vite-plugin/src/main.ts b/packages/vite-plugin/src/main.tsindex 723fdc86..bb4b942d 100644--- a/packages/vite-plugin/src/main.ts+++ b/packages/vite-plugin/src/main.ts@@ -3,7 +3,6 @@ import path from 'path';import fs from 'fs';import {Readable} from 'stream';import mime from 'mime-types';-import projectInstance from './__logs__/project-instance.md';import {motionCanvasCorsProxy,MotionCanvasCorsProxyOptions,@@ -181,10 +180,10 @@ export default ({return source(`import {ValueDispatcher} from '@motion-canvas/core/lib/events';`,- `import meta from './${metaFile}';`,+ `import metaFile from './${metaFile}';`,`import description from './${sceneFile}';`,`description.name = '${name}';`,- `description.meta = meta;`,+ `metaFile.attach(description.meta);`,`if (import.meta.hot) {`,` description.onReplaced = import.meta.hot.data.onReplaced;`,`}`,@@ -206,23 +205,13 @@ export default ({await createMeta(path.join(dir, metaFile));return source(- `import {Project} from '@motion-canvas/core';`,- `import meta from './${metaFile}';`,+ `import metaFile from './${metaFile}';`,`import config from './${name}';`,- `const factory = () => {`,- ` if (config instanceof Project) {`,- ` config.meta = meta;`,- ` config.name = '${name}';`,- ` config.logger.warn({`,- ` message: 'A project instance was exported instead of a project factory.',`,- ` remarks: \`${projectInstance}\`,`,- ` stack: config.creationStack,`,- ` });`,- ` return config;`,- ` }`,- ` return new Project('${name}', meta, config);`,- `}`,- `export default factory;`,+ `metaFile.attach(config.meta)`,+ `export default {`,+ ` name: '${name}',`,+ ` ...config,`,+ `};`,);}}@@ -267,12 +256,12 @@ export default ({if (ext === '.meta') {const sourceFile = viteConfig.command === 'build' ? false : `'${id}'`;return source(- `import {Meta} from '@motion-canvas/core/lib';`,+ `import {MetaFile} from '@motion-canvas/core/lib/meta';`,`let meta;`,`if (import.meta.hot) {`,` meta = import.meta.hot.data.meta;`,`}`,- `meta ??= new Meta('${name}', ${sourceFile}, ${code});`,+ `meta ??= new MetaFile('${name}', ${sourceFile});`,`if (import.meta.hot) {`,` import.meta.hot.accept();`,` import.meta.hot.data.meta = meta;`,