@twick/core 0.11.0

package/lib/app/Renderer.js

@@ -0,0 +1,318 @@
+import { EventDispatcher, ValueDispatcher } from '../events';
+import { FFmpegExporterClient, ImageExporter, WasmExporter, } from '../exporter';
+import { clampRemap } from '../tweening';
+import { Vector2 } from '../types';
+import { Semaphore } from '../utils';
+import { PlaybackManager, PlaybackState } from './PlaybackManager';
+import { PlaybackStatus } from './PlaybackStatus';
+import { SharedWebGLContext } from './SharedWebGLContext';
+import { Stage } from './Stage';
+import { TimeEstimator } from './TimeEstimator';
+export var RendererState;
+(function (RendererState) {
+    RendererState[RendererState["Initial"] = 0] = "Initial";
+    RendererState[RendererState["Working"] = 1] = "Working";
+    RendererState[RendererState["Aborting"] = 2] = "Aborting";
+})(RendererState || (RendererState = {}));
+export var RendererResult;
+(function (RendererResult) {
+    RendererResult[RendererResult["Success"] = 0] = "Success";
+    RendererResult[RendererResult["Error"] = 1] = "Error";
+    RendererResult[RendererResult["Aborted"] = 2] = "Aborted";
+})(RendererResult || (RendererResult = {}));
+/**
+ * The rendering logic used by the editor to export animations.
+ *
+ * @remarks
+ * This class uses the `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 Exporter.
+ */
+export class Renderer {
+    get onStateChanged() {
+        return this.state.subscribable;
+    }
+    get onFinished() {
+        return this.finished.subscribable;
+    }
+    get onFrameChanged() {
+        return this.frame.subscribable;
+    }
+    constructor(project) {
+        this.project = project;
+        this.state = new ValueDispatcher(RendererState.Initial);
+        this.finished = new EventDispatcher();
+        this.frame = new ValueDispatcher(0);
+        this.stage = new Stage();
+        this.estimator = new TimeEstimator();
+        this.lock = new Semaphore();
+        this.exporter = null;
+        this.abortController = null;
+        this.playback = new PlaybackManager();
+        this.status = new PlaybackStatus(this.playback);
+        this.sharedWebGLContext = new SharedWebGLContext(this.project.logger);
+        const scenes = [];
+        for (const description of project.scenes) {
+            const scene = new description.klass({
+                ...description,
+                playback: this.status,
+                logger: this.project.logger,
+                size: new Vector2(1920, 1080),
+                resolutionScale: 1,
+                sharedWebGLContext: this.sharedWebGLContext,
+                experimentalFeatures: project.experimentalFeatures,
+            });
+            scenes.push(scene);
+        }
+        this.playback.setup(scenes);
+    }
+    /**
+     * Returns number of frames that a project will have.
+     */
+    async getNumberOfFrames(settings) {
+        await this.lock.acquire();
+        this.estimator.reset();
+        this.state.current = RendererState.Working;
+        await this.reloadScenes(settings);
+        await this.playback.recalculate();
+        await this.playback.reset();
+        const frames = this.playback.duration;
+        this.state.current = RendererState.Initial;
+        this.sharedWebGLContext.dispose();
+        this.lock.release();
+        return frames;
+    }
+    frameToTime(frame) {
+        return this.status.framesToSeconds(frame);
+    }
+    timeToFrame(second) {
+        return this.status.secondsToFrames(second);
+    }
+    /**
+     * Render the animation using the provided settings.
+     *
+     * @param settings - The rendering settings.
+     */
+    async render(settings) {
+        if (this.state.current !== RendererState.Initial)
+            return;
+        await this.lock.acquire();
+        this.estimator.reset();
+        this.state.current = RendererState.Working;
+        let result;
+        try {
+            this.abortController = new AbortController();
+            result = await this.run(settings, this.abortController.signal);
+        }
+        catch (e) {
+            this.project.logger.error(e);
+            result = RendererResult.Error;
+            if (this.exporter) {
+                try {
+                    await this.exporter.stop?.(result);
+                }
+                catch (_) {
+                    throw Error(e.message);
+                }
+                this.exporter = null;
+                throw Error(e.message);
+            }
+        }
+        this.estimator.update(1);
+        this.state.current = RendererState.Initial;
+        this.finished.dispatch(result);
+        this.sharedWebGLContext.dispose();
+        this.lock.release();
+    }
+    /**
+     * Abort the ongoing render process.
+     */
+    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 `ImageExporter`.
+     *
+     * @param settings - The rendering settings.
+     * @param time - The timestamp to export.
+     */
+    async renderFrame(settings, time) {
+        await this.lock.acquire();
+        try {
+            const frame = this.status.secondsToFrames(time);
+            this.stage.configure(settings);
+            this.playback.fps = settings.fps;
+            this.playback.state = PlaybackState.Rendering;
+            await this.reloadScenes(settings);
+            await this.playback.reset();
+            await this.playback.seek(frame);
+            await this.stage.render(this.playback.currentScene, this.playback.previousScene);
+            if (import.meta.hot) {
+                import.meta.hot.send('twick:export', {
+                    frame,
+                    data: this.stage.finalBuffer.toDataURL('image/png'),
+                    mimeType: 'image/png',
+                    subDirectories: ['still', this.project.name],
+                });
+            }
+        }
+        catch (e) {
+            this.project.logger.error(e);
+        }
+        this.lock.release();
+    }
+    async run(settings, signal) {
+        // Select exporter
+        // TODO(refactor): check if i want to keep it this way
+        const exporters = [
+            FFmpegExporterClient,
+            ImageExporter,
+            WasmExporter,
+        ];
+        const exporterClass = exporters.find(exporter => exporter.id === settings.exporter.name);
+        if (!exporterClass) {
+            this.project.logger.error(`Could not find the "${settings.exporter.name}" exporter.`);
+            return RendererResult.Error;
+        }
+        // Instantiate exporter
+        this.exporter = await exporterClass.create(this.project, settings);
+        if (this.exporter.configuration) {
+            settings = {
+                ...settings,
+                ...((await this.exporter.configuration()) ?? {}),
+            };
+        }
+        this.stage.configure(settings);
+        this.playback.fps = settings.fps;
+        this.playback.state = PlaybackState.Rendering;
+        const from = this.status.secondsToFrames(settings.range[0]);
+        this.frame.current = from;
+        // Reset
+        await this.reloadScenes(settings);
+        await this.playback.recalculate();
+        await this.playback.reset();
+        const to = Math.min(this.playback.duration, this.status.secondsToFrames(settings.range[1]));
+        await this.playback.seek(from);
+        if (signal.aborted)
+            return RendererResult.Aborted;
+        await this.exporter.start?.();
+        let lastRefresh = performance.now();
+        let result = RendererResult.Success;
+        const mediaByFrames = await this.getMediaByFrames(settings);
+        // Start audio export
+        let generateAudioPromise;
+        if (this.exporter && this.exporter.generateAudio) {
+            generateAudioPromise = this.exporter.generateAudio(mediaByFrames, from, to);
+        }
+        if (this.exporter && this.exporter.downloadVideos) {
+            await this.exporter.downloadVideos(mediaByFrames);
+        }
+        // Main rendering loop
+        await this.playback.seek(from);
+        try {
+            this.estimator.reset(1 / (to - from));
+            await this.exportFrame(signal);
+            this.estimator.update(clampRemap(from, to, 0, 1, this.playback.frame));
+            this.estimator.reportProgress();
+            if (signal.aborted) {
+                result = RendererResult.Aborted;
+            }
+            else {
+                let finished = false;
+                while (!finished) {
+                    await this.playback.progress();
+                    await this.exportFrame(signal);
+                    this.estimator.update(clampRemap(from, to, 0, 1, this.playback.frame));
+                    this.estimator.reportProgress();
+                    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) {
+            this.project.logger.error(e);
+            result = RendererResult.Error;
+        }
+        await this.exporter.stop?.(result);
+        // Only merge media when rendering images was actually successful.
+        if (result === RendererResult.Success &&
+            this.exporter &&
+            this.exporter.mergeMedia &&
+            generateAudioPromise) {
+            try {
+                await generateAudioPromise;
+                await this.exporter.mergeMedia();
+            }
+            catch (e) {
+                this.project.logger.error(e);
+                result = RendererResult.Error;
+            }
+        }
+        await this.exporter?.kill?.();
+        this.exporter = null;
+        return result;
+    }
+    async reloadScenes(settings) {
+        for (let i = 0; i < this.project.scenes.length; i++) {
+            const scene = this.playback.onScenesRecalculated.current[i];
+            scene.reload({
+                size: settings.size,
+                resolutionScale: settings.resolutionScale,
+            });
+            scene.variables.updateSignals(this.project.variables ?? {});
+        }
+    }
+    async exportFrame(signal) {
+        this.frame.current = this.playback.frame;
+        await this.stage.render(this.playback.currentScene, this.playback.previousScene);
+        const sceneFrame = this.playback.frame - this.playback.currentScene.firstFrame;
+        await this.exporter.handleFrame(this.stage.finalBuffer, this.playback.frame, sceneFrame, this.playback.currentScene.name, signal);
+    }
+    async getMediaByFrames(settings) {
+        this.stage.configure(settings);
+        this.playback.fps = settings.fps;
+        this.playback.state = PlaybackState.Rendering;
+        const from = this.status.secondsToFrames(settings.range[0]);
+        this.frame.current = from;
+        await this.reloadScenes(settings);
+        await this.playback.recalculate();
+        await this.playback.reset();
+        const to = Math.min(this.playback.duration, this.status.secondsToFrames(settings.range[1]));
+        await this.playback.seek(from);
+        const mediaAssets = [];
+        try {
+            const currentMediaAssets = this.playback.currentScene.getMediaAssets();
+            mediaAssets.push(currentMediaAssets);
+            let finished = false;
+            while (!finished) {
+                await this.playback.progress();
+                mediaAssets.push(this.playback.currentScene.getMediaAssets());
+                if (this.playback.finished || this.playback.frame >= to) {
+                    finished = true;
+                }
+            }
+        }
+        catch (e) {
+            this.project.logger.error(e);
+        }
+        return mediaAssets;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Renderer.js","sourceRoot":"","sources":["../../src/app/Renderer.ts"],"names":[],"mappings":"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"}

package/lib/app/SharedWebGLContext.d.ts

@@ -0,0 +1,24 @@
+import type { Logger } from './Logger';
+/**
+ * @internal
+ */
+export interface WebGLContextOwner {
+    setup(gl: WebGL2RenderingContext): void;
+    teardown(gl: WebGL2RenderingContext): void;
+}
+export declare class SharedWebGLContext {
+    private readonly logger;
+    private gl;
+    private currentOwner;
+    private readonly programLookup;
+    constructor(logger: Logger);
+    borrow(owner: WebGLContextOwner): WebGL2RenderingContext;
+    /**
+     * Dispose the WebGL context to free up resources.
+     */
+    dispose(): void;
+    getProgram(fragment: string, vertex: string): WebGLProgram | null;
+    private getShader;
+    private getGL;
+}
+//# sourceMappingURL=SharedWebGLContext.d.ts.map

package/lib/app/SharedWebGLContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SharedWebGLContext.d.ts","sourceRoot":"","sources":["../../src/app/SharedWebGLContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AAgCrC;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,EAAE,sBAAsB,GAAG,IAAI,CAAC;IACxC,QAAQ,CAAC,EAAE,EAAE,sBAAsB,GAAG,IAAI,CAAC;CAC5C;AAQD,qBAAa,kBAAkB;IAKV,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJ1C,OAAO,CAAC,EAAE,CAAuC;IACjD,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAuC;gBAEjC,MAAM,EAAE,MAAM;IAE3C,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,sBAAsB;IAW/D;;OAEG;IACI,OAAO;IAqBP,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IAqCxE,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,KAAK;CA8Bd"}

package/lib/app/SharedWebGLContext.js

@@ -0,0 +1,200 @@
+const SOURCE_URL_REGEX = /^\/\/# sourceURL=(.*)$/gm;
+const INFO_LOG_REGEX = /ERROR: \d+:(\d+): (.*)/g;
+const INFO_TOKEN_REGEX = /^'([^']+)'/;
+const includeWithoutPreprocessor = `
+The \`#include\` directive requires the use of a preprocessor.
+
+Make sure to import the shader from a file:
+
+\`\`\`ts
+import shader from './shader.glsl';
+\`\`\`
+
+Do **NOT** use the raw loader:
+
+\`\`\`ts
+import shader from './shader.glsl?raw';
+\`\`\`
+
+Do **NOT** use \`#include\` in an inline string:
+
+\`\`\`ts
+const shader = \`\\
+#include "example.glsl"
+\`;
+\`\`\`
+
+[Learn more](https://motioncanvas.io/docs/shaders) about working with shaders.
+`;
+export class SharedWebGLContext {
+    constructor(logger) {
+        this.logger = logger;
+        this.gl = null;
+        this.currentOwner = null;
+        this.programLookup = new Map();
+    }
+    borrow(owner) {
+        if (this.currentOwner === owner) {
+            return this.gl;
+        }
+        this.currentOwner?.teardown(this.gl);
+        this.currentOwner = owner;
+        this.currentOwner.setup(this.getGL());
+        return this.gl;
+    }
+    /**
+     * Dispose the WebGL context to free up resources.
+     */
+    dispose() {
+        if (!this.gl) {
+            return;
+        }
+        this.currentOwner?.teardown(this.gl);
+        this.currentOwner = null;
+        this.gl.useProgram(null);
+        for (const { program, fragment, vertex } of this.programLookup.values()) {
+            this.gl.deleteProgram(program);
+            this.gl.deleteShader(fragment);
+            this.gl.deleteShader(vertex);
+        }
+        this.programLookup.clear();
+        this.gl.getExtension('WEBGL_lose_context')?.loseContext();
+        this.gl.canvas.remove();
+        this.gl = null;
+    }
+    getProgram(fragment, vertex) {
+        const key = `${fragment}#${vertex}`;
+        if (this.programLookup.has(key)) {
+            return this.programLookup.get(key).program;
+        }
+        const gl = this.getGL();
+        const fragmentShader = this.getShader(gl.FRAGMENT_SHADER, fragment);
+        const vertexShader = this.getShader(gl.VERTEX_SHADER, vertex);
+        if (!fragmentShader || !vertexShader) {
+            return null;
+        }
+        const program = gl.createProgram();
+        gl.attachShader(program, fragmentShader);
+        gl.attachShader(program, vertexShader);
+        gl.linkProgram(program);
+        if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+            this.logger.error({
+                message: 'Failed to initialize the shader program.',
+                remarks: gl.getProgramInfoLog(program) ?? undefined,
+                stack: new Error().stack,
+            });
+            gl.deleteProgram(program);
+            return null;
+        }
+        this.programLookup.set(key, {
+            program,
+            fragment: fragmentShader,
+            vertex: vertexShader,
+        });
+        return program;
+    }
+    getShader(type, source) {
+        const gl = this.getGL();
+        const shader = gl.createShader(type);
+        gl.shaderSource(shader, source);
+        gl.compileShader(shader);
+        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+            const log = gl.getShaderInfoLog(shader);
+            logGlslError(this.logger, log, source);
+            gl.deleteShader(shader);
+            return null;
+        }
+        return shader;
+    }
+    getGL() {
+        if (this.gl) {
+            return this.gl;
+        }
+        this.gl = document.createElement('canvas').getContext('webgl2', {
+            depth: false,
+            premultipliedAlpha: false,
+            stencil: false,
+            powerPreference: 'high-performance',
+        });
+        if (!this.gl) {
+            throw new Error('Failed to initialize WebGL.');
+        }
+        /* NOTE: Temporary debugging code
+        const canvas = this.gl.canvas as HTMLCanvasElement;
+        document.body.append(canvas);
+        canvas.style.position = 'absolute';
+        canvas.style.top = '16px';
+        canvas.style.right = '16px';
+        canvas.style.width = '300px';
+        canvas.style.borderRadius = '4px';
+        canvas.style.border = '1px solid #ccc';
+        canvas.style.backgroundColor = '#141414';
+        canvas.style.zIndex = '1000';
+        */
+        return this.gl;
+    }
+}
+function logGlslError(logger, log, source) {
+    let sourceUrl = null;
+    SOURCE_URL_REGEX.lastIndex = 0;
+    const sourceMatch = SOURCE_URL_REGEX.exec(source);
+    if (sourceMatch) {
+        const url = new URL(sourceMatch[1], window.location.origin);
+        url.searchParams.set('t', Date.now().toString());
+        sourceUrl = url.toString();
+    }
+    if (!log) {
+        logger.error({
+            message: `Unknown shader compilation error.`,
+            stack: fakeStackTrace(sourceUrl, 1, 0),
+        });
+        return null;
+    }
+    let logged = false;
+    let result;
+    while ((result = INFO_LOG_REGEX.exec(log))) {
+        const [, line, message] = result;
+        let column = 0;
+        const match = message.match(INFO_TOKEN_REGEX);
+        if (match) {
+            const tokenLine = source.split('\n')[parseInt(line) - 1];
+            const index = tokenLine.indexOf(match[1]);
+            if (index !== -1) {
+                column = index;
+            }
+            if (match[1] === 'include') {
+                const line = source
+                    .split('\n')
+                    .find(line => line.startsWith('#include'));
+                if (line) {
+                    logged = true;
+                    logger.error({
+                        message: `Shader compilation error: ${message}`,
+                        remarks: includeWithoutPreprocessor,
+                    });
+                    break;
+                }
+            }
+        }
+        logged = true;
+        logger.error({
+            message: `Shader compilation error: ${message}`,
+            stack: fakeStackTrace(sourceUrl, line, column),
+        });
+    }
+    if (!logged) {
+        logger.error({
+            message: `Shader compilation error: ${log}`,
+            stack: fakeStackTrace(sourceUrl, 1, 0),
+        });
+    }
+}
+function fakeStackTrace(file, line, column) {
+    if (!file) {
+        return undefined;
+    }
+    return navigator.userAgent.toLowerCase().includes('chrome')
+        ? `  at (${file}:${line}:${column})`
+        : `@${file}:${line}:${column}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/app/Stage.d.ts

@@ -0,0 +1,30 @@
+import type { Scene } from '../scenes';
+import type { CanvasColorSpace, Color } from '../types';
+import { Vector2 } 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 declare class Stage {
+    private background;
+    private resolutionScale;
+    private colorSpace;
+    private size;
+    readonly finalBuffer: HTMLCanvasElement;
+    private readonly currentBuffer;
+    private readonly previousBuffer;
+    private context;
+    private currentContext;
+    private previousContext;
+    private get canvasSize();
+    constructor();
+    configure({ colorSpace, size, resolutionScale, background, }: Partial<StageSettings>): void;
+    render(currentScene: Scene, previousScene: Scene | null): Promise<void>;
+    resizeCanvas(context: CanvasRenderingContext2D): void;
+}
+//# sourceMappingURL=Stage.d.ts.map

package/lib/app/Stage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stage.d.ts","sourceRoot":"","sources":["../../src/app/Stage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,WAAW,CAAC;AAErC,OAAO,KAAK,EAAC,gBAAgB,EAAE,KAAK,EAAC,MAAM,UAAU,CAAC;AACtD,OAAO,EAAC,OAAO,EAAC,MAAM,UAAU,CAAC;AAGjC,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,OAAO,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,gBAAgB,CAAC;IAC7B,UAAU,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CAAC;CACnC;AAED;;GAEG;AACH,qBAAa,KAAK;IAGhB,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,IAAI,CAAgB;IAE5B,SAAgB,WAAW,EAAE,iBAAiB,CAAC;IAC/C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoB;IAClD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAoB;IAEnD,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,cAAc,CAA2B;IACjD,OAAO,CAAC,eAAe,CAA2B;IAElD,OAAO,KAAK,UAAU,GAErB;;IAaM,SAAS,CAAC,EACf,UAA4B,EAC5B,IAAgB,EAChB,eAAsC,EACtC,UAA4B,GAC7B,EAAE,OAAO,CAAC,aAAa,CAAC;IAyBZ,MAAM,CAAC,YAAY,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,GAAG,IAAI;IA6B7D,YAAY,CAAC,OAAO,EAAE,wBAAwB;CAKtD"}