@plasius/gpu-world-generator 0.0.4

package/src/fractal-prepass.wgsl

@@ -0,0 +1,290 @@
+struct FractalParams {
+  grid: vec4<f32>,   // grid_points, extent, step, seed
+  field0: vec4<f32>, // scale, warp_scale, warp_strength, power
+  field1: vec4<f32>, // detail_scale, detail_power, ridge_power, heat_bias
+  field2: vec4<f32>, // moisture_bias, mandel_scale, mandel_strength, mandel_rock_boost
+  field3: vec4<f32>, // iterations, detail_iterations, macro_scale, macro_warp_strength
+  field4: vec4<f32>, // style_mix_strength, terrace_steps, terrace_strength, crater_strength
+  field5: vec4<f32>, // crater_scale, height_min, height_max, pad
+};
+
+struct Sample {
+  data0: vec4<f32>, // height, heat, moisture, rockiness
+  data1: vec4<f32>, // water, ridge, base, detail
+};
+
+@group(0) @binding(0) var<uniform> params: FractalParams;
+@group(0) @binding(1) var<storage, read_write> samples_out: array<Sample>;
+@group(0) @binding(2) var<storage, read> samples_in: array<Sample>;
+
+fn hash32(x: u32) -> u32 {
+  var v = x;
+  v ^= v >> 17u;
+  v *= 0xed5ad4bbu;
+  v ^= v >> 11u;
+  v *= 0xac4c1b51u;
+  v ^= v >> 15u;
+  v *= 0x31848babu;
+  v ^= v >> 14u;
+  return v;
+}
+
+fn hash01(x: u32) -> f32 {
+  let v = hash32(x) & 0x00ffffffu;
+  return f32(v) / 16777216.0;
+}
+
+fn smooth_mandelbrot(cx: f32, cy: f32, iterations: u32, power: f32) -> f32 {
+  var zx = 0.0;
+  var zy = 0.0;
+  var i: u32 = 0u;
+  loop {
+    if (i >= iterations) {
+      break;
+    }
+    let r2 = zx * zx + zy * zy;
+    if (r2 > 4.0) {
+      break;
+    }
+    let r = sqrt(r2);
+    let theta = atan2(zy, zx);
+    let rp = pow(r, power);
+    zx = rp * cos(theta * power) + cx;
+    zy = rp * sin(theta * power) + cy;
+    i = i + 1u;
+  }
+  if (i >= iterations) {
+    return 1.0;
+  }
+  let r = max(sqrt(zx * zx + zy * zy), 1e-6);
+  let nu = log2(log(r));
+  let smoothVal = (f32(i) + 1.0 - nu) / f32(iterations);
+  return clamp(smoothVal, 0.0, 1.0);
+}
+
+fn terrace_height(h: f32, steps: f32) -> f32 {
+  let count = max(1.0, steps);
+  let step = 1.0 / count;
+  let clamped = clamp(h, 0.0, 1.0);
+  let band = floor(clamped / step);
+  let t = fract(clamped / step);
+  let blend = t * t * (3.0 - 2.0 * t);
+  return (band + blend) * step;
+}
+
+fn crater_field(p: vec2<f32>, scale: f32, seed: u32) -> f32 {
+  let sp = p * scale;
+  let cell = floor(sp);
+  let local = sp - cell;
+  let cx = i32(cell.x);
+  let cz = i32(cell.y);
+  let hx = u32(bitcast<u32>(cx));
+  let hz = u32(bitcast<u32>(cz));
+  let h0 = hash01((hx * 374761393u) ^ (hz * 668265263u) ^ seed ^ 0x9e3779b9u);
+  let h1 = hash01((hx * 2246822519u) ^ (hz * 3266489917u) ^ seed ^ 0x85ebca6bu);
+  let h2 = hash01((hx * 1597334677u) ^ (hz * 3812015801u) ^ seed ^ 0xc2b2ae35u);
+  let center = vec2<f32>(h0, h1);
+  let radius = 0.22 + 0.25 * h2;
+  let dist = distance(local, center);
+  return smoothstep(radius, radius * 0.35, dist);
+}
+
+fn macro_map(p: vec2<f32>, iterations: u32, power: f32, scale: f32, warp_strength: f32, mix_strength: f32) -> f32 {
+  let macro_iter = max(12u, iterations / 3u);
+  let macroA = smooth_mandelbrot(p.x * scale, p.y * scale, macro_iter, power);
+  let macroB = smooth_mandelbrot((p.x + 13.7) * scale, (p.y - 9.2) * scale, macro_iter, power + 0.35);
+  let warp = vec2<f32>(macroA - 0.5, macroB - 0.5) * warp_strength;
+  let macroC = smooth_mandelbrot((p.x + warp.x) * scale, (p.y + warp.y) * scale, macro_iter, power);
+  return clamp((macroC - 0.5) * mix_strength + 0.5, 0.0, 1.0);
+}
+
+fn sample_field(p: vec2<f32>) -> Sample {
+  let seed = u32(params.grid.w);
+  let iterations = u32(params.field3.x);
+  let detail_iterations = u32(params.field3.y);
+  let macro_scale = params.field3.z;
+  let macro_warp_strength = params.field3.w;
+  let style_mix_strength = params.field4.x;
+  let terrace_steps = params.field4.y;
+  let terrace_strength = params.field4.z;
+  let crater_strength = params.field4.w;
+  let crater_scale = params.field5.x;
+  let height_min = params.field5.y;
+  let height_max = params.field5.z;
+  let scale = params.field0.x;
+  let warp_scale = params.field0.y;
+  let warp_strength = params.field0.z;
+  let power = params.field0.w;
+  let detail_scale = params.field1.x;
+  let detail_power = params.field1.y;
+  let ridge_power = params.field1.z;
+  let heat_bias = params.field1.w;
+  let moisture_bias = params.field2.x;
+
+  let offX = hash01(seed ^ 0x7f4a7c15u) * 4.0 - 2.0;
+  let offZ = hash01(seed ^ 0xa9d84d2bu) * 4.0 - 2.0;
+  let warpOffX = hash01(seed ^ 0x8c2f1d3bu) * 6.0 - 3.0;
+  let warpOffZ = hash01(seed ^ 0x5d2c79e9u) * 6.0 - 3.0;
+
+  let warpIter = max(16u, iterations * 6u / 10u);
+  let warpA = smooth_mandelbrot(
+    (p.x + warpOffX) * warp_scale,
+    (p.y + warpOffZ) * warp_scale,
+    warpIter,
+    power
+  );
+  let warpB = smooth_mandelbrot(
+    (p.x - warpOffZ) * warp_scale,
+    (p.y + warpOffX) * warp_scale,
+    warpIter,
+    power
+  );
+
+  let warped = vec2<f32>(
+    p.x + (warpA - 0.5) * warp_strength,
+    p.y + (warpB - 0.5) * warp_strength
+  );
+
+  let base = smooth_mandelbrot(
+    warped.x * scale + offX,
+    warped.y * scale + offZ,
+    iterations,
+    power
+  );
+  let mid = smooth_mandelbrot(
+    warped.x * scale * 2.15 + offX * 0.6,
+    warped.y * scale * 2.15 + offZ * 0.6,
+    max(18u, iterations * 7u / 10u),
+    power + 0.2
+  );
+  let detail = smooth_mandelbrot(
+    warped.x * scale * detail_scale + offX * 1.4,
+    warped.y * scale * detail_scale + offZ * 1.4,
+    detail_iterations,
+    detail_power
+  );
+
+  let ridge = 1.0 - abs(2.0 * mid - 1.0);
+  let baseHeight = pow(base, 0.9) * pow(mid, 1.05) * pow(detail, 1.1);
+
+  let styleMask = macro_map(warped, iterations, power, macro_scale, macro_warp_strength, style_mix_strength);
+  let terrace = terrace_height(baseHeight, terrace_steps);
+  let crater = crater_field(warped, crater_scale, seed);
+
+  let styleA = clamp(pow(baseHeight, 0.8) + pow(ridge, 1.4) * 0.2, 0.0, 1.0);
+  let styleB = clamp(
+    baseHeight * (1.0 - terrace_strength) +
+      terrace * terrace_strength -
+      crater * crater_strength +
+      pow(ridge, 1.6) * 0.12,
+    0.0,
+    1.0
+  );
+  let mixed = mix(styleA, styleB, styleMask);
+  let ridgeBoost = pow(ridge, 1.35) * 0.22;
+  let centered = (mixed - 0.5) * 2.0;
+  let shaped = sign(centered) * pow(abs(centered), 0.75);
+  let macroOffset = (styleMask - 0.5) * 0.25;
+  let rawHeight = clamp(0.5 + shaped * 0.8 + macroOffset + ridgeBoost, height_min, height_max);
+  let height01 = clamp(rawHeight, 0.0, 1.0);
+
+  let roughness = clamp(pow(ridge, ridge_power) * 0.7 + detail * 0.3, 0.0, 1.0);
+  let heat = clamp(0.55 * mid + 0.35 * (1.0 - height01) + heat_bias, 0.0, 1.0);
+  let moisture = clamp(
+    0.55 * detail + 0.35 * (1.0 - height01) - (heat - 0.5) * 0.1 + moisture_bias,
+    0.0,
+    1.0
+  );
+  let rockiness = clamp(roughness * 0.6 + height01 * 0.4, 0.0, 1.0);
+  let water = clamp((0.32 - height01) * 3.0 + (moisture - 0.5) * 0.2, 0.0, 1.0);
+
+  return Sample(
+    vec4<f32>(rawHeight, heat, moisture, rockiness),
+    vec4<f32>(water, ridge, base, detail)
+  );
+}
+
+@compute @workgroup_size(8, 8)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let grid_points = u32(params.grid.x);
+  if (gid.x >= grid_points || gid.y >= grid_points) {
+    return;
+  }
+  let extent = params.grid.y;
+  let step = params.grid.z;
+  let x = -extent + f32(gid.x) * step;
+  let z = -extent + f32(gid.y) * step;
+
+  var sample = sample_field(vec2<f32>(x, z));
+
+  let mandel_scale = params.field2.y;
+  let mandel_strength = params.field2.z;
+  let mandel_rock = params.field2.w;
+  let height_min = params.field5.y;
+  let height_max = params.field5.z;
+  let mandel = smooth_mandelbrot(x * mandel_scale, z * mandel_scale, 24u, 2.0);
+  let mandel_bias = (mandel - 0.5) * mandel_strength;
+  let rawHeight = clamp(sample.data0.x + mandel_bias, height_min, height_max);
+  let height01 = clamp(rawHeight, 0.0, 1.0);
+  let rockiness = clamp(sample.data0.w + max(0.0, mandel - 0.55) * mandel_rock, 0.0, 1.0);
+  let water = clamp((0.32 - height01) * 3.0 + (sample.data0.z - 0.5) * 0.2, 0.0, 1.0);
+
+  sample.data0.x = rawHeight;
+  sample.data0.w = rockiness;
+  sample.data1.x = water;
+
+  let index = gid.y * grid_points + gid.x;
+  samples_out[index] = sample;
+}
+
+fn height_at(ix: i32, iy: i32, size: i32) -> f32 {
+  let x = clamp(ix, 0, size - 1);
+  let y = clamp(iy, 0, size - 1);
+  let idx = y * size + x;
+  return samples_in[idx].data0.x;
+}
+
+@compute @workgroup_size(8, 8)
+fn accent_heights(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let grid_points = i32(params.grid.x);
+  let ix = i32(gid.x);
+  let iy = i32(gid.y);
+  if (ix >= grid_points || iy >= grid_points) {
+    return;
+  }
+  let idx = iy * grid_points + ix;
+  let center = samples_in[idx];
+  var sum = 0.0;
+  var count = 0.0;
+  for (var dx = -1; dx <= 1; dx = dx + 1) {
+    for (var dy = -1; dy <= 1; dy = dy + 1) {
+      if (dx == 0 && dy == 0) {
+        continue;
+      }
+      sum = sum + height_at(ix + dx, iy + dy, grid_points);
+      count = count + 1.0;
+    }
+  }
+  let avg = select(center.data0.x, sum / count, count > 0.0);
+  let delta = center.data0.x - avg;
+  let signed = sign(delta) * pow(abs(delta), 0.8);
+  let ridge = max(0.0, delta);
+  let accentStrength = 1.6;
+  let ridgeStrength = 0.35;
+  let macroStrength = 0.25;
+  let minHeight = params.field5.y;
+  let maxHeight = params.field5.z;
+  let macroOffset = (avg - 0.5) * macroStrength;
+  let rawHeight = clamp(
+    avg + signed * accentStrength + ridge * ridgeStrength + macroOffset,
+    minHeight,
+    maxHeight
+  );
+  let clampedHeight = clamp(rawHeight, 0.0, 1.0);
+
+  var out = center;
+  out.data0.x = rawHeight;
+  out.data0.w = clamp(out.data0.w + max(0.0, clampedHeight - 0.65) * 0.5, 0.0, 1.0);
+  out.data1.x = clamp((0.32 - clampedHeight) * 3.0 + (out.data0.z - 0.5) * 0.2, 0.0, 1.0);
+  samples_out[idx] = out;
+}

package/src/generator.ts

@@ -0,0 +1,106 @@
+import {
+  MicroFeature,
+  SlopeBand,
+  SurfaceCover,
+  type HexCell,
+  type MicroFeatureId,
+  type SlopeBandId,
+  type SurfaceCoverId,
+  type TerrainBiomeId,
+  type TerrainCell,
+  type TerrainParams,
+} from "./types";
+
+export function packHexCells(cells: HexCell[]): Int32Array {
+  const data = new Int32Array(cells.length * 4);
+  cells.forEach((cell, i) => {
+    const base = i * 4;
+    data[base] = cell.q | 0;
+    data[base + 1] = cell.r | 0;
+    data[base + 2] = cell.level | 0;
+    data[base + 3] = cell.flags ?? 0;
+  });
+  return data;
+}
+
+export function encodeTerrainParams(params: TerrainParams): ArrayBuffer {
+  const buffer = new ArrayBuffer(16 * 4);
+  const u32 = new Uint32Array(buffer);
+  const f32 = new Float32Array(buffer);
+  u32[0] = params.seed >>> 0;
+  u32[1] = params.cellCount >>> 0;
+  f32[2] = params.heatBias ?? 0;
+  f32[3] = params.heightScale ?? 1;
+  f32[4] = params.macroScale ?? 0.035;
+  f32[5] = params.macroWarpStrength ?? 0.18;
+  f32[6] = params.styleMixStrength ?? 1.0;
+  f32[7] = params.terraceSteps ?? 6;
+  f32[8] = params.terraceStrength ?? 0.35;
+  f32[9] = params.craterStrength ?? 0.25;
+  f32[10] = params.craterScale ?? 0.18;
+  f32[11] = params.heightMin ?? -0.35;
+  f32[12] = params.heightMax ?? 1.6;
+  f32[13] = params.slopeDownMax ?? 0.2;
+  f32[14] = params.slopeUpMin ?? 0.8;
+  f32[15] = 0;
+  return buffer;
+}
+
+function isExpandedTerrainLayout(u32: Uint32Array): boolean {
+  if (u32.length % 8 !== 0) {
+    return false;
+  }
+  const count = u32.length / 8;
+  if (count === 0) {
+    return false;
+  }
+  const sampleCount = Math.min(16, count);
+  let valid = 0;
+  for (let i = 0; i < sampleCount; i += 1) {
+    const base = i * 8;
+    const surface = u32[base + 4];
+    const slopeBand = u32[base + 7];
+    if (surface <= SurfaceCover.Sludge && slopeBand <= SlopeBand.Upward) {
+      valid += 1;
+    }
+  }
+  return valid >= Math.max(1, Math.floor(sampleCount * 0.8));
+}
+
+export function unpackTerrain(buffer: ArrayBuffer): TerrainCell[] {
+  const f32 = new Float32Array(buffer);
+  const u32 = new Uint32Array(buffer);
+  const expanded = isExpandedTerrainLayout(u32);
+  const stride = expanded ? 8 : 4;
+  const count = Math.floor(f32.length / stride);
+  const cells: TerrainCell[] = [];
+  for (let i = 0; i < count; i += 1) {
+    const base = i * stride;
+    const cell: TerrainCell = {
+      height: f32[base],
+      heat: f32[base + 1],
+      moisture: f32[base + 2],
+      biome: u32[base + 3] as TerrainBiomeId,
+    };
+    if (expanded) {
+      const surface = u32[base + 4];
+      const feature = u32[base + 5];
+      const foliage = f32[base + 6];
+      const slopeBand = u32[base + 7];
+      if (surface <= SurfaceCover.Sludge) {
+        cell.surface = surface as SurfaceCoverId;
+      }
+      if (feature <= MicroFeature.Flower) {
+        cell.feature = feature as MicroFeatureId;
+      }
+      if (Number.isFinite(foliage)) {
+        cell.foliage = foliage;
+      }
+      if (slopeBand <= SlopeBand.Upward) {
+        cell.slopeBand = slopeBand as SlopeBandId;
+      }
+    }
+    cells.push(cell);
+  }
+  return cells;
+}

package/src/hex.ts

@@ -0,0 +1,54 @@
+import type { HexCell, HexLevelSpec } from "./types";
+
+const HEX_AREA_FACTOR = (3 * Math.sqrt(3)) / 2;
+
+export function hexAreaFromSide(sideMeters: number): number {
+  return HEX_AREA_FACTOR * sideMeters * sideMeters;
+}
+
+export function hexSideFromArea(areaM2: number): number {
+  return Math.sqrt(areaM2 / HEX_AREA_FACTOR);
+}
+
+export function axialToWorld(q: number, r: number, sizeMeters: number) {
+  const x = sizeMeters * (Math.sqrt(3) * q + (Math.sqrt(3) / 2) * r);
+  const y = sizeMeters * (1.5 * r);
+  return { x, y };
+}
+
+export function generateHexGrid(radius: number, level = 0): HexCell[] {
+  const cells: HexCell[] = [];
+  for (let q = -radius; q <= radius; q += 1) {
+    const r1 = Math.max(-radius, -q - radius);
+    const r2 = Math.min(radius, -q + radius);
+    for (let r = r1; r <= r2; r += 1) {
+      cells.push({ q, r, level, flags: 0 });
+    }
+  }
+  return cells;
+}
+
+export function buildHexLevels(options: {
+  topAreaKm2?: number;
+  minAreaM2?: number;
+  levels?: number;
+} = {}): HexLevelSpec[] {
+  const topAreaKm2 = options.topAreaKm2 ?? 1000;
+  const minAreaM2 = options.minAreaM2 ?? 10;
+  const levels = Math.max(2, options.levels ?? 6);
+  const topAreaM2 = topAreaKm2 * 1_000_000;
+  const ratio = Math.pow(topAreaM2 / minAreaM2, 1 / (levels - 1));
+
+  const specs: HexLevelSpec[] = [];
+  for (let level = 0; level < levels; level += 1) {
+    const areaM2 = topAreaM2 / Math.pow(ratio, level);
+    const sideMeters = hexSideFromArea(areaM2);
+    specs.push({
+      level,
+      areaM2,
+      sideMeters,
+      acrossFlatsMeters: sideMeters * Math.sqrt(3),
+    });
+  }
+  return specs;
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from "./types";
+export * from "./hex";
+export * from "./generator";
+export * from "./wgsl";
+export * from "./fields";
+export * from "./biomes/temperate";
+export * from "./perf-monitor";
+export * from "./fractal-prepass";
+export * from "./tiles";
+export * from "./tile-cache";
+export * from "./mesh";