vgpu-render 0.1.0 → 0.3.0

package/dist/layout-3d.js

@@ -1,226 +0,0 @@
-/**
- * Layout and drawing specifications ported from `the upstream reference`.
- *
- * Every reference scene shares the same layout contract, which is why it lives here rather
- * than being re-derived per scene:
- *
- * ```
- * column_x(column) = column * COLUMN_SPACING + 0.5      // COLUMN_SPACING is 2.0, axes 2.2
- * row_z(row)       = SAMPLE_START_Z - row * spacing     // START_Z is -0.45, rows go along -Z
- * ```
- *
- * Each scene has its own `SAMPLE_SPACING`, and some columns override it (radius, size,
- * angle, height). Coordinates are local to the scene root; the reference capture harness
- * translates the whole root by `REFERENCE_OFFSET` without rescaling any geometry, so the
- * same translation is applied here.
- */
-/** `scene.position = Vector3(-10, 0, 1.5)` from `the reference capture script`. */
-export const REFERENCE_OFFSET = [-10, 0, 1.5];
-export function referenceOffset(p) {
-    return [p[0] + REFERENCE_OFFSET[0], p[1] + REFERENCE_OFFSET[1], p[2] + REFERENCE_OFFSET[2]];
-}
-/** Shared value tables used by the reference scenes. */
-export const WIDTH_VALUES = [1, 2, 5.5, 10];
-export const ALPHA_VALUES = [1, 0.65, 0.35, 0.1];
-export const DASH_VALUES = [[0.1, 0.1], [0.2, 0.1], [0.4, 0.15], [0.04, 0.12]];
-export const JOINT_VALUES = ["none", "round", "bevel", "miter"];
-export const RADIUS_VALUES = [0.18, 0.28, 0.38, 0.5];
-export const SEGMENT_VALUES = [8, 16, 32, 64];
-export const ROTATION_SAMPLE_COUNT = 8;
-export const NORMAL_SAMPLE_COUNT = 4;
-export const WHITE = [1, 1, 1, 1];
-export const CYAN = [0.15, 0.85, 1, 0.95];
-export const LIME = [0.7, 1, 0.25, 1];
-export const ORANGE = [1, 0.45, 0.2, 1];
-export const ORANGE_SOFT = [1, 0.45, 0.2, 0.95];
-export const VIOLET = [0.75, 0.45, 1, 1];
-export const TEAL = [0.25, 0.95, 0.9, 1];
-export const PINK = [1, 0.3, 0.6, 1];
-export const GOLD = [1, 0.75, 0.25, 1];
-/** Reference `_get_normal_sample_color` / `_get_normal_sample_width`, shared by most scenes. */
-export function normalSampleColor(row) {
-    if (row === 1)
-        return [0.25, 0.95, 0.9, 0.35];
-    if (row === 2)
-        return [1, 0.45, 0.2, 1];
-    return [0.25, 0.95, 0.9, 1];
-}
-export function normalSampleWidth(row, baseWidth) {
-    return row === 3 ? 10 : baseWidth;
-}
-/**
- * reference `Color.from_hsv(h, s, v, a)`. The reference solid samples use this, so a fixed
- * palette color cannot reproduce them. `h` is in `[0, 1]`, matching reference.
- */
-export function fromHsv(h, s, v, a) {
-    const hue = ((h % 1) + 1) % 1;
-    const i = Math.floor(hue * 6);
-    const f = hue * 6 - i;
-    const p = v * (1 - s);
-    const q = v * (1 - s * f);
-    const t = v * (1 - s * (1 - f));
-    switch (i % 6) {
-        case 0: return [v, t, p, a];
-        case 1: return [q, v, p, a];
-        case 2: return [p, v, t, a];
-        case 3: return [p, q, v, a];
-        case 4: return [t, p, v, a];
-        default: return [v, p, q, a];
-    }
-}
-export function normalizeVector(p) {
-    const length = Math.hypot(p[0], p[1], p[2]) || 1;
-    return [p[0] / length, p[1] / length, p[2] / length];
-}
-export function crossVector(a, b) {
-    return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
-}
-/** reference `Vector3.rotated(axis, angle)` equivalent (right-handed Rodrigues). */
-export function rotateAroundAxis(p, axis, angle) {
-    const a = normalizeVector(axis);
-    const cos = Math.cos(angle);
-    const sin = Math.sin(angle);
-    const dot = p[0] * a[0] + p[1] * a[1] + p[2] * a[2];
-    const cross = crossVector(a, p);
-    return [
-        p[0] * cos + cross[0] * sin + a[0] * dot * (1 - cos),
-        p[1] * cos + cross[1] * sin + a[1] * dot * (1 - cos),
-        p[2] * cos + cross[2] * sin + a[2] * dot * (1 - cos),
-    ];
-}
-/** Port of `_get_circle_rotation(normal, angle)` from `circle.gd`. */
-export function circleBasis(normal, angle) {
-    const n = normalizeVector(normal);
-    const reference = Math.abs(n[0]) > 0.95 ? [0, 0, 1] : [1, 0, 0];
-    const projection = reference[0] * n[0] + reference[1] * n[1] + reference[2] * n[2];
-    const planar = [reference[0] - n[0] * projection, reference[1] - n[1] * projection, reference[2] - n[2] * projection];
-    const widthAxis = normalizeVector(rotateAroundAxis(normalizeVector(planar), n, angle));
-    const heightAxis = normalizeVector(crossVector(n, widthAxis));
-    return { x: widthAxis, y: heightAxis, z: n };
-}
-/** Points on a circle in the plane spanned by a reference rotation basis. */
-export function basisCirclePoints(centerLocal, radius, segments, basis) {
-    const center = referenceOffset(centerLocal);
-    const points = [];
-    for (let i = 0; i < segments; i++) {
-        const angle = i / segments * Math.PI * 2;
-        const cos = Math.cos(angle) * radius;
-        const sin = Math.sin(angle) * radius;
-        points.push([
-            center[0] + basis.x[0] * cos + basis.y[0] * sin,
-            center[1] + basis.x[1] * cos + basis.y[1] * sin,
-            center[2] + basis.x[2] * cos + basis.y[2] * sin,
-        ]);
-    }
-    return points;
-}
-export function createLayout(layout, baseY) {
-    const columnX = (column) => column * layout.columnSpacing + layout.columnOffset;
-    const rowSpacing = (column) => layout.perColumnSpacing?.[column] ?? layout.sampleSpacing;
-    const rowZ = (column, row) => layout.sampleStartZ - row * rowSpacing(column);
-    const at = (column, row) => {
-        const y = layout.columnY === undefined ? baseY : layout.columnY(column, row, baseY);
-        return referenceOffset([columnX(column), y, rowZ(column, row)]);
-    };
-    /** Local (untranslated) centre, for functions that must offset before the scene shift. */
-    const atLocal = (column, row) => {
-        const y = layout.columnY === undefined ? baseY : layout.columnY(column, row, baseY);
-        return [columnX(column), y, rowZ(column, row)];
-    };
-    return { columnX, rowZ, rowSpacing, at, atLocal };
-}
-/** Reference `circle.gd` layout: radius column uses 1.15 row spacing, the rest 0.82. */
-export const CIRCLE_REFERENCE_LAYOUT = {
-    columnSpacing: 2,
-    columnOffset: 0.5,
-    sampleSpacing: 0.82,
-    sampleStartZ: -0.45,
-    perColumnSpacing: { 1: 1.15 },
-};
-/**
- * Per-scene layouts, copied from the constants at the top of each `examples/*.gd`.
- *
- * Every reference scene differs only in these numbers, so they are data here rather than
- * duplicated coordinate math. `columnSpacing` is 2.0 everywhere except `axes` (2.2).
- */
-export const SCENE_LAYOUTS = {
-    /** `index.gd`: absolute origin, its own row spacing, samples lifted to y = 0.55. */
-    index: { columnSpacing: 2, columnOffset: 1, sampleSpacing: 1.25, sampleStartZ: -1, baseY: 0.55 },
-    arrow: { columnSpacing: 2, columnOffset: 0.5, sampleSpacing: 0.78, sampleStartZ: -0.45, baseY: 0.1 },
-    axes: {
-        columnSpacing: 2.2,
-        columnOffset: 0.5,
-        sampleSpacing: 0.86,
-        sampleStartZ: -0.45,
-        baseY: 0.1,
-        perColumnSpacing: { 0: 1.05, 3: 1.05 },
-    },
-    grid: { columnSpacing: 2, columnOffset: 0.5, sampleSpacing: 0.72, sampleStartZ: -0.45, baseY: 0.06 },
-    rect: {
-        columnSpacing: 2,
-        columnOffset: 0.5,
-        sampleSpacing: 0.62,
-        sampleStartZ: -0.45,
-        baseY: 0.1,
-        perColumnSpacing: { 1: 0.9 },
-    },
-    box: {
-        columnSpacing: 2,
-        columnOffset: 0.5,
-        sampleSpacing: 0.82,
-        sampleStartZ: -0.45,
-        baseY: 0.08,
-        perColumnSpacing: { 1: 1.05 },
-    },
-    arc: {
-        columnSpacing: 2,
-        columnOffset: 0.5,
-        sampleSpacing: 0.92,
-        sampleStartZ: -0.45,
-        baseY: 0.1,
-        perColumnSpacing: { 1: 1.15, 2: 1.08 },
-    },
-    // `curve.gd`: rows start at EXAMPLE_START_Z = -2.0; the transform and closed
-    // columns widen their row spacing to 0.85x and 1.05x of SAMPLE_SPACING.
-    curve: {
-        columnSpacing: 2,
-        columnOffset: 0.5,
-        sampleSpacing: 0.82,
-        sampleStartZ: -2,
-        baseY: 0.1,
-        perColumnSpacing: { 2: 0.82 * 0.85, 4: 0.82 * 1.05 },
-    },
-    sphere: {
-        columnSpacing: 2,
-        columnOffset: 0.5,
-        sampleSpacing: 0.86,
-        sampleStartZ: -0.45,
-        baseY: 0.1,
-        perColumnSpacing: { 1: 1.08 },
-    },
-    cone: {
-        columnSpacing: 2,
-        columnOffset: 0.5,
-        sampleSpacing: 0.84,
-        sampleStartZ: -0.45,
-        baseY: 0.1,
-        perColumnSpacing: { 1: 1.05, 2: 1.08 },
-    },
-    cylinder: {
-        columnSpacing: 2,
-        columnOffset: 0.5,
-        sampleSpacing: 0.84,
-        sampleStartZ: -0.45,
-        baseY: 0.1,
-        perColumnSpacing: { 1: 1.05, 2: 1.08 },
-    },
-    capsule: {
-        columnSpacing: 2,
-        columnOffset: 0.5,
-        sampleSpacing: 0.86,
-        sampleStartZ: -0.45,
-        baseY: 0.1,
-        perColumnSpacing: { 1: 1.02, 2: 1.02 },
-    },
-    world_space_width: { columnSpacing: 2, columnOffset: 1, sampleSpacing: 1.25, sampleStartZ: -1, baseY: 0.55 },
-};

package/dist/scene-examples.d.ts

@@ -1,39 +0,0 @@
-export type ExampleColumn = {
-    readonly label: string;
-    readonly samples: readonly string[];
-    readonly implemented: boolean;
-};
-export type SceneExample = {
-    readonly id: string;
-    readonly title: string;
-    readonly description: string;
-    readonly notes?: string;
-    readonly columns: readonly ExampleColumn[];
-    readonly implemented: boolean;
-    /** Which camera drives the page: the gallery's 3D orbit camera by default, or the 2D pan/zoom one. */
-    readonly family?: "2d" | "3d";
-    /**
-     * Sidebar grouping. Defaults to `family`, so the 2D pages land in "2D Graphics" and every 3D
-     * page in "3D Graphics"; the text pages name "text" explicitly, since they use the 3D camera
-     * without being 3D geometry pages.
-     */
-    readonly group?: "3d" | "2d" | "text";
-    /**
-     * World-space extent the 2D camera fits to this page, in `world2d` units. Only read when
-     * `family` is "2d"; the page draws around the origin.
-     */
-    readonly view2d?: {
-        readonly width: number;
-        readonly height: number;
-    };
-    /**
-     * Hide the infinite grid while this example is selected.
-     *
-     * A screen-space page is its own content in pixel space, so the grid is a world-space reference
-     * that can only cross it as diagonal lines, so those pages set `true`. A world-space page that
-     * wants the grid as its ground plane says `false` explicitly; leaving the flag unset keeps whatever
-     * the sidebar shows, which is what every other world-space example wants.
-     */
-    readonly hideGrid?: boolean;
-};
-export declare const SCENE_EXAMPLES: readonly SceneExample[];

package/dist/scene-examples.js

@@ -1,200 +0,0 @@
-// Columns whose reference variants are only approximated by this vgpu port are flagged false so the
-// gallery never claims parity it does not have: grid boundary (`outer`) handling still differs.
-const approximated = /outer/;
-const column = (label, samples) => ({
-    label,
-    samples,
-    implemented: !approximated.test(label),
-});
-const width = ["width = 1.0", "width = 2.0", "width = 5.5", "width = 10.0"];
-const joints = ["none", "round", "bevel", "miter"];
-const dash = ["dash = 0.10 / 0.10", "dash = 0.20 / 0.10", "dash = 0.40 / 0.15", "dash = 0.04 / 0.12"];
-const normal = ["base", "alpha", "color", "wide"];
-const rotation = Array.from({ length: 8 }, (_, index) => `step ${index}`);
-// Arrow example samples copied from `examples/arrow.gd` `_get_sample_label`.
-const arrowWidth = ["w = 1.0", "w = 2.0", "w = 5.5", "w = 10.0"];
-const arrowDir = ["-63 deg", "-22 deg", "22 deg", "63 deg"];
-const arrowHeadAngle = ["20 deg", "30 deg", "45 deg", "76 deg"];
-const arrowJoints = ["NONE", "ROUND", "BEVEL", "MITER"];
-const arrowHeadLength = ["head = 0.12", "head = 0.22", "head = 0.34", "head = 0.46"];
-const arrowDash = ["0.10 / 0.10", "0.20 / 0.10", "0.40 / 0.15", "0.04 / 0.12"];
-const radius = ["0.18", "0.28", "0.38", "0.50"];
-const segments = ["8", "16", "32", "64"];
-const jointNote = "Round, bevel and miter joins are rebuilt in the vertex stage from the reference joint shaders.";
-const shapeWidth = ["w = 1.0", "w = 2.0", "w = 5.5", "w = 10.0"];
-const shapeRadius = ["r = 0.18", "r = 0.28", "r = 0.38", "r = 0.50"];
-const capsuleRadius = ["r = 0.16", "r = 0.24", "r = 0.32", "r = 0.40"];
-const shapeSegments = ["8 seg", "16 seg", "32 seg", "64 seg"];
-const smallSegments = ["3 seg", "4 seg", "8 seg", "16 seg"];
-const sideSegments = ["3 side", "4 side", "8 side", "16 side"];
-const capsuleSideSegments = ["1 side", "2 side", "4 side", "8 side"];
-const coneHeights = ["h = 0.45", "h = 0.65", "h = 0.85", "h = 1.05"];
-const cylinderHalfHeights = ["hh = 0.225", "hh = 0.325", "hh = 0.425", "hh = 0.525"];
-const capsuleHalfHeights = ["hh = 0.000", "hh = 0.125", "hh = 0.225", "hh = 0.350"];
-const yAxisSegments = ["y = 0", "y = 1", "y = 2", "y = 6"];
-const zAxisSegments = ["z = 0", "z = 1", "z = 2", "z = 6"];
-// Row labels copied from `examples/index.gd` ROW_LABELS (the full API matrix).
-const indexRows = {
-    line: ["draw_line", "draw_line_n", "draw_line_d", "draw_line_n_d"],
-    ray: ["draw_ray", "draw_ray_n", "draw_ray_d", "draw_ray_n_d"],
-    arrow: ["draw_arrow", "draw_arrow_n", "draw_arrow_line", "draw_arrow_line_n", "draw_arrow_line_d", "draw_arrow_line_n_d"],
-    axes: ["draw_axes", "draw_axes_n"],
-    line_list: ["draw_line_list", "draw_line_list_n"],
-    strip: ["draw_line_strip", "draw_line_strip_n", "draw_line_strip_d", "draw_line_strip_n_d"],
-    loop: ["draw_line_loop", "draw_line_loop_n", "draw_line_loop_d", "draw_line_loop_n_d"],
-    curve: ["draw_curve", "draw_curve_d"],
-    grid: ["draw_grid", "draw_grid_n"],
-    rect: ["draw_rect", "draw_rect_s", "draw_rect_n", "draw_rect_d", "draw_rect_n_d"],
-    box: ["draw_box", "draw_box_s", "draw_box_n", "draw_box_d", "draw_box_n_d"],
-    circle: ["draw_circle", "draw_circle_s", "draw_circle_n", "draw_circle_d", "draw_circle_n_d"],
-    arc: ["draw_arc", "draw_arc_n", "draw_arc_d", "draw_arc_n_d"],
-    sphere: ["draw_sphere", "draw_sphere_s", "draw_sphere_n", "draw_sphere_d", "draw_sphere_n_d"],
-    cone: ["draw_cone", "draw_cone_s", "draw_cone_n"],
-    cylinder: ["draw_cylinder", "draw_cylinder_s", "draw_cylinder_n"],
-    capsule: ["draw_capsule", "draw_capsule_n"],
-};
-// `world_space_width.gd` ROW_LABELS: same matrix without the `*_s` solid columns.
-const worldWidthRows = {
-    ...indexRows,
-    rect: ["draw_rect", "draw_rect_n", "draw_rect_d", "draw_rect_n_d"],
-    box: ["draw_box", "draw_box_n", "draw_box_d", "draw_box_n_d"],
-    circle: ["draw_circle", "draw_circle_n", "draw_circle_d", "draw_circle_n_d"],
-    sphere: ["draw_sphere", "draw_sphere_n", "draw_sphere_d", "draw_sphere_n_d"],
-    cone: ["draw_cone", "draw_cone_n"],
-    cylinder: ["draw_cylinder", "draw_cylinder_n"],
-};
-// Column structure copied from the reference scenes. Capsule has no `_s` column.
-const solidExamples = [
-    {
-        id: "sphere",
-        title: "Sphere",
-        description: "Sphere wire and solid meshes across width, radius, segment, axis, dash, joint and normal rows.",
-        notes: "Reference has 14 columns including y/z axis and sphere_s; the UV generator approximates the independent axis ring counts.",
-        implemented: true,
-        columns: [
-            column("sphere(width)", shapeWidth),
-            column("sphere(radius)", shapeRadius),
-            column("sphere(segments)", shapeSegments),
-            column("sphere(y axis)", yAxisSegments),
-            column("sphere(z axis)", zAxisSegments),
-            column("sphere(rotation)", rotation),
-            column("sphere(joint)", joints),
-            column("sphere_d(dash)", dash),
-            column("sphere_d(joint)", joints),
-            column("sphere_n", normal),
-            column("sphere_n(joint)", joints),
-            column("sphere_n_d(dash)", dash),
-            column("sphere_n_d(joint)", joints),
-            column("sphere_s", rotation),
-        ],
-    },
-    {
-        id: "cone",
-        title: "Cone",
-        description: "Cone wire and solid meshes across width, radius, height, segment, rotation, joint and normal rows.",
-        notes: "Reference has 10 columns including cone_s; the generator uses one segment count for the base ring and side lines.",
-        implemented: true,
-        columns: [
-            column("cone(width)", shapeWidth),
-            column("cone(radius)", shapeRadius),
-            column("cone(height)", coneHeights),
-            column("cone(segments)", smallSegments),
-            column("cone(side segments)", sideSegments),
-            column("cone(rotation)", rotation),
-            column("cone(joint)", joints),
-            column("cone_n", normal),
-            column("cone_n(joint)", joints),
-            column("cone_s", rotation),
-        ],
-    },
-    {
-        id: "cylinder",
-        title: "Cylinder",
-        description: "Cylinder wire and solid meshes across width, radius, half height, segment, rotation, joint and normal rows.",
-        notes: "Reference has 10 columns including cylinder_s; the generator uses one segment count for the base ring and side lines.",
-        implemented: true,
-        columns: [
-            column("cylinder(width)", shapeWidth),
-            column("cylinder(radius)", shapeRadius),
-            column("cylinder(half height)", cylinderHalfHeights),
-            column("cylinder(segments)", smallSegments),
-            column("cylinder(side segments)", sideSegments),
-            column("cylinder(rotation)", rotation),
-            column("cylinder(joint)", joints),
-            column("cylinder_n", normal),
-            column("cylinder_n(joint)", joints),
-            column("cylinder_s", rotation),
-        ],
-    },
-    {
-        id: "capsule",
-        title: "Capsule",
-        description: "Capsule wire meshes across width, radius, half height, segment, rotation, joint and normal rows.",
-        notes: "Reference has 9 columns and no solid column: the capsule reference has no solid variant.",
-        implemented: true,
-        columns: [
-            column("capsule(width)", shapeWidth),
-            column("capsule(radius)", capsuleRadius),
-            column("capsule(half height)", capsuleHalfHeights),
-            column("capsule(segments)", shapeSegments),
-            column("capsule(side segments)", capsuleSideSegments),
-            column("capsule(rotation)", rotation),
-            column("capsule(joint)", joints),
-            column("capsule_n", normal),
-            column("capsule_n(joint)", joints),
-        ],
-    },
-];
-export const SCENE_EXAMPLES = [
-    { id: "index", title: "Index", description: "The DebugDraw3D API matrix: 17 primitive columns with the reference per-column row sets.", notes: "Overview of every primitive family; row labels mirror the reference draw calls.", implemented: true, columns: ["line", "ray", "arrow", "axes", "line_list", "strip", "loop", "curve", "grid", "rect", "box", "circle", "arc", "sphere", "cone", "cylinder", "capsule"].map((label) => column(label, indexRows[label])) },
-    { id: "line", title: "Line", description: "Widths, alpha, dashes, strip and loop joints, dashed joints, and normal-aware lines.", notes: jointNote, implemented: true, columns: [column("line(width)", width), column("line(alpha)", ["alpha = 1.00", "alpha = 0.65", "alpha = 0.35", "alpha = 0.10"]), column("line_d(dash)", dash), column("strip(joint)", joints), column("loop(joint)", joints), column("strip_d(joint)", joints), column("line_n(normal)", normal)] },
-    { id: "arrow", title: "Arrow", description: "Arrow direction, width, head length, head angle, joints, normal-aware arrows, and arrow-line variants.", notes: jointNote + " Head angle and length are wired to arrow geometry.", implemented: true, columns: [column("arrow(width)", arrowWidth), column("arrow(dir)", arrowDir), column("arrow(head angle)", arrowHeadAngle), column("arrow(joint)", arrowJoints), column("arrow_n", normal), column("arrow_n(joint)", arrowJoints), column("arrow_line(width)", arrowWidth), column("arrow_line(head length)", arrowHeadLength), column("arrow_line(head angle)", arrowHeadAngle), column("arrow_line(rotation)", rotation), column("arrow_line(joint)", arrowJoints), column("arrow_line_d(dash)", arrowDash), column("arrow_line_d(joint)", arrowJoints), column("arrow_line_n", normal), column("arrow_line_n(joint)", arrowJoints), column("arrow_line_n_d(dash)", arrowDash), column("arrow_line_n_d(joint)", arrowJoints)] },
-    { id: "axes", title: "Axes", description: "Axis length, width, rotation, and normal-aware axis variants.", implemented: true, columns: [column("axes(length)", ["0.35", "0.55", "0.75", "1.00"]), column("axes(width)", width), column("axes(rotation)", rotation), column("axes_n(length)", ["0.35", "0.55", "0.75", "1.00"]), column("axes_n(width)", width), column("axes_n(rotation)", rotation)] },
-    { id: "grid", title: "Grid", description: "Grid width, cell count, spacing, skew, outer edges, rotation, color, and normal rows.", notes: "Column spacing follows each column's measured bounds; rendered skew and outer edges use the library grid semantics.", implemented: true, columns: [column("grid(width)", ["w = 1.0", "w = 2.0", "w = 5.5", "w = 10.0"]), column("grid(cells)", ["4 x 4", "6 x 4", "10 x 3", "3 x 8"]), column("grid(spacing)", ["0.20 x 0.20", "0.28 x 0.28", "0.42 x 0.22", "0.55 x 0.28"]), column("grid(skew)", ["none", "0.28 / 0.00", "-0.28 / 0.00", "0.28 / -0.18"]), column("grid(outer)", ["none", "X", "Z", "XZ"]), column("grid(rotation)", ["step 0", "step 1", "step 2", "step 3", "step 4", "step 5"]), column("grid(color)", ["base", "alpha", "color", "blue"]), column("grid_n", normal)] },
-    { id: "rect", title: "Rect", description: "Wire and solid rectangles with size, rotation, joints, dashes, and normal variants.", notes: jointNote, implemented: true, columns: [column("rect(width)", width), column("rect(size)", ["0.50 × 0.40", "0.80 × 0.40", "0.50 × 0.70", "0.55 × 0.55"]), column("rect(rotation)", rotation), column("rect(joint)", joints), column("rect_d(dash)", dash), column("rect_d(joint)", joints), column("rect_n", normal), column("rect_n_d(dash)", dash), column("rect_n(joint)", joints), column("rect_s(solid)", rotation)] },
-    { id: "box", title: "Box", description: "Wire and solid boxes with size, rotation, dashes, and normal variants.", implemented: true, columns: [column("box(width)", width), column("box(size)", ["0.50 × 0.40 × 0.40", "0.80 × 0.40 × 0.40", "0.50 × 0.60 × 0.40", "0.50 × 0.40 × 0.60"]), column("box(rotation)", rotation), column("box_d(dash)", dash), column("box_n", normal), column("box_n_d(dash)", dash), column("box_s(solid)", rotation)] },
-    { id: "circle", title: "Circle", description: "Circle width, radius, segment count, rotation, joints, dashes, solid and normal variants.", notes: jointNote, implemented: true, columns: [column("circle(width)", width), column("circle(radius)", radius), column("circle(segments)", segments), column("circle(rotation)", rotation), column("circle(joint)", joints), column("circle_d(dash)", dash), column("circle_d(joint)", joints), column("circle_n", normal), column("circle_n_d(dash)", dash), column("circle_n(joint)", joints), column("circle_s(solid)", segments)] },
-    { id: "arc", title: "Arc", description: "Arc width, radius, angle, segments, rotation, joints, dashes, and normal variants.", notes: jointNote, implemented: true, columns: [column("arc(width)", width), column("arc(radius)", radius), column("arc(angle)", ["90°", "180°", "270°", "360°"]), column("arc(segments)", segments), column("arc(rotation)", rotation), column("arc(joint)", joints), column("arc_d(dash)", dash), column("arc_d(joint)", joints), column("arc_n", normal), column("arc_n_d(dash)", dash), column("arc_n(joint)", joints)] },
-    { id: "curve", title: "Curve", description: "Curve widths, shape, transform, tolerance, closed paths, joints and dashes.", notes: jointNote + " Cubic Bezier control points are sampled adaptively from the tolerance row, and the construction band draws the reference anchor and control markers.", implemented: true, columns: [column("curve(width)", width), column("curve(shape)", ["mild", "soft", "base", "wide"]), column("curve(transform)", rotation), column("curve(tolerance)", ["0.04", "0.08", "0.16", "0.32"]), column("curve(closed)", ["open", "closed", "small", "wide"]), column("curve(joint)", joints), column("curve_d(dash)", dash), column("curve_d(joint)", joints)] },
-    ...solidExamples,
-    { id: "world_space_width", title: "World Space Width", description: "The 17-column primitive matrix rendered with world-space line widths and without the `*_s` solid columns.", notes: "Widths are `_world_width(px) = px * 0.01`; row labels mirror the reference.", implemented: true, columns: ["line", "ray", "arrow", "axes", "line_list", "strip", "loop", "curve", "grid", "rect", "box", "circle", "arc", "sphere", "cone", "cylinder", "capsule"].map((label) => column(label, worldWidthRows[label])) },
-    { id: "text-compare", title: "Text Compare", description: "A matrix of one sentence: rows are glyph sources, columns are font sizes.", notes: "Not a reference port: there is no upstream text API, so this is vgpu's own capability. Transposed relative to the line/circle matrices — text grows sideways, so six source columns would be wider than a camera wants to frame. Read down a column to compare encodings at one size, across a row to compare sizes under one encoding. The last row is a fixed-orientation block rather than a camera-facing one, so it foreshortens as you orbit. Every row floats above the grid plane, which writes depth and would otherwise clip it.", implemented: true, group: "text", columns: [column("glyph source", ["bitmap 1x", "bitmap 4x", "sdf 1x", "sdf 4x", "msdf outline", "msdf baked"]), column("font size", ["16 px", "24 px", "36 px"]), column("placement", ["world-billboard", "world-plane", "foreshortens"]), column("what changes", ["coverage interpolation", "supersampled coverage", "distance reconstruction", "per-edge distance", "prebaked at 24 px"])] },
-    { id: "text-encodings", title: "Text Encodings", description: "One sentence from four glyph sources, at two sizes, plus the outline pair.", notes: "Not a reference port: there is no upstream text API, so this is vgpu's own capability. Every block takes the default source — the one that rasterises each glyph at the size it covers on screen — except the columns that name one, so the page doubles as the gallery's own quality check. The lower band repeats the same ink at more than twice the size, which is where a coverage source and a distance field stop looking alike.", implemented: true, group: "text", hideGrid: true, columns: [column("source", ["bitmap 1x", "sdf 4x", "msdf 2x", "msdf baked"]), column("what changes", ["coverage interpolation", "distance reconstruction", "per-edge distance", "prebaked at 24 px"]), column("outline", ["reads the true distance in alpha", "samples coverage in eight directions"])] },
-    { id: "text-scale", title: "Text Scale", description: "One sentence at six sizes, over three raster strategies at one size.", notes: "Not a reference port. The top row puts 26 px under the screen-driven ladder, a fixed 1x raster and a fixed 4x raster; the rows below run 8 px to 96 px, so the rung changes — and the absence of a soft step between them — are visible in one frame. The first strategy is what a caller gets by default.", implemented: true, group: "text", hideGrid: true, columns: [column("raster", ["screen decides the rung", "fixed 1x", "fixed 4x"]), column("sizes", ["8 px", "12 px", "18 px", "28 px", "48 px", "96 px"])] },
-    { id: "text-world-zoom", title: "Text World Zoom", description: "Four sources in world space, made to be magnified with the camera.", notes: "Not a reference port. Screen-space text cannot be magnified — a larger block is simply a request for a new rasterisation — so world-space rows are the only honest test of what a source does past the size its glyphs were built at. Scroll to move the camera in and out: a coverage source runs into the texels it stored, a distance field keeps rebuilding the edge from them.", implemented: true, group: "text", hideGrid: false, columns: [column("source", ["bitmap 1x", "bitmap 4x", "sdf 4x", "msdf baked"]), column("past its raster", ["shows the stored texels", "shows smaller texels", "rebuilds the edge", "rebuilds from a 24 px page"])] },
-    { id: "text-layout", title: "Text Layout", description: "Wrapping, justification, bounds, line height, letter spacing and spans.", notes: "Not a reference port. The layout follows the documented wrapping and justification semantics, and `docs/text-reference.md` records how each capability is verified. Each row is one capability, labelled on the left, and every bounded row draws the box it wrapped into — a wrapping rule is unreadable without it.", implemented: true, group: "text", hideGrid: true, columns: [column("capability", ["word wrap", "character wrap", "justify", "line height", "letter spacing", "spans"]), column("option", ["lineBreak", "lineBreak", "justify", "lineHeight", "letterSpacing", "TextSpan"])] },
-    { id: "text-anchor", title: "Text Anchors", description: "The nine anchors against the position a block is handed and the bounds it lands in.", notes: "Not a reference port. The plus is the position the block is given, the box is the bounds it laid out into, and the label names the anchor — so both of the things an anchor moves between are visible at once.", implemented: true, group: "text", hideGrid: true, columns: [column("anchor", ["top-left", "top-center", "top-right", "center-left", "center", "center-right", "bottom-left", "bottom-center", "bottom-right"])] },
-    { id: "text-cjk", title: "Text CJK", description: "Wrapping per character, kinsoku, mixed scripts and four sizes.", notes: "Not a reference port. CJK has no spaces to break at, so the layout breaks between characters and applies kinsoku: a closing mark never opens a line and an opening bracket never ends one, and the narrow column is tuned so those rules have to act. The family is the bundled latin face, and the canvas falls back to a system CJK face for the ideographs — the same arrangement a system font fallback provides.", implemented: true, group: "text", hideGrid: true, columns: [column("rule", ["per character", "kinsoku", "mixed script"]), column("sizes", ["12 px", "18 px", "28 px", "48 px"])] },
-    {
-        id: "2d-gizmos",
-        title: "2D Gizmos",
-        description: "Immediate-mode 2D strokes in the camera-centred world2d space: lines, rays, joined strips, boxes, rounded boxes, circles, ellipses, arcs, crosses, arrows, curves and a grid.",
-        notes: "Not a reference port: this page is built directly on frame.d2. world2d puts the origin at the canvas centre, +y up, one unit per canvas pixel before the camera's pan and zoom. Drag to pan, scroll to zoom.",
-        implemented: true,
-        family: "2d",
-        // The 2D grid is part of what these pages demonstrate, so it opens on even if the
-        // previous page had it off.
-        hideGrid: false,
-        view2d: { width: 1080, height: 640 },
-        columns: [
-            column("stroke", ["line", "ray", "linestrip", "rect", "roundedRect", "circle", "ellipse", "arc", "cross", "arrow", "curve", "grid"]),
-            column("option", ["width", "joint", "dash", "fill", "strokeWidth", "startAngle", "sweep", "rotation", "space"]),
-        ],
-    },
-    {
-        id: "2d-shapes",
-        title: "2D Shapes",
-        description: "Twelve 2D primitives as filled shapes, with their stroked outlines underneath.",
-        notes: "Not a reference port: this page is built on frame.d2 shape primitives. Each shape is one instanced quad evaluated as a signed distance field, so an outline width is a pixel count at any zoom and nothing is triangulated on the CPU. Drag to pan, scroll to zoom.",
-        implemented: true,
-        family: "2d",
-        // The 2D grid is part of what these pages demonstrate, so it opens on even if the
-        // previous page had it off.
-        hideGrid: false,
-        view2d: { width: 1260, height: 560 },
-        columns: [
-            column("filled", ["circle", "sector", "segment", "ellipse", "annulus", "capsule", "rhombus", "rect", "polygon", "triangle", "segment2d", "polyline2d"]),
-            column("ring", ["circle", "sector", "segment", "ellipse", "annulus", "capsule", "rhombus", "rect", "polygon", "triangle"]),
-        ],
-    },
-];

package/dist/scenes-2d.d.ts

@@ -1,18 +0,0 @@
-/**
- * reference 2D reference pages.
- *
- * These are vgpu's own capability pages built on `frame.d2`, not ports of a reference: the
- * reference has no 2D API, so the models are reference `2d_gizmos` and `2d_shapes`. That also
- * means the coordinate convention is reference: the origin sits at the canvas centre, +y points up,
- * and one world unit covers one canvas pixel before the 2D camera's pan and zoom.
- *
- * Two conventions carry over from the text pages: a page heading in the top-left corner (a
- * screen-space block, so the labels stay put while the 2D camera pans), and one shape per column
- * with the row meaning stated once.
- */
-import type { FrameRecorder } from "./frame-recorder.js";
-/**
- * Dispatches the 2D pages. Returns false for every other id so `buildScene` can fall through to
- * the 3D scenes.
- */
-export declare function buildScene2D(id: string, recorder: FrameRecorder, time: number): boolean;