vgpu-render 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,43 @@
+/**
+ * 2D projection math for the debug-draw layer.
+ *
+ * Two spaces share one pixel-based pipeline:
+ *
+ * - `world2d` mirrors reference `Camera2d`: the origin sits at the canvas centre, +y points up,
+ *   and at `zoom = 1` one world unit covers one canvas pixel. `pan` translates the view in
+ *   world units, `zoom` magnifies it. `2d_shapes`' `X_EXTENT = 1000` is such a pixel-scale
+ *   world coordinate, not a top-left origin one.
+ * - `screen` is the top-left origin, +y down pixel space the text renderer already uses for
+ *   `TextSpace "screen"`, unaffected by pan or zoom.
+ *
+ * Both end up as a clip-space matrix, which is what lets the 2D primitives reuse the 3D line,
+ * point and joint shaders unchanged: those already compute their screen-space geometry after
+ * the projection, so they only need `viewProjection * position` to land the primitive. The
+ * matrices below produce `z = 0, w = 1`, i.e. the near plane, which is also where a screen-space
+ * text block pins itself.
+ */
+/** A point or direction in one of the 2D spaces. */
+export type Vec2 = readonly [number, number];
+/** Which 2D space a command is drawn in. See the module comment for the difference. */
+export type Space2D = "world2d" | "screen";
+export type Camera2D = {
+    /** View translation in `world2d` units. Ignored by `screen` space. */
+    readonly pan: Vec2;
+    /** Canvas pixels per `world2d` unit. Larger magnifies; must be greater than zero. */
+    readonly zoom: number;
+};
+export declare const DEFAULT_CAMERA_2D: Camera2D;
+/**
+ * Clip matrix for `world2d`, column-major like the view matrices in `demo-camera.ts`.
+ *
+ * `x_clip = 2 · zoom · (x - pan.x) / width`, and `y_clip` keeps +y up: a point above the pan
+ * lands nearer the top of the target.
+ */
+export declare function world2dProjection(camera: Camera2D, viewportSize: Vec2): Float32Array;
+/** Clip matrix for the top-left origin `screen` space: `x_clip = 2x/width - 1`, `y` flipped. */
+export declare function screenProjection(viewportSize: Vec2): Float32Array;
+export declare function projection2D(space: Space2D, camera: Camera2D, viewportSize: Vec2): Float32Array;
+/** Converts a `world2d` point to top-left origin canvas pixels, the inverse of {@link screenToWorld2d}. */
+export declare function world2dToScreen(point: Vec2, camera: Camera2D, viewportSize: Vec2): Vec2;
+/** Converts top-left origin canvas pixels to a `world2d` point, the inverse of {@link world2dToScreen}. */
+export declare function screenToWorld2d(point: Vec2, camera: Camera2D, viewportSize: Vec2): Vec2;

package/dist/camera-2d.js

@@ -0,0 +1,75 @@
+/**
+ * 2D projection math for the debug-draw layer.
+ *
+ * Two spaces share one pixel-based pipeline:
+ *
+ * - `world2d` mirrors reference `Camera2d`: the origin sits at the canvas centre, +y points up,
+ *   and at `zoom = 1` one world unit covers one canvas pixel. `pan` translates the view in
+ *   world units, `zoom` magnifies it. `2d_shapes`' `X_EXTENT = 1000` is such a pixel-scale
+ *   world coordinate, not a top-left origin one.
+ * - `screen` is the top-left origin, +y down pixel space the text renderer already uses for
+ *   `TextSpace "screen"`, unaffected by pan or zoom.
+ *
+ * Both end up as a clip-space matrix, which is what lets the 2D primitives reuse the 3D line,
+ * point and joint shaders unchanged: those already compute their screen-space geometry after
+ * the projection, so they only need `viewProjection * position` to land the primitive. The
+ * matrices below produce `z = 0, w = 1`, i.e. the near plane, which is also where a screen-space
+ * text block pins itself.
+ */
+export const DEFAULT_CAMERA_2D = { pan: [0, 0], zoom: 1 };
+/**
+ * Floors a target size at one pixel. `pass.target.size` is `[0, 0]` until the first resize,
+ * and a degenerate matrix would make the whole layer disappear rather than merely misfit.
+ */
+function extent(viewportSize) {
+    return [Math.max(viewportSize[0], 1), Math.max(viewportSize[1], 1)];
+}
+/**
+ * Clip matrix for `world2d`, column-major like the view matrices in `demo-camera.ts`.
+ *
+ * `x_clip = 2 · zoom · (x - pan.x) / width`, and `y_clip` keeps +y up: a point above the pan
+ * lands nearer the top of the target.
+ */
+export function world2dProjection(camera, viewportSize) {
+    if (!(camera.zoom > 0)) {
+        throw new RangeError("camera2d.zoom must be greater than zero");
+    }
+    const [width, height] = extent(viewportSize);
+    const scaleX = (2 * camera.zoom) / width;
+    const scaleY = (2 * camera.zoom) / height;
+    return new Float32Array([
+        scaleX, 0, 0, 0,
+        0, scaleY, 0, 0,
+        0, 0, 0, 0,
+        -scaleX * camera.pan[0], -scaleY * camera.pan[1], 0, 1,
+    ]);
+}
+/** Clip matrix for the top-left origin `screen` space: `x_clip = 2x/width - 1`, `y` flipped. */
+export function screenProjection(viewportSize) {
+    const [width, height] = extent(viewportSize);
+    return new Float32Array([
+        2 / width, 0, 0, 0,
+        0, -2 / height, 0, 0,
+        0, 0, 0, 0,
+        -1, 1, 0, 1,
+    ]);
+}
+export function projection2D(space, camera, viewportSize) {
+    return space === "screen" ? screenProjection(viewportSize) : world2dProjection(camera, viewportSize);
+}
+/** Converts a `world2d` point to top-left origin canvas pixels, the inverse of {@link screenToWorld2d}. */
+export function world2dToScreen(point, camera, viewportSize) {
+    const [width, height] = extent(viewportSize);
+    return [
+        (point[0] - camera.pan[0]) * camera.zoom + width / 2,
+        height / 2 - (point[1] - camera.pan[1]) * camera.zoom,
+    ];
+}
+/** Converts top-left origin canvas pixels to a `world2d` point, the inverse of {@link world2dToScreen}. */
+export function screenToWorld2d(point, camera, viewportSize) {
+    const [width, height] = extent(viewportSize);
+    return [
+        (point[0] - width / 2) / camera.zoom + camera.pan[0],
+        (height / 2 - point[1]) / camera.zoom + camera.pan[1],
+    ];
+}

package/dist/color-space.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Color-space helpers for the debug-draw port.
+ *
+ * Both reference implementations blend in a linear working space and encode only on
+ * output: reference renders with `blend_mix` and encodes into its sRGB framebuffer, and reference
+ * blends on a linear target and presents the swapchain through an sRGB view
+ * (`add_srgb_suffix`). This port therefore renders into a linear `rgba16float` target and
+ * re-encodes in the present pass.
+ *
+ * Which colors need an sRGB decode depends on how the reference declares them:
+ *
+ * - **Primitive colors are passed through as authored.** reference debug shaders do
+ *   `ALBEDO = COLOR.rgb`, and `COLOR` carries no `source_color` qualifier, so
+ *   `Color(1, 0.85, 0.1)` reaches the linear shading math unchanged. Decoding here would
+ *   darken every debug primitive.
+ * - **Grid colors are decoded.** The infinite-grid uniforms are declared
+ *   `uniform vec4 thin_line_color : source_color`, so reference converts them from sRGB to
+ *   linear before the shader sees them. Skipping the decode renders the grid far too
+ *   bright.
+ * - **The clear color is decoded.** reference `default_clear_color` is an sRGB-authored
+ *   project setting that the engine converts before clearing.
+ */
+/**
+ * Decodes an sRGB-authored clear color into the linear value the scene pass clears to.
+ * Returns a new tuple so the caller cannot alias the config array.
+ */
+export declare function linearClearColor(color: readonly [number, number, number, number]): [number, number, number, number];
+/**
+ * Decodes an sRGB-authored grid color to linear, preserving a caller-supplied alpha.
+ * The grid scales alpha per frame, so alpha is passed in separately.
+ */
+export declare function linearGridColor(color: readonly [number, number, number, number], alpha: number): [number, number, number, number];

package/dist/color-space.js

@@ -0,0 +1,45 @@
+/**
+ * Color-space helpers for the debug-draw port.
+ *
+ * Both reference implementations blend in a linear working space and encode only on
+ * output: reference renders with `blend_mix` and encodes into its sRGB framebuffer, and reference
+ * blends on a linear target and presents the swapchain through an sRGB view
+ * (`add_srgb_suffix`). This port therefore renders into a linear `rgba16float` target and
+ * re-encodes in the present pass.
+ *
+ * Which colors need an sRGB decode depends on how the reference declares them:
+ *
+ * - **Primitive colors are passed through as authored.** reference debug shaders do
+ *   `ALBEDO = COLOR.rgb`, and `COLOR` carries no `source_color` qualifier, so
+ *   `Color(1, 0.85, 0.1)` reaches the linear shading math unchanged. Decoding here would
+ *   darken every debug primitive.
+ * - **Grid colors are decoded.** The infinite-grid uniforms are declared
+ *   `uniform vec4 thin_line_color : source_color`, so reference converts them from sRGB to
+ *   linear before the shader sees them. Skipping the decode renders the grid far too
+ *   bright.
+ * - **The clear color is decoded.** reference `default_clear_color` is an sRGB-authored
+ *   project setting that the engine converts before clearing.
+ */
+/** sRGB EOTF: decodes one sRGB-encoded component to linear. */
+function decodeComponent(value) {
+    // `!(value > 0)` also catches NaN, which would otherwise escape as NaN.
+    if (!(value > 0))
+        return 0;
+    if (value >= 1)
+        return 1;
+    return value <= 0.04045 ? value / 12.92 : Math.pow((value + 0.055) / 1.055, 2.4);
+}
+/**
+ * Decodes an sRGB-authored clear color into the linear value the scene pass clears to.
+ * Returns a new tuple so the caller cannot alias the config array.
+ */
+export function linearClearColor(color) {
+    return [decodeComponent(color[0]), decodeComponent(color[1]), decodeComponent(color[2]), color[3]];
+}
+/**
+ * Decodes an sRGB-authored grid color to linear, preserving a caller-supplied alpha.
+ * The grid scales alpha per frame, so alpha is passed in separately.
+ */
+export function linearGridColor(color, alpha) {
+    return [decodeComponent(color[0]), decodeComponent(color[1]), decodeComponent(color[2]), alpha];
+}

package/dist/curve.d.ts

@@ -0,0 +1,16 @@
+import type { Vec3 } from "./frame-recorder.js";
+export type CurvePoint = {
+    readonly position: Vec3;
+    readonly in?: Vec3;
+    readonly out?: Vec3;
+};
+export type Curve3D = {
+    readonly points: readonly CurvePoint[];
+    readonly closed?: boolean;
+};
+export type CurveTransform = {
+    readonly center?: Vec3;
+    readonly rotation?: readonly [number, number, number];
+};
+export declare function rotatePoint(p: Vec3, rotation: readonly [number, number, number]): Vec3;
+export declare function sampleCurve(curve: Curve3D, tolerance?: number, transform?: CurveTransform): Vec3[];

package/dist/curve.js

@@ -0,0 +1,46 @@
+const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+export function rotatePoint(p, rotation) {
+    const [sx, cx] = [Math.sin(rotation[0]), Math.cos(rotation[0])];
+    const [sy, cy] = [Math.sin(rotation[1]), Math.cos(rotation[1])];
+    const [sz, cz] = [Math.sin(rotation[2]), Math.cos(rotation[2])];
+    const x1 = p[0] * cy + p[2] * sy;
+    const z1 = -p[0] * sy + p[2] * cy;
+    const y1 = p[1] * cx - z1 * sx;
+    const z2 = p[1] * sx + z1 * cx;
+    return [x1 * cz - y1 * sz, x1 * sz + y1 * cz, z2];
+}
+function cubic(p0, p1, p2, p3, t) {
+    const u = 1 - t;
+    const a = u * u * u;
+    const b = 3 * u * u * t;
+    const c = 3 * u * t * t;
+    const d = t * t * t;
+    return [
+        a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0],
+        a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1],
+        a * p0[2] + b * p1[2] + c * p2[2] + d * p3[2],
+    ];
+}
+export function sampleCurve(curve, tolerance = 0.08, transform = {}) {
+    const points = curve.points;
+    if (points.length < 2)
+        return points.map((point) => add(rotatePoint(point.position, transform.rotation ?? [0, 0, 0]), transform.center ?? [0, 0, 0]));
+    const rotation = transform.rotation ?? [0, 0, 0];
+    const center = transform.center ?? [0, 0, 0];
+    const place = (p) => add(rotatePoint(p, rotation), center);
+    const steps = Math.max(2, Math.min(64, Math.ceil(0.5 / Math.max(tolerance, 0.001))));
+    const out = [];
+    const count = curve.closed ? points.length : points.length - 1;
+    for (let i = 0; i < count; i++) {
+        const a = points[i];
+        const b = points[(i + 1) % points.length];
+        const p0 = a.position;
+        const p1 = add(a.position, a.out ?? [0, 0, 0]);
+        const p2 = add(b.position, b.in ?? [0, 0, 0]);
+        const p3 = b.position;
+        for (let s = 0; s < steps; s++)
+            out.push(place(cubic(p0, p1, p2, p3, s / steps)));
+    }
+    out.push(place(curve.closed ? points[0].position : points[points.length - 1].position));
+    return out;
+}

package/dist/debug-draw-3d.d.ts

@@ -0,0 +1,14 @@
+import { FrameRecorder, type FrameCommand, type LayerMask, type LineDefaults, type PointDefaults } from "./frame-recorder.js";
+export type DebugDrawOptions = {
+    defaultVisibleLayers?: LayerMask;
+    /** Style applied to every point that does not override it. */
+    defaultPointStyle?: PointDefaults;
+    /** Style applied to every line-like primitive that does not override it. */
+    defaultLineStyle?: LineDefaults;
+};
+export declare class DebugDraw3D {
+    #private;
+    constructor(options?: DebugDrawOptions);
+    beginFrame(): FrameRecorder;
+    finishFrame(recorder: FrameRecorder): readonly FrameCommand[];
+}

package/dist/debug-draw-3d.js

@@ -0,0 +1,36 @@
+import { FrameRecorder, resolveFrameRecorderDefaults, } from "./frame-recorder.js";
+export class DebugDraw3D {
+    #visibleLayers;
+    #defaults;
+    #active;
+    constructor(options = {}) {
+        const visibleLayers = options.defaultVisibleLayers ?? 0xffff_ffff;
+        if (!Number.isInteger(visibleLayers) || visibleLayers < 0) {
+            throw new RangeError("defaultVisibleLayers must be a non-negative integer bitmask");
+        }
+        this.#visibleLayers = visibleLayers;
+        this.#defaults = {
+            ...(options.defaultPointStyle === undefined ? {} : { point: { ...options.defaultPointStyle } }),
+            ...(options.defaultLineStyle === undefined ? {} : { line: { ...options.defaultLineStyle } }),
+        };
+        // Validate eagerly so invalid defaults fail at construction, not on the first frame.
+        resolveFrameRecorderDefaults(this.#defaults);
+    }
+    beginFrame() {
+        if (this.#active !== undefined) {
+            throw new Error("a debug draw frame is already active");
+        }
+        const recorder = new FrameRecorder(this.#defaults);
+        this.#active = recorder;
+        return recorder;
+    }
+    finishFrame(recorder) {
+        if (this.#active !== recorder) {
+            throw new Error("recorder does not belong to this debug draw instance");
+        }
+        const commands = recorder.commands(this.#visibleLayers);
+        recorder.seal();
+        this.#active = undefined;
+        return commands;
+    }
+}

package/dist/frame-recorder-2d.d.ts

@@ -0,0 +1,177 @@
+/**
+ * 2D debug-draw commands and their recorder.
+ *
+ * The 2D layer is the same data flow as the 3D one — `FrameRecorder -> FrameCommand[] -> GPU` —
+ * reached through `frame.d2` instead of a second entry point, so a frame has one lifecycle, one
+ * layer mask and one set of defaults. The commands are separate types rather than 3D commands
+ * with a `space` flag because a 2D point is a `Vec2` and 2D strokes carry no surface normal;
+ * keeping them apart stops a 3D-only field from silently meaning something different here.
+ *
+ * See `camera-2d.ts` for what `world2d` and `screen` mean.
+ */
+import type { Space2D, Vec2 } from "./camera-2d.js";
+import type { Color, LayerMask, LineJoint, RenderedJoint, ResolvedLineDefaults, ResolvedPointDefaults } from "./frame-recorder.js";
+export type Line2DOptions = {
+    color?: Color;
+    colorEnd?: Color;
+    /** Stroke width in canvas pixels (`widthMode: "screen"`) or world2d units. */
+    width?: number;
+    widthMode?: "screen" | "world";
+    dash?: readonly [number, number, number];
+    joint?: LineJoint;
+    /** Defaults to `world2d`; see `camera-2d.ts`. */
+    space?: Space2D;
+    layer?: LayerMask;
+};
+export type Point2DOptions = {
+    color?: Color;
+    size?: number;
+    sizeMode?: "screen" | "world";
+    round?: boolean;
+    space?: Space2D;
+    layer?: LayerMask;
+};
+/** Every filled/stroked 2D shape the layer can draw. */
+export type Shape2DKind = "rect" | "rounded-rect" | "circle" | "ellipse" | "arc" | "annulus" | "capsule" | "polygon" | "triangle" | "rhombus" | "sector" | "segment";
+export type Shape2DOptions = {
+    color?: Color;
+    /** Rotation in radians, anticlockwise in `world2d` and screen-clockwise in `screen`. */
+    rotation?: number;
+    /** Filled by default; `false` strokes the outline with `strokeWidth`. */
+    fill?: boolean;
+    /** Outline width in canvas pixels; only read when `fill` is false. */
+    strokeWidth?: number;
+    /** Start angle of `arc`/`sector`/`segment` in radians. Defaults to `0`, the +x axis. */
+    startAngle?: number;
+    /** Sweep of `arc`/`sector`/`segment` in radians. Defaults to a full turn; negative turns the other way. */
+    sweep?: number;
+    space?: Space2D;
+    layer?: LayerMask;
+};
+export type Shape2DCommand = {
+    readonly kind: "shape2d";
+    readonly shape: Shape2DKind;
+    readonly center: Vec2;
+    /**
+     * Primary half-size, meaning depends on `shape`: box half extents, ellipse radii, circumradius,
+     * capsule `[radius, halfLength]`, annulus `[outer, inner]`, rhombus half diagonals, or a
+     * triangle's first vertex offset from the centroid.
+     */
+    readonly size: Vec2;
+    /** Second/third triangle vertices relative to the centroid; zero for every other shape. */
+    readonly vertexB: Vec2;
+    readonly vertexC: Vec2;
+    readonly cornerRadius: number;
+    /** Outline width in canvas pixels. */
+    readonly thickness: number;
+    readonly filled: boolean;
+    readonly rotation: number;
+    readonly startAngle: number;
+    readonly sweep: number;
+    /** Vertex count of `polygon`; zero for every other shape. */
+    readonly sides: number;
+    readonly color: Color;
+    readonly space: Space2D;
+    readonly layer: LayerMask;
+};
+export type Point2DCommand = {
+    readonly kind: "point2d";
+    readonly position: Vec2;
+    readonly color: Color;
+    readonly size: number;
+    readonly sizeMode: "screen" | "world";
+    readonly round?: boolean;
+    readonly space: Space2D;
+    readonly layer: LayerMask;
+};
+export type Line2DCommand = {
+    readonly kind: "line2d";
+    readonly start: Vec2;
+    readonly end: Vec2;
+    readonly color: Color;
+    readonly colorEnd: Color;
+    readonly width: number;
+    readonly widthMode: "screen" | "world";
+    readonly dash?: readonly [number, number, number];
+    readonly joint?: LineJoint;
+    readonly space: Space2D;
+    readonly layer: LayerMask;
+};
+/**
+ * One path vertex of a `lineStrip`/`polyline`, the 2D twin of `JointCommand`. The renderer
+ * rebuilds the round/bevel/miter wedge from `previous`, `center` and `next`, exactly as the 3D
+ * joint pipeline does.
+ */
+export type Joint2DCommand = {
+    readonly kind: "joint2d";
+    readonly previous: Vec2;
+    readonly center: Vec2;
+    readonly next: Vec2;
+    readonly color: Color;
+    readonly width: number;
+    readonly widthMode: "screen" | "world";
+    readonly dash?: readonly [number, number, number];
+    readonly joint: RenderedJoint;
+    readonly space: Space2D;
+    readonly layer: LayerMask;
+};
+/** Everything a `FrameRecorder2D` can emit. */
+export type FrameCommand2D = Point2DCommand | Line2DCommand | Joint2DCommand | Shape2DCommand;
+/** The 3D recorder's resolved point/line styles, reused so 2D and 3D defaults cannot drift. */
+export type FrameRecorder2DStyleDefaults = {
+    readonly point: ResolvedPointDefaults;
+    readonly line: ResolvedLineDefaults;
+};
+/**
+ * Records 2D primitives for one frame. Obtained through `FrameRecorder.d2`; it seals with its
+ * parent, so a caller cannot keep drawing into a finished frame.
+ */
+export declare class FrameRecorder2D {
+    #private;
+    constructor(defaults: FrameRecorder2DStyleDefaults, assertOpen: () => void);
+    point(position: Vec2, options?: Point2DOptions): this;
+    line(start: Vec2, end: Vec2, options?: Line2DOptions): this;
+    ray(origin: Vec2, direction: Vec2, options?: Line2DOptions): this;
+    /**
+     * Path of segments, the 2D twin of `FrameRecorder.lineStrip`. Dash distance accumulates over
+     * the whole path and an open strip joins only its interior vertices, matching the 3D layer.
+     */
+    lineStrip(points: readonly Vec2[], options?: Line2DOptions, closed?: boolean): this;
+    polyline(points: readonly Vec2[], options?: Line2DOptions, closed?: boolean): this;
+    /**
+     * Axis-aligned grid of lines, the 2D twin of `FrameRecorder.grid` and reference `grid_2d`: `cells`
+     * are the cells per axis, so the drawn line count is one more on each side.
+     */
+    grid(center: Vec2, cells: readonly [number, number], spacing: Vec2, options?: Line2DOptions): this;
+    /** Rectangle with the given full width and height (reference `Rectangle::new`). */
+    rect(center: Vec2, size: Vec2, options?: Shape2DOptions): this;
+    /** Rectangle with rounded corners; the shader clamps the radius to half the shorter side. */
+    roundedRect(center: Vec2, size: Vec2, cornerRadius: number, options?: Shape2DOptions): this;
+    /** Filled disc with the given radius (reference `Circle::new`). */
+    circle(center: Vec2, radius: number, options?: Shape2DOptions): this;
+    /** Ellipse with independent x and y radii (reference `Ellipse::new(x_radius, y_radius)`). */
+    ellipse(center: Vec2, radii: Vec2, options?: Shape2DOptions): this;
+    /**
+     * Circular arc from `startAngle` through `sweep`. It is a curve without an interior, so an
+     * unfilled arc (the default) strokes it with `strokeWidth` while `fill: true` leaves a hairline.
+     */
+    arc(center: Vec2, radius: number, options?: Shape2DOptions): this;
+    /** Ring band between two radii (reference `Annulus::new(inner_radius, outer_radius)`). */
+    annulus(center: Vec2, innerRadius: number, outerRadius: number, options?: Shape2DOptions): this;
+    /** Capsule whose straight section is `length` long along y (reference `Capsule2d::new(radius, length)`). */
+    capsule(center: Vec2, radius: number, length: number, options?: Shape2DOptions): this;
+    /** Regular polygon with a vertex on the +x axis (reference `RegularPolygon::new(circumradius, sides)`). */
+    polygon(center: Vec2, circumradius: number, sides: number, options?: Shape2DOptions): this;
+    /** Arbitrary triangle (reference `Triangle2d::new(a, b, c)`); `rotation` turns about its centroid. */
+    triangle(a: Vec2, b: Vec2, c: Vec2, options?: Shape2DOptions): this;
+    /** Diamond with the given full diagonals (reference `Rhombus::new(horizontal, vertical)`). */
+    rhombus(center: Vec2, diagonals: Vec2, options?: Shape2DOptions): this;
+    /** Disc sector from `startAngle` through `sweep` (reference `CircularSector`). */
+    sector(center: Vec2, radius: number, options?: Shape2DOptions): this;
+    /** Disc region between a chord and its arc (reference `CircularSegment`). */
+    segment(center: Vec2, radius: number, options?: Shape2DOptions): this;
+    get points(): readonly Point2DCommand[];
+    get lines(): readonly Line2DCommand[];
+    get joints(): readonly Joint2DCommand[];
+    get shapes(): readonly Shape2DCommand[];
+}