@aethervtt/shard-mesh 0.0.1 → 0.2.0

package/dist/index.d.ts

@@ -1,3 +1,7 @@
+export { MeshBuilder, perpendicular } from './builder.js';
 export { decodeMesh, encodeMesh } from './codec.js';
 export { type GpuMeshDescriptor, MAX_MORPH_TARGETS, MESH_ATTRIBUTE_WIDTH, MESH_ATTRIBUTES, Mesh, type MeshAttribute, type MeshData, type MorphTarget, } from './mesh.js';
-export { box, capsule, cone, cube, cylinder, plane, sphere, torus } from './primitives.js';
+export { bevelBox, box, capsule, cone, cube, cylinder, plane, sphere, torus, } from './primitives.js';
+export { loadMeshSimplifier, meshSimplifierLoaded, type Simplified, type SimplifyOptions, simplifyLods, simplifyMesh, } from './simplify.js';
+export { type LeafCardOptions, leafCards, type TreeBranch, type TreeSkeleton, type TreeSkeletonOptions, treeSkeleton, tubeAlong, } from './tree.js';
+export { DEG, dcos, dsin, sinCos } from './trig.js';

package/dist/index.js

@@ -1,3 +1,4 @@
+import { MeshBuilder, perpendicular } from "./builder.js";
 import { decodeMesh, encodeMesh } from "./codec.js";
 import {
   MAX_MORPH_TARGETS,
@@ -5,20 +6,56 @@ import {
   MESH_ATTRIBUTES,
   Mesh
 } from "./mesh.js";
-import { box, capsule, cone, cube, cylinder, plane, sphere, torus } from "./primitives.js";
+import {
+  bevelBox,
+  box,
+  capsule,
+  cone,
+  cube,
+  cylinder,
+  plane,
+  sphere,
+  torus
+} from "./primitives.js";
+import {
+  loadMeshSimplifier,
+  meshSimplifierLoaded,
+  simplifyLods,
+  simplifyMesh
+} from "./simplify.js";
+import {
+  leafCards,
+  treeSkeleton,
+  tubeAlong
+} from "./tree.js";
+import { DEG, dcos, dsin, sinCos } from "./trig.js";
 export {
+  DEG,
   MAX_MORPH_TARGETS,
   MESH_ATTRIBUTES,
   MESH_ATTRIBUTE_WIDTH,
   Mesh,
+  MeshBuilder,
+  bevelBox,
   box,
   capsule,
   cone,
   cube,
   cylinder,
+  dcos,
   decodeMesh,
+  dsin,
   encodeMesh,
+  leafCards,
+  loadMeshSimplifier,
+  meshSimplifierLoaded,
+  perpendicular,
   plane,
+  simplifyLods,
+  simplifyMesh,
+  sinCos,
   sphere,
-  torus
+  torus,
+  treeSkeleton,
+  tubeAlong
 };

package/dist/mesh.d.ts

@@ -75,6 +75,8 @@ export declare class Mesh {
     readonly bounds: Float32Array<ArrayBufferLike>;
     /** Increments on `update`, so GPU copies know to re-upload. */
     version: number;
+    /** The stand-in for a mesh that failed to load (0061): drawn with the missing material. */
+    missing: boolean;
     /**
      * Set for meshes the GPU writes (`Mesh.gpu`): their vertex buffers are storage buffers with no
      * CPU copy; `positions` is empty.

package/dist/mesh.js

@@ -36,6 +36,8 @@ class Mesh {
   bounds = aabb.create();
   /** Increments on `update`, so GPU copies know to re-upload. */
   version = 0;
+  /** The stand-in for a mesh that failed to load (0061): drawn with the missing material. */
+  missing = false;
   /**
    * Set for meshes the GPU writes (`Mesh.gpu`): their vertex buffers are storage buffers with no
    * CPU copy; `positions` is empty.

package/dist/primitives.d.ts

@@ -46,3 +46,13 @@ export declare function torus(options?: {
     radialSegments?: number;
     tubularSegments?: number;
 }): Mesh;
+/**
+ * A box with chamfered edges and corners: the stand-in for a mesh that failed to load (0061).
+ * `bevel` is the chamfer width, clamped below half the smallest side.
+ */
+export declare function bevelBox(options?: {
+    x?: number;
+    y?: number;
+    z?: number;
+    bevel?: number;
+}): Mesh;

package/dist/primitives.js

@@ -229,7 +229,96 @@ function torus(options = {}) {
   }
   return b.build();
 }
+function bevelBox(options = {}) {
+  const h = [(options.x ?? 1) / 2, (options.y ?? 1) / 2, (options.z ?? 1) / 2];
+  const bevel = Math.min(options.bevel ?? 0.08, Math.min(h[0], h[1], h[2]) * 0.9);
+  const inner = h.map((v) => v - bevel);
+  const b = new Builder();
+  const unit = (v) => {
+    const l = Math.hypot(v[0], v[1], v[2]);
+    return v.map((c) => c / l);
+  };
+  const polygon = (points, n) => {
+    const [a, c, d] = [points[0], points[1], points[2]];
+    const e1 = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+    const e2 = [d[0] - a[0], d[1] - a[1], d[2] - a[2]];
+    const cross = [
+      e1[1] * e2[2] - e1[2] * e2[1],
+      e1[2] * e2[0] - e1[0] * e2[2],
+      e1[0] * e2[1] - e1[1] * e2[0]
+    ];
+    const ordered = cross[0] * n[0] + cross[1] * n[1] + cross[2] * n[2] < 0 ? [...points].reverse() : points;
+    const axis = n.map((c2) => Math.abs(c2)).indexOf(Math.max(...n.map((c2) => Math.abs(c2))));
+    const [ua, va] = axis === 0 ? [2, 1] : axis === 1 ? [0, 2] : [0, 1];
+    const ids = ordered.map(
+      (p) => b.vertex(p, n, [0.5 + p[ua] / (2 * h[ua]), 0.5 - p[va] / (2 * h[va])])
+    );
+    for (let i = 1; i + 1 < ids.length; i++) b.triangle(ids[0], ids[i], ids[i + 1]);
+  };
+  const point = (axis, value) => [0, 1, 2].map((k) => axis[k] * value[k]);
+  const signs = [-1, 1];
+  for (let a = 0; a < 3; a++) {
+    for (const s of signs) {
+      const u = (a + 1) % 3;
+      const v = (a + 2) % 3;
+      const n = [0, 0, 0];
+      n[a] = s;
+      const corners = [
+        [-1, -1],
+        [1, -1],
+        [1, 1],
+        [-1, 1]
+      ].map(([su, sv]) => {
+        const p = [0, 0, 0];
+        p[a] = s * h[a];
+        p[u] = su * inner[u];
+        p[v] = sv * inner[v];
+        return p;
+      });
+      polygon(corners, n);
+    }
+  }
+  for (let a = 0; a < 3; a++) {
+    const u = (a + 1) % 3;
+    const v = (a + 2) % 3;
+    for (const sa of signs) {
+      for (const su of signs) {
+        const n = [0, 0, 0];
+        n[a] = sa;
+        n[u] = su;
+        const quad = [-1, 1].flatMap((sv) => {
+          const p1 = [0, 0, 0];
+          p1[a] = sa * h[a];
+          p1[u] = su * inner[u];
+          p1[v] = sv * inner[v];
+          const p2 = [0, 0, 0];
+          p2[a] = sa * inner[a];
+          p2[u] = su * h[u];
+          p2[v] = sv * inner[v];
+          return [p1, p2];
+        });
+        polygon([quad[0], quad[1], quad[3], quad[2]], unit(n));
+      }
+    }
+  }
+  for (const sx of signs) {
+    for (const sy of signs) {
+      for (const sz of signs) {
+        const s = [sx, sy, sz];
+        const tri = [0, 1, 2].map(
+          (k) => point(
+            s,
+            k === 0 ? [h[0], inner[1], inner[2]] : k === 1 ? [inner[0], h[1], inner[2]] : [inner[0], inner[1], h[2]]
+          )
+        );
+        polygon(tri, unit(s));
+      }
+    }
+  }
+  return b.build();
+}
 export {
+  bevelBox,
   box,
   capsule,
   cone,

package/dist/simplify.d.ts

@@ -0,0 +1,34 @@
+import type { MeshData } from './mesh.js';
+/**
+ * Loads meshoptimizer's simplifier (WASM, embedded in its module). `simplifyMesh` and
+ * `simplifyLods` are synchronous and need this to have resolved once in the thread that calls
+ * them. Only code that simplifies imports it, so it never reaches a runtime bundle that doesn't.
+ */
+export declare function loadMeshSimplifier(): Promise<void>;
+/** Whether `loadMeshSimplifier` has finished in this thread. */
+export declare function meshSimplifierLoaded(): boolean;
+export interface SimplifyOptions {
+    /** Keep border edges (open edges) in place, so neighboring pieces still meet (default false). */
+    lockBorder?: boolean;
+    /**
+     * Largest error allowed, as a fraction of the mesh's size (or metres with `absolute`). The
+     * default, 1, lets the triangle target decide alone.
+     */
+    error?: number;
+    /** `error` is in mesh units, not relative to its size. */
+    absolute?: boolean;
+}
+export interface Simplified {
+    mesh: MeshData;
+    /** The error reached, in the same units as `SimplifyOptions.error`. */
+    error: number;
+}
+/**
+ * About `fraction` of the mesh's triangles, chosen by meshoptimizer's quadric simplifier. Vertices
+ * aren't moved, only dropped, so UVs, colors, and normals stay the source's; UV seams and borders
+ * (with `lockBorder`) are kept. If seams stop it short of the target, it retries allowed to
+ * collapse across them, and then as a last resort with the positions-only (sloppy) simplifier.
+ */
+export declare function simplifyMesh(mesh: MeshData, fraction: number, options?: SimplifyOptions): Simplified;
+/** One simplified mesh per fraction (each from the source, not from the previous level). */
+export declare function simplifyLods(mesh: MeshData, fractions: readonly number[], options?: SimplifyOptions): MeshData[];

package/dist/simplify.js

@@ -0,0 +1,140 @@
+import { ShardError } from "@aethervtt/shard-core";
+let simplifier;
+let loading;
+function loadMeshSimplifier() {
+  loading ??= import("meshoptimizer/simplifier").then(async (mod) => {
+    await mod.MeshoptSimplifier.ready;
+    simplifier = mod.MeshoptSimplifier;
+  });
+  return loading;
+}
+function meshSimplifierLoaded() {
+  return simplifier !== void 0;
+}
+function loaded() {
+  if (!simplifier) {
+    throw new ShardError("mesh/simplifier-not-loaded", "The mesh simplifier is not loaded", {
+      hint: "await loadMeshSimplifier() once (generators get it loaded for them) before simplifying."
+    });
+  }
+  return simplifier;
+}
+function simplifyMesh(mesh, fraction, options = {}) {
+  const s = loaded();
+  if (!(fraction > 0 && fraction <= 1)) {
+    throw new ShardError("mesh/bad-lod", `A LOD fraction must be in (0, 1], got ${fraction}`, {
+      hint: "lods: [0.5, 0.2] keeps about half, then a fifth, of the triangles."
+    });
+  }
+  const count = mesh.positions.length / 3;
+  const source = mesh.indices ? Uint32Array.from(mesh.indices) : sequence(count);
+  const triangles = source.length / 3;
+  const target = Math.max(1, Math.floor(triangles * fraction)) * 3;
+  if (target >= source.length) return { mesh, error: 0 };
+  const attrStride = 5;
+  const attrs = new Float32Array(count * attrStride);
+  for (let v = 0; v < count; v++) {
+    if (mesh.normals) {
+      attrs[v * 5] = mesh.normals[v * 3];
+      attrs[v * 5 + 1] = mesh.normals[v * 3 + 1];
+      attrs[v * 5 + 2] = mesh.normals[v * 3 + 2];
+    }
+    if (mesh.uvs) {
+      attrs[v * 5 + 3] = mesh.uvs[v * 2];
+      attrs[v * 5 + 4] = mesh.uvs[v * 2 + 1];
+    }
+  }
+  const weights = [0.25, 0.25, 0.25, mesh.uvs ? 0.5 : 0, mesh.uvs ? 0.5 : 0];
+  const flags = [];
+  if (options.lockBorder) flags.push("LockBorder");
+  if (options.absolute) flags.push("ErrorAbsolute");
+  const maxError = options.error ?? 1;
+  const slack = Math.floor(target / 3 * 1.1) * 3;
+  let [indices, error] = s.simplifyWithAttributes(
+    source,
+    mesh.positions,
+    3,
+    attrs,
+    attrStride,
+    weights,
+    null,
+    target,
+    maxError,
+    flags
+  );
+  if (indices.length > slack && options.error === void 0) {
+    ;
+    [indices, error] = s.simplifyWithAttributes(
+      source,
+      mesh.positions,
+      3,
+      attrs,
+      attrStride,
+      weights,
+      null,
+      target,
+      maxError,
+      [...flags, "Permissive"]
+    );
+  }
+  if (indices.length > slack && options.error === void 0 && !options.lockBorder) {
+    ;
+    [indices, error] = s.simplifySloppy(source, mesh.positions, 3, null, target, maxError);
+  }
+  return { mesh: compact(mesh, indices), error };
+}
+function simplifyLods(mesh, fractions, options = {}) {
+  const out = [];
+  for (const f of fractions) {
+    if (!(f > 0 && f < 1)) {
+      throw new ShardError("mesh/bad-lod", `LOD fractions are in (0, 1), got ${f}`, {
+        hint: "lods: [0.5, 0.2] keeps about half, then a fifth, of the triangles."
+      });
+    }
+    out.push(simplifyMesh(mesh, f, options).mesh);
+  }
+  return out;
+}
+function sequence(n) {
+  const out = new Uint32Array(n);
+  for (let i = 0; i < n; i++) out[i] = i;
+  return out;
+}
+function compact(mesh, indices) {
+  const count = mesh.positions.length / 3;
+  const remap = new Int32Array(count).fill(-1);
+  let next = 0;
+  for (let k = 0; k < indices.length; k++) {
+    const v = indices[k];
+    if (remap[v] === -1) remap[v] = next++;
+  }
+  const keep = new Int32Array(next);
+  for (let v = 0; v < count; v++) if (remap[v] >= 0) keep[remap[v]] = v;
+  const pick = (src, width) => {
+    if (!src) return void 0;
+    const out2 = new src.constructor(next * width);
+    for (let i = 0; i < next; i++)
+      for (let c = 0; c < width; c++) out2[i * width + c] = src[keep[i] * width + c];
+    return out2;
+  };
+  const tri = next > 65535 ? new Uint32Array(indices.length) : new Uint16Array(indices.length);
+  for (let k = 0; k < indices.length; k++) tri[k] = remap[indices[k]];
+  const out = { positions: pick(mesh.positions, 3), indices: tri };
+  const normals = pick(mesh.normals, 3);
+  if (normals) out.normals = normals;
+  const uvs = pick(mesh.uvs, 2);
+  if (uvs) out.uvs = uvs;
+  const colors = pick(mesh.colors, 4);
+  if (colors) out.colors = colors;
+  const tangents = pick(mesh.tangents, 4);
+  if (tangents) out.tangents = tangents;
+  const uvs1 = pick(mesh.uvs1, 2);
+  if (uvs1) out.uvs1 = uvs1;
+  return out;
+}
+export {
+  loadMeshSimplifier,
+  meshSimplifierLoaded,
+  simplifyLods,
+  simplifyMesh
+};

package/dist/tree.d.ts

@@ -0,0 +1,81 @@
+import { type MeshBuilder } from './builder.js';
+export interface TreeSkeletonOptions {
+    /** The trunk: length (m), base radius (m), and segments along it. */
+    trunk?: {
+        length?: number;
+        radius?: number;
+        segments?: number;
+    };
+    /** Children per branch (default 4). */
+    branches?: number;
+    /** Levels of branches below the trunk (default 2; 0 is a bare trunk). */
+    levels?: number;
+    /** Degrees between a child and its parent (default 45). */
+    spread?: number;
+    /** A child's length as a fraction of its parent's (default 0.55). */
+    lengthScale?: number;
+    /** A child's base radius as a fraction of its parent's radius where it starts (default 0.7). */
+    radiusScale?: number;
+    /** Tip radius as a fraction of the base radius (default 0.35). */
+    taper?: number;
+    /** Downward bend per metre of branch (default 0.08; negative bends up). */
+    gravity?: number;
+    /** Random wander of a branch's direction per segment (default 0.15). */
+    wobble?: number;
+    /** Where along its parent the first child starts, 0 to 1 (default 0.35). */
+    start?: number;
+    seed: number;
+}
+/** One branch: a polyline with a radius per point. */
+export interface TreeBranch {
+    /** 0 is the trunk. */
+    level: number;
+    /** Index of the parent branch, or −1 for the trunk. */
+    parent: number;
+    /** xyz per point, base first. */
+    points: Float64Array;
+    radii: Float64Array;
+}
+export interface TreeSkeleton {
+    branches: TreeBranch[];
+    /** Highest point (m). */
+    height: number;
+}
+/**
+ * A recursive branch graph (spec 0045): a trunk up +Y from the origin, each branch sprouting
+ * `branches` children along its upper part, bent by `gravity` and a seeded wobble. Deterministic
+ * per seed on every host (seeded RNG, trig through `sinCos`).
+ */
+export declare function treeSkeleton(options: TreeSkeletonOptions): TreeSkeleton;
+/**
+ * Skins a skeleton with tubes (`sides` around each; fewer on deeper levels), appended to `b`.
+ * Returns the index of the first vertex added.
+ */
+export declare function tubeAlong(b: MeshBuilder, skeleton: TreeSkeleton, options?: {
+    sides?: number;
+    minSides?: number;
+    vScale?: number;
+}): number;
+export interface LeafCardOptions {
+    /** Cards per metre of branch (default 6). */
+    density?: number;
+    /** Card size in metres (default 0.35). */
+    size?: number;
+    /** Branch levels that carry leaves (default: the deepest level). */
+    levels?: readonly number[];
+    /**
+     * `quad`: a square with UVs into a leaf atlas cell (alpha-tested texture). `leaf`: a pointed
+     * six-vertex leaf shape that needs no texture (default).
+     */
+    shape?: 'quad' | 'leaf';
+    /** Atlas columns and rows: each card picks a cell (default [1, 1]). */
+    atlas?: readonly [number, number];
+    /** How far cards droop, 0 (facing out) to 1 (hanging) (default 0.3). */
+    droop?: number;
+    seed: number;
+}
+/**
+ * Leaf cards along the given branch levels, appended to `b`: each card is two-sided (front and
+ * back faces), so it lights correctly with any material. Returns the index of the first vertex.
+ */
+export declare function leafCards(b: MeshBuilder, skeleton: TreeSkeleton, options: LeafCardOptions): number;

package/dist/tree.js

@@ -0,0 +1,211 @@
+import { Rng } from "@aethervtt/shard-core";
+import { perpendicular } from "./builder.js";
+import { DEG, sinCos } from "./trig.js";
+const sc = new Float64Array(2);
+function treeSkeleton(options) {
+  const rng = new Rng(options.seed);
+  const trunkLength = options.trunk?.length ?? 6;
+  const trunkRadius = options.trunk?.radius ?? 0.25;
+  const segments = Math.max(2, options.trunk?.segments ?? 8);
+  const children = Math.max(0, Math.floor(options.branches ?? 4));
+  const levels = Math.max(0, Math.floor(options.levels ?? 2));
+  const spread = (options.spread ?? 45) * DEG;
+  const lengthScale = options.lengthScale ?? 0.55;
+  const radiusScale = options.radiusScale ?? 0.7;
+  const taper = options.taper ?? 0.35;
+  const gravity = options.gravity ?? 0.08;
+  const wobble = options.wobble ?? 0.15;
+  const start = options.start ?? 0.35;
+  const branches = [];
+  let height = 0;
+  const grow = (level, parent, ox, oy, oz, dx, dy, dz, length, radius) => {
+    const n = Math.max(2, Math.ceil(segments / (level + 1)));
+    const points = new Float64Array((n + 1) * 3);
+    const radii = new Float64Array(n + 1);
+    const step = length / n;
+    let x = ox;
+    let y = oy;
+    let z = oz;
+    for (let i = 0; i <= n; i++) {
+      points[i * 3] = x;
+      points[i * 3 + 1] = y;
+      points[i * 3 + 2] = z;
+      radii[i] = radius * (1 - (1 - taper) * (i / n));
+      if (y > height) height = y;
+      if (i === n) break;
+      x += dx * step;
+      y += dy * step;
+      z += dz * step;
+      dy -= gravity * step * (level === 0 ? 0.2 : 1);
+      dx += (rng.float() - 0.5) * wobble;
+      dy += (rng.float() - 0.5) * wobble * 0.5;
+      dz += (rng.float() - 0.5) * wobble;
+      const len = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;
+      dx /= len;
+      dy /= len;
+      dz /= len;
+    }
+    const index = branches.length;
+    branches.push({ level, parent, points, radii });
+    if (level >= levels || children === 0) return;
+    const side = new Float64Array(3);
+    const other = new Float64Array(3);
+    const azimuth0 = rng.float() * Math.PI * 2;
+    for (let c = 0; c < children; c++) {
+      const t = start + (1 - start) * ((c + 0.3 + rng.float() * 0.4) / children);
+      const f = t * n;
+      const i = Math.min(n - 1, Math.floor(f));
+      const k = f - i;
+      const px = points[i * 3] + (points[i * 3 + 3] - points[i * 3]) * k;
+      const py = points[i * 3 + 1] + (points[i * 3 + 4] - points[i * 3 + 1]) * k;
+      const pz = points[i * 3 + 2] + (points[i * 3 + 5] - points[i * 3 + 2]) * k;
+      let tx = points[i * 3 + 3] - points[i * 3];
+      let ty = points[i * 3 + 4] - points[i * 3 + 1];
+      let tz = points[i * 3 + 5] - points[i * 3 + 2];
+      const tl = Math.sqrt(tx * tx + ty * ty + tz * tz) || 1;
+      tx /= tl;
+      ty /= tl;
+      tz /= tl;
+      perpendicular(tx, ty, tz, side);
+      other[0] = ty * side[2] - tz * side[1];
+      other[1] = tz * side[0] - tx * side[2];
+      other[2] = tx * side[1] - ty * side[0];
+      sinCos(azimuth0 + c * 2.399963229728653 + (rng.float() - 0.5) * 0.5, sc);
+      const sx = side[0] * sc[1] + other[0] * sc[0];
+      const sy = side[1] * sc[1] + other[1] * sc[0];
+      const sz = side[2] * sc[1] + other[2] * sc[0];
+      sinCos(spread * (0.8 + rng.float() * 0.4), sc);
+      let cx = tx * sc[1] + sx * sc[0];
+      let cy = ty * sc[1] + sy * sc[0];
+      let cz = tz * sc[1] + sz * sc[0];
+      const cl = Math.sqrt(cx * cx + cy * cy + cz * cz) || 1;
+      cx /= cl;
+      cy /= cl;
+      cz /= cl;
+      const r = radii[i] + (radii[i + 1] - radii[i]) * k;
+      const len = length * lengthScale * (1.15 - 0.4 * t) * (0.85 + rng.float() * 0.3);
+      grow(level + 1, index, px, py, pz, cx, cy, cz, len, r * radiusScale);
+    }
+  };
+  grow(0, -1, 0, 0, 0, 0, 1, 0, trunkLength, trunkRadius);
+  return { branches, height };
+}
+function tubeAlong(b, skeleton, options = {}) {
+  const first = b.vertexCount;
+  const sides = options.sides ?? 8;
+  const minSides = options.minSides ?? 3;
+  for (const branch of skeleton.branches) {
+    const s = Math.max(minSides, sides >> branch.level);
+    b.tube(branch.points, branch.radii, { sides: s, caps: true, vScale: options.vScale ?? 1 });
+  }
+  return first;
+}
+function leafCards(b, skeleton, options) {
+  const first = b.vertexCount;
+  const rng = new Rng(options.seed);
+  const deepest = skeleton.branches.reduce((m, br) => Math.max(m, br.level), 0);
+  const levels = new Set(options.levels ?? [deepest]);
+  const density = options.density ?? 6;
+  const size = options.size ?? 0.35;
+  const shape = options.shape ?? "leaf";
+  const cols = options.atlas?.[0] ?? 1;
+  const rows = options.atlas?.[1] ?? 1;
+  const droop = options.droop ?? 0.3;
+  const side = new Float64Array(3);
+  for (const branch of skeleton.branches) {
+    if (!levels.has(branch.level)) continue;
+    const p = branch.points;
+    const n = p.length / 3 - 1;
+    for (let i = 0; i < n; i++) {
+      const ax = p[i * 3];
+      const ay = p[i * 3 + 1];
+      const az = p[i * 3 + 2];
+      let tx = p[i * 3 + 3] - ax;
+      let ty = p[i * 3 + 4] - ay;
+      let tz = p[i * 3 + 5] - az;
+      const segment = Math.sqrt(tx * tx + ty * ty + tz * tz);
+      if (!(segment > 0)) continue;
+      tx /= segment;
+      ty /= segment;
+      tz /= segment;
+      const want = segment * density;
+      const cards = Math.floor(want) + (rng.float() < want - Math.floor(want) ? 1 : 0);
+      for (let c = 0; c < cards; c++) {
+        const t = rng.float();
+        const ox = ax + tx * segment * t;
+        const oy = ay + ty * segment * t;
+        const oz = az + tz * segment * t;
+        perpendicular(tx, ty, tz, side);
+        sinCos(rng.float() * Math.PI * 2, sc);
+        const bx = ty * side[2] - tz * side[1];
+        const by = tz * side[0] - tx * side[2];
+        const bz = tx * side[1] - ty * side[0];
+        let ux = side[0] * sc[1] + bx * sc[0] + tx * 0.5;
+        let uy = side[1] * sc[1] + by * sc[0] + ty * 0.5 - droop;
+        let uz = side[2] * sc[1] + bz * sc[0] + tz * 0.5;
+        const ul = Math.sqrt(ux * ux + uy * uy + uz * uz) || 1;
+        ux /= ul;
+        uy /= ul;
+        uz /= ul;
+        let wx = uy * 0 - uz * 1;
+        let wy = uz * 0 - ux * 0;
+        let wz = ux * 1 - uy * 0;
+        let wl = Math.sqrt(wx * wx + wy * wy + wz * wz);
+        if (wl < 1e-6) {
+          wx = 1;
+          wy = 0;
+          wz = 0;
+          wl = 1;
+        }
+        wx /= wl;
+        wy /= wl;
+        wz /= wl;
+        let nx = wy * uz - wz * uy;
+        let ny = wz * ux - wx * uz;
+        let nz = wx * uy - wy * ux;
+        if (ny < 0) {
+          nx = -nx;
+          ny = -ny;
+          nz = -nz;
+          wx = -wx;
+          wy = -wy;
+          wz = -wz;
+        }
+        const s = size * (0.75 + rng.float() * 0.5);
+        const cell = Math.floor(rng.float() * cols * rows);
+        const cu = cell % cols / cols;
+        const cv = Math.floor(cell / cols) / rows;
+        const outline = shape === "quad" ? [-0.5, 0, 0.5, 0, 0.5, 1, -0.5, 1] : [0, 0, 0.3, 0.3, 0.32, 0.65, 0, 1, -0.32, 0.65, -0.3, 0.3];
+        const count = outline.length / 2;
+        for (let face = 0; face < 2; face++) {
+          const sign = face === 0 ? 1 : -1;
+          const base = b.vertexCount;
+          for (let k = 0; k < count; k++) {
+            const a = outline[k * 2] * s;
+            const l = outline[k * 2 + 1] * s;
+            b.vertex(
+              ox + wx * a + ux * l,
+              oy + wy * a + uy * l,
+              oz + wz * a + uz * l,
+              nx * sign,
+              ny * sign,
+              nz * sign,
+              cu + (outline[k * 2] + 0.5) / cols,
+              cv + (1 - outline[k * 2 + 1]) / rows
+            );
+          }
+          for (let k = 1; k < count - 1; k++) {
+            if (face === 0) b.triangle(base, base + k, base + k + 1);
+            else b.triangle(base, base + k + 1, base + k);
+          }
+        }
+      }
+    }
+  }
+  return first;
+}
+export {
+  leafCards,
+  treeSkeleton,
+  tubeAlong
+};

package/dist/trig.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Sine and cosine from + and * only, so mesh code gets the same bits in V8, JavaScriptCore, and
+ * SpiderMonkey (their `Math.sin` differ in the last place). Accurate to about 1e-15 over any
+ * argument a mesh uses.
+ */
+/** Writes [sin t, cos t] into `out` (from index `o`). */
+export declare function sinCos(t: number, out: {
+    [i: number]: number;
+}, o?: number): void;
+/** Deterministic sine (see `sinCos`). */
+export declare function dsin(t: number): number;
+/** Deterministic cosine (see `sinCos`). */
+export declare function dcos(t: number): number;
+/** Degrees to radians. */
+export declare const DEG: number;