vgpu-render 0.2.0 → 0.3.0

package/README.md

@@ -129,10 +129,12 @@ const frame = debug.beginFrame();
 frame.d2.line([0, 0], [120, 40], { width: 2, color: [1, 0, 0, 1] });
 frame.d2.lineStrip([[0, 0], [40, 80], [90, 10]], { width: 4, joint: "round" });
 frame.d2.grid([0, 0], [8, 5], [40, 40], { color: [0.4, 0.4, 0.5, 1] });
-frame.d2.rect([0, 0], [80, 40], { fill: false, strokeWidth: 2 });
-frame.d2.roundedRect([0, -60], [120, 40], 12, { color: [1, 0.7, 0.3, 1] });
-frame.d2.circle([0, 120], 60, { color: [0, 0.5, 1, 1] });
-frame.d2.arc([0, 120], 80, { fill: false, strokeWidth: 3, startAngle: 0, sweep: Math.PI / 2 });
+frame.d2.rect([0, 0], [80, 40], { strokeWidth: 2 });
+frame.d2.rect_s([160, 0], [80, 40], { color: [0.9, 0.9, 1, 1] });
+frame.d2.rect_d([320, 0], [80, 40], [12, 6, 0], { strokeWidth: 2 });
+frame.d2.rect_r_s([0, -60], [120, 40], 12, { color: [1, 0.7, 0.3, 1] });
+frame.d2.circle_s([0, 120], 60, { color: [0, 0.5, 1, 1] });
+frame.d2.arc([0, 120], 80, { strokeWidth: 3, startAngle: 0, sweep: Math.PI / 2 });
 const commands = debug.finishFrame(frame);
 // The third argument is the 2D camera; omit it and the last one stays in effect.
 renderer.prepare(commands, { viewProjection, view }, { pan: [0, 0], zoom: 1 });
@@ -152,13 +154,26 @@ gallery); `world2d` needs no such step because its projection already reads the
 coordinate in that sense, not a top-left one — the top-left, +y-down space is the reference UI space,
 and here it is `screen`, the same one `TextSpace "screen"` already uses.
 
-- Strokes: `line`, `ray`, `lineStrip`/`polyline`, `grid`, `point`; screen-pixel or world widths,
-dashes with the same phase accumulation as the 3D paths, and round/bevel/miter joints.
-- Shapes: `rect`, `roundedRect`, `circle`, `ellipse`, `arc`, `annulus`, `capsule`, `polygon`,
+- Strokes: `line`, `ray`, `lineStrip`/`polyline`, `lineLoop`, `grid`, `point`; every stroke has a
+`_d` twin (`line_d`, `ray_d`, `lineStrip_d`, `polyline_d`, `lineLoop_d`, `grid_d`) that takes the
+same `[visible, gap, phase]` triple and phase accumulation as the 3D dashed paths. Screen-pixel or
+world widths, and round/bevel/miter joints.
+- Arrows: `arrow` / `arrow_s` / `arrow_d` / `arrow_s_d` — the open V head by default, a filled head
+for `_s`, and the same two forms dashed for `_d`, with `headLength` / `headAngle` options.
+- Curves: `curve(curve, options)` / `curve_d(curve, dash, options)` sample a cubic control polygon
+(`Curve2D`, the 2D twin of `Curve3D`) into a strip, with `tolerance`, `transform.center/rotation/scale`
+and `closed` the same way the 3D page uses them. The 2D Curve page mirrors the 3D one: a
+construction band below the matrix draws every control point (pink anchors, amber handles) for the
+seven reference curve shapes.
+- Shapes: `rect`, `rect_r`, `circle`, `ellipse`, `arc`, `annulus`, `capsule`, `polygon`,
 `triangle`, `rhombus`, `sector`, `segment`. Each is one instanced quad evaluated as a signed
 distance field in the fragment stage, so nothing is triangulated on the CPU and an outline
-width stays a pixel count at any zoom. `fill: false` plus `strokeWidth` turns any of them into
-an outline; an `arc`'s outline is clipped to its `startAngle`/`sweep` wedge.
+width stays a pixel count at any zoom. Every primitive follows the 3D naming: `<shape>` strokes
+the outline, `<shape>_s` fills it and `<shape>_d` dashes the outline along its perimeter,
+taking the same `[visible, gap, phase]` triple as the line layer. `arc` has no interior, so it
+has no `_s` variant, and `Shape2DOptions` no longer carries `fill` — the method name decides.
+Dashes are cut from the shape's perimeter parameter, a closed form for every primitive except
+the ellipse (Simpson-integrated arc length), so they stay continuous across corners.
 - The layer is an overlay: it draws after every 3D primitive, pins itself to the near plane and
 does not write depth. Screen-space text remains the last thing drawn.
 - `InfiniteGrid2D` renders the reference's 2D grid as a full-viewport shader quad: decimal LOD levels,
@@ -166,10 +181,12 @@ does not write depth. Screen-space text remains the last thing drawn.
   `cellSize`, `lineWidthPixels`, `minPixelsBetweenCells`, the LOD range and both line colors from
   the gallery's grid panel, and draws as the 2D layer's background.
 - The 2D camera is independent of the 3D one (`mode: "3d" | "2d"` in the gallery config); the
-`2d-*` pages fit their declared `view2d` extent, drag or hold WASD to pan, and scroll to zoom. The gallery
-classifies the 2D layer like the 3D scenes: `2d-gizmos` and `2d-shapes` are overviews, while
-`2d-lines`, `2d-curves`, `2d-markers`, `2d-outlines`, `2d-fill`, `2d-spaces` and `2d-grid` are
-column-by-row matrices whose column titles and sample labels are `world2d` text, so they pan
+`2d-*` pages fit their declared `view2d` extent, drag or hold WASD to pan, hold shift to sprint, and scroll to zoom. The gallery
+classifies the 2D layer like the 3D scenes: `2d-index` is the API index, the twelve shape pages
+(`2d-rect`, `2d-rounded-rect`, `2d-circle`, `2d-ellipse`, `2d-arc`, `2d-annulus`, `2d-capsule`,
+`2d-polygon`, `2d-triangle`, `2d-rhombus`, `2d-sector`, `2d-segment`) each own one primitive, and
+`2d-lines`, `2d-curves`, `2d-markers`, `2d-arrows`, `2d-spaces`, `2d-grid` cover the stroke API
+families. Every matrix page's column titles and sample labels are `world2d` text, so they pan
 and zoom with the geometry they annotate.
 
 ## Text

package/dist/curve.d.ts

@@ -1,3 +1,4 @@
+import type { Vec2 } from "./camera-2d.js";
 import type { Vec3 } from "./frame-draw-list.js";
 export type CurvePoint = {
     readonly position: Vec3;
@@ -14,3 +15,27 @@ export type CurveTransform = {
 };
 export declare function rotatePoint(p: Vec3, rotation: readonly [number, number, number]): Vec3;
 export declare function sampleCurve(curve: Curve3D, tolerance?: number, transform?: CurveTransform): Vec3[];
+/** One control point of a 2D cubic curve; `in`/`out` are handles relative to `position`. */
+export type CurvePoint2D = {
+    readonly position: Vec2;
+    readonly in?: Vec2;
+    readonly out?: Vec2;
+};
+export type Curve2D = {
+    readonly points: readonly CurvePoint2D[];
+    readonly closed?: boolean;
+};
+export type CurveTransform2D = {
+    readonly center?: Vec2;
+    /** Anticlockwise rotation in radians. */
+    readonly rotation?: number;
+    readonly scale?: number;
+};
+/** Applies a curve transform to one point; callers drawing control points use this. */
+export declare function placeCurvePoint2D(point: Vec2, transform?: CurveTransform2D): Vec2;
+/**
+ * Samples a 2D cubic curve into a polyline, the 2D twin of `sampleCurve`. `tolerance` is the
+ * approximate segment length in `world2d` units: smaller values subdivide each cubic further, so
+ * a `lineStrip` can follow the curve as closely as the caller needs.
+ */
+export declare function sampleCurve2D(curve: Curve2D, tolerance?: number, transform?: CurveTransform2D): Vec2[];

package/dist/curve.js

@@ -44,3 +44,56 @@ export function sampleCurve(curve, tolerance = 0.08, transform = {}) {
     out.push(place(curve.closed ? points[0].position : points[points.length - 1].position));
     return out;
 }
+const add2 = (a, b) => [a[0] + b[0], a[1] + b[1]];
+function cubic2(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],
+    ];
+}
+/** Applies a curve transform to one point; callers drawing control points use this. */
+export function placeCurvePoint2D(point, transform = {}) {
+    const rotation = transform.rotation ?? 0;
+    const scale = transform.scale ?? 1;
+    const center = transform.center ?? [0, 0];
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    const x = point[0] * scale;
+    const y = point[1] * scale;
+    return [center[0] + x * cos - y * sin, center[1] + x * sin + y * cos];
+}
+/**
+ * Samples a 2D cubic curve into a polyline, the 2D twin of `sampleCurve`. `tolerance` is the
+ * approximate segment length in `world2d` units: smaller values subdivide each cubic further, so
+ * a `lineStrip` can follow the curve as closely as the caller needs.
+ */
+export function sampleCurve2D(curve, tolerance = 1, transform = {}) {
+    const points = curve.points;
+    const place = (p) => placeCurvePoint2D(p, transform);
+    if (points.length < 2)
+        return points.map((point) => place(point.position));
+    const out = [];
+    const count = curve.closed ? points.length : points.length - 1;
+    const step = Math.max(tolerance, 0.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 = add2(a.position, a.out ?? [0, 0]);
+        const p2 = add2(b.position, b.in ?? [0, 0]);
+        const p3 = b.position;
+        const hull = Math.hypot(p1[0] - p0[0], p1[1] - p0[1]) +
+            Math.hypot(p2[0] - p1[0], p2[1] - p1[1]) +
+            Math.hypot(p3[0] - p2[0], p3[1] - p2[1]);
+        const steps = Math.max(2, Math.min(64, Math.ceil(hull / step)));
+        for (let s = 0; s < steps; s++)
+            out.push(place(cubic2(p0, p1, p2, p3, s / steps)));
+    }
+    out.push(place(curve.closed ? points[0].position : points[points.length - 1].position));
+    return out;
+}

package/dist/frame-draw-list-2d.d.ts

@@ -10,6 +10,7 @@
  * See `camera-2d.ts` for what `world2d` and `screen` mean.
  */
 import type { Space2D, Vec2 } from "./camera-2d.js";
+import { type Curve2D, type CurveTransform2D } from "./curve.js";
 import type { Color, LayerMask, LineJoint, RenderedJoint, ResolvedLineDefaults, ResolvedPointDefaults } from "./frame-draw-list.js";
 export type Line2DOptions = {
     color?: Color;
@@ -17,12 +18,33 @@ export type Line2DOptions = {
     /** 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;
 };
+/** `arrow` options: the line style plus the head size and half-angle. */
+export type Arrow2DOptions = Line2DOptions & {
+    /** Head length in `world2d` units; defaults to a quarter of the shaft, clamped to 6..14. */
+    headLength?: number;
+    /** Half-angle of the head in radians; defaults to 30 degrees. */
+    headAngle?: number;
+};
+/** `curve` options: the line style plus sampling tolerance and placement. */
+export type Curve2DOptions = Line2DOptions & {
+    /** Approximate segment length in `world2d` units; smaller values subdivide each cubic further. */
+    readonly tolerance?: number;
+    readonly transform?: CurveTransform2D;
+};
+/** `grid` options: the 3D grid parameters in the XY plane, plus the line style. */
+export type Grid2DOptions = Line2DOptions & {
+    /** Anticlockwise rotation around the grid centre, in radians. */
+    rotation?: number;
+    /** Skew angles whose tangents shift the opposite family of lines. */
+    skew?: readonly [number, number];
+    /** Keep the x-axis or y-axis boundary lines (the 2D counterpart of 3D's x/z edges). */
+    outer?: "none" | "x" | "y" | "xy";
+};
 export type Point2DOptions = {
     color?: Color;
     size?: number;
@@ -37,9 +59,7 @@ 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. */
+    /** Outline width in canvas pixels; the `<shape>` and `<shape>_d` variants read it. */
     strokeWidth?: number;
     /** Start angle of `arc`/`sector`/`segment` in radians. Defaults to `0`, the +x axis. */
     startAngle?: number;
@@ -65,6 +85,11 @@ export type Shape2DCommand = {
     /** Outline width in canvas pixels. */
     readonly thickness: number;
     readonly filled: boolean;
+    /**
+     * Dashed-outline pattern `[visible, gap, phase]` in shape-space units for the `_d` variants;
+     * absent for solid shapes and solid outlines.
+     */
+    readonly dash?: readonly [number, number, number];
     readonly rotation: number;
     readonly startAngle: number;
     readonly sweep: number;
@@ -130,46 +155,130 @@ export declare class FrameDrawList2D {
     #private;
     constructor(defaults: FrameDrawList2DStyleDefaults, assertOpen: () => void);
     point(position: Vec2, options?: Point2DOptions): this;
+    /** Straight segment (the 3D `draw_line`). */
     line(start: Vec2, end: Vec2, options?: Line2DOptions): this;
+    /** Straight segment dashed along its length (the 3D `draw_line_d`). */
+    line_d(start: Vec2, end: Vec2, dash: readonly [number, number, number], options?: Line2DOptions): this;
+    /**
+     * Arrow with an open V head, the 2D twin of `FrameDrawList.arrow`: the shaft runs to `origin +
+     * direction`, and the head is two lines back from the tip.
+     */
+    arrow(origin: Vec2, direction: Vec2, options?: Arrow2DOptions): this;
+    /** Arrow with a filled triangular head (`arrow` keeps the open line head). */
+    arrow_s(origin: Vec2, direction: Vec2, options?: Arrow2DOptions): this;
+    /** Arrow whose shaft is dashed; the two head lines stay solid like the filled head. */
+    arrow_d(origin: Vec2, direction: Vec2, dash: readonly [number, number, number], options?: Arrow2DOptions): this;
+    /** Arrow with a filled head and a dashed shaft. */
+    arrow_s_d(origin: Vec2, direction: Vec2, dash: readonly [number, number, number], options?: Arrow2DOptions): this;
     ray(origin: Vec2, direction: Vec2, options?: Line2DOptions): this;
+    /** Ray dashed along its length. */
+    ray_d(origin: Vec2, direction: Vec2, dash: readonly [number, number, number], options?: Line2DOptions): this;
     /**
      * Path of segments, the 2D twin of `FrameDrawList.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;
+    /** Open strip dashed along its length. */
+    lineStrip_d(points: readonly Vec2[], dash: readonly [number, number, number], options?: Line2DOptions, closed?: boolean): this;
+    /** Closed strip: the last point joins the first (the 3D `draw_line_loop`). */
+    lineLoop(points: readonly Vec2[], options?: Line2DOptions): this;
+    /** Closed strip dashed along its length. */
+    lineLoop_d(points: readonly Vec2[], dash: readonly [number, number, number], options?: Line2DOptions): this;
     polyline(points: readonly Vec2[], options?: Line2DOptions, closed?: boolean): this;
+    polyline_d(points: readonly Vec2[], dash: readonly [number, number, number], options?: Line2DOptions, closed?: boolean): this;
+    /**
+     * Cubic curve sampled into a polyline, the 2D twin of `FrameDrawList.curve`. The curve's own
+     * `closed` flag decides whether the last point joins the first.
+     */
+    curve(curve: Curve2D, options?: Curve2DOptions): this;
+    /** Cubic curve sampled into a dashed polyline. */
+    curve_d(curve: Curve2D, dash: readonly [number, number, number], options?: Curve2DOptions): this;
     /**
      * Axis-aligned grid of lines, the 2D twin of `FrameDrawList.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`). */
+    grid(center: Vec2, cells: readonly [number, number], spacing: Vec2, options?: Grid2DOptions): this;
+    /** Grid whose lines are dashed along their length. */
+    grid_d(center: Vec2, cells: readonly [number, number], spacing: Vec2, dash: readonly [number, number, number], options?: Grid2DOptions): this;
+    /**
+     * Rectangle with the given full width and height, stroked by default like the 3D `draw_rect`.
+     * `rect_s` fills it and `rect_d` dashes the outline.
+     */
     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`). */
+    /** Solid rectangle (reference `Rectangle`, the 3D `draw_rect_s`). */
+    rect_s(center: Vec2, size: Vec2, options?: Shape2DOptions): this;
+    /**
+     * Rectangle outline dashed along its perimeter (the 3D `draw_rect_d`). `dash` is
+     * `[visible, gap, phase]` in shape-space units, the same triple the line layer takes.
+     */
+    rect_d(center: Vec2, size: Vec2, dash: readonly [number, number, number], options?: Shape2DOptions): this;
+    /** Rounded rectangle outline; the shader clamps the radius to half the shorter side. */
+    rect_r(center: Vec2, size: Vec2, cornerRadius: number, options?: Shape2DOptions): this;
+    /** Solid rounded rectangle (reference `RoundedRectangle`, the 3D `_s` counterpart). */
+    rect_r_s(center: Vec2, size: Vec2, cornerRadius: number, options?: Shape2DOptions): this;
+    /** Rounded rectangle outline dashed along its perimeter. */
+    rect_r_d(center: Vec2, size: Vec2, cornerRadius: number, dash: readonly [number, number, number], options?: Shape2DOptions): this;
+    /** Disc outline with the given radius (reference `Circle`, the 3D `draw_circle`). */
     circle(center: Vec2, radius: number, options?: Shape2DOptions): this;
-    /** Ellipse with independent x and y radii (reference `Ellipse::new(x_radius, y_radius)`). */
+    /** Solid disc (reference `Circle::new`, the 3D `draw_circle_s`). */
+    circle_s(center: Vec2, radius: number, options?: Shape2DOptions): this;
+    /** Dashed circle outline. */
+    circle_d(center: Vec2, radius: number, dash: readonly [number, number, number], options?: Shape2DOptions): this;
+    /** Ellipse outline with independent x and y radii (reference `Ellipse`). */
     ellipse(center: Vec2, radii: Vec2, options?: Shape2DOptions): this;
+    /** Solid ellipse (reference `Ellipse::new`, the 3D `_s` counterpart). */
+    ellipse_s(center: Vec2, radii: Vec2, options?: Shape2DOptions): this;
+    /** Dashed ellipse outline. */
+    ellipse_d(center: Vec2, radii: Vec2, dash: readonly [number, number, number], 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.
+     * Circular arc from `startAngle` through `sweep`. It is a curve without an interior, so it is
+     * only ever stroked; `arc_s` would have nothing to fill.
      */
     arc(center: Vec2, radius: number, options?: Shape2DOptions): this;
-    /** Ring band between two radii (reference `Annulus::new(inner_radius, outer_radius)`). */
+    /** Arc outline dashed along its sweep. */
+    arc_d(center: Vec2, radius: number, dash: readonly [number, number, number], options?: Shape2DOptions): this;
+    /** Ring outline between two radii (reference `Annulus`). */
     annulus(center: Vec2, innerRadius: number, outerRadius: number, options?: Shape2DOptions): this;
-    /** Capsule whose straight section is `length` long along y (reference `Capsule2d::new(radius, length)`). */
+    /** Filled ring band (reference `Annulus::new`, the 3D `_s` counterpart). */
+    annulus_s(center: Vec2, innerRadius: number, outerRadius: number, options?: Shape2DOptions): this;
+    /** Dashed annulus outline; both boundaries are stroked. */
+    annulus_d(center: Vec2, innerRadius: number, outerRadius: number, dash: readonly [number, number, number], options?: Shape2DOptions): this;
+    /** Capsule outline whose straight section is `length` long along y (reference `Capsule2d`). */
     capsule(center: Vec2, radius: number, length: number, options?: Shape2DOptions): this;
-    /** Regular polygon with a vertex on the +x axis (reference `RegularPolygon::new(circumradius, sides)`). */
+    /** Solid capsule (reference `Capsule2d::new`, the 3D `_s` counterpart). */
+    capsule_s(center: Vec2, radius: number, length: number, options?: Shape2DOptions): this;
+    /** Dashed capsule outline. */
+    capsule_d(center: Vec2, radius: number, length: number, dash: readonly [number, number, number], options?: Shape2DOptions): this;
+    /** Regular polygon outline with a vertex on the +x axis (reference `RegularPolygon`). */
     polygon(center: Vec2, circumradius: number, sides: number, options?: Shape2DOptions): this;
-    /** Arbitrary triangle (reference `Triangle2d::new(a, b, c)`); `rotation` turns about its centroid. */
+    /** Solid regular polygon (reference `RegularPolygon::new`, the 3D `_s` counterpart). */
+    polygon_s(center: Vec2, circumradius: number, sides: number, options?: Shape2DOptions): this;
+    /** Dashed regular polygon outline. */
+    polygon_d(center: Vec2, circumradius: number, sides: number, dash: readonly [number, number, number], options?: Shape2DOptions): this;
+    /** Triangle outline (reference `Triangle2d`); `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)`). */
+    /** Solid triangle (reference `Triangle2d::new`, the 3D `_s` counterpart). */
+    triangle_s(a: Vec2, b: Vec2, c: Vec2, options?: Shape2DOptions): this;
+    /** Dashed triangle outline. */
+    triangle_d(a: Vec2, b: Vec2, c: Vec2, dash: readonly [number, number, number], options?: Shape2DOptions): this;
+    /** Diamond outline with the given full diagonals (reference `Rhombus`). */
     rhombus(center: Vec2, diagonals: Vec2, options?: Shape2DOptions): this;
-    /** Disc sector from `startAngle` through `sweep` (reference `CircularSector`). */
+    /** Solid diamond (reference `Rhombus::new`, the 3D `_s` counterpart). */
+    rhombus_s(center: Vec2, diagonals: Vec2, options?: Shape2DOptions): this;
+    /** Dashed diamond outline. */
+    rhombus_d(center: Vec2, diagonals: Vec2, dash: readonly [number, number, number], options?: Shape2DOptions): this;
+    /** Disc sector outline from `startAngle` through `sweep` (reference `CircularSector`). */
     sector(center: Vec2, radius: number, options?: Shape2DOptions): this;
-    /** Disc region between a chord and its arc (reference `CircularSegment`). */
+    /** Solid disc sector (reference `CircularSector`, the 3D `_s` counterpart). */
+    sector_s(center: Vec2, radius: number, options?: Shape2DOptions): this;
+    /** Dashed sector outline: the arc plus both radii. */
+    sector_d(center: Vec2, radius: number, dash: readonly [number, number, number], options?: Shape2DOptions): this;
+    /** Disc segment outline between a chord and its arc (reference `CircularSegment`). */
     segment(center: Vec2, radius: number, options?: Shape2DOptions): this;
+    /** Solid disc segment (reference `CircularSegment`, the 3D `_s` counterpart). */
+    segment_s(center: Vec2, radius: number, options?: Shape2DOptions): this;
+    /** Dashed segment outline: the arc plus the chord. */
+    segment_d(center: Vec2, radius: number, dash: readonly [number, number, number], options?: Shape2DOptions): this;
     get points(): readonly Point2DCommand[];
     get lines(): readonly Line2DCommand[];
     get joints(): readonly Joint2DCommand[];