@micahdb/tscon 0.0.0-stage → 0.1.0

package/dist/glyphs.js

@@ -0,0 +1,449 @@
+import { Colour } from "./colour.js";
+import { charCodeInCp437 } from "./cp437.js";
+/**
+ * Number of columns a tab advances the cursor by.
+ *
+ * Tabs in text processed by {@link textToLines} and {@link textGlyphs}
+ * advance the column position to the next multiple of this width.
+ */
+export const TAB_WIDTH = 8;
+function finalSpaceIdx(text, start) {
+    // skip remaining white space
+    while (start < text.length &&
+        (text[start] === " " || text[start] === "\t")) {
+        start++;
+    }
+    // just incase there was a newline
+    if (start < text.length && text[start] === "\n") {
+        start++;
+    }
+    // reached the end of text
+    if (start >= text.length) {
+        return -1;
+    }
+    // return index of last space
+    return start - 1;
+}
+/**
+ * Layout `text` into lines no wider than `cols` columns.
+ *
+ * This is the line-breaking pass used by {@link textGlyphs}. It interprets
+ * the tscon text escape sequences so they are not counted against the
+ * column budget, and returns the raw visible content of each line as a
+ * string (still containing the escape codes for later processing).
+ *
+ * The following escape sequences are recognised and treated as taking up
+ * zero columns:
+ *
+ * - `\\` -- a literal backslash (collapses to one displayed char)
+ * - `\aX` and `\aX{options}` -- an anchor in group `X` (0-9), with an
+ *   optional `{...}` options string
+ * - `\fX` / `\FX` -- set foreground to colour `X` (dark / bright)
+ * - `\bX` / `\BX` -- set background to colour `X` (dark / bright)
+ *
+ * Newlines always break the line. A backslash immediately followed by a
+ * newline is a line continuation: the two characters are removed and the
+ * following content joins the current line. Tabs advance to the next
+ * multiple of {@link TAB_WIDTH}.
+ *
+ * When `wrap` is `true`, lines longer than `cols` are wrapped at the most
+ * recent space (or broken mid-word if a single word fills a whole line).
+ * When `wrap` is `false`, lines longer than `cols` are truncated at the
+ * end of the line and the rest of that logical line is discarded.
+ *
+ * @example
+ * ```ts
+ * import { textToLines } from "@micahdb/tscon";
+ *
+ * textToLines("hello world", 80, true);   // ["hello world"]
+ * ```
+ *
+ * @param text  The text to lay out, possibly with escape sequences.
+ * @param cols  Maximum number of visible columns per line. If `<= 0`, an
+ *              empty array is returned.
+ * @param wrap  Whether to word-wrap long lines (`true`) or truncate them
+ *              (`false`).
+ * @returns     The laid-out visible lines, with escape sequences preserved.
+ */
+export function textToLines(text, cols, wrap) {
+    const lines = [];
+    if (cols <= 0) {
+        return lines; // empty
+    }
+    let start = 0;
+    let running_cols = 0;
+    let last_space = -1;
+    // "text that breaks \
+    // a line into two"
+    // ->
+    // "text that breaks a line into two"
+    text = text.replaceAll("\\\n", "");
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        let escape = c === "\\";
+        // single back slash
+        if (escape && i + 1 < text.length && text[i + 1] === "\\") {
+            i++; // skip one character
+            escape = false;
+        }
+        // anchor escape sequence
+        // \aX                 : anchor in group X, no options
+        // \aX{options string} : anchor in group X, with options
+        if (escape && i + 2 < text.length && text[i + 1] === "a" &&
+            !isNaN(Number(text[i + 2]))) {
+            let skip_chars = 2;
+            // options string
+            if (i + 3 < text.length && text[i + 3] === "{") {
+                const closing_brace = text.indexOf("}", i + 3);
+                if (closing_brace > i + 3) {
+                    // skip right until the closing brace
+                    skip_chars = closing_brace - i;
+                } // else, no matching closing brace, ignore "{"
+            }
+            i += skip_chars;
+            continue; // i++
+        }
+        // colours escape sequence
+        // \fX : set foreground to X, dark
+        // \FX : set foreground to X, bright
+        // \bX : set background to X, dark
+        // \BX : set background to X, bright
+        if (escape &&
+            i + 2 < text.length &&
+            "fFbB".includes(text[i + 1]) &&
+            !isNaN(Number(text[i + 2]))) {
+            // skip the 3 char combo
+            i += 2;
+            continue; // i++
+        }
+        // newline
+        if (c === "\n") {
+            lines.push(text.slice(start, i).trimEnd());
+            start = i + 1;
+            running_cols = 0;
+            last_space = -1;
+            continue;
+        }
+        // tab
+        if (c === "\t") {
+            const cols_to_tab = TAB_WIDTH -
+                (running_cols % TAB_WIDTH);
+            if (running_cols + cols_to_tab > cols) {
+                lines.push(text.slice(start, i).trimEnd());
+                if (!wrap) {
+                    i = text.indexOf("\n", i + 1);
+                }
+                else {
+                    i = finalSpaceIdx(text, i + 1);
+                }
+                // end of text
+                if (i < 0) {
+                    break;
+                }
+                start = i + 1;
+                running_cols = 0;
+                last_space = -1;
+            }
+            else {
+                running_cols += cols_to_tab;
+                last_space = i;
+            }
+            continue;
+        }
+        // space
+        if (c === " ") {
+            last_space = i;
+        }
+        // exceeding available width
+        if (running_cols + 1 > cols) {
+            // skip rest of line if not wrapping
+            if (!wrap) {
+                lines.push(text.slice(start, i).trimEnd());
+                i = text.indexOf("\n", i + 1);
+                // end of text
+                if (i < 0) {
+                    break;
+                }
+                start = i + 1;
+                running_cols = 0;
+                last_space = -1;
+                continue;
+            }
+            // this is a continuous word that filled the whole line
+            if (last_space < 0) {
+                lines.push(text.slice(start, i).trimEnd());
+                start = i;
+                running_cols = 0;
+                i--;
+                continue;
+            }
+            // otherwise, will break at last space
+            lines.push(text.slice(start, last_space).trimEnd());
+            i = finalSpaceIdx(text, last_space);
+            start = i + 1;
+            running_cols = 0;
+            last_space = -1;
+            continue;
+        }
+        running_cols++;
+    }
+    // push last line if it isn't a space
+    if (start < text.length) {
+        lines.push(text.slice(start));
+    }
+    return lines;
+}
+/**
+ * Render `text` into a grid of terminal glyphs `cols` wide.
+ *
+ * This is the primary text-rendering entry point. It runs {@link textToLines}
+ * to lay the text out, then encodes each visible character as a packed
+ * 16-bit glyph (CP437 code + colour pair) into the resulting {@link Glyphs}.
+ *
+ * The escape sequences understood by the text format are interpreted here:
+ *
+ * - `\\` -- emits a single literal backslash
+ * - `\aX` / `\aX{options}` -- records an anchor in group `X` (0-9) at the
+ *   current position, with optional `options` string (see {@link Anchor})
+ * - `\fX` / `\FX` -- set foreground colour to `X` (dark / bright)
+ * - `\bX` / `\BX` -- set background colour to `X` (dark / bright)
+ *
+ * Colours `X` are clamped to 0-7; the `F`/`B` (capital) variants add 8 to
+ * select the bright half of the palette. The initial foreground is
+ * {@link Colour.WHITE} and the initial background is {@link Colour.BLACK}.
+ *
+ * Tabs advance the column to the next multiple of {@link TAB_WIDTH} but
+ * do not emit anything. Characters outside the CP437 range map to 0
+ * (blank), and trailing space on the default colour is left as zero so it
+ * does not overwrite whatever is already on the console.
+ *
+ * @example
+ * ```ts
+ * import { textGlyphs } from "@micahdb/tscon";
+ *
+ * // bright-blue on black "Link", 4 cols wide
+ * const g = textGlyphs("\\F4\\b0Link", 4, false);
+ * ```
+ *
+ * @param text  The text to render, with escape sequences.
+ * @param cols  Width of the grid in cells. If `<= 0`, an empty grid is
+ *              returned.
+ * @param wrap  Whether to word-wrap long lines (`true`) or truncate them
+ *              (`false`).
+ * @returns     The rendered glyph grid, with anchors populated.
+ */
+export function textGlyphs(text, cols, wrap) {
+    if (cols <= 0) {
+        return {
+            data: new Uint16Array(),
+            rows: 0,
+            cols: 0,
+            anchors: {},
+        };
+    }
+    const lines = textToLines(text, cols, wrap);
+    const rows = lines.length;
+    if (rows === 0) {
+        return {
+            data: new Uint16Array(),
+            rows: 0,
+            cols: 0,
+            anchors: {},
+        };
+    }
+    const glyphs = {
+        data: new Uint16Array(rows * cols),
+        rows,
+        cols: cols,
+        anchors: {},
+    };
+    let fg = Colour.WHITE;
+    let bg = Colour.BLACK;
+    for (let row = 0; row < rows; row++) {
+        const line = lines[row];
+        let col = 0;
+        for (let i = 0; i < line.length; i++) {
+            const c = line[i];
+            let escape = c === "\\";
+            // \\ : display a single back slash
+            if (escape && i + 1 < line.length &&
+                line[i + 1] === "\\") {
+                i++; // this will be displayed as a single character
+                escape = false; // skip below checks
+            }
+            // anchor escape sequence
+            // \aX                 : anchor in group X, no options
+            // \aX{options string} : anchor in group X, with options
+            if (escape && i + 2 < line.length &&
+                line[i + 1] === "a" &&
+                !isNaN(Number(line[i + 2]))) {
+                const num = Math.max(Math.min(Number(line[i + 2]), 9), 0); // 0..9
+                let skip_chars = 2;
+                if (glyphs.anchors[num] === undefined) {
+                    glyphs.anchors[num] = [];
+                }
+                const anchors = glyphs.anchors[num];
+                let options = null;
+                // options string
+                if (i + 4 <= line.length &&
+                    line[i + 3] === "{") {
+                    const closing_brace = line.indexOf("}", i + 3);
+                    if (closing_brace > i + 3) {
+                        // \aX{options} <- take text from inner braces
+                        options = line.slice(i + 4, closing_brace);
+                        // skip right until the closing brace
+                        skip_chars = closing_brace - i;
+                    } // else, options = null
+                }
+                // empty string should be null
+                if (options === "") {
+                    options = null;
+                }
+                anchors.push({ options, row, col });
+                i += skip_chars;
+                continue; // i++
+            }
+            // colour escape sequence:
+            // \fX : foreground X, dark
+            // \FX : foreground X, bright
+            // \bX : background X, dark
+            // \BX : background X, bright
+            if (escape &&
+                i + 2 < line.length &&
+                "fFbB".includes(line[i + 1]) &&
+                !isNaN(Number(line[i + 2]))) {
+                const num = Math.max(Math.min(Number(line[i + 2]), 7), 0); // 0..7
+                switch (line[i + 1]) {
+                    case "f":
+                        fg = num;
+                        break;
+                    case "F":
+                        fg = num + 8;
+                        break;
+                    case "b":
+                        bg = num;
+                        break;
+                    case "B":
+                        bg = num + 8;
+                        break;
+                }
+                i += 2;
+                continue;
+            }
+            // tab
+            if (c === "\t") {
+                const tab_chars = TAB_WIDTH - (col % TAB_WIDTH);
+                col += tab_chars;
+                continue;
+            }
+            if (col + 1 > cols) {
+                // in theory, shouldn't happen; but be safe if it does
+                break;
+            }
+            const char_code = charCodeInCp437(line.codePointAt(i) ?? " ".codePointAt(0));
+            const colour_byte = ((fg & 0b1111) << 4) |
+                (bg & 0b1111);
+            if (char_code !== " ".codePointAt(0) ||
+                colour_byte !== 0) {
+                const data_idx = row * cols + col;
+                const glyph = (colour_byte << 8) |
+                    (char_code & 0xff);
+                glyphs.data[data_idx] = glyph;
+            }
+            col++;
+        }
+    }
+    return glyphs;
+}
+/**
+ * How each cell of a {@link TexGlyphs} grid samples its source texture.
+ *
+ * The value is packed into each texture-glyph and read by the renderer's
+ * vertex shader to decide, per cell, how to turn the source texture into a
+ * drawn glyph.
+ *
+ * - `SAMPLE`    -- render the source texture directly. Each cell is given UV
+ *                  coordinates into the texture, so the full rendered region
+ *                  simply shows the source texture as-is.
+ * - `GLYPHS`    -- sample the texture and convert it to a glyph: the
+ *                  character is chosen by the sample's brightness and the
+ *                  colour by dithering (Bayer matrix + nearest palette hue).
+ *                  The background stays black. Preferred when you want the
+ *                  texture rendered as coloured characters without it being
+ *                  too bright or jarring.
+ * - `BG_GLYPHS` -- like `GLYPHS`, but also sets the background colour, so
+ *                  the full glyph (foreground + background) carries more of
+ *                  the sample's colour. This is noticeably brighter and more
+ *                  visually accurate; use it when no text is drawn on top of
+ *                  the rendered texture.
+ * - `MIX`       -- alternate `SAMPLE`/`GLYPHS` in a checkerboard pattern.
+ * - `ROWS`      -- alternate `SAMPLE`/`GLYPHS` by row.
+ * - `COLS`      -- alternate `SAMPLE`/`GLYPHS` by column.
+ */
+export var TexGlyphMode;
+(function (TexGlyphMode) {
+    TexGlyphMode[TexGlyphMode["SAMPLE"] = 0] = "SAMPLE";
+    TexGlyphMode[TexGlyphMode["GLYPHS"] = 1] = "GLYPHS";
+    TexGlyphMode[TexGlyphMode["BG_GLYPHS"] = 2] = "BG_GLYPHS";
+    TexGlyphMode[TexGlyphMode["MIX"] = 3] = "MIX";
+    TexGlyphMode[TexGlyphMode["ROWS"] = 4] = "ROWS";
+    TexGlyphMode[TexGlyphMode["COLS"] = 5] = "COLS";
+})(TexGlyphMode || (TexGlyphMode = {}));
+/**
+ * Build a {@link TexGlyphs} grid of `rows` by `cols` cells that samples a
+ * texture in the given {@link TexGlyphMode}.
+ *
+ * The grid is sized to match a region of the terminal (typically the whole
+ * canvas, `canvas.rows` x `canvas.cols`, or a smaller sub-region) and is
+ * passed to {@link Renderer.draw} along with the texture to display.
+ *
+ * For the `MIX`, `ROWS`, and `COLS` modes the requested `mode` is used as a
+ * base and individual cells are switched between `SAMPLE` and `GLYPHS`
+ * according to the pattern (see {@link TexGlyphMode} for what each mode does
+ * to the sampled texture). The packed per-cell value encodes the cell's own
+ * row/column and the (possibly per-cell) effective mode.
+ *
+ * @example
+ * ```ts
+ * import { TexGlyphMode, textureGlyphs } from "@micahdb/tscon";
+ *
+ * // whole-canvas glyphs that sample the texture as coloured characters
+ * const tg = textureGlyphs(canvas.rows, canvas.cols, TexGlyphMode.GLYPHS);
+ * ```
+ *
+ * @param rows  Height of the grid in cells.
+ * @param cols  Width of the grid in cells.
+ * @param mode  Sampling mode to apply to the cells.
+ * @returns     The packed texture-glyph grid.
+ */
+export function textureGlyphs(rows, cols, mode) {
+    const tglyphs = {
+        data: new Uint32Array(rows * cols),
+        rows,
+        cols,
+    };
+    const global_mode = mode;
+    for (let data_idx = 0; data_idx < rows * cols; data_idx++) {
+        const row = Math.floor(data_idx / cols);
+        const col = data_idx % cols;
+        if (global_mode == TexGlyphMode.MIX) {
+            mode = (row + col) % 2 == 0
+                ? TexGlyphMode.SAMPLE
+                : TexGlyphMode.GLYPHS;
+        }
+        else if (global_mode == TexGlyphMode.ROWS) {
+            mode = row % 2 == 0
+                ? TexGlyphMode.SAMPLE
+                : TexGlyphMode.GLYPHS;
+        }
+        else if (global_mode == TexGlyphMode.COLS) {
+            mode = col % 2 == 0
+                ? TexGlyphMode.SAMPLE
+                : TexGlyphMode.GLYPHS;
+        }
+        const glyph = ((row & 0xff) << 24) | ((mode & 0xff) << 16) |
+            (col & 0xffff);
+        tglyphs.data[data_idx] = glyph;
+    }
+    return tglyphs;
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { Canvas } from "./canvas.ts";
+export { Terminal } from "./terminal.ts";
+export { TAB_WIDTH, TexGlyphMode, textGlyphs, textToLines, textureGlyphs, } from "./glyphs.ts";
+export type { Anchor, Glyphs, TexGlyphs } from "./glyphs.ts";
+export { Renderer } from "./renderer.ts";
+export { Mat4, Vec4 } from "./math.ts";
+export { compileProgram, getAttribLocations, getUniformLocations, } from "./program.ts";
+export { renderCp437 } from "./cp437.ts";
+export { Colour, PALETTE } from "./colour.ts";
+export type { Rect } from "./rect.ts";
+export { loadCubeMap, loadTexture } from "./texture.ts";

package/dist/index.js

@@ -0,0 +1,9 @@
+export { Canvas } from "./canvas.js";
+export { Terminal } from "./terminal.js";
+export { TAB_WIDTH, TexGlyphMode, textGlyphs, textToLines, textureGlyphs, } from "./glyphs.js";
+export { Renderer } from "./renderer.js";
+export { Mat4, Vec4 } from "./math.js";
+export { compileProgram, getAttribLocations, getUniformLocations, } from "./program.js";
+export { renderCp437 } from "./cp437.js";
+export { Colour, PALETTE } from "./colour.js";
+export { loadCubeMap, loadTexture } from "./texture.js";

package/dist/math.d.ts

@@ -0,0 +1,214 @@
+/**
+ * A column-major 4x4 matrix stored as a 16-element `Float32Array`.
+ *
+ * `Mat4` provides static helpers for creating and operating on 4x4 matrices
+ * following the conventions of `gl-matrix`-style libraries: the `o` argument
+ * of each operation is the output buffer (which may alias an input) and the
+ * same buffer is returned to allow chaining.
+ *
+ * Matrices are stored column-major; element `m[col * 4 + row]` is row `row`,
+ * column `col`.
+ */
+export declare class Mat4 {
+    /**
+     * Create and return a new 4x4 identity matrix.
+     *
+     * @returns A 16-element `Float32Array` initialised to the identity
+     *          matrix.
+     */
+    static create(): Float32Array;
+    /**
+     * Set all 16 components of matrix `o` to the given values, which are
+     * supplied in column-major order (`m00, m01, m02, m03, m10, ...`).
+     *
+     * `o` is returned for convenience.
+     *
+     * @param o  The matrix to write into.
+     * @returns  The same matrix `o`, with its components overwritten.
+     */
+    static set(o: Float32Array, m00: number, m01: number, m02: number, m03: number, m10: number, m11: number, m12: number, m13: number, m20: number, m21: number, m22: number, m23: number, m30: number, m31: number, m32: number, m33: number): Float32Array;
+    /**
+     * Multiply matrices `a` and `b` and store the result in `o`
+     * (`o = a * b`).
+     *
+     * `o` may be the same buffer as `a` or `b`. The result is equivalent to
+     * first applying `b` then `a` (i.e. `a * b` in standard column-vector
+     * notation), which is the order used for building model/view/projection
+     * chains.
+     *
+     * @param o  Output matrix (may alias `a` or `b`).
+     * @param a  Left-hand matrix.
+     * @param b  Right-hand matrix.
+     * @returns  The matrix `o`.
+     */
+    static multiply(o: Float32Array, a: Float32Array, b: Float32Array): Float32Array;
+    /**
+     * Set `o` to the transpose of `a`.
+     *
+     * `o` may be the same buffer as `a`; in that case the transpose is
+     * performed in place.
+     *
+     * @param o  Output matrix (may alias `a`).
+     * @param a  Source matrix.
+     * @returns  The matrix `o`.
+     */
+    static transpose(o: Float32Array, a: Float32Array): Float32Array;
+    /**
+     * Set `o` to the inverse of `a`.
+     *
+     * The determinant is computed internally; if it is zero the resulting
+     * matrix is undefined. `o` must not alias `a` (the computation
+     * reads `a` while writing `o`).
+     *
+     * @param o  Output matrix (must not alias `a`).
+     * @param a  Source matrix.
+     * @returns  The matrix `o`.
+     */
+    static inverse(o: Float32Array, a: Float32Array): Float32Array;
+    /**
+     * Compute the upper-left 3x3 inverse-transpose of `a` and write it into
+     * the 9-element output `o`.
+     *
+     * This is the standard "normal matrix" used to transform normals in a
+     * lighting shader. `o` must be a `Float32Array` of length 9 and
+     * must not alias `a`.
+     *
+     * @example
+     * ```ts
+     * import { Mat4 } from "@micahdb/tscon";
+     *
+     * const mv = Mat4.create();
+     * Mat4.multiply(mv, view, model);
+     * const normals = new Float32Array(9);
+     * Mat4.inverseTranspose3x3(normals, mv);
+     * gl.uniformMatrix3fv(loc, false, normals);
+     * ```
+     *
+     * @param o  Output 3x3 matrix (length-9 `Float32Array`).
+     * @param a  Source 4x4 matrix.
+     * @returns  The matrix `o`.
+     */
+    static inverseTranspose3x3(o: Float32Array, a: Float32Array): Float32Array;
+    /**
+     * Set `o` to a perspective projection matrix.
+     *
+     * The matrix maps a view frustum defined by a vertical field of view
+     * `fovy` (in radians), the viewport `aspect` ratio (width /
+     * height), and the `near` and `far` clip-plane distances into clip
+     * space, with the camera looking down -Z.
+     *
+     * @param o       Output matrix.
+     * @param fovy    Vertical field of view, in radians.
+     * @param aspect  Width / height of the viewport.
+     * @param near    Distance to the near clip plane.
+     * @param far     Distance to the far clip plane.
+     * @returns       The matrix `o`.
+     */
+    static perspective(o: Float32Array, fovy: number, aspect: number, near: number, far: number): Float32Array;
+    /**
+     * Set `o` to an orthographic projection matrix.
+     *
+     * The matrix maps the axis-aligned box with the given left/right,
+     * bottom/top, and near/far planes into clip space.
+     *
+     * @param o      Output matrix.
+     * @param left   Left edge of the view volume.
+     * @param right  Right edge of the view volume.
+     * @param bottom Bottom edge of the view volume.
+     * @param top    Top edge of the view volume.
+     * @param near   Distance to the near clip plane.
+     * @param far    Distance to the far clip plane.
+     * @returns      The matrix `o`.
+     */
+    static orthographic(o: Float32Array, left: number, right: number, bottom: number, top: number, near: number, far: number): Float32Array;
+    /**
+     * Set `o` to a "look at" view matrix.
+     *
+     * Builds a camera/view matrix placed at `eye`, oriented to look towards
+     * `center`, with the given `up` axis. The result transforms world-space
+     * coordinates into view space (camera looking down -Z).
+     *
+     * @param o       Output matrix.
+     * @param eye     Camera position as a length-3 array `[x, y, z]`.
+     * @param center  Point the camera looks towards, `[x, y, z]`.
+     * @param up      Camera up direction, `[x, y, z]`.
+     * @returns       The matrix `o`.
+     */
+    static lookAt(o: Float32Array, e: Float32Array, c: Float32Array, up: Float32Array): Float32Array;
+    /**
+     * Create and return a translation matrix for the given offsets.
+     *
+     * @param tx  Translation along X.
+     * @param ty  Translation along Y.
+     * @param tz  Translation along Z.
+     * @returns   A new translation matrix.
+     */
+    static translation(tx: number, ty: number, tz: number): Float32Array;
+    /**
+     * Create and return a non-uniform scale matrix.
+     *
+     * @param sx  Scale factor along X.
+     * @param sy  Scale factor along Y.
+     * @param sz  Scale factor along Z.
+     * @returns   A new scale matrix.
+     */
+    static scale(sx: number, sy: number, sz: number): Float32Array;
+    /**
+     * Create and return a rotation matrix.
+     *
+     * The rotation is by `radians` about one of the principal axes. The
+     * returned matrix follows a right-handed convention.
+     *
+     * @param axis     The axis to rotate about: `"x"`, `"y"`, or `"z"`.
+     * @param radians  Rotation angle in radians.
+     * @returns        A new rotation matrix, or an identity matrix if
+     *                `axis` is not recognised.
+     */
+    static rotation(axis: string, radians: number): Float32Array;
+}
+/**
+ * A 4-component vector stored as a 4-element `Float32Array`.
+ *
+ * Like {@link Mat4}, `Vec4` exposes static helpers that take an output buffer
+ * `o` (returned for chaining) rather than allocating on each operation.
+ */
+export declare class Vec4 {
+    /**
+     * Create and return a new zeroed 4-component vector.
+     *
+     * @returns A length-4 `Float32Array` initialised to `[0, 0, 0, 0]`.
+     */
+    static create(): Float32Array;
+    /**
+     * Set the four components of vector `o` to the given values.
+     *
+     * @param o  The vector to write into.
+     * @param x  Component 0.
+     * @param y  Component 1.
+     * @param z  Component 2.
+     * @param w  Component 3.
+     */
+    static set(o: Float32Array, x: number, y: number, z: number, w: number): void;
+    /**
+     * Create and return a new vector initialised to the given values.
+     *
+     * @param x  Component 0.
+     * @param y  Component 1.
+     * @param z  Component 2.
+     * @param w  Component 3.
+     * @returns  A new length-4 `Float32Array`.
+     */
+    static from(x: number, y: number, z: number, w: number): Float32Array;
+    /**
+     * Transform vector `a` by matrix `m` and store the result in `o`
+     * (`o = m * a`, treating `a` as a column vector).
+     *
+     * `o` may be the same buffer as `a`.
+     *
+     * @param o  Output vector (may alias `a`).
+     * @param a  Source vector.
+     * @param m  Transformation matrix.
+     * @returns  The vector `o`.
+     */
+    static transformMat4(o: Float32Array, a: Float32Array, m: Float32Array): Float32Array;
+}