Skip to content

Visualize Your Ideas With Code

feat: new playback architecture (#402)

Jacobbbe3e2a24de0
diff --git a/package.json b/package.json
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.json
index 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.ts
deleted file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
similarity index 97%
rename from packages/core/src/Logger.ts
rename to packages/core/src/app/Logger.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
deleted file mode 100644
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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 seconds
const 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.meta
index 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 file
diff --git a/packages/examples/src/components.meta b/packages/examples/src/components.meta
index 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 file
diff --git a/packages/examples/src/components.ts b/packages/examples/src/components.ts
index 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.meta
index 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 file
diff --git a/packages/examples/src/layout.meta b/packages/examples/src/layout.meta
index 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 file
diff --git a/packages/examples/src/layout.ts b/packages/examples/src/layout.ts
index 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.meta
index 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 file
diff --git a/packages/examples/src/media-image.meta b/packages/examples/src/media-image.meta
index 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 file
diff --git a/packages/examples/src/media-video.meta b/packages/examples/src/media-video.meta
index 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 file
diff --git a/packages/examples/src/node-signal.meta b/packages/examples/src/node-signal.meta
index 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 file
diff --git a/packages/examples/src/positioning.meta b/packages/examples/src/positioning.meta
index 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 file
diff --git a/packages/examples/src/positioning.ts b/packages/examples/src/positioning.ts
index 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.meta
index 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 file
diff --git a/packages/examples/src/random.meta b/packages/examples/src/random.meta
index 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 file
diff --git a/packages/examples/src/random.ts b/packages/examples/src/random.ts
index 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.meta
index 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 file
diff --git a/packages/examples/src/scenes/components.meta b/packages/examples/src/scenes/components.meta
index 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 file
diff --git a/packages/examples/src/scenes/layout-group.meta b/packages/examples/src/scenes/layout-group.meta
index 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 file
diff --git a/packages/examples/src/scenes/layout.meta b/packages/examples/src/scenes/layout.meta
index 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 file
diff --git a/packages/examples/src/scenes/logging.meta b/packages/examples/src/scenes/logging.meta
index 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 file
diff --git a/packages/examples/src/scenes/media-image.meta b/packages/examples/src/scenes/media-image.meta
index 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 file
diff --git a/packages/examples/src/scenes/media-image.tsx b/packages/examples/src/scenes/media-image.tsx
index 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.meta
index 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 file
diff --git a/packages/examples/src/scenes/node-signal.meta b/packages/examples/src/scenes/node-signal.meta
index 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 file
diff --git a/packages/examples/src/scenes/positioning.meta b/packages/examples/src/scenes/positioning.meta
index 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 file
diff --git a/packages/examples/src/scenes/quickstart.meta b/packages/examples/src/scenes/quickstart.meta
index 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 file
diff --git a/packages/examples/src/scenes/random.meta b/packages/examples/src/scenes/random.meta
index 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 file
diff --git a/packages/examples/src/scenes/tex.meta b/packages/examples/src/scenes/tex.meta
index 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 file
diff --git a/packages/examples/src/scenes/transitions-first.meta b/packages/examples/src/scenes/transitions-first.meta
index 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 file
diff --git a/packages/examples/src/scenes/transitions-second.meta b/packages/examples/src/scenes/transitions-second.meta
index 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 file
diff --git a/packages/examples/src/scenes/tweening-color.meta b/packages/examples/src/scenes/tweening-color.meta
index 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 file
diff --git a/packages/examples/src/scenes/tweening-cubic.meta b/packages/examples/src/scenes/tweening-cubic.meta
index 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 file
diff --git a/packages/examples/src/scenes/tweening-linear.meta b/packages/examples/src/scenes/tweening-linear.meta
index 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 file
diff --git a/packages/examples/src/scenes/tweening-spring.meta b/packages/examples/src/scenes/tweening-spring.meta
index 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 file
diff --git a/packages/examples/src/scenes/tweening-vector.meta b/packages/examples/src/scenes/tweening-vector.meta
index 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 file
diff --git a/packages/examples/src/scenes/tweening-visualiser.meta b/packages/examples/src/scenes/tweening-visualiser.meta
index 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 file
diff --git a/packages/examples/src/tex.meta b/packages/examples/src/tex.meta
index 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 file
diff --git a/packages/examples/src/tex.ts b/packages/examples/src/tex.ts
index 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.meta
index 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 file
diff --git a/packages/examples/src/tweening-color.meta b/packages/examples/src/tweening-color.meta
index 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 file
diff --git a/packages/examples/src/tweening-cubic.meta b/packages/examples/src/tweening-cubic.meta
index 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 file
diff --git a/packages/examples/src/tweening-linear.meta b/packages/examples/src/tweening-linear.meta
index 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 file
diff --git a/packages/examples/src/tweening-spring.meta b/packages/examples/src/tweening-spring.meta
index 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 file
diff --git a/packages/examples/src/tweening-vector.meta b/packages/examples/src/tweening-vector.meta
index 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 file
diff --git a/packages/examples/src/tweening-visualiser.meta b/packages/examples/src/tweening-visualiser.meta
index 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 file
diff --git a/packages/player/src/global.d.ts b/packages/player/src/global.d.ts
index 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.ts
index 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.html
index 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.ts
index 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.meta
index 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 file
diff --git a/packages/template/src/project.ts b/packages/template/src/project.ts
index 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.json
index 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.tsx
index 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.tsx
new file mode 100644
index 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.scss
index 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.tsx
index 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 (
<button
className={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.ts
index 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.scss
new file mode 100644
index 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.tsx
new file mode 100644
index 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.ts
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.ts
index 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.scss
index 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.tsx
index 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,
+ )}
+ >
<Select
title="Playback speed"
options={[
@@ -118,13 +124,27 @@ export function PlaybackControls() {
<Input
title="Current framerate"
readOnly
- value={paused ? 'PAUSED' : `${framerate} FPS`}
+ value={
+ rendererState === RendererState.Working
+ ? 'RENDERING'
+ : paused
+ ? 'PAUSED'
+ : `${framerate} FPS`
+ }
/>
)}
/>
<IconButton
title="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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.tsx
deleted file mode 100644
index 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.tsx
index 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.tsx
new file mode 100644
index 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.tsx
index 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.tsx
index 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.tsx
index 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 (
<div
className={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.tsx
index 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.tsx
index 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.scss
index 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.tsx
index 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)}>
<div
className={styles.timelineWrapper}
ref={containerRef}
diff --git a/packages/ui/src/components/viewport/Debug.tsx b/packages/ui/src/components/viewport/Debug.tsx
index 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.tsx
similarity index 80%
rename from packages/ui/src/components/viewport/View.tsx
rename to packages/ui/src/components/viewport/EditorPreview.tsx
index 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() {
>
<div
className={
- 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.scss
index 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.tsx
index 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}>
<CurrentTime
render={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.ts
index 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.tsx
new file mode 100644
index 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.ts
index 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.tsx
index 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.tsx
deleted file mode 100644
index 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.tsx
deleted file mode 100644
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.tsx
index 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.ts
index 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.ts
new file mode 100644
index 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.md
deleted file mode 100644
index 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.ts
index 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;`,