vgpu-render 0.1.0 → 0.2.0

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;

package/dist/scenes-2d.js

@@ -1,160 +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.
- */
-const TITLE = [0.92, 0.95, 1, 1];
-const HINT = [0.55, 0.62, 0.72, 1];
-const GRID = [0.32, 0.36, 0.44, 0.55];
-const FILL = [0.93, 0.95, 0.98, 1];
-const RING = [0.55, 0.72, 1, 1];
-const WARM = [1, 0.72, 0.36, 1];
-const COOL = [0.42, 0.86, 0.78, 1];
-const ACCENT = [1, 0.55, 0.66, 1];
-const ACTION = [0.98, 0.86, 0.42, 1];
-/** Page heading: a screen-space title and note, fixed to the top-left corner. */
-function heading(recorder, title, note) {
-    recorder.text([24, 16, 0], title, { space: "screen", fontSize: 17, anchor: "top-left", color: TITLE });
-    recorder.text([24, 38, 0], note, { space: "screen", fontSize: 12, anchor: "top-left", color: HINT });
-}
-/**
- * Dispatches the 2D pages. Returns false for every other id so `buildScene` can fall through to
- * the 3D scenes.
- */
-export function buildScene2D(id, recorder, time) {
-    switch (id) {
-        case "2d-gizmos":
-            gizmos2D(recorder, time);
-            return true;
-        case "2d-shapes":
-            shapes2D(recorder);
-            return true;
-        default:
-            return false;
-    }
-}
-/** The twelve reference 2D primitives, filled in one row and outlined in the next. */
-function shapes2D(recorder) {
-    heading(recorder, "2D Shapes", "filled row, ring row · drag to pan, scroll to zoom");
-    const d2 = recorder.d2;
-    const columns = 12;
-    const spacing = 100;
-    const startX = -((columns - 1) * spacing) / 2;
-    for (let index = 0; index < columns; index++) {
-        const x = startX + index * spacing;
-        drawShape(d2, index, [x, 110], true);
-        // The two polyline shapes have no interior to outline.
-        if (index < 10)
-            drawShape(d2, index, [x, -110], false);
-    }
-}
-/** One column of `shapes2D`, in the order reference `2d_shapes` example lists them. */
-function drawShape(d2, shape, center, filled) {
-    const style = { fill: filled, strokeWidth: 4, color: filled ? FILL : RING };
-    const [x, y] = center;
-    switch (shape) {
-        case 0: // Circle::new(50)
-            d2.circle(center, 50, style);
-            return;
-        case 1: // CircularSector::new(50, 1.0)
-            d2.sector(center, 50, { ...style, sweep: 1.0 });
-            return;
-        case 2: // CircularSegment::new(50, 1.25)
-            d2.segment(center, 50, { ...style, sweep: 1.25 });
-            return;
-        case 3: // Ellipse::new(25, 50)
-            d2.ellipse(center, [25, 50], style);
-            return;
-        case 4: // Annulus::new(25, 50)
-            d2.annulus(center, 25, 50, style);
-            return;
-        case 5: // Capsule2d::new(25, 50)
-            d2.capsule(center, 25, 50, style);
-            return;
-        case 6: // Rhombus::new(75, 100)
-            d2.rhombus(center, [75, 100], style);
-            return;
-        case 7: // Rectangle::new(50, 100)
-            d2.rect(center, [50, 100], style);
-            return;
-        case 8: // RegularPolygon::new(50, 6)
-            d2.polygon(center, 50, 6, style);
-            return;
-        case 9: // Triangle2d::new(Vec2::Y * 50, Vec2::new(-50, -50), Vec2::new(50, -50))
-            d2.triangle([x, y + 50], [x - 50, y - 50], [x + 50, y - 50], style);
-            return;
-        case 10: // Segment2d::new(Vec2::new(-50, 50), Vec2::new(50, -50))
-            d2.line([x - 50, y + 50], [x + 50, y - 50], { width: 8, color: filled ? FILL : RING });
-            return;
-        default: // Polyline2d::new([(-50, 50), (0, -50), (50, 50)])
-            d2.lineStrip([[x - 50, y + 50], [x, y - 50], [x + 50, y + 50]], {
-                width: 8,
-                joint: "round",
-                color: filled ? FILL : RING,
-            });
-    }
-}
-/** reference `2d_gizmos` example, rebuilt with the stroke and shape primitives. */
-function gizmos2D(recorder, time) {
-    heading(recorder, "2D Gizmos", "strokes and outlined shapes · drag to pan, scroll to zoom");
-    const d2 = recorder.d2;
-    // Background grid, drawn first so the strokes sit on top of it.
-    const cell = 60;
-    for (let index = -6; index <= 6; index++) {
-        d2.line([index * cell, -260], [index * cell, 260], { width: 1, color: GRID });
-        d2.line([-380, index * cell], [380, index * cell], { width: 1, color: GRID });
-    }
-    // line and ray.
-    d2.line([-460, 200], [-300, 200], { width: 5, color: ACTION });
-    d2.ray([-460, 140], [160, -40], { width: 5, color: COOL });
-    // Joined strip (round joints) and a dashed stroke with the same width.
-    d2.lineStrip([[-460, 60], [-410, 0], [-360, 60], [-310, 0], [-260, 60]], { width: 6, joint: "round", color: RING });
-    d2.line([-460, -20], [-260, -20], { width: 6, dash: [20, 14, 0], color: RING });
-    // Outlined boxes, one with rounded corners.
-    d2.rect([-120, 170], [120, 80], { fill: false, strokeWidth: 4, color: WARM });
-    d2.roundedRect([-120, 40], [140, 80], 26, { fill: false, strokeWidth: 4, color: WARM });
-    d2.grid([-120, -100], [4, 3], [40, 40], { width: 2, color: WARM });
-    // Circle, ellipse and an arc.
-    d2.circle([120, 170], 55, { fill: false, strokeWidth: 4, color: ACCENT });
-    d2.ellipse([120, 60], [75, 35], { fill: false, strokeWidth: 4, color: ACCENT });
-    d2.arc([120, -80], 55, { fill: false, strokeWidth: 4, startAngle: 0.4, sweep: 2.2, color: ACCENT });
-    // Cross marker.
-    for (const [x, y] of [[340, 200], [400, 200], [370, 170], [370, 230]]) {
-        d2.point([x, y], { size: 4, round: true, color: ACTION });
-    }
-    cross(d2, [340, 170], 34, ACTION);
-    cross(d2, [340, 230], 34, ACTION);
-    // Arrow: a shaft plus a filled triangle head that swings with time.
-    const angle = 1.1 + Math.sin(time * 0.9) * 0.5;
-    const origin = [330, 60];
-    const tip = [origin[0] + Math.cos(angle) * 140, origin[1] + Math.sin(angle) * 140];
-    const ux = Math.cos(angle);
-    const uy = Math.sin(angle);
-    const back = 22;
-    const spread = 11;
-    d2.line(origin, tip, { width: 5, color: ACTION });
-    d2.triangle(tip, [tip[0] - ux * back - uy * spread, tip[1] - uy * back + ux * spread], [tip[0] - ux * back + uy * spread, tip[1] - uy * back - ux * spread], { color: ACTION });
-    // A travelling sine curve, sampled into a strip.
-    const wave = [];
-    for (let step = 0; step <= 64; step++) {
-        const x = -460 + step * 12;
-        wave.push([x, -170 + Math.sin((x + time * 90) / 55) * 34]);
-    }
-    d2.lineStrip(wave, { width: 4, color: COOL });
-    // Outlined hexagon and a filled diamond, the two closed shapes reference example draws last.
-    d2.polygon([330, -170], 60, 6, { fill: false, strokeWidth: 4, color: WARM });
-    d2.rhombus([450, -170], [90, 110], { color: ACCENT });
-}
-/** Two crossing strokes, reference `cross_2d`. */
-function cross(d2, center, size, color) {
-    const [x, y] = center;
-    d2.line([x - size, y], [x + size, y], { width: 3, color });
-    d2.line([x, y - size], [x, y + size], { width: 3, color });
-}

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

@@ -1,46 +0,0 @@
-import type { FrameRecorder, Vec3, Color } from "./frame-recorder.js";
-export type SceneContext = {
-    readonly time: number;
-    readonly lineJoint?: "none" | "round" | "bevel" | "miter";
-};
-declare function lineColumnX(column: number): number;
-declare function lineRowZ(row: number): number;
-declare function lineStart(column: number, row: number): Vec3;
-declare function lineEnd(column: number, row: number): Vec3;
-declare function referenceStripPoints(column: number, row: number): Vec3[];
-declare function referenceLoopPoints(column: number, row: number): Vec3[];
-declare function circleColumnX(column: number): number;
-/** Raw reference layout data, exported so tests and future 3D labels share one source. */
-export declare const CIRCLE_REFERENCE: {
-    readonly columns: 11;
-    readonly columnSpacing: 2;
-    readonly columnOffset: 0.5;
-    readonly rowSpacing: 0.82;
-    readonly radiusRowSpacing: 1.15;
-    readonly startZ: -0.45;
-    readonly radius: 0.32;
-    readonly baseWidth: 2;
-    readonly sceneOffset: Vec3;
-    readonly solidColor: Color;
-    readonly columnX: typeof circleColumnX;
-    readonly center: (column: number, row: number) => Vec3;
-};
-/** Raw reference layout data for the Line example. */
-export declare const LINE_REFERENCE: {
-    readonly columns: 7;
-    readonly columnSpacing: 2;
-    readonly rowSpacing: 0.78;
-    readonly startZ: -0.45;
-    readonly length: 1.1;
-    readonly stripHalfDepth: 0.18;
-    readonly loopHalfDepth: 0.25;
-    readonly sceneOffset: Vec3;
-    readonly columnX: typeof lineColumnX;
-    readonly rowZ: typeof lineRowZ;
-    readonly start: typeof lineStart;
-    readonly end: typeof lineEnd;
-    readonly strip: typeof referenceStripPoints;
-    readonly loop: typeof referenceLoopPoints;
-};
-export declare function buildScene(id: string, recorder: FrameRecorder, time: number, lineJoint?: SceneContext["lineJoint"]): void;
-export {};