@aethervtt/shard-terrain 0.0.1

package/dist/kernel.js

@@ -0,0 +1,243 @@
+import {
+  generateWgsl,
+  registerNoiseLibrary
+} from "@aethervtt/shard-noise";
+const nodeGraphs = /* @__PURE__ */ new WeakMap();
+function kernelGraph(graph, node) {
+  if (!node) {
+    return {
+      module: graph.module,
+      name: graph.name,
+      wgsl: graph.wgsl,
+      program: graph.program,
+      hash: graph.hash
+    };
+  }
+  let byNode = nodeGraphs.get(graph);
+  if (!byNode) {
+    byNode = /* @__PURE__ */ new Map();
+    nodeGraphs.set(graph, byNode);
+  }
+  const cached = byNode.get(node);
+  if (cached && cached.hash === `${graph.hash}:${node}`) return cached;
+  const name = `${graph.name}_${node}`;
+  const program = graph.programFor(node);
+  const out = {
+    module: `${graph.module}_${node}`,
+    name,
+    wgsl: generateWgsl(program, { name }),
+    program,
+    hash: `${graph.hash}:${node}`
+  };
+  byNode.set(node, out);
+  return out;
+}
+const POINT_FLOATS = 10;
+const PARAMS_BYTES = 64;
+const GEN_HEIGHT = 1;
+const GEN_CLIMATE = 2;
+const GEN_ROOT = 4;
+const GEN_OCEAN = 8;
+const PARAMS = `
+struct GenParams {
+  count: u32,
+  side: u32,
+  n: u32,
+  surface: u32,
+  ring: u32,
+  seed: u32,
+  flags: u32,
+  /** The chunk's slot: its normal tile, packed into uv1.x (see packGrid). */
+  tile: u32,
+  /** Ellipsoid axis ratios (xyz), metres per height unit (w). */
+  shape: vec4f,
+  /** x: surface offset (m, the ocean's sea level), y: morph error, z: skirt depth. */
+  misc: vec4f,
+}
+
+@group(0) @binding(0) var<uniform> params: GenParams;
+@group(0) @binding(1) var<storage, read> pts: array<f32>;
+`;
+function sampleKernel(height, temperature, moisture) {
+  const imports = [];
+  const bindings = [];
+  const body = [];
+  const add = (g, binding, target) => {
+    if (!g) return;
+    imports.push(`import ${g.module}::{ noise_${g.name}_at, NoiseOrigins_${g.name} };`);
+    bindings.push(
+      `@group(0) @binding(${binding}) var<storage, read> origins_${target}: array<NoiseOrigins_${g.name}>;`
+    );
+    body.push(
+      `  { var o = origins_${target}[g]; ${target} = noise_${g.name}_at(&o, local, params.seed); }`
+    );
+  };
+  add(height, 3, "h");
+  add(temperature, 4, "t");
+  add(moisture, 5, "m");
+  return `${imports.join("\n")}
+${PARAMS}
+@group(0) @binding(2) var<storage, read_write> values: array<f32>;
+${bindings.join("\n")}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id: vec3u) {
+  let k = id.x;
+  if (k >= params.count) { return; }
+  let p = k * ${POINT_FLOATS}u;
+  let local = vec3f(pts[p], pts[p + 1u], pts[p + 2u]);
+  let g = bitcast<u32>(pts[p + 9u]);
+  var h = 0.0;
+  var t = 0.0;
+  var m = 0.0;
+${body.join("\n")}
+  values[k * 3u] = h;
+  values[k * 3u + 1u] = t;
+  values[k * 3u + 2u] = m;
+}
+`;
+}
+const VERTEX_KERNEL = `${PARAMS}
+@group(0) @binding(2) var<storage, read> values: array<f32>;
+@group(0) @binding(3) var<storage, read_write> positions: array<f32>;
+@group(0) @binding(4) var<storage, read_write> normals: array<f32>;
+@group(0) @binding(5) var<storage, read_write> uvs: array<f32>;
+@group(0) @binding(6) var<storage, read_write> uvs1: array<f32>;
+@group(0) @binding(7) var<storage, read_write> tangents: array<f32>;
+/** Min height, max height (mm), largest morph delta (mm). */
+@group(0) @binding(8) var<storage, read_write> stats: array<atomic<i32>, 4>;
+
+/** Vertex index of grid point (i, j): the border ring first (counter-clockwise), then rows. */
+fn vertex_index(i: u32, j: u32, n: u32) -> u32 {
+  let s = n - 1u;
+  if (j == 0u) { return i; }
+  if (i == s) { return s + j; }
+  if (j == s) { return 2u * s + (s - i); }
+  if (i == 0u) { return 3u * s + (s - j); }
+  return 4u * s + (j - 1u) * (n - 2u) + (i - 1u);
+}
+
+fn terrain_height(k: u32) -> f32 {
+  return values[k * 3u] * params.shape.w;
+}
+
+fn surface_height(k: u32) -> f32 {
+  if ((params.flags & ${GEN_OCEAN}u) != 0u) { return params.misc.x; }
+  return terrain_height(k) + params.misc.x;
+}
+
+fn point_position(k: u32) -> vec3f {
+  let p = k * ${POINT_FLOATS}u;
+  let q = vec3f(pts[p + 3u], pts[p + 4u], pts[p + 5u]);
+  let d = vec3f(pts[p + 6u], pts[p + 7u], pts[p + 8u]);
+  return q + params.shape.xyz * d * surface_height(k);
+}
+
+fn write_vertex(v: u32, p: vec3f, n: vec3f, climate: vec2f, lock: vec2f, t: vec4f) {
+  positions[v * 3u] = p.x;
+  positions[v * 3u + 1u] = p.y;
+  positions[v * 3u + 2u] = p.z;
+  normals[v * 3u] = n.x;
+  normals[v * 3u + 1u] = n.y;
+  normals[v * 3u + 2u] = n.z;
+  uvs[v * 2u] = climate.x;
+  uvs[v * 2u + 1u] = climate.y;
+  uvs1[v * 2u] = lock.x;
+  uvs1[v * 2u + 1u] = lock.y;
+  tangents[v * 4u] = t.x;
+  tangents[v * 4u + 1u] = t.y;
+  tangents[v * 4u + 2u] = t.z;
+  tangents[v * 4u + 3u] = t.w;
+}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id: vec3u) {
+  let v = id.x;
+  if (v >= params.surface) { return; }
+  let n = params.n;
+  let b = params.side;
+  let i = v % n;
+  let j = v / n;
+  let k = (i + 1u) + (j + 1u) * b;
+  let p = point_position(k);
+  let normal = normalize(cross(point_position(k + 1u) - point_position(k - 1u), point_position(k + b) - point_position(k - b)));
+  var delta = vec3f(0.0);
+  let oi = (i & 1u) == 1u;
+  let oj = (j & 1u) == 1u;
+  if ((oi || oj) && (params.flags & ${GEN_ROOT}u) == 0u) {
+    let ka = select(k, k - 1u, oi) - select(0u, b, oj);
+    let kb = select(k, k + 1u, oi) + select(0u, b, oj);
+    delta = (point_position(ka) + point_position(kb)) * 0.5 - p;
+    atomicMax(&stats[2], i32(ceil(length(delta) * 1000.0)));
+  }
+  let h = terrain_height(k);
+  let surface = surface_height(k);
+  var w = h;
+  if ((params.flags & ${GEN_OCEAN}u) != 0u) { w = params.misc.x - h; }
+  let climate = vec2f(values[k * 3u + 1u], values[k * 3u + 2u]);
+  let vi = vertex_index(i, j, n);
+  let lock = vec2f(f32(i + j * n + n * n * params.tile), params.misc.y);
+  let tangent = vec4f(delta, w);
+  write_vertex(vi, p, normal, climate, lock, tangent);
+  if (vi < params.ring) {
+    let q = k * ${POINT_FLOATS}u;
+    let down = normalize(params.shape.xyz * vec3f(pts[q + 6u], pts[q + 7u], pts[q + 8u]));
+    write_vertex(params.surface + vi, p - down * params.misc.z, normal, climate, lock, tangent);
+  }
+  atomicMin(&stats[0], i32(floor(surface * 1000.0)));
+  atomicMax(&stats[1], i32(ceil(surface * 1000.0)));
+}
+`;
+const NORMAL_KERNEL = `${PARAMS}
+@group(0) @binding(2) var<storage, read> values: array<f32>;
+@group(0) @binding(3) var tile_out: texture_storage_2d<rgba8unorm, write>;
+
+fn point_position(k: u32) -> vec3f {
+  let p = k * ${POINT_FLOATS}u;
+  let q = vec3f(pts[p + 3u], pts[p + 4u], pts[p + 5u]);
+  let d = vec3f(pts[p + 6u], pts[p + 7u], pts[p + 8u]);
+  return q + params.shape.xyz * d * (values[k * 3u] * params.shape.w);
+}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id: vec3u) {
+  let t = params.n;
+  if (id.x >= t * t) { return; }
+  let b = params.side;
+  let i = id.x % t;
+  let j = id.x / t;
+  let k = (i + 1u) + (j + 1u) * b;
+  let normal = normalize(cross(point_position(k + 1u) - point_position(k - 1u), point_position(k + b) - point_position(k - b)));
+  // The tile's corner in its layer: surface (texel x) and ring (texel y) carry it.
+  textureStore(tile_out, vec2u(params.surface + i, params.ring + j), vec4f(normal * 0.5 + 0.5, 1.0));
+}
+`;
+function packGrid(i, j, n, tile) {
+  return i + j * n + n * n * tile;
+}
+function registerKernel(library, key, height, temperature, moisture) {
+  registerNoiseLibrary(library);
+  for (const g of [height, temperature, moisture])
+    if (g) library.register(g.module, g.wgsl, g.module);
+  const sample = `terrain::gen::k${key}::sample`;
+  const vertices = "terrain::gen::vertices";
+  const normals = "terrain::gen::normals";
+  library.register(sample, sampleKernel(height, temperature, moisture), "terrain chunk sampling");
+  if (!library.has(vertices)) library.register(vertices, VERTEX_KERNEL, "terrain chunk vertices");
+  if (!library.has(normals)) library.register(normals, NORMAL_KERNEL, "terrain normal tiles");
+  return { sample, vertices, normals };
+}
+export {
+  GEN_CLIMATE,
+  GEN_HEIGHT,
+  GEN_OCEAN,
+  GEN_ROOT,
+  NORMAL_KERNEL,
+  PARAMS_BYTES,
+  POINT_FLOATS,
+  VERTEX_KERNEL,
+  kernelGraph,
+  packGrid,
+  registerKernel,
+  sampleKernel
+};

package/dist/lod.d.ts

@@ -0,0 +1,22 @@
+import type { NoiseGraph } from '@aethervtt/shard-noise';
+export interface ErrorSpec {
+    radius: number;
+    shape: ArrayLike<number>;
+    heightScale: number;
+    seed: number;
+    resolution: number;
+    maxDepth: number;
+    height: NoiseGraph | undefined;
+    heightOffset?: number;
+}
+/**
+ * Each depth's geometric error (m): the largest distance between a vertex and where its parent
+ * level puts it, over sample chunks spread across the six faces, with some headroom. Depth 0 has no
+ * parent and gets depth 1's doubled. Errors never grow with depth, so split distances shrink with
+ * it. Deterministic for a (graph, seed, radius), and cheap enough to redo when the graph changes.
+ *
+ * Selection splits a depth-d node when `K × errors[d + 1] / distance` passes the planet's
+ * `errorPixels`; every chunk of depth d morphs over the band set by `errors[d]`. One error per depth
+ * (not per node) keeps neighbors at one depth in the same band, so their shared edges morph alike.
+ */
+export declare function measureErrors(spec: ErrorSpec): Float32Array;

package/dist/lod.js

@@ -0,0 +1,44 @@
+import { hash32 } from "@aethervtt/shard-core";
+import { buildChunk } from "./chunk.js";
+const SAMPLES_PER_DEPTH = 24;
+const SAFETY = 1.25;
+function measureErrors(spec) {
+  const out = new Float32Array(spec.maxDepth + 2);
+  for (let d = 1; d <= spec.maxDepth; d++) {
+    const n = 2 ** d;
+    let worst = 0;
+    for (let s = 0; s < SAMPLES_PER_DEPTH; s++) {
+      const face = s % 6;
+      const h = hash32(spec.seed ^ 8262049, d, s);
+      const x = h % n;
+      const y = hash32(h, d, s, 1) % n;
+      const chunk = buildChunk({
+        face,
+        depth: d,
+        x,
+        y,
+        radius: spec.radius,
+        shape: spec.shape,
+        heightScale: spec.heightScale,
+        seed: spec.seed,
+        resolution: spec.resolution,
+        height: spec.height,
+        climate: void 0,
+        morphError: 0,
+        skirtDepth: 0,
+        // Statistics only: coarse origins keep it quick (every vertex its own batch otherwise).
+        snap: 8192,
+        ...spec.heightOffset !== void 0 ? { heightOffset: spec.heightOffset } : {}
+      });
+      if (chunk.error > worst) worst = chunk.error;
+    }
+    out[d] = worst * SAFETY;
+  }
+  out[0] = out[1] * 2;
+  out[spec.maxDepth + 1] = 0;
+  for (let d = spec.maxDepth - 1; d >= 0; d--) out[d] = Math.max(out[d], out[d + 1]);
+  return out;
+}
+export {
+  measureErrors
+};

package/dist/material.d.ts

@@ -0,0 +1,14 @@
+/** Texture repeats line up every this many metres of planet space (layer scales divide it). */
+export declare const TEXTURE_PERIOD = 1024;
+/**
+ * The planet surface material (spec 0043), extending standard. Its vertex stage geomorphs each
+ * chunk toward its parent level by distance (or by the edge locks toward coarser and finer
+ * neighbors); its surface stage picks the four heaviest biomes per fragment from temperature,
+ * moisture, height, slope, and latitude, and samples their layers from the three texture arrays,
+ * triplanar in planet space (one top-down sample per biome far away). A project can replace the
+ * shader with its own `pbr_input` on a type that extends this one's fields.
+ */
+export declare const PlanetMaterial: import("@aethervtt/shard-render").MaterialType;
+/** The sea surface material: transparent, wave normals, absorption by water depth, Fresnel. */
+export declare const OceanMaterial: import("@aethervtt/shard-render").MaterialType;
+export declare const TERRAIN_SHADERS: Record<string, string>;