@aethervtt/shard-procgen 0.1.0 → 0.2.1

package/dist/engine/generators.d.ts

@@ -0,0 +1,67 @@
+export declare const RockGenerator: import("..").Generator<{
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly roughness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly flatness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly facets: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly detail: import("@aethervtt/shard-core").FieldType<number, "u8">;
+}, "mesh">;
+export declare const TreeGenerator: import("..").Generator<{
+    readonly height: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly trunkRadius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly levels: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly branching: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly spread: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly leafDensity: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly leafSize: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}, "mesh">;
+export declare const BushGenerator: import("..").Generator<{
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly stems: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly leafDensity: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}, "mesh">;
+export declare const GrassClumpGenerator: import("..").Generator<{
+    readonly blades: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly height: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly width: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly bend: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly spread: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}, "mesh">;
+export declare const CrystalGenerator: import("..").Generator<{
+    readonly count: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly length: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly spread: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly sides: import("@aethervtt/shard-core").FieldType<number, "u8">;
+}, "mesh">;
+/** Every engine generator (importing this module defines them). */
+export declare const ENGINE_GENERATORS: readonly [import("..").Generator<{
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly roughness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly flatness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly facets: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly detail: import("@aethervtt/shard-core").FieldType<number, "u8">;
+}, "mesh">, import("..").Generator<{
+    readonly height: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly trunkRadius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly levels: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly branching: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly spread: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly leafDensity: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly leafSize: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}, "mesh">, import("..").Generator<{
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly stems: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly leafDensity: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}, "mesh">, import("..").Generator<{
+    readonly blades: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly height: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly width: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly bend: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly spread: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}, "mesh">, import("..").Generator<{
+    readonly count: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly length: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly spread: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly sides: import("@aethervtt/shard-core").FieldType<number, "u8">;
+}, "mesh">];

package/dist/engine/generators.js

@@ -0,0 +1,355 @@
+import { Rng, t } from "@aethervtt/shard-core";
+import { DEG, sinCos } from "@aethervtt/shard-mesh";
+import { defineGenerator } from "../generator.js";
+import { fbm } from "./shape-noise.js";
+const sc = new Float64Array(2);
+function standOnGround(b, sink) {
+  let lo = Number.POSITIVE_INFINITY;
+  let hi = Number.NEGATIVE_INFINITY;
+  for (let i = 0; i < b.vertexCount; i++) {
+    const y = b.positions[i * 3 + 1];
+    if (y < lo) lo = y;
+    if (y > hi) hi = y;
+  }
+  b.translate(0, -lo - (hi - lo) * sink, 0);
+}
+const RockGenerator = defineGenerator("shard/Rock", {
+  description: "A boulder: a noisy, faceted, flattened icosphere sitting on its origin, part-buried. LODs at 50% and 20%.",
+  params: {
+    radius: t.f32({ default: 1, min: 0.05, unit: "m", description: "Rough size before noise." }),
+    roughness: t.f32({
+      default: 0.5,
+      min: 0,
+      max: 1,
+      description: "Lumpiness: 0 smooth, 1 craggy."
+    }),
+    flatness: t.f32({
+      default: 0.3,
+      min: 0,
+      max: 1,
+      description: "Squash toward a slab: 0 round, 1 flat."
+    }),
+    facets: t.u8({
+      default: 6,
+      max: 32,
+      description: "Flat cuts across the surface, for fractured stone (0: none)."
+    }),
+    detail: t.u8({
+      default: 4,
+      min: 1,
+      max: 6,
+      description: "Icosphere subdivisions: 4 is 2 562 vertices."
+    })
+  },
+  output: "mesh",
+  version: 1,
+  run(ctx, p) {
+    const b = ctx.mesh.create().icosphere(p.detail, 1);
+    const rng = ctx.rng;
+    const sx = 0.85 + rng.float() * 0.3;
+    const sz = 0.85 + rng.float() * 0.3;
+    const sy = (0.75 + rng.float() * 0.25) * (1 - 0.6 * p.flatness);
+    b.scale(sx, sy, sz);
+    const pos = b.positions;
+    for (let f = 0; f < p.facets; f++) {
+      let x = rng.float() * 2 - 1;
+      let y = rng.float() * 1.6 - 0.4;
+      let z = rng.float() * 2 - 1;
+      const len = Math.sqrt(x * x + y * y + z * z) || 1;
+      x /= len;
+      y /= len;
+      z /= len;
+      const d = 0.62 + rng.float() * 0.25;
+      for (let i = 0; i < b.vertexCount; i++) {
+        const k = pos[i * 3] * x + pos[i * 3 + 1] * y + pos[i * 3 + 2] * z - d;
+        if (k <= 0) continue;
+        pos[i * 3] = pos[i * 3] - x * k;
+        pos[i * 3 + 1] = pos[i * 3 + 1] - y * k;
+        pos[i * 3 + 2] = pos[i * 3 + 2] - z * k;
+      }
+    }
+    b.normals();
+    const seed = ctx.childSeed("shape");
+    b.displace((q) => p.roughness * 0.22 * fbm(seed, q[0] * 1.7, q[1] * 1.7, q[2] * 1.7, 4));
+    b.scale(p.radius);
+    standOnGround(b, 0.15);
+    for (let i = 0; i < b.vertexCount; i++) {
+      const q = b.positions;
+      const shade = 0.5 + 0.5 * fbm(seed + 7, q[i * 3] * 3, q[i * 3 + 1] * 3, q[i * 3 + 2] * 3, 2);
+      b.uv1(i, 0, shade);
+    }
+    b.normals({ angle: p.facets > 0 ? 50 : 180 }).uvsTriplanar(Math.max(0.25, p.radius));
+    return ctx.mesh.finish(b, { tangents: true, lods: [0.5, 0.2] });
+  }
+});
+const TreeGenerator = defineGenerator("shard/Tree", {
+  description: "A broadleaf tree: a branching skeleton skinned with tubes, leaf cards on the outer branches. LODs at 40% and 12%.",
+  params: {
+    height: t.f32({ default: 8, min: 0.5, unit: "m", description: "About how tall it grows." }),
+    trunkRadius: t.f32({ default: 0.22, min: 0.01, unit: "m" }),
+    levels: t.u8({ default: 2, max: 4, description: "Branching levels below the trunk." }),
+    branching: t.u8({ default: 5, min: 1, max: 12, description: "Children per branch." }),
+    spread: t.f32({
+      default: 42,
+      min: 0,
+      max: 90,
+      unit: "deg",
+      description: "Angle between a branch and its parent."
+    }),
+    leafDensity: t.f32({
+      default: 10,
+      min: 0,
+      description: "Leaf cards per metre of outer branch."
+    }),
+    leafSize: t.f32({ default: 0.45, min: 0.01, unit: "m" })
+  },
+  output: "mesh",
+  version: 1,
+  run(ctx, p) {
+    const b = ctx.mesh.create();
+    const sk = ctx.mesh.treeSkeleton({
+      seed: ctx.childSeed("skeleton"),
+      trunk: { length: p.height * 0.55, radius: p.trunkRadius, segments: 8 },
+      levels: p.levels,
+      branches: p.branching,
+      spread: p.spread,
+      lengthScale: 0.62,
+      start: 0.4,
+      gravity: 0.05
+    });
+    ctx.mesh.tubeAlong(b, sk, { sides: 8 });
+    b.uv1All(0, 0.5);
+    const leaves = ctx.mesh.leafCards(b, sk, {
+      seed: ctx.childSeed("leaves"),
+      density: p.leafDensity,
+      size: p.leafSize,
+      levels: p.levels > 0 ? [p.levels, Math.max(1, p.levels - 1)] : [0]
+    });
+    shadeCards(b, leaves, ctx.rng);
+    return ctx.mesh.finish(b, { lods: [0.4, 0.12] });
+  }
+});
+const BushGenerator = defineGenerator("shard/Bush", {
+  description: "A shrub: several short branching stems from one point, densely leaved. LODs at 40% and 12%.",
+  params: {
+    radius: t.f32({ default: 0.8, min: 0.05, unit: "m", description: "About how wide it grows." }),
+    stems: t.u8({ default: 6, min: 1, max: 24 }),
+    leafDensity: t.f32({ default: 18, min: 0, description: "Leaf cards per metre of branch." })
+  },
+  output: "mesh",
+  version: 1,
+  run(ctx, p) {
+    const b = ctx.mesh.create();
+    const rng = ctx.rng;
+    let leaves = -1;
+    for (let s = 0; s < p.stems; s++) {
+      const sk = ctx.mesh.treeSkeleton({
+        seed: ctx.childSeed(`stem${s}`),
+        trunk: {
+          length: p.radius * (0.9 + rng.float() * 0.5),
+          radius: p.radius * 0.025,
+          segments: 4
+        },
+        levels: 1,
+        branches: 3,
+        spread: 35,
+        lengthScale: 0.6,
+        gravity: 0.2,
+        start: 0.3
+      });
+      sinCos(s / p.stems * Math.PI * 2 + rng.float() * 0.6, sc);
+      const lean = 0.5 + rng.float() * 0.35;
+      sinCos(lean, sc2);
+      const ax = sc[1];
+      const az = sc[0];
+      const first = b.vertexCount;
+      ctx.mesh.tubeAlong(b, sk, { sides: 5 });
+      b.uv1All(0, 0.4, first);
+      const cards = ctx.mesh.leafCards(b, sk, {
+        seed: ctx.childSeed(`leaves${s}`),
+        density: p.leafDensity,
+        size: p.radius * 0.3,
+        levels: [0, 1],
+        droop: 0.1
+      });
+      if (leaves < 0) leaves = cards;
+      shadeCards(b, cards, rng);
+      b.transform(rotationAbout(-az, 0, ax, sc2[0], sc2[1]), first);
+    }
+    return ctx.mesh.finish(b, { lods: [0.4, 0.12] });
+  }
+});
+const sc2 = new Float64Array(2);
+const GrassClumpGenerator = defineGenerator("shard/GrassClump", {
+  description: "A clump of grass blades: tapered, bent strips from one root. One-sided (foliage draws two-sided); uv1.x runs 0 at the root to 1 at the tip, for wind and tint. LODs: 5/8 of the blades, wider, at 2 segments; then 5/16 at 1 (a triangle each).",
+  params: {
+    blades: t.u8({ default: 12, min: 1, max: 64 }),
+    height: t.f32({ default: 0.55, min: 0.01, unit: "m" }),
+    width: t.f32({
+      default: 0.045,
+      min: 1e-3,
+      unit: "m",
+      description: "Blade width at the root."
+    }),
+    bend: t.f32({ default: 0.35, min: 0, max: 1, description: "How far blades curve over." }),
+    spread: t.f32({
+      default: 0.18,
+      min: 0,
+      unit: "m",
+      description: "Radius the roots scatter over."
+    })
+  },
+  output: "mesh",
+  version: 2,
+  run(ctx, p) {
+    const clump = (segments, keep) => {
+      const b = ctx.mesh.create();
+      const rng = new Rng(ctx.childSeed("blades"));
+      for (let k = 0; k < p.blades; k++) {
+        sinCos(rng.float() * Math.PI * 2, sc);
+        const r = Math.sqrt(rng.float()) * p.spread;
+        const rx = sc[1] * r;
+        const rz = sc[0] * r;
+        const dx = r > 0 ? rx / r : 1;
+        const dz = r > 0 ? rz / r : 0;
+        sinCos(r > 0 ? (rng.float() - 0.5) * 1.2 : rng.float() * Math.PI * 2, sc);
+        const fx = dx * sc[1] - dz * sc[0];
+        const fz = dx * sc[0] + dz * sc[1];
+        const h = p.height * (0.6 + rng.float() * 0.5);
+        const w = p.width * (0.7 + rng.float() * 0.6) / keep;
+        const bend = p.bend * (0.5 + rng.float());
+        const shade = rng.float();
+        if (k * 0.618033988749895 % 1 >= keep) continue;
+        const first = b.vertexCount;
+        const rows = segments === 1 ? 1 : segments + 1;
+        for (let s = 0; s < rows; s++) {
+          const f = s / segments;
+          const out = bend * h * f * f;
+          const y = h * f * (1 - 0.35 * bend * f);
+          const half = w / 2 * (1 - f * 0.92);
+          const cx = rx + fx * out;
+          const cz = rz + fz * out;
+          const wx = -fz * half;
+          const wz = fx * half;
+          const ty = h * (1 - 0.7 * bend * f);
+          const tf = 2 * bend * h * f;
+          const nx = fx * ty;
+          const ny = -tf;
+          const nz = fz * ty;
+          const nl = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+          b.vertex(cx - wx, y, cz - wz, nx / nl, ny / nl, nz / nl, 0, 1 - f);
+          b.vertex(cx + wx, y, cz + wz, nx / nl, ny / nl, nz / nl, 1, 1 - f);
+          b.uv1(first + s * 2, f, shade);
+          b.uv1(first + s * 2 + 1, f, shade);
+        }
+        if (segments === 1) {
+          const out = bend * h;
+          const tip = b.vertex(
+            rx + fx * out,
+            h * (1 - 0.35 * bend),
+            rz + fz * out,
+            fx * h * (1 - 0.7 * bend),
+            -2 * bend * h,
+            fz * h * (1 - 0.7 * bend),
+            0.5,
+            0
+          );
+          b.uv1(tip, 1, shade);
+          b.triangle(first, tip, first + 1);
+          continue;
+        }
+        for (let s = 0; s < segments; s++) {
+          const a = first + s * 2;
+          b.quad(a, a + 2, a + 3, a + 1);
+        }
+      }
+      return b.finish();
+    };
+    return { kind: "mesh", mesh: clump(4, 1), lods: [clump(2, 0.625), clump(1, 0.3125)] };
+  }
+});
+const CrystalGenerator = defineGenerator("shard/Crystal", {
+  description: "A crystal cluster: pointed prisms fanning out from a base, with hard edges. LODs at 50% and 20%.",
+  params: {
+    count: t.u8({ default: 6, min: 1, max: 32, description: "Prisms in the cluster." }),
+    length: t.f32({ default: 1.2, min: 0.01, unit: "m", description: "The longest prism." }),
+    radius: t.f32({ default: 0.14, min: 5e-3, unit: "m" }),
+    spread: t.f32({
+      default: 28,
+      min: 0,
+      max: 80,
+      unit: "deg",
+      description: "How far prisms tilt from upright."
+    }),
+    sides: t.u8({ default: 6, min: 3, max: 12 })
+  },
+  output: "mesh",
+  version: 1,
+  run(ctx, p) {
+    const b = ctx.mesh.create();
+    const rng = ctx.rng;
+    for (let k = 0; k < p.count; k++) {
+      const main = k === 0;
+      const len = p.length * (main ? 1 : 0.35 + rng.float() * 0.5);
+      const r = p.radius * (main ? 1 : 0.5 + rng.float() * 0.5) * (len / p.length) ** 0.3;
+      const first = b.vertexCount;
+      b.lathe([r * 0.85, -r, r, len * 0.72, 0, len], { sides: p.sides, caps: true });
+      for (let i = first; i < b.vertexCount; i++) {
+        const y = b.positions[i * 3 + 1];
+        b.uv1(i, Math.max(0, Math.min(1, y / len)), rng.float());
+      }
+      const tilt = (main ? 0.3 : 0.6 + rng.float() * 0.5) * p.spread * DEG;
+      sinCos(rng.float() * Math.PI * 2, sc);
+      sinCos(tilt, sc2);
+      const m = rotationAbout(sc[1], 0, sc[0], sc2[0], sc2[1]);
+      const off = main ? 0 : r * 1.4;
+      m[12] = -sc[0] * off;
+      m[14] = sc[1] * off;
+      b.transform(m, first);
+    }
+    standOnGround(b, 0.08);
+    b.normals({ angle: 30 });
+    return ctx.mesh.finish(b, { lods: [0.5, 0.2] });
+  }
+});
+function rotationAbout(x, y, z, s, c) {
+  const len = Math.sqrt(x * x + y * y + z * z) || 1;
+  x /= len;
+  y /= len;
+  z /= len;
+  const k = 1 - c;
+  const m = new Float64Array(16);
+  m[0] = c + x * x * k;
+  m[1] = y * x * k + z * s;
+  m[2] = z * x * k - y * s;
+  m[4] = x * y * k - z * s;
+  m[5] = c + y * y * k;
+  m[6] = z * y * k + x * s;
+  m[8] = x * z * k + y * s;
+  m[9] = y * z * k - x * s;
+  m[10] = c + z * z * k;
+  m[15] = 1;
+  return m;
+}
+function shadeCards(b, first, rng) {
+  let shade = rng.float();
+  for (let i = first; i < b.vertexCount; i++) {
+    if ((i - first) % 12 === 0) shade = rng.float();
+    b.uv1(i, 1, shade);
+  }
+}
+const ENGINE_GENERATORS = [
+  RockGenerator,
+  TreeGenerator,
+  BushGenerator,
+  GrassClumpGenerator,
+  CrystalGenerator
+];
+export {
+  BushGenerator,
+  CrystalGenerator,
+  ENGINE_GENERATORS,
+  GrassClumpGenerator,
+  RockGenerator,
+  TreeGenerator
+};

package/dist/engine/shape-noise.d.ts

@@ -0,0 +1,4 @@
+/** Smooth value noise in [−1, 1]. */
+export declare function valueNoise(seed: number, x: number, y: number, z: number): number;
+/** Fractal sum of `octaves` value-noise layers (halving amplitude, doubling frequency), ~[−1, 1]. */
+export declare function fbm(seed: number, x: number, y: number, z: number, octaves: number): number;

package/dist/engine/shape-noise.js

@@ -0,0 +1,46 @@
+import { hash32 } from "@aethervtt/shard-core";
+const INV = 1 / 4294967296;
+function lattice(seed, x, y, z) {
+  return hash32(seed, x, y, z) * INV * 2 - 1;
+}
+const fade = (t) => t * t * t * (t * (t * 6 - 15) + 10);
+function valueNoise(seed, x, y, z) {
+  const xi = Math.floor(x);
+  const yi = Math.floor(y);
+  const zi = Math.floor(z);
+  const u = fade(x - xi);
+  const v = fade(y - yi);
+  const w = fade(z - zi);
+  const a = lattice(seed, xi, yi, zi);
+  const b = lattice(seed, xi + 1, yi, zi);
+  const c = lattice(seed, xi, yi + 1, zi);
+  const d = lattice(seed, xi + 1, yi + 1, zi);
+  const e = lattice(seed, xi, yi, zi + 1);
+  const f = lattice(seed, xi + 1, yi, zi + 1);
+  const g = lattice(seed, xi, yi + 1, zi + 1);
+  const h = lattice(seed, xi + 1, yi + 1, zi + 1);
+  const ab = a + (b - a) * u;
+  const cd = c + (d - c) * u;
+  const ef = e + (f - e) * u;
+  const gh = g + (h - g) * u;
+  const lo = ab + (cd - ab) * v;
+  const hi = ef + (gh - ef) * v;
+  return lo + (hi - lo) * w;
+}
+function fbm(seed, x, y, z, octaves) {
+  let sum = 0;
+  let amp = 0.5;
+  let norm = 0;
+  let f = 1;
+  for (let o = 0; o < octaves; o++) {
+    sum += valueNoise(seed + o * 1013, x * f, y * f, z * f) * amp;
+    norm += amp;
+    amp *= 0.5;
+    f *= 2.03;
+  }
+  return sum / norm;
+}
+export {
+  fbm,
+  valueNoise
+};

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export { findNondeterminism, type NondeterministicCall } from './check.js';
 export { type ContextState, createContext, type GenContext, guardNondeterminism, type LoadedDependency, type NoiseApi, } from './context.js';
+export { BushGenerator, CrystalGenerator, ENGINE_GENERATORS, GrassClumpGenerator, RockGenerator, TreeGenerator, } from './engine/generators.js';
+export { fbm, valueNoise } from './engine/shape-noise.js';
 export { allGenerators, canonicalParams, codeHashOf, defineGenerator, type Fragment, type FragmentEntity, findGenerator, type Generator, type GeneratorOptions, type GenParams, type GenRequest, guidOf, hashString, identityOf, type MeshResult, type OutputAsset, type OutputSpec, parseProceduralRef, proceduralPath, type RunResult, requestOf, requireGenerator, setGeneratorCodeHashes, type TextureData, } from './generator.js';
 export { GeneratorImporter, type GenFile, parseGenFile } from './importer.js';
 export { Generated, GeneratorInstance, instanceRequest } from './instance.js';

package/dist/index.js

@@ -3,6 +3,15 @@ import {
   createContext,
   guardNondeterminism
 } from "./context.js";
+import {
+  BushGenerator,
+  CrystalGenerator,
+  ENGINE_GENERATORS,
+  GrassClumpGenerator,
+  RockGenerator,
+  TreeGenerator
+} from "./engine/generators.js";
+import { fbm, valueNoise } from "./engine/shape-noise.js";
 import {
   allGenerators,
   canonicalParams,
@@ -54,15 +63,21 @@ import {
 import { genFileSchema } from "./schema.js";
 import { contactSheet, drawLabel, parseSeeds } from "./sheet.js";
 export {
+  BushGenerator,
+  CrystalGenerator,
   DataAssetType,
+  ENGINE_GENERATORS,
   Generated,
   GeneratedData,
   GeneratorAssetType,
   GeneratorBindings,
   GeneratorImporter,
   GeneratorInstance,
+  GrassClumpGenerator,
   ProcgenResource,
   ProcgenRuntime,
+  RockGenerator,
+  TreeGenerator,
   allGenerators,
   canonicalParams,
   codeHashOf,
@@ -75,6 +90,7 @@ export {
   encodeOutput,
   encodeRecord,
   executeJob,
+  fbm,
   findGenerator,
   findNondeterminism,
   genFileSchema,
@@ -105,5 +121,6 @@ export {
   runJob,
   setGeneratorCodeHashes,
   toJson,
+  valueNoise,
   warmGeneratorWorkers
 };

package/dist/job.js

@@ -1,5 +1,6 @@
 import { findAssetType } from "@aethervtt/shard-assets";
 import { ShardError } from "@aethervtt/shard-core";
+import { loadMeshSimplifier } from "@aethervtt/shard-mesh";
 import { useNoiseKernel } from "@aethervtt/shard-noise";
 import {
   createContext,
@@ -47,6 +48,7 @@ async function executeJob(job) {
   const gen = requireGenerator(job.generator);
   if (job.noise) useNoiseKernel(job.noise, job.noiseSimd ?? true);
   const deps = await loadDependencies(job);
+  await loadMeshSimplifier();
   const state = { children: [], warnings: [] };
   const params = gen.params.deserialize(job.params);
   const ctx = createContext(gen, job, deps, job.chain, state);

package/dist/mesh-builder.d.ts

@@ -1,4 +1,4 @@
-import { type MeshData } from '@aethervtt/shard-mesh';
+import { type LeafCardOptions, MeshBuilder, type MeshData, type SimplifyOptions, type TreeSkeleton, type TreeSkeletonOptions } from '@aethervtt/shard-mesh';
 import type { MeshResult } from './generator.js';
 /**
  * Mesh building inside a generator. Deterministic across hosts: only +, *, and sqrt (no trig),
@@ -14,11 +14,26 @@ export interface MeshBuilderApi {
     primitive(name: 'box' | 'cube' | 'sphere' | 'plane' | 'cylinder' | 'cone' | 'capsule' | 'torus', params?: Record<string, number>): MeshData;
     /** Recomputes smooth normals from the triangles (area-weighted). */
     computeNormals(mesh: MeshData): MeshData;
+    /** A procedural modelling builder (0045): shapes, deformation, merge, weld, normals, UVs. */
+    create(): MeshBuilder;
+    /** A builder holding a copy of `mesh`. */
+    from(mesh: MeshData): MeshBuilder;
+    /** A recursive branch graph for trees and bushes (seeded). */
+    treeSkeleton(options: TreeSkeletonOptions): TreeSkeleton;
+    /** Skins a skeleton with tubes, appended to `b`; returns the first vertex added. */
+    tubeAlong(b: MeshBuilder, skeleton: TreeSkeleton, options?: {
+        sides?: number;
+    }): number;
+    /** Leaf cards along a skeleton's branches, appended to `b`; returns the first vertex added. */
+    leafCards(b: MeshBuilder, skeleton: TreeSkeleton, options: LeafCardOptions): number;
+    /** Simplified copies at fractions of the triangle count (meshoptimizer). */
+    simplifyLods(mesh: MeshData, fractions: readonly number[], options?: SimplifyOptions): MeshData[];
     /**
-     * Finishes a mesh: optional normals and tangents, and levels of detail as fractions of the
-     * triangle count (`lods: [0.5, 0.2]`), made by vertex clustering.
+     * Finishes a mesh (data or a builder): optional normals and tangents, and levels of detail as
+     * fractions of the triangle count (`lods: [0.5, 0.2]`), simplified by meshoptimizer (UV seams
+     * kept, each level's vertices a subset of the source's).
      */
-    finish(mesh: MeshData, options?: {
+    finish(mesh: MeshData | MeshBuilder, options?: {
         normals?: boolean;
         tangents?: boolean;
         lods?: readonly number[];

package/dist/mesh-builder.js

@@ -5,9 +5,14 @@ import {
   cone,
   cube,
   cylinder,
+  leafCards,
+  MeshBuilder,
   plane,
+  simplifyLods,
   sphere,
-  torus
+  torus,
+  treeSkeleton,
+  tubeAlong
 } from "@aethervtt/shard-mesh";
 function icosphere(detail) {
   if (!Number.isInteger(detail) || detail < 0 || detail > 8) {
@@ -289,112 +294,19 @@ function computeTangents(mesh) {
   }
   return out;
 }
-function cluster(mesh, cells) {
-  const p = mesh.positions;
-  const count = p.length / 3;
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (let v = 0; v < count; v++) {
-    minX = Math.min(minX, p[v * 3]);
-    minY = Math.min(minY, p[v * 3 + 1]);
-    minZ = Math.min(minZ, p[v * 3 + 2]);
-    maxX = Math.max(maxX, p[v * 3]);
-    maxY = Math.max(maxY, p[v * 3 + 1]);
-    maxZ = Math.max(maxZ, p[v * 3 + 2]);
-  }
-  const size = Math.max(maxX - minX, maxY - minY, maxZ - minZ) || 1;
-  const cell = size / cells;
-  const map = new Int32Array(count);
-  const byKey = /* @__PURE__ */ new Map();
-  const sums = [];
-  const members = [];
-  for (let v = 0; v < count; v++) {
-    const ix = Math.min(cells - 1, Math.floor((p[v * 3] - minX) / cell));
-    const iy = Math.min(cells - 1, Math.floor((p[v * 3 + 1] - minY) / cell));
-    const iz = Math.min(cells - 1, Math.floor((p[v * 3 + 2] - minZ) / cell));
-    const key = (ix * cells + iy) * cells + iz;
-    let c = byKey.get(key);
-    if (c === void 0) {
-      c = members.length;
-      byKey.set(key, c);
-      members.push(0);
-      sums.push(0, 0, 0);
-    }
-    map[v] = c;
-    members[c] = members[c] + 1;
-    sums[c * 3] = sums[c * 3] + p[v * 3];
-    sums[c * 3 + 1] = sums[c * 3 + 1] + p[v * 3 + 1];
-    sums[c * 3 + 2] = sums[c * 3 + 2] + p[v * 3 + 2];
-  }
-  const tri = triangles(mesh);
-  const kept = [];
-  for (let t = 0; t < tri.length; t += 3) {
-    const a = map[tri[t]];
-    const b = map[tri[t + 1]];
-    const c = map[tri[t + 2]];
-    if (a !== b && b !== c && c !== a) kept.push(a, b, c);
-  }
-  const n = members.length;
-  const positions = new Float32Array(n * 3);
-  for (let c = 0; c < n; c++) {
-    positions[c * 3] = sums[c * 3] / members[c];
-    positions[c * 3 + 1] = sums[c * 3 + 1] / members[c];
-    positions[c * 3 + 2] = sums[c * 3 + 2] / members[c];
-  }
-  const out = {
-    positions,
-    indices: n > 65535 ? new Uint32Array(kept) : new Uint16Array(kept)
-  };
-  for (const [name, width] of [
-    ["uvs", 2],
-    ["colors", 4]
-  ]) {
-    const src = mesh[name];
-    if (!src) continue;
-    const acc = new Float64Array(n * width);
-    for (let v = 0; v < count; v++)
-      for (let k = 0; k < width; k++)
-        acc[map[v] * width + k] = acc[map[v] * width + k] + src[v * width + k];
-    const avg = new Float32Array(n * width);
-    for (let c = 0; c < n; c++)
-      for (let k = 0; k < width; k++) avg[c * width + k] = acc[c * width + k] / members[c];
-    out[name] = avg;
-  }
-  return out;
-}
-function simplify(mesh, fraction) {
-  const target = Math.max(4, Math.floor(triangles(mesh).length / 3 * fraction));
-  let lo = 1;
-  let hi = 256;
-  let best = cluster(mesh, 2);
-  for (let step = 0; step < 8 && lo <= hi; step++) {
-    const cells = lo + hi >> 1;
-    const candidate = cluster(mesh, cells);
-    const tris = (candidate.indices?.length ?? 0) / 3;
-    if (tris <= target) {
-      best = candidate;
-      lo = cells + 1;
-    } else hi = cells - 1;
-  }
-  return best;
-}
-function finish(mesh, options = {}) {
+function finish(input, options = {}) {
+  const mesh = input instanceof MeshBuilder ? input.finish() : input;
   const withNormals = (m) => options.normals === true || !m.normals ? computeNormals(m) : m;
   const withTangents = (m) => options.tangents ? { ...m, tangents: computeTangents(m) } : m;
   const base = withTangents(withNormals(mesh));
-  const lods = [];
   for (const fraction of options.lods ?? []) {
     if (!(fraction > 0 && fraction < 1)) {
       throw new ShardError("procgen/bad-mesh", `LOD fractions are in (0, 1), got ${fraction}`, {
         hint: "lods: [0.5, 0.2] keeps about half, then a fifth, of the triangles."
       });
     }
-    lods.push(withTangents(computeNormals(simplify(mesh, fraction))));
   }
+  const lods = options.lods?.length ? simplifyLods(base, options.lods) : [];
   return { kind: "mesh", mesh: base, lods };
 }
 const meshBuilder = {
@@ -414,6 +326,12 @@ const meshBuilder = {
     return out;
   },
   computeNormals,
+  create: () => MeshBuilder.create(),
+  from: (mesh) => MeshBuilder.from(mesh),
+  treeSkeleton,
+  tubeAlong,
+  leafCards,
+  simplifyLods,
   finish
 };
 export {

package/dist/methods.js

@@ -1,4 +1,4 @@
-import { assetServer } from "@aethervtt/shard-assets";
+import { assetServer, findAssetPreview } from "@aethervtt/shard-assets";
 import {
   defineSchema,
   isPlainObject,
@@ -48,6 +48,8 @@ async function resolveGenerator(world, target2) {
   if (exact) return { gen: exact, params: {} };
   const matches = allGenerators().filter((g) => g.name.endsWith(`/${name}`));
   if (matches.length === 1) return { gen: matches[0], params: {} };
+  const own = matches.filter((g) => !g.name.startsWith("shard/"));
+  if (own.length === 1) return { gen: own[0], params: {} };
   throw new ShardError("procgen/unknown-generator", `No generator "${target2}"`, {
     hint: matches.length ? `Several match: ${matches.map((g) => g.name).join(", ")}.` : `Generators: ${allGenerators().map((g) => g.name).join(", ") || "(none)"}.`
   });
@@ -136,7 +138,7 @@ const procgenMethods = [
   },
   {
     name: "procgen.preview",
-    description: 'A PNG of a generator output: a mesh in a neutral studio light from a three-quarter view, a texture as is, entities as a scene framed on their bounds. With seeds ("1-9" or [1, 4, 9]) it is a labelled contact sheet, one cell per seed: change a param, preview nine seeds, compare.',
+    description: 'A PNG of a generator output: a mesh in a neutral studio light from a three-quarter view, a texture as is, entities as a scene framed on their bounds. With seeds ("1-9" or [1, 4, 9]) it is a labelled contact sheet, one cell per seed: change a param, preview nine seeds, compare. A *.scatter.json path previews the set on a 64 m patch, from above and at eye level.',
     params: defineSchema("procgen/PreviewParams", {
       generator: target,
       params: t.json({ description: "Param values." }),
@@ -145,9 +147,21 @@ const procgenMethods = [
       size: t.u32({ default: 256, min: 32, max: 1024, description: "Pixels per cell." })
     }),
     handler: async ({ world }, p) => {
+      const size = p.size;
+      const asset = assetServer(world).entry(p.generator);
+      if (asset && !p.generator.includes(".gen.json") && findAssetPreview(asset.type)) {
+        const image2 = await findAssetPreview(asset.type)(world, asset.path, size * 2, size, {});
+        const png2 = await encodePng(image2.data, image2.width, image2.height);
+        return {
+          width: image2.width,
+          height: image2.height,
+          data: toBase64(png2),
+          asset: asset.path,
+          type: asset.type
+        };
+      }
       const found = await resolveGenerator(world, p.generator);
       const params = { ...found.params, ...paramsOf(p.params) };
-      const size = p.size;
       const seeds = p.seeds === void 0 || p.seeds === null ? void 0 : parseSeeds(p.seeds);
       let image;
       const keys = [];

package/dist/plugin.js

@@ -1,6 +1,7 @@
 import { assetServer } from "@aethervtt/shard-assets";
 import { definePlugin } from "@aethervtt/shard-runtime";
 import { updateInstances } from "@aethervtt/shard-scene";
+import * as engineModule from "./engine/generators.js";
 import * as importerModule from "./importer.js";
 import * as instanceModule from "./instance.js";
 import { procgenMethods } from "./methods.js";
@@ -10,7 +11,8 @@ import { procgen } from "./runtime.js";
 function procgenPlugin(options = {}) {
   return definePlugin({
     name: "procgen",
-    provides: [importerModule, instanceModule, refsModule, runtimeModule],
+    // The engine's generators (shard/Rock, shard/Tree, …) are defined by importing their module.
+    provides: [engineModule, importerModule, instanceModule, refsModule, runtimeModule],
     build(app) {
       const runtime = procgen(app.world).configure({
         ...options.fs ? { fs: options.fs } : {},

package/dist/worker.d.ts

@@ -6,5 +6,5 @@ import { type GenJob } from './job.js';
 export declare function runGeneratorJob(job: GenJob): Promise<{
     packed: Uint8Array;
 }>;
-/** Nothing: loading this module (and the project's code) is the point. */
-export declare function warmUp(): true;
+/** Nothing: loading this module (the engine's generators and the project's code) is the point. */
+export declare function warmUp(): boolean;

package/dist/worker.js

@@ -1,3 +1,4 @@
+import { ENGINE_GENERATORS } from "./engine/generators.js";
 import { executeJob } from "./job.js";
 import { encodeRecord } from "./record.js";
 async function runGeneratorJob(job) {
@@ -5,7 +6,7 @@ async function runGeneratorJob(job) {
   return { packed: encodeRecord({ key: "", ...result, bytes: 0 }) };
 }
 function warmUp() {
-  return true;
+  return ENGINE_GENERATORS.length > 0;
 }
 export {
   runGeneratorJob,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aethervtt/shard-procgen",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -20,16 +20,16 @@
     "README.md"
   ],
   "dependencies": {
-    "@aethervtt/shard-assets": "0.1.0",
-    "@aethervtt/shard-core": "0.1.0",
-    "@aethervtt/shard-mesh": "0.1.0",
-    "@aethervtt/shard-noise": "0.1.0",
-    "@aethervtt/shard-platform": "0.1.0",
-    "@aethervtt/shard-protocol": "0.1.0",
-    "@aethervtt/shard-render": "0.1.0",
-    "@aethervtt/shard-runtime": "0.1.0",
-    "@aethervtt/shard-scene": "0.1.0",
-    "@aethervtt/shard-texture": "0.1.0"
+    "@aethervtt/shard-assets": "0.2.1",
+    "@aethervtt/shard-core": "0.2.1",
+    "@aethervtt/shard-mesh": "0.2.1",
+    "@aethervtt/shard-noise": "0.2.1",
+    "@aethervtt/shard-platform": "0.2.1",
+    "@aethervtt/shard-protocol": "0.2.1",
+    "@aethervtt/shard-render": "0.2.1",
+    "@aethervtt/shard-runtime": "0.2.1",
+    "@aethervtt/shard-scene": "0.2.1",
+    "@aethervtt/shard-texture": "0.2.1"
   },
   "repository": {
     "type": "git",
@@ -41,6 +41,6 @@
     "provenance": true
   },
   "shard": {
-    "buildSha": "8e14c9896f82a3554b156f1ffdd68f2cc3e7d78a"
+    "buildSha": "772eb0d2b8a5fc499105708f4ae92c58788cc9ea"
   }
 }