@redwilly/anima 0.1.0

package/dist/core/math/bezier/sampling.js

@@ -0,0 +1,153 @@
+import { Vector2 } from '../Vector2/Vector2';
+import { evaluateQuadratic, evaluateCubic } from './evaluators';
+import { evaluateQuadraticDerivative, evaluateCubicDerivative } from './evaluators';
+import { getQuadraticLength, getCubicLength } from './length';
+export function getPathLength(commands) {
+    let length = 0;
+    let cursor = new Vector2(0, 0);
+    let subpathStart = new Vector2(0, 0);
+    for (const cmd of commands) {
+        switch (cmd.type) {
+            case 'Move':
+                cursor = cmd.end;
+                subpathStart = cmd.end;
+                break;
+            case 'Line':
+                length += cursor.subtract(cmd.end).length();
+                cursor = cmd.end;
+                break;
+            case 'Quadratic':
+                if (cmd.control1) {
+                    length += getQuadraticLength(cursor, cmd.control1, cmd.end);
+                }
+                cursor = cmd.end;
+                break;
+            case 'Cubic':
+                if (cmd.control1 && cmd.control2) {
+                    length += getCubicLength(cursor, cmd.control1, cmd.control2, cmd.end);
+                }
+                cursor = cmd.end;
+                break;
+            case 'Close':
+                length += cursor.subtract(subpathStart).length();
+                cursor = subpathStart;
+                break;
+        }
+    }
+    return length;
+}
+/** Point on the path at normalized position t (0-1). */
+export function getPointAtPath(commands, t) {
+    const totalLength = getPathLength(commands);
+    if (totalLength === 0) {
+        return commands.length > 0 ? commands[commands.length - 1].end : Vector2.ZERO;
+    }
+    t = Math.max(0, Math.min(1, t));
+    const targetDistance = t * totalLength;
+    let currentDistance = 0;
+    let cursor = new Vector2(0, 0);
+    let subpathStart = new Vector2(0, 0);
+    for (const cmd of commands) {
+        let segmentLength = 0;
+        switch (cmd.type) {
+            case 'Move':
+                cursor = cmd.end;
+                subpathStart = cmd.end;
+                break;
+            case 'Line':
+                segmentLength = cursor.subtract(cmd.end).length();
+                if (currentDistance + segmentLength >= targetDistance) {
+                    const localT = (targetDistance - currentDistance) / segmentLength;
+                    return cursor.lerp(cmd.end, localT);
+                }
+                cursor = cmd.end;
+                break;
+            case 'Quadratic':
+                if (cmd.control1) {
+                    segmentLength = getQuadraticLength(cursor, cmd.control1, cmd.end);
+                    if (currentDistance + segmentLength >= targetDistance) {
+                        const localT = (targetDistance - currentDistance) / segmentLength;
+                        return evaluateQuadratic(cursor, cmd.control1, cmd.end, localT);
+                    }
+                }
+                cursor = cmd.end;
+                break;
+            case 'Cubic':
+                if (cmd.control1 && cmd.control2) {
+                    segmentLength = getCubicLength(cursor, cmd.control1, cmd.control2, cmd.end);
+                    if (currentDistance + segmentLength >= targetDistance) {
+                        const localT = (targetDistance - currentDistance) / segmentLength;
+                        return evaluateCubic(cursor, cmd.control1, cmd.control2, cmd.end, localT);
+                    }
+                }
+                cursor = cmd.end;
+                break;
+            case 'Close':
+                segmentLength = cursor.subtract(subpathStart).length();
+                if (currentDistance + segmentLength >= targetDistance) {
+                    const localT = (targetDistance - currentDistance) / segmentLength;
+                    return cursor.lerp(subpathStart, localT);
+                }
+                cursor = subpathStart;
+                break;
+        }
+        currentDistance += segmentLength;
+    }
+    return cursor;
+}
+/** Tangent vector on the path at normalized position t (0-1). */
+export function getTangentAtPath(commands, t) {
+    const totalLength = getPathLength(commands);
+    if (totalLength === 0)
+        return Vector2.RIGHT;
+    t = Math.max(0, Math.min(1, t));
+    const targetDistance = t * totalLength;
+    let currentDistance = 0;
+    let cursor = new Vector2(0, 0);
+    let subpathStart = new Vector2(0, 0);
+    for (const cmd of commands) {
+        let segmentLength = 0;
+        switch (cmd.type) {
+            case 'Move':
+                cursor = cmd.end;
+                subpathStart = cmd.end;
+                break;
+            case 'Line':
+                segmentLength = cursor.subtract(cmd.end).length();
+                if (currentDistance + segmentLength >= targetDistance) {
+                    return cmd.end.subtract(cursor).normalize();
+                }
+                cursor = cmd.end;
+                break;
+            case 'Quadratic':
+                if (cmd.control1) {
+                    segmentLength = getQuadraticLength(cursor, cmd.control1, cmd.end);
+                    if (currentDistance + segmentLength >= targetDistance) {
+                        const localT = (targetDistance - currentDistance) / segmentLength;
+                        return evaluateQuadraticDerivative(cursor, cmd.control1, cmd.end, localT).normalize();
+                    }
+                }
+                cursor = cmd.end;
+                break;
+            case 'Cubic':
+                if (cmd.control1 && cmd.control2) {
+                    segmentLength = getCubicLength(cursor, cmd.control1, cmd.control2, cmd.end);
+                    if (currentDistance + segmentLength >= targetDistance) {
+                        const localT = (targetDistance - currentDistance) / segmentLength;
+                        return evaluateCubicDerivative(cursor, cmd.control1, cmd.control2, cmd.end, localT).normalize();
+                    }
+                }
+                cursor = cmd.end;
+                break;
+            case 'Close':
+                segmentLength = cursor.subtract(subpathStart).length();
+                if (currentDistance + segmentLength >= targetDistance) {
+                    return subpathStart.subtract(cursor).normalize();
+                }
+                cursor = subpathStart;
+                break;
+        }
+        currentDistance += segmentLength;
+    }
+    return Vector2.RIGHT;
+}

package/dist/core/math/bezier/split.d.ts

@@ -0,0 +1,19 @@
+import { Vector2 } from '../Vector2/Vector2';
+/**
+ * Result of splitting a cubic Bezier curve at parameter t.
+ */
+export interface CubicSegment {
+    start: Vector2;
+    control1: Vector2;
+    control2: Vector2;
+    end: Vector2;
+}
+/** Splits a cubic Bezier curve at t using de Casteljau's algorithm into two segments. */
+export declare function splitCubicAt(p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2, t: number): [CubicSegment, CubicSegment];
+/** Splits a quadratic Bezier curve at t into two segments. */
+export interface QuadraticSegment {
+    start: Vector2;
+    control: Vector2;
+    end: Vector2;
+}
+export declare function splitQuadraticAt(p0: Vector2, p1: Vector2, p2: Vector2, t: number): [QuadraticSegment, QuadraticSegment];

package/dist/core/math/bezier/split.js

@@ -0,0 +1,44 @@
+/** Splits a cubic Bezier curve at t using de Casteljau's algorithm into two segments. */
+export function splitCubicAt(p0, p1, p2, p3, t) {
+    // de Casteljau's algorithm - first level
+    const p01 = p0.lerp(p1, t);
+    const p12 = p1.lerp(p2, t);
+    const p23 = p2.lerp(p3, t);
+    // Second level
+    const p012 = p01.lerp(p12, t);
+    const p123 = p12.lerp(p23, t);
+    // Third level - the split point
+    const p0123 = p012.lerp(p123, t);
+    // First segment: [0, t]
+    const first = {
+        start: p0,
+        control1: p01,
+        control2: p012,
+        end: p0123,
+    };
+    // Second segment: [t, 1]
+    const second = {
+        start: p0123,
+        control1: p123,
+        control2: p23,
+        end: p3,
+    };
+    return [first, second];
+}
+export function splitQuadraticAt(p0, p1, p2, t) {
+    // de Casteljau for quadratic
+    const p01 = p0.lerp(p1, t);
+    const p12 = p1.lerp(p2, t);
+    const p012 = p01.lerp(p12, t);
+    const first = {
+        start: p0,
+        control: p01,
+        end: p012,
+    };
+    const second = {
+        start: p012,
+        control: p12,
+        end: p2,
+    };
+    return [first, second];
+}

package/dist/core/math/bezier/types.d.ts

@@ -0,0 +1,8 @@
+import type { Vector2 } from '../Vector2/Vector2';
+export type PathCommandType = 'Move' | 'Line' | 'Quadratic' | 'Cubic' | 'Close';
+export interface PathCommand {
+    type: PathCommandType;
+    end: Vector2;
+    control1?: Vector2;
+    control2?: Vector2;
+}

package/dist/core/math/color/Color.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A class representing a color with Red, Green, Blue, and Alpha components.
+ * RGB values are in the range [0, 255].
+ * Alpha value is in the range [0, 1].
+ */
+export declare class Color {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly a: number;
+    constructor(r: number, g: number, b: number, a?: number);
+    /**
+     * Creates a Color from a hex string.
+     * Supports formats: #RRGGBB, #RGB, #RRGGBBAA, #RGBA.
+     */
+    static fromHex(hex: string): Color;
+    static fromHSL(h: number, s: number, l: number, a?: number): Color;
+    toHex(): string;
+    toRGBA(): string;
+    lerp(other: Color, t: number): Color;
+    static readonly WHITE: Color;
+    static readonly BLACK: Color;
+    static readonly RED: Color;
+    static readonly GREEN: Color;
+    static readonly BLUE: Color;
+    static readonly YELLOW: Color;
+    static readonly TRANSPARENT: Color;
+}

package/dist/core/math/color/Color.js

@@ -0,0 +1,60 @@
+import { parseHex, hslToRgb } from './conversions';
+/**
+ * A class representing a color with Red, Green, Blue, and Alpha components.
+ * RGB values are in the range [0, 255].
+ * Alpha value is in the range [0, 1].
+ */
+export class Color {
+    r;
+    g;
+    b;
+    a;
+    constructor(r, g, b, a = 1.0) {
+        this.r = Math.max(0, Math.min(255, r));
+        this.g = Math.max(0, Math.min(255, g));
+        this.b = Math.max(0, Math.min(255, b));
+        this.a = Math.max(0, Math.min(1, a));
+    }
+    /**
+     * Creates a Color from a hex string.
+     * Supports formats: #RRGGBB, #RGB, #RRGGBBAA, #RGBA.
+     */
+    static fromHex(hex) {
+        const { r, g, b, a } = parseHex(hex);
+        return new Color(r, g, b, a);
+    }
+    static fromHSL(h, s, l, a = 1.0) {
+        const rgb = hslToRgb(h, s, l, a);
+        return new Color(rgb.r, rgb.g, rgb.b, rgb.a);
+    }
+    toHex() {
+        const r = Math.round(this.r).toString(16).padStart(2, '0');
+        const g = Math.round(this.g).toString(16).padStart(2, '0');
+        const b = Math.round(this.b).toString(16).padStart(2, '0');
+        if (this.a >= 0.999) {
+            return `#${r}${g}${b}`;
+        }
+        else {
+            const a = Math.round(this.a * 255).toString(16).padStart(2, '0');
+            return `#${r}${g}${b}${a}`;
+        }
+    }
+    toRGBA() {
+        return `rgba(${Math.round(this.r)}, ${Math.round(this.g)}, ${Math.round(this.b)}, ${this.a})`;
+    }
+    lerp(other, t) {
+        t = Math.max(0, Math.min(1, t));
+        const r = this.r + (other.r - this.r) * t;
+        const g = this.g + (other.g - this.g) * t;
+        const b = this.b + (other.b - this.b) * t;
+        const a = this.a + (other.a - this.a) * t;
+        return new Color(r, g, b, a);
+    }
+    static WHITE = new Color(255, 255, 255);
+    static BLACK = new Color(0, 0, 0);
+    static RED = new Color(255, 0, 0);
+    static GREEN = new Color(0, 255, 0);
+    static BLUE = new Color(0, 0, 255);
+    static YELLOW = new Color(255, 255, 0);
+    static TRANSPARENT = new Color(0, 0, 0, 0);
+}

package/dist/core/math/color/conversions.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Creates a Color from a hex string.
+ * Supports formats: #RRGGBB, #RGB, #RRGGBBAA, #RGBA.
+ */
+export declare function parseHex(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+/** Converts HSL values to RGB. */
+export declare function hslToRgb(h: number, s: number, l: number, a?: number): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};

package/dist/core/math/color/conversions.js

@@ -0,0 +1,100 @@
+/**
+ * Creates a Color from a hex string.
+ * Supports formats: #RRGGBB, #RGB, #RRGGBBAA, #RGBA.
+ */
+export function parseHex(hex) {
+    hex = hex.replace(/^#/, '');
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let a = 1;
+    if (hex.length === 3) {
+        // #RGB
+        const rHex = hex[0] || '';
+        const gHex = hex[1] || '';
+        const bHex = hex[2] || '';
+        r = parseInt(rHex + rHex, 16);
+        g = parseInt(gHex + gHex, 16);
+        b = parseInt(bHex + bHex, 16);
+    }
+    else if (hex.length === 4) {
+        // #RGBA
+        const rHex = hex[0] || '';
+        const gHex = hex[1] || '';
+        const bHex = hex[2] || '';
+        const aHex = hex[3] || '';
+        r = parseInt(rHex + rHex, 16);
+        g = parseInt(gHex + gHex, 16);
+        b = parseInt(bHex + bHex, 16);
+        a = parseInt(aHex + aHex, 16) / 255;
+    }
+    else if (hex.length === 6) {
+        // #RRGGBB
+        r = parseInt(hex.substring(0, 2), 16);
+        g = parseInt(hex.substring(2, 4), 16);
+        b = parseInt(hex.substring(4, 6), 16);
+    }
+    else if (hex.length === 8) {
+        // #RRGGBBAA
+        r = parseInt(hex.substring(0, 2), 16);
+        g = parseInt(hex.substring(2, 4), 16);
+        b = parseInt(hex.substring(4, 6), 16);
+        a = parseInt(hex.substring(6, 8), 16) / 255;
+    }
+    else {
+        throw new Error(`Invalid hex string: ${hex}`);
+    }
+    if (isNaN(r) || isNaN(g) || isNaN(b) || isNaN(a)) {
+        throw new Error(`Invalid hex string: ${hex}`);
+    }
+    return { r, g, b, a };
+}
+/** Converts HSL values to RGB. */
+export function hslToRgb(h, s, l, a = 1.0) {
+    h = h % 360;
+    if (h < 0)
+        h += 360;
+    s = Math.max(0, Math.min(1, s));
+    l = Math.max(0, Math.min(1, l));
+    a = Math.max(0, Math.min(1, a));
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+    const m = l - c / 2;
+    let rPrime = 0;
+    let gPrime = 0;
+    let bPrime = 0;
+    if (0 <= h && h < 60) {
+        rPrime = c;
+        gPrime = x;
+        bPrime = 0;
+    }
+    else if (60 <= h && h < 120) {
+        rPrime = x;
+        gPrime = c;
+        bPrime = 0;
+    }
+    else if (120 <= h && h < 180) {
+        rPrime = 0;
+        gPrime = c;
+        bPrime = x;
+    }
+    else if (180 <= h && h < 240) {
+        rPrime = 0;
+        gPrime = x;
+        bPrime = c;
+    }
+    else if (240 <= h && h < 300) {
+        rPrime = x;
+        gPrime = 0;
+        bPrime = c;
+    }
+    else if (300 <= h && h < 360) {
+        rPrime = c;
+        gPrime = 0;
+        bPrime = x;
+    }
+    const r = Math.round((rPrime + m) * 255);
+    const g = Math.round((gPrime + m) * 255);
+    const b = Math.round((bPrime + m) * 255);
+    return { r, g, b, a };
+}

package/dist/core/math/color/index.d.ts

@@ -0,0 +1,2 @@
+export { Color } from './Color';
+export { parseHex, hslToRgb } from './conversions';

package/dist/core/math/color/index.js

@@ -0,0 +1,2 @@
+export { Color } from './Color';
+export { parseHex, hslToRgb } from './conversions';

package/dist/core/math/index.d.ts

@@ -0,0 +1,4 @@
+export { Vector2 } from './Vector2';
+export { Matrix3x3 } from './matrix';
+export { Color } from './color';
+export * from './bezier';

package/dist/core/math/index.js

@@ -0,0 +1,5 @@
+// Core Math Utilities
+export { Vector2 } from './Vector2';
+export { Matrix3x3 } from './matrix';
+export { Color } from './color';
+export * from './bezier';

package/dist/core/math/matrix/Matrix3x3.d.ts

@@ -0,0 +1,23 @@
+import { Vector2 } from '../Vector2/Vector2';
+/**
+ * A 3x3 matrix class for 2D affine transformations.
+ * Stored in row-major order:
+ * [ 0  1  2 ]
+ * [ 3  4  5 ]
+ * [ 6  7  8 ]
+ */
+export declare class Matrix3x3 {
+    readonly values: Float32Array;
+    constructor(values: number[] | Float32Array);
+    multiply(other: Matrix3x3): Matrix3x3;
+    /** Transforms a Vector2 point (assumes z=1). */
+    transformPoint(point: Vector2): Vector2;
+    /** @throws Error if the matrix is not invertible. */
+    inverse(): Matrix3x3;
+    static identity(): Matrix3x3;
+    static translation(tx: number, ty: number): Matrix3x3;
+    static rotation(angle: number): Matrix3x3;
+    static scale(sx: number, sy: number): Matrix3x3;
+    static shear(shx: number, shy: number): Matrix3x3;
+    static readonly IDENTITY: Matrix3x3;
+}

package/dist/core/math/matrix/Matrix3x3.js

@@ -0,0 +1,91 @@
+import { Vector2 } from '../Vector2/Vector2';
+import { createIdentity, createTranslation, createRotation, createScale, createShear } from './factories';
+/**
+ * A 3x3 matrix class for 2D affine transformations.
+ * Stored in row-major order:
+ * [ 0  1  2 ]
+ * [ 3  4  5 ]
+ * [ 6  7  8 ]
+ */
+export class Matrix3x3 {
+    values;
+    constructor(values) {
+        if (values.length !== 9) {
+            throw new Error('Matrix3x3 requires 9 values');
+        }
+        this.values = new Float32Array(values);
+    }
+    multiply(other) {
+        const a = this.values;
+        const b = other.values;
+        const out = new Float32Array(9);
+        const a00 = a[0], a01 = a[1], a02 = a[2];
+        const a10 = a[3], a11 = a[4], a12 = a[5];
+        const a20 = a[6], a21 = a[7], a22 = a[8];
+        const b00 = b[0], b01 = b[1], b02 = b[2];
+        const b10 = b[3], b11 = b[4], b12 = b[5];
+        const b20 = b[6], b21 = b[7], b22 = b[8];
+        out[0] = a00 * b00 + a01 * b10 + a02 * b20;
+        out[1] = a00 * b01 + a01 * b11 + a02 * b21;
+        out[2] = a00 * b02 + a01 * b12 + a02 * b22;
+        out[3] = a10 * b00 + a11 * b10 + a12 * b20;
+        out[4] = a10 * b01 + a11 * b11 + a12 * b21;
+        out[5] = a10 * b02 + a11 * b12 + a12 * b22;
+        out[6] = a20 * b00 + a21 * b10 + a22 * b20;
+        out[7] = a20 * b01 + a21 * b11 + a22 * b21;
+        out[8] = a20 * b02 + a21 * b12 + a22 * b22;
+        return new Matrix3x3(out);
+    }
+    /** Transforms a Vector2 point (assumes z=1). */
+    transformPoint(point) {
+        const m = this.values;
+        const x = point.x;
+        const y = point.y;
+        const m00 = m[0], m01 = m[1], m02 = m[2];
+        const m10 = m[3], m11 = m[4], m12 = m[5];
+        const tx = m00 * x + m01 * y + m02;
+        const ty = m10 * x + m11 * y + m12;
+        return new Vector2(tx, ty);
+    }
+    /** @throws Error if the matrix is not invertible. */
+    inverse() {
+        const m = this.values;
+        const m00 = m[0], m01 = m[1], m02 = m[2];
+        const m10 = m[3], m11 = m[4], m12 = m[5];
+        const m20 = m[6], m21 = m[7], m22 = m[8];
+        const det = m00 * (m11 * m22 - m12 * m21) -
+            m01 * (m10 * m22 - m12 * m20) +
+            m02 * (m10 * m21 - m11 * m20);
+        if (Math.abs(det) < 1e-10) {
+            throw new Error('Matrix is not invertible');
+        }
+        const invDet = 1.0 / det;
+        const out = new Float32Array(9);
+        out[0] = (m11 * m22 - m12 * m21) * invDet;
+        out[1] = (m02 * m21 - m01 * m22) * invDet;
+        out[2] = (m01 * m12 - m02 * m11) * invDet;
+        out[3] = (m12 * m20 - m10 * m22) * invDet;
+        out[4] = (m00 * m22 - m02 * m20) * invDet;
+        out[5] = (m02 * m10 - m00 * m12) * invDet;
+        out[6] = (m10 * m21 - m11 * m20) * invDet;
+        out[7] = (m01 * m20 - m00 * m21) * invDet;
+        out[8] = (m00 * m11 - m01 * m10) * invDet;
+        return new Matrix3x3(out);
+    }
+    static identity() {
+        return Matrix3x3.IDENTITY;
+    }
+    static translation(tx, ty) {
+        return new Matrix3x3(createTranslation(tx, ty));
+    }
+    static rotation(angle) {
+        return new Matrix3x3(createRotation(angle));
+    }
+    static scale(sx, sy) {
+        return new Matrix3x3(createScale(sx, sy));
+    }
+    static shear(shx, shy) {
+        return new Matrix3x3(createShear(shx, shy));
+    }
+    static IDENTITY = new Matrix3x3(createIdentity());
+}

package/dist/core/math/matrix/factories.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates an identity matrix.
+ */
+export declare function createIdentity(): Float32Array;
+/** Creates a translation matrix. */
+export declare function createTranslation(tx: number, ty: number): Float32Array;
+/** Creates a rotation matrix (angle in radians). */
+export declare function createRotation(angle: number): Float32Array;
+/** Creates a scaling matrix. */
+export declare function createScale(sx: number, sy: number): Float32Array;
+/** Creates a shear matrix. */
+export declare function createShear(shx: number, shy: number): Float32Array;

package/dist/core/math/matrix/factories.js

@@ -0,0 +1,44 @@
+/**
+ * Creates an identity matrix.
+ */
+export function createIdentity() {
+    return new Float32Array([
+        1, 0, 0,
+        0, 1, 0,
+        0, 0, 1
+    ]);
+}
+/** Creates a translation matrix. */
+export function createTranslation(tx, ty) {
+    return new Float32Array([
+        1, 0, tx,
+        0, 1, ty,
+        0, 0, 1
+    ]);
+}
+/** Creates a rotation matrix (angle in radians). */
+export function createRotation(angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return new Float32Array([
+        c, -s, 0,
+        s, c, 0,
+        0, 0, 1
+    ]);
+}
+/** Creates a scaling matrix. */
+export function createScale(sx, sy) {
+    return new Float32Array([
+        sx, 0, 0,
+        0, sy, 0,
+        0, 0, 1
+    ]);
+}
+/** Creates a shear matrix. */
+export function createShear(shx, shy) {
+    return new Float32Array([
+        1, shx, 0,
+        shy, 1, 0,
+        0, 0, 1
+    ]);
+}

package/dist/core/math/matrix/index.d.ts

@@ -0,0 +1,2 @@
+export { Matrix3x3 } from './Matrix3x3';
+export { createIdentity, createTranslation, createRotation, createScale, createShear } from './factories';

package/dist/core/math/matrix/index.js

@@ -0,0 +1,2 @@
+export { Matrix3x3 } from './Matrix3x3';
+export { createIdentity, createTranslation, createRotation, createScale, createShear } from './factories';

package/dist/core/renderer/FrameRenderer.d.ts

@@ -0,0 +1,37 @@
+import { type Canvas } from '@napi-rs/canvas';
+import type { Scene } from '../scene';
+/**
+ * Renders individual frames from a Scene.
+ * Responsible for drawing mobjects to a canvas at a specific point in time.
+ */
+export declare class FrameRenderer {
+    private readonly scene;
+    private readonly width;
+    private readonly height;
+    constructor(scene: Scene, width: number, height: number);
+    /**
+     * Calculates the matrix that transforms Manim world coordinates to screen pixels.
+     *
+     * Manim coordinate system:
+     * - Origin at center of screen
+     * - Y-axis points up
+     * - frameHeight = 8.0 units
+     *
+     * Screen coordinate system:
+     * - Origin at top-left
+     * - Y-axis points down
+     * - Width x Height pixels
+     */
+    private calculateWorldToScreenMatrix;
+    /**
+     * Renders a single frame at the specified time.
+     */
+    renderFrame(time: number): Canvas;
+    /**
+     * Gets the canvas dimensions.
+     */
+    getDimensions(): {
+        width: number;
+        height: number;
+    };
+}