@twick/core 0.11.0

package/lib/scenes/GeneratorScene.js

@@ -0,0 +1,273 @@
+import { decorate, threadable } from '../decorators';
+import { EventDispatcher, ValueDispatcher } from '../events';
+import { DependencyContext } from '../signals';
+import { isPromisable, isPromise, threads } from '../threading';
+import { endPlayback, endScene, startPlayback, startScene } from '../utils';
+import { LifecycleEvents } from './LifecycleEvents';
+import { SceneState } from './SceneState';
+import { Shaders } from './Shaders';
+import { Slides } from './Slides';
+import { Variables } from './Variables';
+/**
+ * The default implementation of the {@link Scene} interface.
+ *
+ * Uses generators to control the animation.
+ */
+export class GeneratorScene {
+    get firstFrame() {
+        return this.cache.current.firstFrame;
+    }
+    get lastFrame() {
+        return this.firstFrame + this.cache.current.duration;
+    }
+    get onCacheChanged() {
+        return this.cache.subscribable;
+    }
+    get onReloaded() {
+        return this.reloaded.subscribable;
+    }
+    get onRecalculated() {
+        return this.recalculated.subscribable;
+    }
+    get onThreadChanged() {
+        return this.thread.subscribable;
+    }
+    get onRenderLifecycle() {
+        return this.renderLifecycle.subscribable;
+    }
+    get onReset() {
+        return this.afterReset.subscribable;
+    }
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    get LifecycleEvents() {
+        this.logger.warn('LifecycleEvents is deprecated. Use lifecycleEvents instead.');
+        return this.lifecycleEvents;
+    }
+    get previous() {
+        return this.previousScene;
+    }
+    getMediaAssets() {
+        return [];
+    }
+    stopAllMedia() { }
+    constructor(description) {
+        this.cache = new ValueDispatcher({
+            firstFrame: 0,
+            transitionDuration: 0,
+            duration: 0,
+            lastFrame: 0,
+        });
+        this.reloaded = new EventDispatcher();
+        this.recalculated = new EventDispatcher();
+        this.thread = new ValueDispatcher(null);
+        this.renderLifecycle = new EventDispatcher();
+        this.afterReset = new EventDispatcher();
+        this.lifecycleEvents = new LifecycleEvents(this);
+        this.previousScene = null;
+        this.runner = null;
+        this.state = SceneState.Initial;
+        this.cached = false;
+        // TODO(refactor): seems to be unused
+        this.counters = {};
+        this.name = description.name;
+        this.size = description.size;
+        this.resolutionScale = description.resolutionScale;
+        this.logger = description.logger;
+        this.playback = description.playback;
+        this.runnerFactory = description.config;
+        this.creationStack = description.stack;
+        this.experimentalFeatures = description.experimentalFeatures ?? false;
+        decorate(this.runnerFactory, threadable(this.name));
+        this.variables = new Variables(this);
+        this.shaders = new Shaders(this, description.sharedWebGLContext);
+        this.slides = new Slides(this);
+        this.previousOnTop = false;
+    }
+    /**
+     * Update the view.
+     *
+     * Invoked after each step of the main generator.
+     * Can be used for calculating layout.
+     *
+     * Can modify the state of the view.
+     */
+    update() {
+        // do nothing
+    }
+    async render(context) {
+        let iterations = 0;
+        do {
+            iterations++;
+            await DependencyContext.consumePromises();
+            context.save();
+            context.clearRect(0, 0, context.canvas.width, context.canvas.height);
+            await this.draw(context);
+            context.restore();
+        } while (DependencyContext.hasPromises() && iterations < 10);
+        if (iterations > 1) {
+            this.logger.debug(`render iterations: ${iterations}`);
+        }
+    }
+    reload({ config, size, stack, resolutionScale, } = {}) {
+        if (config) {
+            this.runnerFactory = config;
+        }
+        if (size) {
+            this.size = size;
+        }
+        if (resolutionScale) {
+            this.resolutionScale = resolutionScale;
+        }
+        if (stack) {
+            this.creationStack = stack;
+        }
+        this.cached = false;
+        this.reloaded.dispatch();
+    }
+    async recalculate(setFrame) {
+        const cached = this.cache.current;
+        cached.firstFrame = this.playback.frame;
+        cached.lastFrame = cached.firstFrame + cached.duration;
+        if (this.isCached()) {
+            setFrame(cached.lastFrame);
+            this.cache.current = { ...cached };
+            return;
+        }
+        cached.transitionDuration = -1;
+        await this.reset();
+        while (!this.canTransitionOut()) {
+            if (cached.transitionDuration < 0 &&
+                this.state === SceneState.AfterTransitionIn) {
+                cached.transitionDuration = this.playback.frame - cached.firstFrame;
+            }
+            setFrame(this.playback.frame + 1);
+            await this.next();
+        }
+        if (cached.transitionDuration === -1) {
+            cached.transitionDuration = 0;
+        }
+        cached.lastFrame = this.playback.frame;
+        cached.duration = cached.lastFrame - cached.firstFrame;
+        // Prevent the page from becoming unresponsive.
+        await new Promise(resolve => setTimeout(resolve, 0));
+        this.cached = true;
+        this.cache.current = { ...cached };
+        this.recalculated.dispatch();
+    }
+    async next() {
+        if (!this.runner) {
+            return;
+        }
+        let result = this.execute(() => this.runner.next());
+        this.update();
+        while (result.value) {
+            if (isPromisable(result.value)) {
+                const value = await result.value.toPromise();
+                result = this.execute(() => this.runner.next(value));
+            }
+            else if (isPromise(result.value)) {
+                const value = await result.value;
+                result = this.execute(() => this.runner.next(value));
+            }
+            else {
+                this.logger.warn({
+                    message: 'Invalid value yielded by the scene.',
+                    object: result.value,
+                });
+                result = this.execute(() => this.runner.next(result.value));
+            }
+            this.update();
+        }
+        if (DependencyContext.hasPromises()) {
+            const promises = await DependencyContext.consumePromises();
+            this.logger.warn({
+                message: 'Tried to access an asynchronous property before the node was ready. ' +
+                    'Make sure to yield the node before accessing the property.',
+                stack: promises[0].stack,
+                inspect: promises[0].owner?.key ?? undefined,
+            });
+        }
+        if (result.done) {
+            this.state = SceneState.Finished;
+        }
+    }
+    async reset(previousScene = null) {
+        this.counters = {};
+        this.previousScene = previousScene;
+        this.previousOnTop = false;
+        this.runner = threads(() => this.runnerFactory(this.getView()), thread => {
+            this.thread.current = thread;
+        });
+        this.state = SceneState.AfterTransitionIn;
+        this.afterReset.dispatch();
+        await this.next();
+    }
+    getSize() {
+        return this.size;
+    }
+    getRealSize() {
+        return this.size.mul(this.resolutionScale);
+    }
+    isAfterTransitionIn() {
+        return this.state === SceneState.AfterTransitionIn;
+    }
+    canTransitionOut() {
+        return (this.state === SceneState.CanTransitionOut ||
+            this.state === SceneState.Finished);
+    }
+    isFinished() {
+        return this.state === SceneState.Finished;
+    }
+    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}`);
+        }
+    }
+    enterAfterTransitionIn() {
+        if (this.state === SceneState.Initial) {
+            this.state = SceneState.AfterTransitionIn;
+        }
+        else {
+            this.logger.warn(`Scene ${this.name} transitioned in an unexpected state: ${this.state}`);
+        }
+    }
+    enterCanTransitionOut() {
+        if (this.state === SceneState.AfterTransitionIn ||
+            this.state === SceneState.Initial // only on recalculate
+        ) {
+            this.state = SceneState.CanTransitionOut;
+        }
+        else {
+            this.logger.warn(`Scene ${this.name} was marked as finished in an unexpected state: ${this.state}`);
+        }
+    }
+    isCached() {
+        return this.cached;
+    }
+    /**
+     * Invoke the given callback in the context of this scene.
+     *
+     * @remarks
+     * This method makes sure that the context of this scene is globally available
+     * during the execution of the callback.
+     *
+     * @param callback - The callback to invoke.
+     */
+    execute(callback) {
+        let result;
+        startScene(this);
+        startPlayback(this.playback);
+        try {
+            result = callback();
+        }
+        finally {
+            endPlayback(this.playback);
+            endScene(this);
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GeneratorScene.js","sourceRoot":"","sources":["../../src/scenes/GeneratorScene.ts"],"names":[],"mappings":"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"}

package/lib/scenes/Inspectable.d.ts

@@ -0,0 +1,71 @@
+import type { Vector2 } from '../types/Vector';
+/**
+ * Represents an element to inspect.
+ *
+ * @remarks
+ * The type is not important because the UI does not interact with it.
+ * It serves as a key that will be passed back to an Inspectable scene to
+ * receive more information about said element.
+ */
+export type InspectedElement = unknown;
+/**
+ * Represents attributes of an inspected element.
+ */
+export type InspectedAttributes = {
+    stack?: string;
+    [K: string]: any;
+};
+/**
+ * Scenes can implement this interface to make their components
+ * inspectable through the UI.
+ */
+export interface Inspectable {
+    /**
+     * Get a possible element to inspect at a given position.
+     *
+     * @param x - The x coordinate.
+     * @param y - The y coordinate.
+     */
+    inspectPosition(x: number, y: number): InspectedElement | null;
+    /**
+     * Check if the inspected element is still valid.
+     *
+     * @remarks
+     * If a scene destroys and recreates its components upon every reset, the
+     * reference may no longer be valid. Even though the component is still
+     * present. This method should check that and return a new reference.
+     *
+     * @param element - The element to validate.
+     */
+    validateInspection(element: InspectedElement | null): InspectedElement | null;
+    /**
+     * Return the attributes of the inspected element.
+     *
+     * @remarks
+     * This information will be displayed in the "Properties" panel.
+     *
+     * @param element - The element to inspect.
+     */
+    inspectAttributes(element: InspectedElement): InspectedAttributes | null;
+    /**
+     * Draw an overlay for the inspected element.
+     *
+     * @remarks
+     * This method can be used to overlay additional information about an
+     * element on top of the animation.
+     *
+     * @param element - The element for which to draw an overlay.
+     * @param matrix - A local-to-screen matrix.
+     * @param context - The context to draw with.
+     */
+    drawOverlay(element: InspectedElement, matrix: DOMMatrix, context: CanvasRenderingContext2D): void;
+    /**
+     * Transform the absolute mouse coordinates into the scene's coordinate system.
+     *
+     * @param x - The x coordinate.
+     * @param y - The y coordinate.
+     */
+    transformMousePosition(x: number, y: number): Vector2 | null;
+}
+export declare function isInspectable(value: any): value is Inspectable;
+//# sourceMappingURL=Inspectable.d.ts.map

package/lib/scenes/Inspectable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Inspectable.d.ts","sourceRoot":"","sources":["../../src/scenes/Inspectable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC;AAEvC;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;CAClB,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAAC;IAE/D;;;;;;;;;OASG;IACH,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,GAAG,gBAAgB,GAAG,IAAI,CAAC;IAE9E;;;;;;;OAOG;IACH,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,GAAG,mBAAmB,GAAG,IAAI,CAAC;IAEzE;;;;;;;;;;OAUG;IACH,WAAW,CACT,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,wBAAwB,GAChC,IAAI,CAAC;IAER;;;;;OAKG;IACH,sBAAsB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;CAC9D;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,WAAW,CAE9D"}

package/lib/scenes/Inspectable.js

@@ -0,0 +1,4 @@
+export function isInspectable(value) {
+    return value && typeof value === 'object' && 'validateInspection' in value;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zcGVjdGFibGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2NlbmVzL0luc3BlY3RhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWlGQSxNQUFNLFVBQVUsYUFBYSxDQUFDLEtBQVU7SUFDdEMsT0FBTyxLQUFLLElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxJQUFJLG9CQUFvQixJQUFJLEtBQUssQ0FBQztBQUM3RSxDQUFDIn0=

package/lib/scenes/LifecycleEvents.d.ts

@@ -0,0 +1,18 @@
+import { EventDispatcher } from '../events';
+import type { Scene } from './Scene';
+/**
+ * Lifecycle events for {@link Scene} that are cleared on every reset.
+ */
+export declare class LifecycleEvents {
+    private readonly scene;
+    get onBeforeRender(): import("../events").Subscribable<CanvasRenderingContext2D, import("../events").EventHandler<CanvasRenderingContext2D>>;
+    protected readonly beforeRender: EventDispatcher<CanvasRenderingContext2D>;
+    get onBeginRender(): import("../events").Subscribable<CanvasRenderingContext2D, import("../events").EventHandler<CanvasRenderingContext2D>>;
+    protected readonly beginRender: EventDispatcher<CanvasRenderingContext2D>;
+    get onFinishRender(): import("../events").Subscribable<CanvasRenderingContext2D, import("../events").EventHandler<CanvasRenderingContext2D>>;
+    protected readonly finishRender: EventDispatcher<CanvasRenderingContext2D>;
+    get onAfterRender(): import("../events").Subscribable<CanvasRenderingContext2D, import("../events").EventHandler<CanvasRenderingContext2D>>;
+    protected readonly afterRender: EventDispatcher<CanvasRenderingContext2D>;
+    constructor(scene: Scene);
+}
+//# sourceMappingURL=LifecycleEvents.d.ts.map

package/lib/scenes/LifecycleEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LifecycleEvents.d.ts","sourceRoot":"","sources":["../../src/scenes/LifecycleEvents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,WAAW,CAAC;AAC1C,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,SAAS,CAAC;AAGnC;;GAEG;AACH,qBAAa,eAAe;IAyBP,OAAO,CAAC,QAAQ,CAAC,KAAK;IAxBzC,IAAW,cAAc,2HAExB;IACD,SAAS,CAAC,QAAQ,CAAC,YAAY,4CACmB;IAElD,IAAW,aAAa,2HAEvB;IACD,SAAS,CAAC,QAAQ,CAAC,WAAW,4CACoB;IAElD,IAAW,cAAc,2HAExB;IACD,SAAS,CAAC,QAAQ,CAAC,YAAY,4CACmB;IAElD,IAAW,aAAa,2HAEvB;IACD,SAAS,CAAC,QAAQ,CAAC,WAAW,4CACoB;gBAEd,KAAK,EAAE,KAAK;CAoBjD"}

package/lib/scenes/LifecycleEvents.js

@@ -0,0 +1,45 @@
+import { EventDispatcher } from '../events';
+import { SceneRenderEvent } from './Scene';
+/**
+ * Lifecycle events for {@link Scene} that are cleared on every reset.
+ */
+export class LifecycleEvents {
+    get onBeforeRender() {
+        return this.beforeRender.subscribable;
+    }
+    get onBeginRender() {
+        return this.beginRender.subscribable;
+    }
+    get onFinishRender() {
+        return this.finishRender.subscribable;
+    }
+    get onAfterRender() {
+        return this.afterRender.subscribable;
+    }
+    constructor(scene) {
+        this.scene = scene;
+        this.beforeRender = new EventDispatcher();
+        this.beginRender = new EventDispatcher();
+        this.finishRender = new EventDispatcher();
+        this.afterRender = new EventDispatcher();
+        this.scene.onRenderLifecycle.subscribe(([event, ctx]) => {
+            switch (event) {
+                case SceneRenderEvent.BeforeRender:
+                    return this.beforeRender.dispatch(ctx);
+                case SceneRenderEvent.BeginRender:
+                    return this.beginRender.dispatch(ctx);
+                case SceneRenderEvent.FinishRender:
+                    return this.finishRender.dispatch(ctx);
+                case SceneRenderEvent.AfterRender:
+                    return this.afterRender.dispatch(ctx);
+            }
+        });
+        this.scene.onReset.subscribe(() => {
+            this.beforeRender.clear();
+            this.beginRender.clear();
+            this.finishRender.clear();
+            this.afterRender.clear();
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTGlmZWN5Y2xlRXZlbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NjZW5lcy9MaWZlY3ljbGVFdmVudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLFdBQVcsQ0FBQztBQUUxQyxPQUFPLEVBQUMsZ0JBQWdCLEVBQUMsTUFBTSxTQUFTLENBQUM7QUFFekM7O0dBRUc7QUFDSCxNQUFNLE9BQU8sZUFBZTtJQUMxQixJQUFXLGNBQWM7UUFDdkIsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FBQztJQUN4QyxDQUFDO0lBSUQsSUFBVyxhQUFhO1FBQ3RCLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQyxZQUFZLENBQUM7SUFDdkMsQ0FBQztJQUlELElBQVcsY0FBYztRQUN2QixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsWUFBWSxDQUFDO0lBQ3hDLENBQUM7SUFJRCxJQUFXLGFBQWE7UUFDdEIsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLFlBQVksQ0FBQztJQUN2QyxDQUFDO0lBSUQsWUFBb0MsS0FBWTtRQUFaLFVBQUssR0FBTCxLQUFLLENBQU87UUFyQjdCLGlCQUFZLEdBQzdCLElBQUksZUFBZSxFQUE0QixDQUFDO1FBSy9CLGdCQUFXLEdBQzVCLElBQUksZUFBZSxFQUE0QixDQUFDO1FBSy9CLGlCQUFZLEdBQzdCLElBQUksZUFBZSxFQUE0QixDQUFDO1FBSy9CLGdCQUFXLEdBQzVCLElBQUksZUFBZSxFQUE0QixDQUFDO1FBR2hELElBQUksQ0FBQyxLQUFLLENBQUMsaUJBQWlCLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxLQUFLLEVBQUUsR0FBRyxDQUFDLEVBQUUsRUFBRTtZQUN0RCxRQUFRLEtBQUssRUFBRSxDQUFDO2dCQUNkLEtBQUssZ0JBQWdCLENBQUMsWUFBWTtvQkFDaEMsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQztnQkFDekMsS0FBSyxnQkFBZ0IsQ0FBQyxXQUFXO29CQUMvQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDO2dCQUN4QyxLQUFLLGdCQUFnQixDQUFDLFlBQVk7b0JBQ2hDLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUM7Z0JBQ3pDLEtBQUssZ0JBQWdCLENBQUMsV0FBVztvQkFDL0IsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUMxQyxDQUFDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7UUFDSCxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFO1lBQ2hDLElBQUksQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDMUIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUN6QixJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssRUFBRSxDQUFDO1lBQzFCLElBQUksQ0FBQyxXQUFXLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDM0IsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0NBQ0YifQ==

package/lib/scenes/Random.d.ts

@@ -0,0 +1,66 @@
+/**
+ * // TODO(refactor): maybe we can delete this
+ *
+ * A random number generator based on
+ * {@link https://gist.github.com/tommyettinger/46a874533244883189143505d203312c | Mulberry32}.
+ */
+export declare class Random {
+    private state;
+    /**
+     * Previously generated Gaussian random number.
+     *
+     * @remarks
+     * This is an optimization.
+     * Since {@link gauss} generates a pair of independent Gaussian random
+     * numbers, it returns one immediately and stores the other for the next call
+     * to {@link gauss}.
+     */
+    private nextGauss;
+    constructor(state: number);
+    /**
+     * @internal
+     */
+    static createSeed(): number;
+    /**
+     * Get the next random float in the given range.
+     *
+     * @param from - The start of the range.
+     * @param to - The end of the range.
+     */
+    nextFloat(from?: number, to?: number): number;
+    /**
+     * Get the next random integer in the given range.
+     *
+     * @param from - The start of the range.
+     * @param to - The end of the range. Exclusive.
+     */
+    nextInt(from?: number, to?: number): number;
+    /**
+     * Get a random float from a gaussian distribution.
+     * @param mean - The mean of the distribution.
+     * @param stdev - The standard deviation of the distribution.
+     */
+    gauss(mean?: number, stdev?: number): number;
+    /**
+     * Get an array filled with random floats in the given range.
+     *
+     * @param size - The size of the array.
+     * @param from - The start of the range.
+     * @param to - The end of the range.
+     */
+    floatArray(size: number, from?: number, to?: number): number[];
+    /**
+     Get an array filled with random integers in the given range.
+     *
+     * @param size - The size of the array.
+     * @param from - The start of the range.
+     * @param to - The end of the range. Exclusive.
+     */
+    intArray(size: number, from?: number, to?: number): number[];
+    /**
+     * Create a new independent generator.
+     */
+    spawn(): Random;
+    private next;
+}
+//# sourceMappingURL=Random.d.ts.map

package/lib/scenes/Random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Random.d.ts","sourceRoot":"","sources":["../../src/scenes/Random.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,qBAAa,MAAM;IAYE,OAAO,CAAC,KAAK;IAXhC;;;;;;;;OAQG;IACH,OAAO,CAAC,SAAS,CAAuB;gBAEb,KAAK,EAAE,MAAM;IAExC;;OAEG;WACW,UAAU;IAIxB;;;;;OAKG;IACI,SAAS,CAAC,IAAI,SAAI,EAAE,EAAE,SAAI;IAIjC;;;;;OAKG;IACI,OAAO,CAAC,IAAI,SAAI,EAAE,EAAE,SAAa;IASxC;;;;OAIG;IACI,KAAK,CAAC,IAAI,SAAI,EAAE,KAAK,SAAI,GAAG,MAAM;IAYzC;;;;;;OAMG;IACI,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,SAAI,EAAE,EAAE,SAAI,GAAG,MAAM,EAAE;IAI3D;;;;;;OAMG;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,SAAI,EAAE,EAAE,SAAa,GAAG,MAAM,EAAE;IAIlE;;OAEG;IACI,KAAK;IAIZ,OAAO,CAAC,IAAI;CAOb"}

package/lib/scenes/Random.js

@@ -0,0 +1,101 @@
+import { map } from '../tweening';
+import { range } from '../utils';
+/**
+ * // TODO(refactor): maybe we can delete this
+ *
+ * A random number generator based on
+ * {@link https://gist.github.com/tommyettinger/46a874533244883189143505d203312c | Mulberry32}.
+ */
+export class Random {
+    constructor(state) {
+        this.state = state;
+        /**
+         * Previously generated Gaussian random number.
+         *
+         * @remarks
+         * This is an optimization.
+         * Since {@link gauss} generates a pair of independent Gaussian random
+         * numbers, it returns one immediately and stores the other for the next call
+         * to {@link gauss}.
+         */
+        this.nextGauss = null;
+    }
+    /**
+     * @internal
+     */
+    static createSeed() {
+        return Math.floor(Math.random() * 4294967296);
+    }
+    /**
+     * Get the next random float in the given range.
+     *
+     * @param from - The start of the range.
+     * @param to - The end of the range.
+     */
+    nextFloat(from = 0, to = 1) {
+        return map(from, to, this.next());
+    }
+    /**
+     * Get the next random integer in the given range.
+     *
+     * @param from - The start of the range.
+     * @param to - The end of the range. Exclusive.
+     */
+    nextInt(from = 0, to = 4294967296) {
+        let value = Math.floor(map(from, to, this.next()));
+        if (value === to) {
+            value = from;
+        }
+        return value;
+    }
+    /**
+     * Get a random float from a gaussian distribution.
+     * @param mean - The mean of the distribution.
+     * @param stdev - The standard deviation of the distribution.
+     */
+    gauss(mean = 0, stdev = 1) {
+        let z = this.nextGauss;
+        this.nextGauss = null;
+        if (z === null) {
+            const x2pi = this.next() * 2 * Math.PI;
+            const g2rad = Math.sqrt(-2 * Math.log(1 - this.next()));
+            z = Math.cos(x2pi) * g2rad;
+            this.nextGauss = Math.sin(x2pi) * g2rad;
+        }
+        return mean + z * stdev;
+    }
+    /**
+     * Get an array filled with random floats in the given range.
+     *
+     * @param size - The size of the array.
+     * @param from - The start of the range.
+     * @param to - The end of the range.
+     */
+    floatArray(size, from = 0, to = 1) {
+        return range(size).map(() => this.nextFloat(from, to));
+    }
+    /**
+     Get an array filled with random integers in the given range.
+     *
+     * @param size - The size of the array.
+     * @param from - The start of the range.
+     * @param to - The end of the range. Exclusive.
+     */
+    intArray(size, from = 0, to = 4294967296) {
+        return range(size).map(() => this.nextInt(from, to));
+    }
+    /**
+     * Create a new independent generator.
+     */
+    spawn() {
+        return new Random(this.nextInt());
+    }
+    next() {
+        this.state |= 0;
+        this.state = (this.state + 0x6d2b79f5) | 0;
+        let t = Math.imul(this.state ^ (this.state >>> 15), 1 | this.state);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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