@weasel-js/kernel3d 1.15.2 → 1.16.1

package/README.md

@@ -4,8 +4,9 @@ Poses, an orbit camera, ray picking and screen-projected chrome geometry for
 weasel, over `@weasel-js/core`'s scene graph and dispatcher.
 
 **It hosts a renderer rather than owning one.** A consumer brings its own — a
-bespoke WebGL pass, three.js, anything — and the kernel hands it poses. Nothing
-here touches WebGL.
+bespoke WebGL pass, three.js, anything — and the kernel hands it poses. The one
+thing here that touches WebGL is the line pass (below), which that renderer
+calls into its own context.
 
 ```ts
 import { createScene } from '@weasel-js/core';
@@ -110,6 +111,41 @@ makes a pane a target, unprojecting onto the same ground, and `cameraOfAim3d`
 gives back the camera a dragged aim stands for — what an `AimSource`'s `setAim`
 writes.
 
+## Lines
+
+A stroke has no mesh a renderer can draw, so the kernel ships a pass for it.
+`packLines` turns polylines into vertices, and `createLinePass(gl)` draws them
+into a WebGL2 context the host owns, between its own draws:
+
+```ts
+const pass = createLinePass(gl);
+pass.draw(
+  packLines([{ runs: [{ points }], color: [1, 0.4, 0.2, 1], width: 4, trim: { end: 0.6 }, model }]),
+  cameraViewProjection(camera, width / height),
+  { width, height }, // the viewport in CSS pixels
+);
+```
+
+- **Widths are pixels.** Each line is widened after projection, so its shaft and
+  head are the same size near the camera and far from it. Corners miter along
+  the bisector, up to a limit past which a hairpin keeps a notch.
+- **A trim is a `StrokeTrim`, measured in the line's own space** before `model`
+  places it, through geom's length table and stroke's `resolveTrim`, as a 2D
+  stroke's is. It is applied when packing, so an animated trim repacks.
+- **A head caps each open run's end**: `HEAD` by default, a `HeadShape` to set
+  one, `null` for none. It is capped at a share of the line's length on screen,
+  and the shaft narrows by what the cap took. It stands back from the tip along
+  its own segment's direction on screen, so a head longer than its segment
+  stays on that segment's line. A closed subpath, or a run cut from one, has no
+  head.
+- **A segment with an end behind the eye is dropped**, not drawn across the
+  screen.
+
+Depth is tested against the bound buffer by default and never written; pass
+`{ depthTest: false }` to draw over everything. The pass puts back the GL state
+it changes. A three.js host calls it after `renderer.render`, with
+`renderer.getContext()`, and then `renderer.resetState()`.
+
 ## Math
 
 Vectors, quaternions, 4×4 matrices and ray intersection live in

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { Vec3, Mat4, Quat, Aabb, Ray } from '@weasel-js/geom/3d';
 import { PoseComposition, SceneNode, Scene, NodeId, SnapSource, SnapOutcomeStore, AreaSelectDep, NodeAtPointDep, PoseDescriptor, SnapDep, InsertExtras, InsertDep, ViewAim, AimSpace, SnapMark, OngoingHandle, Action, Tool } from '@weasel-js/core';
 import { KitSettingsStore } from '@weasel-js/react';
+import { StrokeTrim } from '@weasel-js/paint';
 import * as _weasel_js_prefs from '@weasel-js/prefs';
 
 /**
@@ -464,6 +465,145 @@ declare function collectOverlayBoxes(handles: Iterable<OngoingHandle>, origin: {
     y: number;
 }): ChromeBox[];
 
+/**
+ * The numbers an arrowhead is cut from, and how a line's shaft and head share
+ * its length on screen. The line pass's vertex shader repeats {@link layoutLine}
+ * in GLSL; the two must agree.
+ */
+/**
+ * An arrowhead, set by the shaft it caps: a line is set by its width alone and
+ * its head follows, so a wide line is still an arrow rather than a band with a
+ * small head poking out of it.
+ */
+interface HeadShape {
+    /** The head's length, in multiples of half the shaft's width. */
+    lenRatio: number;
+    /** The most of the line's on-screen length the head may take. */
+    maxShare: number;
+    /** Half the head's base as a share of its length. The cap shortens a head; it never reshapes it. */
+    aspect: number;
+}
+/** A 16 px head 14 px across on a 4 px shaft, taking at most half the line. */
+declare const HEAD: HeadShape;
+/**
+ * How far the shaft runs on under the head, as a share of the head's length:
+ * enough to close the seam between them, little enough that a curving shaft
+ * stays inside the triangle.
+ */
+declare const HEAD_OVERDRAW = 0.1;
+/** The head a shaft carries, in pixels, and the shaft that goes under it. */
+interface HeadSize {
+    /** The head's length. */
+    headLen: number;
+    /** Half the head's base. */
+    headHalf: number;
+    /** Half the shaft's width: narrowed by whatever the cap took off the head. */
+    shaftHalf: number;
+}
+/**
+ * The head `shaftHalf` carries on a line `linePx` long on screen. The head is
+ * capped at `head.maxShare` of the line, and the shaft narrows by the share
+ * the cap took, so a short line is the same arrow drawn smaller rather than a
+ * full-width band with a stub on the end. Left out, `linePx` caps nothing.
+ */
+declare function headFor(shaftHalf: number, linePx?: number, head?: HeadShape): HeadSize;
+/** {@link HeadSize}, plus where along the line its shaft stops. */
+interface LineLayout extends HeadSize {
+    /** Where the shaft ends, in the line's own length units. */
+    shaftEnd: number;
+}
+/**
+ * How a line `length` long in its own units, drawn at `pxPerUnit` pixels per
+ * unit near its tip, splits between shaft and head. A line with no head
+ * (`head` null) or no known scale runs its shaft to the end.
+ */
+declare function layoutLine(shaftHalf: number, length: number, pxPerUnit: number, head: HeadShape | null): LineLayout;
+
+/**
+ * Lines as the line pass's vertices. Trimming happens here, on the CPU and in
+ * the line's own space; widths and the head are pixels, laid out by the shader
+ * once the camera is known.
+ */
+
+/** One subpath of a {@link Line3}: points joined by straight segments. */
+interface LineRun3 {
+    points: readonly Vec3[];
+    /** Whether a closing edge runs from the last point back to the first. */
+    closed?: boolean;
+}
+/** A polyline drawn a fixed number of pixels wide, whatever its depth. */
+interface Line3 {
+    /** Subpaths in pen order, which is the order a trim runs. */
+    runs: readonly LineRun3[];
+    /** Straight (not premultiplied) RGBA, each 0–1. */
+    color: readonly [number, number, number, number];
+    /** The shaft's width in CSS pixels. Default 4. */
+    width?: number;
+    /** The head at each open run's end; null for none. Default {@link HEAD}. */
+    head?: HeadShape | null;
+    /** The stretch drawn, measured in the line's own space. */
+    trim?: StrokeTrim;
+    /** From the line's own space to the world. Default identity. */
+    model?: Mat4;
+}
+/** A visible stretch of a line: what the pass draws as one shaft and at most one head. */
+interface VisibleRun3 {
+    /** In the line's own space. */
+    points: Vec3[];
+    closed: boolean;
+    headed: boolean;
+}
+/** Floats per vertex; see {@link packLines} for the layout. */
+declare const LINE_FLOATS = 29;
+/**
+ * The stretches of `line` its trim leaves, one per subpath the trim reaches.
+ * A closed subpath the trim covers whole stays closed; one it cuts is open and,
+ * as a closed subpath takes no marker, carries no head.
+ */
+declare function visibleRuns(line: Line3): VisibleRun3[];
+/**
+ * `lines` as the line pass draws them: six vertices a segment, three more for
+ * a head, `LINE_FLOATS` floats each, laid out as
+ *
+ * | floats | holds |
+ * |---|---|
+ * | 0–2, 3–5 | the segment's two ends, in the world |
+ * | 6–8 | the point past this vertex's own end, so the shaft can miter |
+ * | 9, 10 | role and side |
+ * | 11–13 | the segment's start and end along its run, and the run's length, in the line's own units |
+ * | 14–17 | half the shaft's width in pixels, then the head's `lenRatio`, `maxShare` and `aspect` (`lenRatio` 0: no head) |
+ * | 18–20, 21–23, 24 | the run's tip, the start of its last segment, and that segment's length: one screen scale for every vertex of the run |
+ * | 25–28 | straight RGBA |
+ */
+declare function packLines(lines: readonly Line3[]): Float32Array;
+
+/** Options for {@link LinePass.draw}. */
+interface LineDrawOptions {
+    /** Hide the parts of a line behind what the bound depth buffer holds. Default true. */
+    depthTest?: boolean;
+}
+/**
+ * Lines drawn into a WebGL2 context the host owns. The kernel hosts a renderer
+ * rather than owning one; this is a pass that renderer calls, between its own.
+ */
+interface LinePass {
+    /**
+     * Draw `vertices`, as {@link packLines} lays them out, into the bound
+     * framebuffer under the host's `gl.viewport`. `viewProjection` takes world
+     * points to clip space; `size` is that viewport in CSS pixels, the unit a
+     * line's width is given in. Depth is tested, not written, and blending is
+     * straight alpha. The capabilities, depth mask, blend function, program,
+     * vertex array and array buffer it changes are put back as it found them.
+     */
+    draw(vertices: Float32Array, viewProjection: Mat4, size: {
+        width: number;
+        height: number;
+    }, options?: LineDrawOptions): void;
+    dispose(): void;
+}
+/** A {@link LinePass} on `gl`: one program, one vertex array, one buffer refilled each draw. */
+declare function createLinePass(gl: WebGL2RenderingContext): LinePass;
+
 /**
  * Camera tools and their actions.
  *
@@ -556,4 +696,4 @@ declare const kernel3dKitSettingsSchema: Omit<_weasel_js_prefs.PrefGroup, "child
     };
 };
 
-export { type Aim3d, type Aim3dOptions, type Camera3d, type Camera3dDep, type ChromeBox, DEFAULT_ORBIT_LIMITS, type Footprint, type Frustum3d, type GroundGridSourceOptions, MAX_PITCH, type Node3d, type NodeBounds, type Orbit3dKitSettings, type OrbitLimits, POSE3_COMPOSITION, type Pose3, type Scene3d, type ScreenBox, type ScreenLine, type ScreenPoint, type Snap3dOptions, UNIT_CUBE, type Viewport3d, type ViewportSource, type World3d, aabbOfPose, aimOf3d, aimSpace3d, alignPlaneSource, boxSnapSource, cameraEye, cameraOfAim3d, cameraView, cameraViewProjection, clampCamera, collectOverlayBoxes, createAreaSelect, createCamera, createInsert, createNodeAtPoint, createPoseDescriptor, createSnap, dollyAction, dollyBy, dollyToward, groundGridSource, homeAction, kernel3dKitSettingsSchema, ndcToScreen, orbitAction, orbitBy, panAction, panBy, pinchDollyAction, pose3, poseMatrix, projectAabbToScreen, projectPoint, projectSnapMarks, rayThroughScreenPoint, screenBoxOf, screenToNdc, useOrbitTool, worldPoseOf };
+export { type Aim3d, type Aim3dOptions, type Camera3d, type Camera3dDep, type ChromeBox, DEFAULT_ORBIT_LIMITS, type Footprint, type Frustum3d, type GroundGridSourceOptions, HEAD, HEAD_OVERDRAW, type HeadShape, type HeadSize, LINE_FLOATS, type Line3, type LineDrawOptions, type LineLayout, type LinePass, type LineRun3, MAX_PITCH, type Node3d, type NodeBounds, type Orbit3dKitSettings, type OrbitLimits, POSE3_COMPOSITION, type Pose3, type Scene3d, type ScreenBox, type ScreenLine, type ScreenPoint, type Snap3dOptions, UNIT_CUBE, type Viewport3d, type ViewportSource, type VisibleRun3, type World3d, aabbOfPose, aimOf3d, aimSpace3d, alignPlaneSource, boxSnapSource, cameraEye, cameraOfAim3d, cameraView, cameraViewProjection, clampCamera, collectOverlayBoxes, createAreaSelect, createCamera, createInsert, createLinePass, createNodeAtPoint, createPoseDescriptor, createSnap, dollyAction, dollyBy, dollyToward, groundGridSource, headFor, homeAction, kernel3dKitSettingsSchema, layoutLine, ndcToScreen, orbitAction, orbitBy, packLines, panAction, panBy, pinchDollyAction, pose3, poseMatrix, projectAabbToScreen, projectPoint, projectSnapMarks, rayThroughScreenPoint, screenBoxOf, screenToNdc, useOrbitTool, visibleRuns, worldPoseOf };

package/dist/index.js

@@ -1,8 +1,9 @@
 import { lookAt, multiply, perspective, add, scale, quatIdentity, compose, transformAabb, quatMultiply, quatConjugate, quatRotate, sub, invert, transformPoint, normalize, transformPoint4, distance, dot, len, aabbOfPoints, intersectRayPlane, pointOnRay, cross, intersectRayAabb } from '@weasel-js/geom/3d';
-import { clamp, rectsOverlap } from '@weasel-js/geom';
+import { clamp, lengthTable, curveSpan, rectsOverlap } from '@weasel-js/geom';
 import { scenePoseFrame, createSnapOutcomeStore, assertSnapSourceIds, DEFAULT_SNAP_PX, overlaysOf, resolveOverlays, defineTool, snapSourcesFor, resolvedSnapMarks, SNAP_AXIS_STEP, gatherSnapCandidates, scenePoseAdapter, composeWorldPose } from '@weasel-js/core';
 import { isDev } from '@weasel-js/react';
 import { closestOnFlat, resolveSnap, createBvh, stepLine, createSettledCache } from '@weasel-js/geom/nd';
+import { resolveTrim } from '@weasel-js/stroke';
 import { useMemo } from 'react';
 import { pref } from '@weasel-js/prefs';
 
@@ -1125,6 +1126,341 @@ function collectOverlayBoxes(handles, origin) {
   }
   return boxes;
 }
+
+// src/lines/head.ts
+var HEAD = { lenRatio: 8, maxShare: 0.5, aspect: 7 / 16 };
+var HEAD_OVERDRAW = 0.1;
+function headFor(shaftHalf, linePx = Number.POSITIVE_INFINITY, head = HEAD) {
+  const wanted = shaftHalf * head.lenRatio;
+  const headLen = Math.max(0, Math.min(wanted, head.maxShare * linePx));
+  const headHalf = headLen * head.aspect;
+  const shrunk = wanted > 0 ? shaftHalf * headLen / wanted : shaftHalf;
+  return { headLen, headHalf, shaftHalf: wanted > 0 ? Math.min(shrunk, headHalf) : shrunk };
+}
+function layoutLine(shaftHalf, length, pxPerUnit, head) {
+  if (!head || !(pxPerUnit > 0)) return { headLen: 0, headHalf: 0, shaftHalf, shaftEnd: length };
+  const size = headFor(shaftHalf, pxPerUnit * length, head);
+  return { ...size, shaftEnd: length - size.headLen / pxPerUnit * (1 - HEAD_OVERDRAW) };
+}
+var LINE_FLOATS = 29;
+var ROLE_BACK = 0;
+var ROLE_SHAFT_END = 1;
+var ROLE_HEAD_BASE = 2;
+var ROLE_TIP = 3;
+var SHAFT_CORNERS = [
+  [ROLE_BACK, -1],
+  [ROLE_BACK, 1],
+  [ROLE_SHAFT_END, 1],
+  [ROLE_BACK, -1],
+  [ROLE_SHAFT_END, 1],
+  [ROLE_SHAFT_END, -1]
+];
+var HEAD_CORNERS = [[ROLE_HEAD_BASE, -1], [ROLE_HEAD_BASE, 1], [ROLE_TIP, 0]];
+var flat = (points) => points.flatMap((p) => [p.x, p.y, p.z]);
+var lerp3 = (a, b, t) => ({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t, z: a.z + (b.z - a.z) * t });
+var dist = (a, b) => Math.hypot(b.x - a.x, b.y - a.y, b.z - a.z);
+function visibleRuns(line) {
+  const runs = line.runs.filter((r) => r.points.length >= 2);
+  if (runs.length === 0) return [];
+  const table = lengthTable(runs.map((r) => ({ points: flat(r.points), closed: !!r.closed })), 3);
+  const span = resolveTrim(table, line.trim);
+  const cut = span && curveSpan(table, span);
+  if (!cut) return [];
+  const out = [];
+  for (let r = cut.from.run; r <= cut.to.run; r++) {
+    const run = windowRun(runs[r], r, cut);
+    if (run) out.push({ ...run, headed: !run.closed && !runs[r].closed && line.head !== null });
+  }
+  return out;
+}
+function windowRun(run, r, cut) {
+  const pts = run.points;
+  const n = pts.length;
+  const segments = run.closed ? n : n - 1;
+  const at = (i) => pts[i % n];
+  const from = r === cut.from.run ? cut.from : { segment: 0, t: 0 };
+  const to = r === cut.to.run ? cut.to : { segment: segments - 1, t: 1 };
+  if (run.closed && from.segment === 0 && from.t === 0 && to.segment === segments - 1 && to.t === 1) {
+    return { points: [...pts], closed: true };
+  }
+  const out = [lerp3(at(from.segment), at(from.segment + 1), from.t)];
+  for (let k = from.segment + 1; k <= to.segment; k++) out.push(at(k));
+  out.push(lerp3(at(to.segment), at(to.segment + 1), to.t));
+  const kept = out.filter((p, i) => i === 0 || dist(out[i - 1], p) > 0);
+  return kept.length >= 2 ? { points: kept, closed: false } : null;
+}
+function packLines(lines) {
+  const chunks = [];
+  for (const line of lines) {
+    const shaftHalf = (line.width ?? 4) / 2;
+    const head = line.head === void 0 ? HEAD : line.head;
+    const toWorld = line.model ? (p) => transformPoint(line.model, p) : (p) => p;
+    for (const run of visibleRuns(line)) {
+      packRun(chunks, run, run.points.map(toWorld), shaftHalf, run.headed ? head : null, line.color);
+    }
+  }
+  return Float32Array.from(chunks);
+}
+function packRun(out, run, world, shaftHalf, head, color) {
+  const n = world.length;
+  const segments = run.closed ? n : n - 1;
+  const at = (i) => world[(i % n + n) % n];
+  const along = [0];
+  for (let i = 0; i < segments; i++) along.push(along[i] + dist(run.points[i], run.points[(i + 1) % n]));
+  const total = along[segments];
+  const apex = at(segments);
+  const apexBack = at(segments - 1);
+  const reach = total - along[segments - 1];
+  const shape = head ? [head.lenRatio, head.maxShare, head.aspect] : [0, 0, 0];
+  for (let i = 0; i < segments; i++) {
+    const a = at(i);
+    const b = at(i + 1);
+    const before = run.closed || i > 0 ? at(i - 1) : a;
+    const after = run.closed || i + 2 <= n - 1 ? at(i + 2) : b;
+    const corners = head && i === segments - 1 ? [...SHAFT_CORNERS, ...HEAD_CORNERS] : SHAFT_CORNERS;
+    for (const [role, side] of corners) {
+      const adj = role === ROLE_BACK ? before : role === ROLE_SHAFT_END ? after : b;
+      out.push(
+        a.x,
+        a.y,
+        a.z,
+        b.x,
+        b.y,
+        b.z,
+        adj.x,
+        adj.y,
+        adj.z,
+        role,
+        side,
+        along[i],
+        along[i + 1],
+        total,
+        shaftHalf,
+        ...shape,
+        apex.x,
+        apex.y,
+        apex.z,
+        apexBack.x,
+        apexBack.y,
+        apexBack.z,
+        reach,
+        ...color
+      );
+    }
+  }
+}
+
+// src/lines/pass.glsl.ts
+var LINE_VS = `#version 300 es
+precision highp float;
+layout(location = 0) in vec3 a_from;
+layout(location = 1) in vec3 a_to;
+layout(location = 2) in vec3 a_adj;
+layout(location = 3) in vec2 a_corner;
+layout(location = 4) in vec3 a_along;
+layout(location = 5) in vec4 a_shape;
+layout(location = 6) in vec3 a_apex;
+layout(location = 7) in vec4 a_apexBack;
+layout(location = 8) in vec4 a_color;
+uniform mat4 u_viewProjection;
+/* Half the viewport in CSS pixels: ndc times this is pixels. */
+uniform vec2 u_halfViewport;
+out vec4 v_color;
+const float OVERDRAW = ${HEAD_OVERDRAW.toFixed(3)};
+/* How far a bisector may stretch before the corner is let go; a hairpin would run to infinity. */
+const float MITER_LIMIT = 4.0;
+const vec4 CULLED = vec4(0.0, 0.0, 2.0, 1.0);
+
+vec2 screenOf(vec4 c) { return c.xy / c.w * u_halfViewport; }
+
+void main() {
+  v_color = a_color;
+  vec4 ca = u_viewProjection * vec4(a_from, 1.0);
+  vec4 cb = u_viewProjection * vec4(a_to, 1.0);
+  /* An end behind the eye projects to a line across the whole screen; drop the segment instead. */
+  if (ca.w <= 0.0 || cb.w <= 0.0) { gl_Position = CULLED; return; }
+  vec2 sa = screenOf(ca);
+  vec2 sb = screenOf(cb);
+  vec2 d = sb - sa;
+  float L = length(d);
+  vec2 dir = L > 0.0 ? d / L : vec2(1.0, 0.0);
+  vec2 perp = vec2(-dir.y, dir.x);
+  float role = a_corner.x;
+  float side = a_corner.y;
+  float s0 = a_along.x;
+  float s1 = a_along.y;
+  float total = a_along.z;
+  float span = s1 - s0;
+
+  /* Pixels per unit near the tip, the same for every segment of the run; this segment's own where the tip is unseen. */
+  float density = span > 0.0 ? L / span : 0.0;
+  vec4 cp = u_viewProjection * vec4(a_apex, 1.0);
+  vec4 cq = u_viewProjection * vec4(a_apexBack.xyz, 1.0);
+  float reach = a_apexBack.w;
+  if (reach > 0.0 && cp.w > 0.0 && cq.w > 0.0) {
+    float px = length(screenOf(cp) - screenOf(cq));
+    if (px > 0.0) density = px / reach;
+  }
+
+  /* layoutLine in head.ts, repeated. */
+  float shaftHalf = a_shape.x;
+  float wanted = shaftHalf * a_shape.y;
+  float headPx = 0.0;
+  float headHalf = 0.0;
+  float shaft = shaftHalf;
+  float shaftEnd = total;
+  if (wanted > 0.0 && density > 0.0) {
+    headPx = max(0.0, min(wanted, a_shape.z * density * total));
+    headHalf = headPx * a_shape.w;
+    shaft = min(shaftHalf * headPx / wanted, headHalf);
+    shaftEnd = total - headPx / density * (1.0 - OVERDRAW);
+  }
+
+  if (role > ${(ROLE_SHAFT_END + 0.5).toFixed(1)}) {
+    if (headPx <= 0.0) { gl_Position = CULLED; return; }
+    if (role > ${(ROLE_TIP - 0.5).toFixed(1)}) { gl_Position = cb; return; }
+    vec2 base = sb - dir * headPx + perp * side * headHalf;
+    gl_Position = vec4(base / u_halfViewport * cb.w, cb.z, cb.w);
+    return;
+  }
+
+  float to = min(s1, shaftEnd);
+  if (to <= s0 || span <= 0.0) { gl_Position = CULLED; return; }
+  bool atEnd = role > 0.5;
+  /* Clip space is linear in the world, so a fraction of the segment lands at its true depth. */
+  vec4 c = mix(ca, cb, atEnd ? (to - s0) / span : 0.0);
+  vec2 miter = perp;
+  float stretch = 1.0;
+  /* Only an end that meets its neighbor miters; a shaft cut short under the head stays square. */
+  if (!atEnd || to >= s1) {
+    vec4 cj = u_viewProjection * vec4(a_adj, 1.0);
+    if (cj.w > 0.0) {
+      vec2 sj = screenOf(cj);
+      vec2 e = atEnd ? sj - sb : sa - sj;
+      float eL = length(e);
+      if (eL > 0.0) {
+        vec2 o = e / eL;
+        vec2 bisect = perp + vec2(-o.y, o.x);
+        float bL = length(bisect);
+        if (bL > 0.0001) {
+          vec2 m = bisect / bL;
+          float cosHalf = dot(m, perp);
+          if (cosHalf > 1.0 / MITER_LIMIT) { miter = m; stretch = 1.0 / cosHalf; }
+        }
+      }
+    }
+  }
+  c.xy += miter * side * shaft * stretch / u_halfViewport * c.w;
+  gl_Position = c;
+}`;
+var LINE_FS = `#version 300 es
+precision mediump float;
+in vec4 v_color;
+out vec4 fragColor;
+void main() {
+  fragColor = v_color;
+}`;
+
+// src/lines/pass.ts
+var ATTRIBUTES = [
+  [3, 0],
+  [3, 3],
+  [3, 6],
+  [2, 9],
+  [3, 11],
+  [4, 14],
+  [3, 18],
+  [4, 21],
+  [4, 25]
+];
+function compile(gl, type, source) {
+  const shader = gl.createShader(type);
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS) && !gl.isContextLost()) {
+    const log = gl.getShaderInfoLog(shader);
+    gl.deleteShader(shader);
+    throw new Error(`kernel3d line pass: shader failed to compile: ${log}`);
+  }
+  return shader;
+}
+function link(gl) {
+  const program = gl.createProgram();
+  const vs = compile(gl, gl.VERTEX_SHADER, LINE_VS);
+  const fs = compile(gl, gl.FRAGMENT_SHADER, LINE_FS);
+  gl.attachShader(program, vs);
+  gl.attachShader(program, fs);
+  gl.linkProgram(program);
+  gl.deleteShader(vs);
+  gl.deleteShader(fs);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS) && !gl.isContextLost()) {
+    const log = gl.getProgramInfoLog(program);
+    gl.deleteProgram(program);
+    throw new Error(`kernel3d line pass: program failed to link: ${log}`);
+  }
+  return program;
+}
+function createLinePass(gl) {
+  const program = link(gl);
+  const viewProjection = gl.getUniformLocation(program, "u_viewProjection");
+  const halfViewport = gl.getUniformLocation(program, "u_halfViewport");
+  const buffer = gl.createBuffer();
+  const vao = gl.createVertexArray();
+  const prevVao = gl.getParameter(gl.VERTEX_ARRAY_BINDING);
+  const prevBuffer = gl.getParameter(gl.ARRAY_BUFFER_BINDING);
+  gl.bindVertexArray(vao);
+  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+  ATTRIBUTES.forEach(([size, offset], loc) => {
+    gl.enableVertexAttribArray(loc);
+    gl.vertexAttribPointer(loc, size, gl.FLOAT, false, LINE_FLOATS * 4, offset * 4);
+  });
+  gl.bindVertexArray(prevVao);
+  gl.bindBuffer(gl.ARRAY_BUFFER, prevBuffer);
+  const matrix = new Float32Array(16);
+  return {
+    draw(vertices, vp, size, options = {}) {
+      if (vertices.length === 0) return;
+      const was = {
+        program: gl.getParameter(gl.CURRENT_PROGRAM),
+        vao: gl.getParameter(gl.VERTEX_ARRAY_BINDING),
+        buffer: gl.getParameter(gl.ARRAY_BUFFER_BINDING),
+        blend: gl.isEnabled(gl.BLEND),
+        depth: gl.isEnabled(gl.DEPTH_TEST),
+        cull: gl.isEnabled(gl.CULL_FACE),
+        depthMask: gl.getParameter(gl.DEPTH_WRITEMASK),
+        blendFunc: [gl.BLEND_SRC_RGB, gl.BLEND_DST_RGB, gl.BLEND_SRC_ALPHA, gl.BLEND_DST_ALPHA].map((p) => gl.getParameter(p))
+      };
+      gl.useProgram(program);
+      matrix.set(vp);
+      gl.uniformMatrix4fv(viewProjection, false, matrix);
+      gl.uniform2f(halfViewport, Math.max(1, size.width) / 2, Math.max(1, size.height) / 2);
+      gl.enable(gl.BLEND);
+      gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+      gl.disable(gl.CULL_FACE);
+      if (options.depthTest ?? true) gl.enable(gl.DEPTH_TEST);
+      else gl.disable(gl.DEPTH_TEST);
+      gl.depthMask(false);
+      gl.bindVertexArray(vao);
+      gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+      gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.DYNAMIC_DRAW);
+      gl.drawArrays(gl.TRIANGLES, 0, vertices.length / LINE_FLOATS);
+      gl.useProgram(was.program);
+      gl.bindVertexArray(was.vao);
+      gl.bindBuffer(gl.ARRAY_BUFFER, was.buffer);
+      const set = (cap, on) => on ? gl.enable(cap) : gl.disable(cap);
+      set(gl.BLEND, was.blend);
+      set(gl.DEPTH_TEST, was.depth);
+      set(gl.CULL_FACE, was.cull);
+      gl.depthMask(was.depthMask);
+      gl.blendFuncSeparate(...was.blendFunc);
+    },
+    dispose() {
+      gl.deleteVertexArray(vao);
+      gl.deleteBuffer(buffer);
+      gl.deleteProgram(program);
+    }
+  };
+}
 var ORBIT_RATE = 6e-3;
 var DOLLY_RATE = 15e-4;
 function screenDelta(move) {
@@ -1260,6 +1596,6 @@ var kernel3dKitSettingsSchema = pref.group("3D camera", {
   })
 });
 
-export { DEFAULT_ORBIT_LIMITS, MAX_PITCH, POSE3_COMPOSITION, UNIT_CUBE, aabbOfPose, aimOf3d, aimSpace3d, alignPlaneSource, boxSnapSource, cameraEye, cameraOfAim3d, cameraView, cameraViewProjection, clampCamera, collectOverlayBoxes, createAreaSelect, createCamera, createInsert, createNodeAtPoint, createPoseDescriptor, createSnap, dollyAction, dollyBy, dollyToward, groundGridSource, homeAction, kernel3dKitSettingsSchema, ndcToScreen, orbitAction, orbitBy, panAction, panBy, pinchDollyAction, pose3, poseMatrix, projectAabbToScreen, projectPoint, projectSnapMarks, rayThroughScreenPoint, screenBoxOf, screenToNdc, useOrbitTool, worldPoseOf };
+export { DEFAULT_ORBIT_LIMITS, HEAD, HEAD_OVERDRAW, LINE_FLOATS, MAX_PITCH, POSE3_COMPOSITION, UNIT_CUBE, aabbOfPose, aimOf3d, aimSpace3d, alignPlaneSource, boxSnapSource, cameraEye, cameraOfAim3d, cameraView, cameraViewProjection, clampCamera, collectOverlayBoxes, createAreaSelect, createCamera, createInsert, createLinePass, createNodeAtPoint, createPoseDescriptor, createSnap, dollyAction, dollyBy, dollyToward, groundGridSource, headFor, homeAction, kernel3dKitSettingsSchema, layoutLine, ndcToScreen, orbitAction, orbitBy, packLines, panAction, panBy, pinchDollyAction, pose3, poseMatrix, projectAabbToScreen, projectPoint, projectSnapMarks, rayThroughScreenPoint, screenBoxOf, screenToNdc, useOrbitTool, visibleRuns, worldPoseOf };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map