@plasius/gpu-world-generator 0.0.4

package/src/biomes/temperate.ts

@@ -0,0 +1,387 @@
+import { axialToWorld, buildHexLevels, generateHexGrid } from "../hex";
+import { defaultFieldParams, sampleFieldStack, type FieldSample } from "../fields";
+import {
+  MacroBiome,
+  MicroFeature,
+  SlopeBand,
+  SurfaceCover,
+  TerrainBiome,
+  type HexCell,
+  type HexLevelSpec,
+  type TerrainCell,
+  type MacroBiomeId,
+  type MicroFeatureId,
+  type TerrainBiomeId,
+  type SurfaceCoverId,
+} from "../types";
+
+export interface MixedForestOptions {
+  seed?: number;
+  terrainSeed?: number;
+  featureSeed?: number;
+  foliageSeed?: number;
+  radius?: number;
+  topAreaKm2?: number;
+  minAreaM2?: number;
+  levels?: number;
+}
+
+export interface MixedForestLayer {
+  levelSpec: HexLevelSpec;
+  cells: HexCell[];
+  terrain: TerrainCell[];
+}
+
+function hash32(x: number): number {
+  let v = x >>> 0;
+  v ^= v >>> 17;
+  v = Math.imul(v, 0xed5ad4bb);
+  v ^= v >>> 11;
+  v = Math.imul(v, 0xac4c1b51);
+  v ^= v >>> 15;
+  v = Math.imul(v, 0x31848bab);
+  v ^= v >>> 14;
+  return v >>> 0;
+}
+
+function hash01(x: number): number {
+  return (hash32(x) & 0x00ffffff) / 16777216;
+}
+
+function hashCell(cell: HexCell, seed: number, salt: number): number {
+  const q = cell.q | 0;
+  const r = cell.r | 0;
+  const level = cell.level | 0;
+  const mixed =
+    (Math.imul(q, 1664525) ^ Math.imul(r, 1013904223) ^ Math.imul(level, 747796405) ^ seed ^ salt) >>>
+    0;
+  return hash01(mixed);
+}
+
+function clamp01(value: number): number {
+  return Math.min(1, Math.max(0, value));
+}
+
+function createBiomeFieldParams(seed: number) {
+  const params = defaultFieldParams(seed);
+  params.heatBias = -0.02;
+  params.moistureBias = 0.08;
+  return params;
+}
+
+function selectSurface(sample: FieldSample): SurfaceCoverId {
+  if (sample.water > 0.58 || sample.cumulativeHeight < 0.14) {
+    return SurfaceCover.Water;
+  }
+  if (sample.heat < 0.18 && sample.water > 0.36) {
+    return SurfaceCover.Ice;
+  }
+  if (
+    sample.heat < 0.3 &&
+    (sample.slopeBand === SlopeBand.Upward || sample.cumulativeHeight > 0.52)
+  ) {
+    return sample.obstacleMask > 0.58 ? SurfaceCover.Rock : SurfaceCover.Gravel;
+  }
+  if (sample.slopeBand === SlopeBand.Downward && sample.moisture > 0.52) {
+    return SurfaceCover.Mud;
+  }
+  if (sample.obstacleMask > 0.72 || sample.slopeBand === SlopeBand.Upward) {
+    return sample.heat > 0.72 ? SurfaceCover.Basalt : SurfaceCover.Rock;
+  }
+  if (sample.heat > 0.74 && sample.moisture < 0.32) {
+    return SurfaceCover.Sand;
+  }
+  const grassCapable =
+    sample.heat >= 0.32 &&
+    sample.heat <= 0.82 &&
+    sample.moisture >= 0.34 &&
+    sample.moisture <= 0.88 &&
+    sample.slopeBand === SlopeBand.Flat;
+  if (grassCapable && sample.foliageMask > 0.4) {
+    return SurfaceCover.Grass;
+  }
+  if (sample.moisture > 0.6) {
+    return SurfaceCover.Dirt;
+  }
+  return sample.obstacleMask > 0.5 ? SurfaceCover.Gravel : SurfaceCover.Dirt;
+}
+
+function supportsGroundFoliage(surface: SurfaceCoverId): boolean {
+  return (
+    surface === SurfaceCover.Grass ||
+    surface === SurfaceCover.Dirt ||
+    surface === SurfaceCover.Mud
+  );
+}
+
+function supportsObstacleSurface(surface: SurfaceCoverId): boolean {
+  return (
+    surface === SurfaceCover.Rock ||
+    surface === SurfaceCover.Gravel ||
+    surface === SurfaceCover.Basalt
+  );
+}
+
+function axialDistance(a: HexCell, b: HexCell): number {
+  const dq = a.q - b.q;
+  const dr = a.r - b.r;
+  return (Math.abs(dq) + Math.abs(dr) + Math.abs(dq + dr)) * 0.5;
+}
+
+function selectFeature(
+  surface: SurfaceCoverId,
+  sample: FieldSample,
+  variation: number,
+  nearestTreeDistance: number,
+  nearestObstacleDistance: number,
+  nearbyObstacleRatio: number,
+  isTreeAnchor: boolean
+): MicroFeatureId | undefined {
+  if (isTreeAnchor) {
+    return MicroFeature.Tree;
+  }
+  if (surface === SurfaceCover.Water) {
+    return variation > 0.88 && sample.moisture > 0.64 ? MicroFeature.Reed : MicroFeature.WaterRipple;
+  }
+  if (surface === SurfaceCover.Ice && variation > 0.45) {
+    return MicroFeature.IceSpike;
+  }
+  if (
+    surface === SurfaceCover.Rock ||
+    surface === SurfaceCover.Gravel ||
+    surface === SurfaceCover.Basalt
+  ) {
+    return sample.obstacleMask > 0.85 ? MicroFeature.Boulder : MicroFeature.Rock;
+  }
+  if (surface === SurfaceCover.Mud && variation > 0.78) {
+    return MicroFeature.Reed;
+  }
+  const nearTree = nearestTreeDistance <= 2.0;
+  const underCanopy = nearestTreeDistance <= 1.2;
+
+  if (nearTree && sample.foliageMask > 0.48 && sample.moisture > 0.42 && variation > 0.36) {
+    if (surface === SurfaceCover.Mud) {
+      return MicroFeature.Bush;
+    }
+    if (variation > 0.7 || underCanopy) {
+      return MicroFeature.Bush;
+    }
+    return MicroFeature.GrassTuft;
+  }
+
+  const openArea =
+    nearestTreeDistance >= 3.0 &&
+    nearestObstacleDistance >= 2.2 &&
+    (surface === SurfaceCover.Grass || surface === SurfaceCover.Dirt);
+  if (
+    openArea &&
+    sample.moisture > 0.32 &&
+    sample.moisture < 0.76 &&
+    sample.heat > 0.28 &&
+    sample.heat < 0.82 &&
+    variation > 0.9
+  ) {
+    return MicroFeature.Flower;
+  }
+
+  const obstacleFalloff = Number.isFinite(nearestObstacleDistance)
+    ? clamp01((3.5 - nearestObstacleDistance) / 3.5)
+    : 0;
+  const snowLikeGrassDeposit = clamp01(obstacleFalloff * 0.7 + nearbyObstacleRatio * 0.3);
+
+  if (
+    supportsGroundFoliage(surface) &&
+    sample.heat >= 0.3 &&
+    sample.heat <= 0.84 &&
+    sample.moisture >= 0.28 &&
+    sample.moisture <= 0.9 &&
+    sample.water < 0.24 &&
+    variation < 0.96
+  ) {
+    const depositThreshold = clamp01(
+      0.44 -
+        snowLikeGrassDeposit * 0.24 -
+        sample.foliageMask * 0.08 +
+        Math.max(0, sample.moisture - 0.75) * 0.1
+    );
+    if (variation > depositThreshold) {
+      return MicroFeature.GrassTuft;
+    }
+  }
+
+  if (sample.slopeBand === SlopeBand.Upward && sample.obstacleMask > 0.6 && variation > 0.94) {
+    return MicroFeature.Ruin;
+  }
+
+  return undefined;
+}
+
+function selectBiome(surface: SurfaceCoverId, sample: FieldSample): TerrainBiomeId {
+  if (surface === SurfaceCover.Water) {
+    return sample.heat < 0.25 ? TerrainBiome.Ice : TerrainBiome.River;
+  }
+  if (surface === SurfaceCover.Ice) {
+    return TerrainBiome.Ice;
+  }
+  if (sample.slopeBand === SlopeBand.Upward && sample.obstacleMask > 0.68) {
+    return sample.heat > 0.72 ? TerrainBiome.Volcanic : TerrainBiome.Mountainous;
+  }
+  if (sample.heat < 0.3) {
+    return TerrainBiome.Tundra;
+  }
+  if (sample.heat > 0.74 && sample.moisture < 0.33) {
+    return TerrainBiome.Savanna;
+  }
+  if (sample.foliageMask > 0.55 && sample.moisture > 0.45) {
+    return TerrainBiome.MixedForest;
+  }
+  return TerrainBiome.Plains;
+}
+
+function selectMacroBiome(sample: FieldSample): MacroBiomeId {
+  if (sample.water > 0.62) {
+    return MacroBiome.Freshwater;
+  }
+  if (sample.slopeBand === SlopeBand.Upward && sample.obstacleMask > 0.68) {
+    return MacroBiome.Alpine;
+  }
+  if (sample.heat > 0.74 && sample.moisture < 0.33) {
+    return MacroBiome.Arid;
+  }
+  if (sample.heat < 0.3) {
+    return MacroBiome.ColdTemperate;
+  }
+  return MacroBiome.Temperate;
+}
+
+export function generateTemperateMixedForest(options: MixedForestOptions): MixedForestLayer {
+  const terrainSeed = (options.terrainSeed ?? options.seed ?? 1337) >>> 0;
+  const featureSeed = (options.featureSeed ?? terrainSeed ^ 0x9e3779b9) >>> 0;
+  const foliageSeed = (options.foliageSeed ?? terrainSeed ^ 0x85ebca6b) >>> 0;
+  const levelSpecs = buildHexLevels({
+    topAreaKm2: options.topAreaKm2 ?? 1000,
+    minAreaM2: options.minAreaM2 ?? 10,
+    levels: options.levels ?? 6,
+  });
+  const levelSpec = levelSpecs[levelSpecs.length - 1];
+  const radius = options.radius ?? 6;
+  const cells = generateHexGrid(radius, levelSpec.level);
+  const terrainParams = createBiomeFieldParams(terrainSeed);
+  const featureParams = createBiomeFieldParams(featureSeed);
+  const foliageParams = createBiomeFieldParams(foliageSeed);
+
+  const candidates = cells.map((cell) => {
+    const world = axialToWorld(cell.q, cell.r, 1);
+    const terrainSample = sampleFieldStack(world.x, world.y, terrainParams);
+    const featureSample = sampleFieldStack(world.x, world.y, featureParams);
+    const foliageSample = sampleFieldStack(world.x, world.y, foliageParams);
+    const sample: FieldSample = {
+      ...terrainSample,
+      featureMask: featureSample.featureMask,
+      obstacleMask: featureSample.obstacleMask,
+      foliageMask: foliageSample.foliageMask,
+    };
+    const featureNoise = hashCell(cell, featureSeed, 0x77ab);
+    const foliageNoise = hashCell(cell, foliageSeed, 0x51ac);
+    const variation = clamp01(featureNoise * 0.65 + foliageNoise * 0.35);
+    const surface = selectSurface(sample);
+    const biome = selectBiome(surface, sample);
+    return {
+      cell,
+      sample,
+      variation,
+      surface,
+      biome,
+      macroBiome: selectMacroBiome(sample),
+    };
+  });
+
+  const treeAnchorIndexes: number[] = [];
+  for (let i = 0; i < candidates.length; i += 1) {
+    const candidate = candidates[i];
+    if (!supportsGroundFoliage(candidate.surface)) {
+      continue;
+    }
+    const treeChance = clamp01(
+      0.008 +
+        candidate.sample.foliageMask * 0.03 +
+        Math.max(0, candidate.sample.moisture - 0.45) * 0.04 -
+        candidate.sample.obstacleMask * 0.02
+    );
+    const treeRoll = hashCell(candidate.cell, foliageSeed, 0xa11c);
+    if (
+      candidate.sample.heat > 0.24 &&
+      candidate.sample.heat < 0.82 &&
+      candidate.sample.moisture > 0.42 &&
+      candidate.sample.water < 0.2 &&
+      treeRoll < treeChance
+    ) {
+      treeAnchorIndexes.push(i);
+    }
+  }
+
+  const treeAnchorSet = new Set<number>(treeAnchorIndexes);
+  const obstacleAnchorIndexes: number[] = [];
+  for (let i = 0; i < candidates.length; i += 1) {
+    const candidate = candidates[i];
+    if (supportsObstacleSurface(candidate.surface) || candidate.sample.obstacleMask > 0.72) {
+      obstacleAnchorIndexes.push(i);
+    }
+  }
+  const obstacleRadius = 4;
+
+  const terrain = candidates.map((candidate, index) => {
+    const isTreeAnchor = treeAnchorSet.has(index);
+    let nearestTreeDistance = Number.POSITIVE_INFINITY;
+    if (isTreeAnchor) {
+      nearestTreeDistance = 0;
+    } else {
+      for (const treeIndex of treeAnchorIndexes) {
+        const distance = axialDistance(candidate.cell, candidates[treeIndex].cell);
+        if (distance < nearestTreeDistance) {
+          nearestTreeDistance = distance;
+        }
+      }
+    }
+
+    let nearestObstacleDistance = Number.POSITIVE_INFINITY;
+    let nearbyObstacleCount = 0;
+    for (const obstacleIndex of obstacleAnchorIndexes) {
+      const distance = axialDistance(candidate.cell, candidates[obstacleIndex].cell);
+      if (distance < nearestObstacleDistance) {
+        nearestObstacleDistance = distance;
+      }
+      if (distance <= obstacleRadius) {
+        nearbyObstacleCount += 1;
+      }
+    }
+    const nearbyObstacleRatio = clamp01(nearbyObstacleCount / 12);
+
+    const feature = selectFeature(
+      candidate.surface,
+      candidate.sample,
+      candidate.variation,
+      nearestTreeDistance,
+      nearestObstacleDistance,
+      nearbyObstacleRatio,
+      isTreeAnchor
+    );
+
+    const cellData: TerrainCell = {
+      height: clamp01(candidate.sample.height),
+      heat: candidate.sample.heat,
+      moisture: candidate.sample.moisture,
+      biome: candidate.biome,
+      macroBiome: candidate.macroBiome,
+      surface: candidate.surface,
+      feature,
+      obstacle: candidate.sample.obstacleMask,
+      foliage: candidate.sample.foliageMask,
+      slopeBand: candidate.sample.slopeBand,
+    };
+
+    return cellData;
+  });
+
+  return { levelSpec, cells, terrain };
+}

package/src/field.wgsl

@@ -0,0 +1,225 @@
+struct FieldParams {
+  seed: u32,
+  sample_count: u32,
+  scale: f32,
+  warp_scale: f32,
+  warp_strength: f32,
+  iterations: u32,
+  power: f32,
+  detail_scale: f32,
+  detail_iterations: u32,
+  detail_power: f32,
+  ridge_power: f32,
+  heat_bias: f32,
+  moisture_bias: f32,
+  macro_scale: f32,
+  macro_warp_strength: f32,
+  style_mix_strength: f32,
+  terrace_steps: f32,
+  terrace_strength: f32,
+  crater_strength: f32,
+  crater_scale: f32,
+  height_min: f32,
+  height_max: f32,
+};
+
+struct FieldSample {
+  height: f32,
+  heat: f32,
+  moisture: f32,
+  roughness: f32,
+  rockiness: f32,
+  water: f32,
+  ridge: f32,
+  base: f32,
+  detail: f32,
+};
+
+@group(1) @binding(0) var<storage, read> points: array<vec2<f32>>;
+@group(1) @binding(1) var<storage, read_write> samples: array<FieldSample>;
+@group(1) @binding(2) var<uniform> params: FieldParams;
+
+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) -> f32 {
+  let macro_iter = max(12u, iterations / 3u);
+  let macroA = smooth_mandelbrot(p.x * params.macro_scale, p.y * params.macro_scale, macro_iter, power);
+  let macroB = smooth_mandelbrot(
+    (p.x + 13.7) * params.macro_scale,
+    (p.y - 9.2) * params.macro_scale,
+    macro_iter,
+    power + 0.35
+  );
+  let warp = vec2<f32>(macroA - 0.5, macroB - 0.5) * params.macro_warp_strength;
+  let macroC = smooth_mandelbrot(
+    (p.x + warp.x) * params.macro_scale,
+    (p.y + warp.y) * params.macro_scale,
+    macro_iter,
+    power
+  );
+  return clamp((macroC - 0.5) * params.style_mix_strength + 0.5, 0.0, 1.0);
+}
+
+fn sample_field(p: vec2<f32>) -> FieldSample {
+  let seed = params.seed;
+  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, params.iterations * 6u / 10u);
+  let warpA = smooth_mandelbrot(
+    (p.x + warpOffX) * params.warp_scale,
+    (p.y + warpOffZ) * params.warp_scale,
+    warpIter,
+    params.power
+  );
+  let warpB = smooth_mandelbrot(
+    (p.x - warpOffZ) * params.warp_scale,
+    (p.y + warpOffX) * params.warp_scale,
+    warpIter,
+    params.power
+  );
+
+  let warped = vec2<f32>(
+    p.x + (warpA - 0.5) * params.warp_strength,
+    p.y + (warpB - 0.5) * params.warp_strength
+  );
+
+  let base = smooth_mandelbrot(
+    warped.x * params.scale + offX,
+    warped.y * params.scale + offZ,
+    params.iterations,
+    params.power
+  );
+  let mid = smooth_mandelbrot(
+    warped.x * params.scale * 2.15 + offX * 0.6,
+    warped.y * params.scale * 2.15 + offZ * 0.6,
+    max(18u, params.iterations * 7u / 10u),
+    params.power + 0.2
+  );
+  let detail = smooth_mandelbrot(
+    warped.x * params.scale * params.detail_scale + offX * 1.4,
+    warped.y * params.scale * params.detail_scale + offZ * 1.4,
+    params.detail_iterations,
+    params.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(p, params.iterations, params.power);
+  let terrace = terrace_height(baseHeight, params.terrace_steps);
+  let crater = crater_field(p, params.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 - params.terrace_strength) +
+      terrace * params.terrace_strength -
+      crater * params.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,
+    params.height_min,
+    params.height_max
+  );
+  let height01 = clamp(rawHeight, 0.0, 1.0);
+
+  let roughness = clamp(pow(ridge, params.ridge_power) * 0.7 + detail * 0.3, 0.0, 1.0);
+  let heat = clamp(0.55 * mid + 0.35 * (1.0 - height01) + params.heat_bias, 0.0, 1.0);
+  let moisture = clamp(
+    0.55 * detail + 0.35 * (1.0 - height01) - (heat - 0.5) * 0.1 + params.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 FieldSample(rawHeight, heat, moisture, roughness, rockiness, water, ridge, base, detail);
+}
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  if (job_index >= params.sample_count) {
+    return;
+  }
+  let p = points[job_index];
+  samples[job_index] = sample_field(p);
+}