@aethervtt/shard-mesh 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @aethervtt/shard-mesh
+
+Part of [Shard](https://github.com/aethervtt/shard), a WebGPU-first 2D/3D game engine in TypeScript. See the repository for documentation.

package/dist/codec.d.ts

@@ -0,0 +1,4 @@
+import { Mesh, type MeshData } from './mesh.js';
+export declare function encodeMesh(data: MeshData | Mesh): Uint8Array;
+/** Decodes a mesh artifact. Arrays are views over `bytes` (copied only if misaligned). */
+export declare function decodeMesh(bytes: Uint8Array): Mesh;

package/dist/codec.js

@@ -0,0 +1,100 @@
+import { ShardError } from "@aethervtt/shard-core";
+import {
+  MESH_ATTRIBUTE_WIDTH,
+  MESH_ATTRIBUTES,
+  Mesh
+} from "./mesh.js";
+const MAGIC = 1397573715;
+const HEADER = 32;
+const align4 = (n) => n + 3 & ~3;
+function encodeMesh(data) {
+  const d = data instanceof Mesh ? data.data() : data;
+  const vertices = d.positions.length / 3;
+  const arrays = [d.positions];
+  let mask = 0;
+  MESH_ATTRIBUTES.forEach((a, i) => {
+    const arr = d[a];
+    if (arr) {
+      mask |= 1 << i;
+      arrays.push(arr);
+    }
+  });
+  const indexType = !d.indices ? 0 : d.indices instanceof Uint16Array ? 16 : 32;
+  if (d.indices) arrays.push(d.indices);
+  const targets = d.targets ?? [];
+  const morphMask = (targets.some((t) => t.normals) ? 1 : 0) | (targets.some((t) => t.tangents) ? 2 : 0);
+  for (const t of targets) {
+    arrays.push(t.positions);
+    if (morphMask & 1) arrays.push(t.normals ?? new Float32Array(vertices * 3));
+    if (morphMask & 2) arrays.push(t.tangents ?? new Float32Array(vertices * 3));
+  }
+  let size = HEADER;
+  for (const a of arrays) size += align4(a.byteLength);
+  const out = new Uint8Array(size);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, MAGIC, true);
+  view.setUint32(4, targets.length ? 2 : 1, true);
+  view.setUint32(8, vertices, true);
+  view.setUint32(12, d.indices?.length ?? 0, true);
+  view.setUint32(16, indexType, true);
+  view.setUint32(20, mask, true);
+  view.setUint32(24, targets.length, true);
+  view.setUint32(28, morphMask, true);
+  let offset = HEADER;
+  for (const a of arrays) {
+    out.set(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), offset);
+    offset += align4(a.byteLength);
+  }
+  return out;
+}
+function decodeMesh(bytes) {
+  if (bytes.byteOffset % 4 !== 0) bytes = bytes.slice();
+  if (bytes.byteLength < HEADER) throw invalid("is shorter than its header");
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (view.getUint32(0, true) !== MAGIC) throw invalid("has the wrong magic number");
+  const version = view.getUint32(4, true);
+  if (version !== 1 && version !== 2)
+    throw invalid(`has version ${version}; this engine reads 1 and 2`);
+  const vertices = view.getUint32(8, true);
+  const indexCount = view.getUint32(12, true);
+  const indexType = view.getUint32(16, true);
+  const mask = view.getUint32(20, true);
+  let offset = bytes.byteOffset + HEADER;
+  const end = bytes.byteOffset + bytes.byteLength;
+  const take = (ctor, n) => {
+    const byteLength = n * ctor.BYTES_PER_ELEMENT;
+    if (offset + byteLength > end) throw invalid("is truncated");
+    const arr = new ctor(bytes.buffer, offset, n);
+    offset += align4(byteLength);
+    return arr;
+  };
+  const data = { positions: take(Float32Array, vertices * 3) };
+  MESH_ATTRIBUTES.forEach((a, i) => {
+    if (!(mask & 1 << i)) return;
+    const n = vertices * MESH_ATTRIBUTE_WIDTH[a];
+    data[a] = a === "joints" ? take(Uint16Array, n) : take(Float32Array, n);
+  });
+  if (indexType === 16) data.indices = take(Uint16Array, indexCount);
+  else if (indexType === 32) data.indices = take(Uint32Array, indexCount);
+  if (version === 2) {
+    const count = view.getUint32(24, true);
+    const morphMask = view.getUint32(28, true);
+    data.targets = [];
+    for (let k = 0; k < count; k++) {
+      const target = { positions: take(Float32Array, vertices * 3) };
+      if (morphMask & 1) target.normals = take(Float32Array, vertices * 3);
+      if (morphMask & 2) target.tangents = take(Float32Array, vertices * 3);
+      data.targets.push(target);
+    }
+  }
+  return Mesh.trusted(data);
+}
+function invalid(what) {
+  return new ShardError("mesh/invalid-artifact", `Mesh artifact ${what}`, {
+    hint: "Re-import the source (`shard import --force`)."
+  });
+}
+export {
+  decodeMesh,
+  encodeMesh
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+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';

package/dist/index.js

@@ -0,0 +1,24 @@
+import { decodeMesh, encodeMesh } from "./codec.js";
+import {
+  MAX_MORPH_TARGETS,
+  MESH_ATTRIBUTE_WIDTH,
+  MESH_ATTRIBUTES,
+  Mesh
+} from "./mesh.js";
+import { box, capsule, cone, cube, cylinder, plane, sphere, torus } from "./primitives.js";
+export {
+  MAX_MORPH_TARGETS,
+  MESH_ATTRIBUTES,
+  MESH_ATTRIBUTE_WIDTH,
+  Mesh,
+  box,
+  capsule,
+  cone,
+  cube,
+  cylinder,
+  decodeMesh,
+  encodeMesh,
+  plane,
+  sphere,
+  torus
+};

package/dist/mesh.d.ts

@@ -0,0 +1,120 @@
+export interface MeshData {
+    /** xyz per vertex. */
+    positions: Float32Array;
+    /** xyz per vertex, unit length. */
+    normals?: Float32Array;
+    /** uv per vertex. */
+    uvs?: Float32Array;
+    /** rgba per vertex, linear. */
+    colors?: Float32Array;
+    /** xyzw per vertex: tangent direction plus handedness in w (glTF / MikkTSpace). */
+    tangents?: Float32Array;
+    /** Second uv set, per vertex. */
+    uvs1?: Float32Array;
+    /** Four joint indices per vertex (skinning). */
+    joints?: Uint16Array;
+    /** Four joint weights per vertex, summing to 1 (skinning). */
+    weights?: Float32Array;
+    indices?: Uint16Array | Uint32Array;
+    /** Morph targets (blend shapes): per-vertex deltas added by `render/MorphWeights`. */
+    targets?: MorphTarget[];
+}
+/** One morph target: deltas from the base mesh, xyz per vertex. */
+export interface MorphTarget {
+    positions: Float32Array;
+    normals?: Float32Array;
+    tangents?: Float32Array;
+}
+/**
+ * A mesh the GPU writes (compute shaders fill its vertex buffers): sizes and bounds, no CPU data.
+ * Every mesh passing the same `indices` array shares one GPU index buffer.
+ */
+export interface GpuMeshDescriptor {
+    vertexCount: number;
+    /** Triangles, shared: the renderer uploads each array once. */
+    indices: Uint16Array | Uint32Array;
+    /** Indices drawn (default: all of them), e.g. a prefix without skirt triangles. */
+    indexCount?: number;
+    /** Local-space bounds `[minX, minY, minZ, maxX, maxY, maxZ]` (update them when known). */
+    bounds: ArrayLike<number>;
+    /**
+     * Draw another GPU mesh's vertex buffers with these indices (a subset of its triangles) instead
+     * of owning buffers.
+     */
+    share?: Mesh;
+    /**
+     * Where this mesh's vertices start in `share`'s buffers (default: where `share`'s do), so many
+     * meshes can live in one set of buffers and draw without rebinding them.
+     */
+    baseVertex?: number;
+}
+/** Morph targets a mesh can blend at once (the vertex stage adds the heaviest ones). */
+export declare const MAX_MORPH_TARGETS = 8;
+export declare const MESH_ATTRIBUTES: readonly ['normals', 'uvs', 'colors', 'tangents', 'uvs1', 'joints', 'weights'];
+export type MeshAttribute = (typeof MESH_ATTRIBUTES)[number];
+export declare const MESH_ATTRIBUTE_WIDTH: Record<MeshAttribute, number>;
+/**
+ * Geometry on the CPU: separate attribute arrays plus optional indices. The renderer uploads it
+ * once per version; replace a mesh's data with `update` and the version bumps.
+ */
+export declare class Mesh {
+    positions: Float32Array;
+    normals: Float32Array | undefined;
+    uvs: Float32Array | undefined;
+    colors: Float32Array | undefined;
+    tangents: Float32Array | undefined;
+    uvs1: Float32Array | undefined;
+    joints: Uint16Array | undefined;
+    weights: Float32Array | undefined;
+    indices: Uint16Array | Uint32Array | undefined;
+    targets: MorphTarget[] | undefined;
+    /**
+     * Local-space bounds: `[minX, minY, minZ, maxX, maxY, maxZ]`. With morph targets, they cover
+     * every blend of weights in [0, 1].
+     */
+    readonly bounds: Float32Array<ArrayBufferLike>;
+    /** Increments on `update`, so GPU copies know to re-upload. */
+    version: number;
+    /**
+     * Set for meshes the GPU writes (`Mesh.gpu`): their vertex buffers are storage buffers with no
+     * CPU copy; `positions` is empty.
+     */
+    gpu: Readonly<{
+        vertexCount: number;
+        indexCount: number;
+        indices: Uint16Array | Uint32Array;
+        share: Mesh | undefined;
+        baseVertex: number;
+    }> | undefined;
+    private constructor();
+    static create(data: MeshData): Mesh;
+    /**
+     * A mesh whose vertex buffers the GPU fills: positions, normals, uvs, uvs1, and tangents as
+     * separate storage + vertex buffers (f32, 3/3/2/2/4 per vertex), written by a compute pass and
+     * drawn like any mesh. Terrain chunks (0043) and GPU foliage (0045) use it.
+     */
+    static gpu(desc: GpuMeshDescriptor): Mesh;
+    /**
+     * Draws a GPU mesh (`Mesh.gpu`) with other triangles over the same vertices: another shared
+     * index array (and count). Cheap: the vertex buffers stay, and its batch stays the same.
+     */
+    setIndices(indices: Uint16Array | Uint32Array, indexCount?: number): void;
+    /**
+     * A mesh from data already validated (artifacts the importer checked): attribute lengths are
+     * still checked, but the per-index range scan is skipped, which dominates load time for big meshes.
+     */
+    static trusted(data: MeshData): Mesh;
+    private static skipIndexCheck;
+    get vertexCount(): number;
+    /** Whether draws are indexed: CPU meshes with indices, and every GPU mesh. */
+    get indexed(): boolean;
+    /** Where the mesh's vertices start in its vertex buffers (non-zero only for shared GPU meshes). */
+    get baseVertex(): number;
+    /** Vertices drawn: the index count, or the vertex count for non-indexed meshes. */
+    get drawCount(): number;
+    update(data: MeshData): void;
+    private assign;
+    /** The mesh's data as plain arrays (shared, not copied). */
+    data(): MeshData;
+    private validate;
+}

package/dist/mesh.js

@@ -0,0 +1,202 @@
+import { aabb, ShardError } from "@aethervtt/shard-core";
+const MAX_MORPH_TARGETS = 8;
+const MESH_ATTRIBUTES = [
+  "normals",
+  "uvs",
+  "colors",
+  "tangents",
+  "uvs1",
+  "joints",
+  "weights"
+];
+const MESH_ATTRIBUTE_WIDTH = {
+  normals: 3,
+  uvs: 2,
+  colors: 4,
+  tangents: 4,
+  uvs1: 2,
+  joints: 4,
+  weights: 4
+};
+class Mesh {
+  positions;
+  normals;
+  uvs;
+  colors;
+  tangents;
+  uvs1;
+  joints;
+  weights;
+  indices;
+  targets;
+  /**
+   * Local-space bounds: `[minX, minY, minZ, maxX, maxY, maxZ]`. With morph targets, they cover
+   * every blend of weights in [0, 1].
+   */
+  bounds = aabb.create();
+  /** Increments on `update`, so GPU copies know to re-upload. */
+  version = 0;
+  /**
+   * Set for meshes the GPU writes (`Mesh.gpu`): their vertex buffers are storage buffers with no
+   * CPU copy; `positions` is empty.
+   */
+  gpu;
+  constructor(data) {
+    if (data) this.assign(data);
+  }
+  static create(data) {
+    return new Mesh(data);
+  }
+  /**
+   * A mesh whose vertex buffers the GPU fills: positions, normals, uvs, uvs1, and tangents as
+   * separate storage + vertex buffers (f32, 3/3/2/2/4 per vertex), written by a compute pass and
+   * drawn like any mesh. Terrain chunks (0043) and GPU foliage (0045) use it.
+   */
+  static gpu(desc) {
+    const mesh = new Mesh(void 0);
+    mesh.positions = new Float32Array(0);
+    mesh.indices = void 0;
+    mesh.gpu = {
+      vertexCount: desc.vertexCount,
+      indexCount: desc.indexCount ?? desc.indices.length,
+      indices: desc.indices,
+      share: desc.share,
+      baseVertex: desc.baseVertex ?? desc.share?.baseVertex ?? 0
+    };
+    for (let i = 0; i < 6; i++) mesh.bounds[i] = desc.bounds[i];
+    return mesh;
+  }
+  /**
+   * Draws a GPU mesh (`Mesh.gpu`) with other triangles over the same vertices: another shared
+   * index array (and count). Cheap: the vertex buffers stay, and its batch stays the same.
+   */
+  setIndices(indices, indexCount = indices.length) {
+    const g = this.gpu;
+    if (!g) {
+      throw new ShardError("mesh/not-gpu", "setIndices is for GPU meshes (Mesh.gpu)", {
+        hint: "Change a CPU mesh with update()."
+      });
+    }
+    if (g.indices === indices && g.indexCount === indexCount) return;
+    this.gpu = { ...g, indices, indexCount };
+    this.version++;
+  }
+  /**
+   * A mesh from data already validated (artifacts the importer checked): attribute lengths are
+   * still checked, but the per-index range scan is skipped, which dominates load time for big meshes.
+   */
+  static trusted(data) {
+    Mesh.skipIndexCheck = true;
+    try {
+      return new Mesh(data);
+    } finally {
+      Mesh.skipIndexCheck = false;
+    }
+  }
+  static skipIndexCheck = false;
+  get vertexCount() {
+    return this.gpu ? this.gpu.vertexCount : this.positions.length / 3;
+  }
+  /** Whether draws are indexed: CPU meshes with indices, and every GPU mesh. */
+  get indexed() {
+    return this.gpu !== void 0 || this.indices !== void 0;
+  }
+  /** Where the mesh's vertices start in its vertex buffers (non-zero only for shared GPU meshes). */
+  get baseVertex() {
+    return this.gpu ? this.gpu.baseVertex : 0;
+  }
+  /** Vertices drawn: the index count, or the vertex count for non-indexed meshes. */
+  get drawCount() {
+    if (this.gpu) return this.gpu.indexCount;
+    return this.indices ? this.indices.length : this.vertexCount;
+  }
+  update(data) {
+    this.gpu = void 0;
+    this.assign(data);
+    this.version++;
+  }
+  assign(data) {
+    this.positions = data.positions;
+    this.normals = data.normals;
+    this.uvs = data.uvs;
+    this.colors = data.colors;
+    this.tangents = data.tangents;
+    this.uvs1 = data.uvs1;
+    this.joints = data.joints;
+    this.weights = data.weights;
+    this.indices = data.indices;
+    this.targets = data.targets?.length ? data.targets : void 0;
+    this.validate();
+  }
+  /** The mesh's data as plain arrays (shared, not copied). */
+  data() {
+    const out = { positions: this.positions };
+    for (const a of MESH_ATTRIBUTES)
+      if (this[a]) out[a] = this[a];
+    if (this.indices) out.indices = this.indices;
+    if (this.targets) out.targets = this.targets;
+    return out;
+  }
+  validate() {
+    const n = this.positions.length / 3;
+    const bad = (what) => new ShardError("mesh/invalid", `Mesh ${what}`, {
+      hint: "positions/normals: 3 per vertex, uvs/uvs1: 2, colors/tangents/joints/weights: 4; indices must be < vertex count."
+    });
+    if (!Number.isInteger(n) || n === 0)
+      throw bad(`has ${this.positions.length} position floats (need a multiple of 3, > 0)`);
+    for (const a of MESH_ATTRIBUTES) {
+      const arr = this[a];
+      if (arr && arr.length !== n * MESH_ATTRIBUTE_WIDTH[a])
+        throw bad(`has ${arr.length / MESH_ATTRIBUTE_WIDTH[a]} ${a} for ${n} vertices`);
+    }
+    if (this.indices) {
+      if (this.indices.length % 3 !== 0)
+        throw bad(`has ${this.indices.length} indices (need triangles)`);
+      for (let i = 0; !Mesh.skipIndexCheck && i < this.indices.length; i++) {
+        if (this.indices[i] >= n)
+          throw bad(`index ${this.indices[i]} is out of range (${n} vertices)`);
+      }
+    }
+    for (const [k, target] of (this.targets ?? []).entries()) {
+      for (const a of ["positions", "normals", "tangents"]) {
+        const arr = target[a];
+        if (arr && arr.length !== n * 3)
+          throw bad(`morph target ${k} has ${arr.length / 3} ${a} for ${n} vertices`);
+      }
+      if (!target.positions) throw bad(`morph target ${k} has no positions`);
+    }
+    aabb.fromPoints(this.bounds, this.positions);
+    if (this.targets) {
+      const b = this.bounds;
+      for (const target of this.targets) {
+        const d = target.positions;
+        let lx = 0;
+        let ly = 0;
+        let lz = 0;
+        let hx = 0;
+        let hy = 0;
+        let hz = 0;
+        for (let i = 0; i < d.length; i += 3) {
+          lx = Math.min(lx, d[i]);
+          ly = Math.min(ly, d[i + 1]);
+          lz = Math.min(lz, d[i + 2]);
+          hx = Math.max(hx, d[i]);
+          hy = Math.max(hy, d[i + 1]);
+          hz = Math.max(hz, d[i + 2]);
+        }
+        b[0] = b[0] + lx;
+        b[1] = b[1] + ly;
+        b[2] = b[2] + lz;
+        b[3] = b[3] + hx;
+        b[4] = b[4] + hy;
+        b[5] = b[5] + hz;
+      }
+    }
+  }
+}
+export {
+  MAX_MORPH_TARGETS,
+  MESH_ATTRIBUTES,
+  MESH_ATTRIBUTE_WIDTH,
+  Mesh
+};

package/dist/primitives.d.ts

@@ -0,0 +1,48 @@
+import { Mesh } from './mesh.js';
+/** Axis-aligned box with the given full extents. */
+export declare function box(options?: {
+    x?: number;
+    y?: number;
+    z?: number;
+}): Mesh;
+export declare function cube(options?: {
+    size?: number;
+}): Mesh;
+/** UV sphere. The seam column is duplicated so UVs wrap cleanly; normals match across it. */
+export declare function sphere(options?: {
+    radius?: number;
+    segments?: number;
+    rings?: number;
+}): Mesh;
+/** Flat square in the XZ plane, facing +Y, optionally subdivided (terrain, water, floors). */
+export declare function plane(options?: {
+    size?: number;
+    subdivisions?: number;
+}): Mesh;
+/** Cylinder (or cone, with `radiusTop: 0`) along Y, with caps. */
+export declare function cylinder(options?: {
+    radius?: number;
+    radiusTop?: number;
+    height?: number;
+    segments?: number;
+    caps?: boolean;
+}): Mesh;
+export declare function cone(options?: {
+    radius?: number;
+    height?: number;
+    segments?: number;
+}): Mesh;
+/** Capsule along Y: `height` is the full height including the hemispherical ends. */
+export declare function capsule(options?: {
+    radius?: number;
+    height?: number;
+    segments?: number;
+    rings?: number;
+}): Mesh;
+/** Torus in the XZ plane. */
+export declare function torus(options?: {
+    radius?: number;
+    tube?: number;
+    radialSegments?: number;
+    tubularSegments?: number;
+}): Mesh;

package/dist/primitives.js

@@ -0,0 +1,241 @@
+import { Mesh } from "./mesh.js";
+class Builder {
+  positions = [];
+  normals = [];
+  uvs = [];
+  indices = [];
+  vertex(p, n, uv) {
+    this.positions.push(p[0], p[1], p[2]);
+    this.normals.push(n[0], n[1], n[2]);
+    this.uvs.push(uv[0], uv[1]);
+    return this.positions.length / 3 - 1;
+  }
+  triangle(a, b, c) {
+    this.indices.push(a, b, c);
+  }
+  quad(a, b, c, d) {
+    this.indices.push(a, b, c, a, c, d);
+  }
+  build() {
+    const count = this.positions.length / 3;
+    return Mesh.create({
+      positions: new Float32Array(this.positions),
+      normals: new Float32Array(this.normals),
+      uvs: new Float32Array(this.uvs),
+      indices: count > 65535 ? new Uint32Array(this.indices) : new Uint16Array(this.indices)
+    });
+  }
+}
+function box(options = {}) {
+  const hx = (options.x ?? 1) / 2;
+  const hy = (options.y ?? 1) / 2;
+  const hz = (options.z ?? 1) / 2;
+  const b = new Builder();
+  const faces = [
+    [
+      [1, 0, 0],
+      [0, 0, -1],
+      [0, 1, 0]
+    ],
+    [
+      [-1, 0, 0],
+      [0, 0, 1],
+      [0, 1, 0]
+    ],
+    [
+      [0, 1, 0],
+      [1, 0, 0],
+      [0, 0, -1]
+    ],
+    [
+      [0, -1, 0],
+      [1, 0, 0],
+      [0, 0, 1]
+    ],
+    [
+      [0, 0, 1],
+      [1, 0, 0],
+      [0, 1, 0]
+    ],
+    [
+      [0, 0, -1],
+      [-1, 0, 0],
+      [0, 1, 0]
+    ]
+  ];
+  const h = [hx, hy, hz];
+  for (const [n, u, v] of faces) {
+    const corner = (su, sv) => [0, 1, 2].map((k) => (n[k] + u[k] * su + v[k] * sv) * h[k]);
+    const a = b.vertex(corner(-1, -1), n, [0, 1]);
+    const c = b.vertex(corner(1, -1), n, [1, 1]);
+    const d = b.vertex(corner(1, 1), n, [1, 0]);
+    const e = b.vertex(corner(-1, 1), n, [0, 0]);
+    b.quad(a, c, d, e);
+  }
+  return b.build();
+}
+function cube(options = {}) {
+  const s = options.size ?? 1;
+  return box({ x: s, y: s, z: s });
+}
+function sphere(options = {}) {
+  const radius = options.radius ?? 0.5;
+  const segments = Math.max(3, options.segments ?? 32);
+  const rings = Math.max(2, options.rings ?? Math.ceil(segments / 2));
+  const b = new Builder();
+  for (let r = 0; r <= rings; r++) {
+    const v = r / rings;
+    const phi = v * Math.PI;
+    for (let s = 0; s <= segments; s++) {
+      const u = s / segments;
+      const theta = u * Math.PI * 2;
+      const n = [Math.sin(phi) * Math.sin(theta), Math.cos(phi), Math.sin(phi) * Math.cos(theta)];
+      b.vertex([n[0] * radius, n[1] * radius, n[2] * radius], n, [u, v]);
+    }
+  }
+  const row = segments + 1;
+  for (let r = 0; r < rings; r++) {
+    for (let s = 0; s < segments; s++) {
+      const a = r * row + s;
+      const c = a + row;
+      if (r !== 0) b.triangle(a, c, a + 1);
+      if (r !== rings - 1) b.triangle(a + 1, c, c + 1);
+    }
+  }
+  return b.build();
+}
+function plane(options = {}) {
+  const size = options.size ?? 1;
+  const n = Math.max(1, options.subdivisions ?? 1);
+  const b = new Builder();
+  for (let z = 0; z <= n; z++) {
+    for (let x = 0; x <= n; x++) {
+      b.vertex([(x / n - 0.5) * size, 0, (z / n - 0.5) * size], [0, 1, 0], [x / n, z / n]);
+    }
+  }
+  for (let z = 0; z < n; z++) {
+    for (let x = 0; x < n; x++) {
+      const a = z * (n + 1) + x;
+      b.quad(a, a + n + 1, a + n + 2, a + 1);
+    }
+  }
+  return b.build();
+}
+function cylinder(options = {}) {
+  const r0 = options.radius ?? 0.5;
+  const r1 = options.radiusTop ?? r0;
+  const h = options.height ?? 1;
+  const segments = Math.max(3, options.segments ?? 32);
+  const b = new Builder();
+  const slope = (r0 - r1) / h;
+  const ny = slope / Math.sqrt(1 + slope * slope);
+  const nr = 1 / Math.sqrt(1 + slope * slope);
+  for (let s = 0; s <= segments; s++) {
+    const u = s / segments;
+    const t = u * Math.PI * 2;
+    const sin = Math.sin(t);
+    const cos = Math.cos(t);
+    const n = [sin * nr, ny, cos * nr];
+    b.vertex([sin * r0, -h / 2, cos * r0], n, [u, 1]);
+    b.vertex([sin * r1, h / 2, cos * r1], n, [u, 0]);
+  }
+  for (let s = 0; s < segments; s++) {
+    const a = s * 2;
+    if (r1 === 0) b.triangle(a, a + 2, a + 1);
+    else b.quad(a, a + 2, a + 3, a + 1);
+  }
+  if (options.caps ?? true) {
+    for (const [y, sign, radius] of [
+      [h / 2, 1, r1],
+      [-h / 2, -1, r0]
+    ]) {
+      if (radius === 0) continue;
+      const center = b.vertex([0, y, 0], [0, sign, 0], [0.5, 0.5]);
+      const first = b.positions.length / 3;
+      for (let s = 0; s <= segments; s++) {
+        const t = s / segments * Math.PI * 2;
+        b.vertex(
+          [Math.sin(t) * radius, y, Math.cos(t) * radius],
+          [0, sign, 0],
+          [0.5 + Math.sin(t) / 2, 0.5 - Math.cos(t) / 2]
+        );
+      }
+      for (let s = 0; s < segments; s++) {
+        if (sign > 0) b.triangle(center, first + s, first + s + 1);
+        else b.triangle(center, first + s + 1, first + s);
+      }
+    }
+  }
+  return b.build();
+}
+function cone(options = {}) {
+  return cylinder({ ...options, radiusTop: 0 });
+}
+function capsule(options = {}) {
+  const radius = options.radius ?? 0.5;
+  const height = Math.max(options.height ?? 2, radius * 2);
+  const segments = Math.max(3, options.segments ?? 32);
+  const ringsPerCap = Math.max(2, options.rings ?? 8);
+  const half = height / 2 - radius;
+  const b = new Builder();
+  const rows = [];
+  for (let r = 0; r <= ringsPerCap; r++) rows.push([r / ringsPerCap * (Math.PI / 2), half]);
+  for (let r = 0; r <= ringsPerCap; r++)
+    rows.push([Math.PI / 2 + r / ringsPerCap * (Math.PI / 2), -half]);
+  rows.forEach(([phi, offset], r) => {
+    for (let s = 0; s <= segments; s++) {
+      const u = s / segments;
+      const theta = u * Math.PI * 2;
+      const n = [Math.sin(phi) * Math.sin(theta), Math.cos(phi), Math.sin(phi) * Math.cos(theta)];
+      b.vertex([n[0] * radius, n[1] * radius + offset, n[2] * radius], n, [
+        u,
+        r / (rows.length - 1)
+      ]);
+    }
+  });
+  const row = segments + 1;
+  for (let r = 0; r < rows.length - 1; r++) {
+    for (let s = 0; s < segments; s++) {
+      const a = r * row + s;
+      const c = a + row;
+      if (r !== rows.length - 2) b.triangle(a, c, c + 1);
+      if (r !== 0) b.triangle(a, c + 1, a + 1);
+    }
+  }
+  return b.build();
+}
+function torus(options = {}) {
+  const R = options.radius ?? 0.5;
+  const r = options.tube ?? 0.2;
+  const radial = Math.max(3, options.radialSegments ?? 16);
+  const tubular = Math.max(3, options.tubularSegments ?? 48);
+  const b = new Builder();
+  for (let j = 0; j <= radial; j++) {
+    const v = j / radial * Math.PI * 2;
+    for (let i = 0; i <= tubular; i++) {
+      const u = i / tubular * Math.PI * 2;
+      const cx = Math.sin(u) * R;
+      const cz = Math.cos(u) * R;
+      const n = [Math.sin(u) * Math.cos(v), Math.sin(v), Math.cos(u) * Math.cos(v)];
+      b.vertex([cx + n[0] * r, n[1] * r, cz + n[2] * r], n, [i / tubular, j / radial]);
+    }
+  }
+  const row = tubular + 1;
+  for (let j = 0; j < radial; j++) {
+    for (let i = 0; i < tubular; i++) {
+      const a = j * row + i;
+      b.quad(a, a + 1, a + row + 1, a + row);
+    }
+  }
+  return b.build();
+}
+export {
+  box,
+  capsule,
+  cone,
+  cube,
+  cylinder,
+  plane,
+  sphere,
+  torus
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@aethervtt/shard-mesh",
+  "version": "0.0.1",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@aethervtt/shard-core": "0.0.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aethervtt/shard.git",
+    "directory": "packages/mesh"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "shard": {
+    "buildSha": "d6c5c6aef4675575c878b02cf2c8f738b4190229"
+  }
+}