@plasius/gpu-world-generator 0.0.4

package/src/shaders/library/materials.wgsl

@@ -0,0 +1,175 @@
+const MATERIAL_DEFAULT: u32 = 0u;
+const MATERIAL_GRASS: u32 = 1u;
+const MATERIAL_WATER: u32 = 2u;
+const MATERIAL_ROCK: u32 = 3u;
+const MATERIAL_SAND: u32 = 4u;
+const MATERIAL_MUD: u32 = 5u;
+const MATERIAL_SNOW: u32 = 6u;
+const MATERIAL_FOLIAGE: u32 = 7u;
+
+struct MaterialResponse {
+  albedo: vec3<f32>,
+  normal: vec3<f32>,
+  specular: f32,
+  emission: vec3<f32>,
+};
+
+fn make_material(albedo: vec3<f32>, normal: vec3<f32>) -> MaterialResponse {
+  return MaterialResponse(albedo, normal, 0.08, vec3<f32>(0.0));
+}
+
+fn apply_grass(base: vec3<f32>, normal: vec3<f32>, world_pos: vec3<f32>, wind: vec4<f32>) -> MaterialResponse {
+  let wind_dir = normalize(vec3<f32>(wind.x, 0.0, wind.z));
+  let time = wind.w;
+  let wave = sin(dot(world_pos.xz, wind_dir.xz) * 2.2 + time * 1.3);
+  let detail = fbm2(world_pos.xz * 1.6 + vec2<f32>(time * 0.08, time * 0.04));
+  let bend = (wave * 0.14 + detail * 0.12);
+  let perturbed = normalize(vec3<f32>(
+    normal.x + bend * wind_dir.x,
+    normal.y + bend * 0.4,
+    normal.z + bend * wind_dir.z
+  ));
+  let tint = base * (0.92 + wave * 0.06);
+  var out = make_material(tint, perturbed);
+  out.specular = 0.12;
+  return out;
+}
+
+fn apply_water(
+  base: vec3<f32>,
+  normal: vec3<f32>,
+  world_pos: vec3<f32>,
+  wind: vec4<f32>,
+  view_dir: vec3<f32>,
+  view_dist: f32
+) -> MaterialResponse {
+  let time = wind.w;
+  let wind2 = normalize(vec2<f32>(wind.x, wind.z) + vec2<f32>(1e-3, 0.0));
+  let dir0 = wind2;
+  let dir1 = normalize(vec2<f32>(-wind2.y, wind2.x));
+  let dir2 = normalize(mix(wind2, vec2<f32>(0.7, 0.7), 0.35));
+
+  let detail = clamp01(1.0 - (view_dist - 6.0) / 25.0);
+  let detail2 = detail * detail;
+
+  let k0 = 1.6;
+  let k1 = 3.2;
+  let k2 = 6.4;
+  let a0 = 0.12;
+  let a1 = 0.05 * detail;
+  let a2 = 0.02 * detail2;
+
+  let p0 = dot(world_pos.xz, dir0) * k0 + time * 1.1;
+  let p1 = dot(world_pos.xz, dir1) * k1 + time * 1.7;
+  let p2 = dot(world_pos.xz, dir2) * k2 + time * 2.4;
+
+  let h0 = a0 * sin(p0);
+  let h1 = a1 * sin(p1);
+  let h2 = a2 * sin(p2);
+
+  var dHd = vec2<f32>(
+    a0 * k0 * cos(p0) * dir0.x + a1 * k1 * cos(p1) * dir1.x + a2 * k2 * cos(p2) * dir2.x,
+    a0 * k0 * cos(p0) * dir0.y + a1 * k1 * cos(p1) * dir1.y + a2 * k2 * cos(p2) * dir2.y
+  );
+
+  let ripple_phase = dot(world_pos.xz, vec2<f32>(12.7, 9.3)) + time * 3.5;
+  let ripple_amp = 0.006 * detail2;
+  let ripple = sin(ripple_phase) * ripple_amp;
+  dHd = dHd + vec2<f32>(12.7, 9.3) * cos(ripple_phase) * ripple_amp;
+
+  let wave_height = h0 + h1 + h2 + ripple;
+  let wave_normal = normalize(vec3<f32>(-dHd.x, 1.0, -dHd.y));
+  let water_normal = normalize(mix(normal, wave_normal, 0.85));
+
+  let ndv = clamp(dot(water_normal, view_dir), 0.0, 1.0);
+  let fresnel = 0.02 + (1.0 - 0.02) * pow(1.0 - ndv, 5.0);
+
+  let deep = vec3<f32>(0.02, 0.08, 0.14);
+  let tint = mix(base, deep, 0.55 + wave_height * 0.2);
+
+  let sky_low = vec3<f32>(0.05, 0.1, 0.16);
+  let sky_high = vec3<f32>(0.2, 0.35, 0.55);
+  let sky = mix(sky_low, sky_high, clamp01(view_dir.y * 0.5 + 0.5));
+
+  let steepness = length(dHd);
+  let foam_noise = fbm2(world_pos.xz * 0.8 + vec2<f32>(time * 0.05, time * 0.04));
+  let foam = smoothstep(0.35, 0.75, steepness) * (0.6 + 0.4 * foam_noise) * detail;
+
+  var out = make_material(tint * 0.6, water_normal);
+  out.albedo = mix(out.albedo, vec3<f32>(0.92, 0.94, 0.98), foam);
+  out.specular = mix(0.35, 0.95, fresnel);
+  out.emission = sky * fresnel * (0.35 + 0.65 * detail);
+  return out;
+}
+
+fn apply_rock(base: vec3<f32>, normal: vec3<f32>, world_pos: vec3<f32>) -> MaterialResponse {
+  let grain = fbm2(world_pos.xz * 2.4);
+  let tint = base * (0.85 + grain * 0.25);
+  var out = make_material(tint, normal);
+  out.specular = 0.18;
+  return out;
+}
+
+fn apply_sand(base: vec3<f32>, normal: vec3<f32>, world_pos: vec3<f32>) -> MaterialResponse {
+  let grain = noise2(world_pos.xz * 3.5);
+  let tint = base * (0.95 + grain * 0.12);
+  var out = make_material(tint, normal);
+  out.specular = 0.12;
+  return out;
+}
+
+fn apply_mud(base: vec3<f32>, normal: vec3<f32>, world_pos: vec3<f32>) -> MaterialResponse {
+  let ooze = fbm2(world_pos.xz * 2.0);
+  let tint = base * (0.78 + ooze * 0.1);
+  var out = make_material(tint, normal);
+  out.specular = 0.22;
+  return out;
+}
+
+fn apply_surface_material(
+  material_id: u32,
+  base_color: vec3<f32>,
+  normal: vec3<f32>,
+  world_pos: vec3<f32>,
+  wind: vec4<f32>,
+  weather: vec4<f32>,
+  view_dir: vec3<f32>,
+  view_dist: f32
+) -> MaterialResponse {
+  let season = clamp01(weather.x);
+  let wetness = clamp01(weather.y + weather.w * 0.5);
+  var snow = clamp01(weather.z + season * 0.2);
+
+  var result = make_material(base_color, normal);
+  if (material_id == MATERIAL_GRASS || material_id == MATERIAL_FOLIAGE) {
+    result = apply_grass(base_color, normal, world_pos, wind);
+  } else if (material_id == MATERIAL_WATER) {
+    result = apply_water(base_color, normal, world_pos, wind, view_dir, view_dist);
+  } else if (material_id == MATERIAL_ROCK) {
+    result = apply_rock(base_color, normal, world_pos);
+  } else if (material_id == MATERIAL_SAND) {
+    result = apply_sand(base_color, normal, world_pos);
+  } else if (material_id == MATERIAL_MUD) {
+    result = apply_mud(base_color, normal, world_pos);
+  }
+
+  if (material_id == MATERIAL_SNOW) {
+    snow = max(snow, 0.7);
+  }
+
+  if (material_id != MATERIAL_WATER) {
+    let snow_mask = snow * smoothstep(0.35, 0.92, result.normal.y);
+    result.albedo = mix(result.albedo, vec3<f32>(0.88, 0.9, 0.95), snow_mask);
+    result.specular = max(result.specular, snow_mask * 0.22);
+  }
+
+  if (material_id != MATERIAL_WATER) {
+    let flatness = smoothstep(0.55, 0.96, result.normal.y);
+    let puddle_noise = fbm2(world_pos.xz * 0.7 + vec2<f32>(wind.w * 0.03, wind.w * 0.02));
+    let puddle = wetness * flatness * smoothstep(0.45, 0.8, puddle_noise);
+    result.albedo = mix(result.albedo, result.albedo * 0.78, wetness * 0.35);
+    result.specular = max(result.specular, puddle * 0.65);
+  }
+
+  return result;
+}

package/src/terrain.wgsl

@@ -0,0 +1,451 @@
+struct HexCell {
+  q: i32,
+  r: i32,
+  level: i32,
+  flags: i32,
+};
+
+struct TerrainCell {
+  height: f32,
+  heat: f32,
+  moisture: f32,
+  biome: u32,
+  surface: u32,
+  feature: u32,
+  foliage: f32,
+  slope_band: u32,
+};
+
+struct TerrainParams {
+  seed: u32,
+  cell_count: u32,
+  heat_bias: f32,
+  height_scale: 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,
+  slope_low: f32,
+  slope_high: f32,
+  pad0: f32,
+};
+
+@group(1) @binding(0) var<storage, read> cells: array<HexCell>;
+@group(1) @binding(1) var<storage, read_write> terrain: array<TerrainCell>;
+@group(1) @binding(2) var<uniform> params: TerrainParams;
+
+const BIOME_PLAINS: u32 = 0u;
+const BIOME_TUNDRA: u32 = 1u;
+const BIOME_SAVANNA: u32 = 2u;
+const BIOME_RIVER: u32 = 3u;
+const BIOME_CITY: u32 = 4u;
+const BIOME_VILLAGE: u32 = 5u;
+const BIOME_ICE: u32 = 6u;
+const BIOME_MOUNTAINOUS: u32 = 8u;
+const BIOME_VOLCANIC: u32 = 9u;
+const BIOME_ROAD: u32 = 10u;
+const BIOME_TOWN: u32 = 11u;
+const BIOME_CASTLE: u32 = 12u;
+const BIOME_MIXED_FOREST: u32 = 13u;
+
+const SURFACE_GRASS: u32 = 0u;
+const SURFACE_DIRT: u32 = 1u;
+const SURFACE_SAND: u32 = 2u;
+const SURFACE_ROCK: u32 = 3u;
+const SURFACE_GRAVEL: u32 = 4u;
+const SURFACE_ICE: u32 = 6u;
+const SURFACE_MUD: u32 = 7u;
+const SURFACE_WATER: u32 = 11u;
+const SURFACE_BASALT: u32 = 12u;
+
+const FEATURE_TREE: u32 = 0u;
+const FEATURE_BUSH: u32 = 1u;
+const FEATURE_GRASS_TUFT: u32 = 2u;
+const FEATURE_REED: u32 = 3u;
+const FEATURE_ROCK: u32 = 4u;
+const FEATURE_BOULDER: u32 = 5u;
+const FEATURE_WATER_RIPPLE: u32 = 6u;
+const FEATURE_ICE_SPIKE: u32 = 7u;
+const FEATURE_RUIN: u32 = 13u;
+const FEATURE_NONE: u32 = 4294967295u;
+
+const SLOPE_DOWNWARD: u32 = 0u;
+const SLOPE_FLAT: u32 = 1u;
+const SLOPE_UPWARD: u32 = 2u;
+
+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(10u, 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 hash_cell(cell: HexCell, seed: u32, salt: u32) -> f32 {
+  let q = u32(bitcast<u32>(cell.q));
+  let r = u32(bitcast<u32>(cell.r));
+  let lvl = u32(bitcast<u32>(cell.level));
+  let mixed = q * 1664525u ^ r * 1013904223u ^ lvl * 747796405u ^ seed ^ salt;
+  return hash01(mixed);
+}
+
+fn classify_slope(cumulative_height: f32, low: f32, high: f32) -> u32 {
+  if (cumulative_height < low) {
+    return SLOPE_DOWNWARD;
+  }
+  if (cumulative_height >= high) {
+    return SLOPE_UPWARD;
+  }
+  return SLOPE_FLAT;
+}
+
+fn classify_biome(
+  heat: f32,
+  moisture: f32,
+  surface: u32,
+  slope_band: u32,
+  obstacle: f32,
+  foliage: f32
+) -> u32 {
+  if (surface == SURFACE_WATER) {
+    if (heat < 0.25) {
+      return BIOME_ICE;
+    }
+    return BIOME_RIVER;
+  }
+  if (surface == SURFACE_ICE) {
+    return BIOME_ICE;
+  }
+  if (slope_band == SLOPE_UPWARD && obstacle > 0.68) {
+    if (heat > 0.72) {
+      return BIOME_VOLCANIC;
+    }
+    return BIOME_MOUNTAINOUS;
+  }
+  if (heat < 0.3) {
+    return BIOME_TUNDRA;
+  }
+  if (heat > 0.74 && moisture < 0.33) {
+    return BIOME_SAVANNA;
+  }
+  if (foliage > 0.55 && moisture > 0.45) {
+    return BIOME_MIXED_FOREST;
+  }
+  return BIOME_PLAINS;
+}
+
+fn maybe_settlement(current: u32, height: f32, cell: HexCell, seed: u32, obstacle: f32) -> u32 {
+  let settlement = hash_cell(cell, seed, 0x9e3779b9u);
+  let level = cell.level;
+  if (obstacle > 0.8) {
+    return current;
+  }
+  if (height > 0.6 && settlement > 0.997) {
+    return BIOME_CASTLE;
+  }
+  if (level <= 0 && settlement > 0.994) {
+    return BIOME_CITY;
+  }
+  if (level <= 1 && settlement > 0.992) {
+    return BIOME_TOWN;
+  }
+  if (level <= 2 && settlement > 0.988) {
+    return BIOME_VILLAGE;
+  }
+  let roadNoise = hash_cell(cell, seed, 0x6c8e9cf5u);
+  if (level >= 2 && roadNoise > 0.996) {
+    return BIOME_ROAD;
+  }
+  return current;
+}
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  if (job_index >= params.cell_count) {
+    return;
+  }
+
+  let cell = cells[job_index];
+  let p = vec2<f32>(f32(cell.q), f32(cell.r));
+  let seed = params.seed;
+
+  let scale = 0.14;
+  let warp_scale = 0.5;
+  let warp_strength = 0.75;
+  let power = 2.2;
+  let detail_scale = 3.2;
+  let detail_power = 2.0;
+  let iterations = 24u;
+  let detail_iterations = 14u;
+
+  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(12u, 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(14u, 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);
+  let terrace = terrace_height(baseHeight, params.terrace_steps);
+  let crater = crater_field(warped, 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 cumulative_height = clamp(
+    base * 0.38 + mid * 0.33 + detail * 0.21 + styleMask * 0.08,
+    0.0,
+    1.0
+  );
+  let slopeLow = clamp(params.slope_low, 0.01, 0.49);
+  let slopeHigh = clamp(max(slopeLow + 0.01, params.slope_high), 0.5, 0.99);
+  let slopeBand = classify_slope(cumulative_height, slopeLow, slopeHigh);
+  let downwardStrength = 1.0 - smoothstep(0.0, slopeLow, cumulative_height);
+  let upwardStrength = smoothstep(slopeHigh, 1.0, cumulative_height);
+  let flatStrength = clamp(1.0 - max(downwardStrength, upwardStrength), 0.0, 1.0);
+
+  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 +
+      upwardStrength * 0.22 -
+      downwardStrength * 0.22,
+    params.height_min,
+    params.height_max
+  );
+  let height01 = clamp(rawHeight, 0.0, 1.0);
+
+  let roughness = clamp(pow(ridge, 1.25) * 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,
+    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);
+
+  let feature_mask = smooth_mandelbrot(
+    warped.x * scale * (detail_scale + 1.25) - offX * 0.85,
+    warped.y * scale * (detail_scale + 1.25) - offZ * 0.85,
+    max(12u, detail_iterations),
+    detail_power + 0.15
+  );
+  let obstacle = clamp(
+    feature_mask * 0.58 +
+      roughness * 0.25 +
+      upwardStrength * 0.25 -
+      moisture * 0.16 -
+      water * 0.2,
+    0.0,
+    1.0
+  );
+  let foliage_field = smooth_mandelbrot(
+    warped.x * scale * (detail_scale * 1.85 + 0.35) + offX * 1.9,
+    warped.y * scale * (detail_scale * 1.85 + 0.35) + offZ * 1.9,
+    max(16u, detail_iterations + 2u),
+    max(1.6, detail_power - 0.2)
+  );
+  let foliage = clamp(
+    foliage_field * moisture * (1.0 - water) * (0.35 + flatStrength * 0.65) * (1.0 - obstacle * 0.82),
+    0.0,
+    1.0
+  );
+
+  var surface = SURFACE_DIRT;
+  if (water > 0.58 || cumulative_height < 0.14) {
+    surface = SURFACE_WATER;
+  } else if (heat < 0.2 && water > 0.42) {
+    surface = SURFACE_ICE;
+  } else if (slopeBand == SLOPE_DOWNWARD && moisture > 0.52) {
+    surface = SURFACE_MUD;
+  } else if (obstacle > 0.72 || slopeBand == SLOPE_UPWARD) {
+    surface = SURFACE_ROCK;
+    if (heat > 0.72) {
+      surface = SURFACE_BASALT;
+    }
+  } else if (heat > 0.74 && moisture < 0.32) {
+    surface = SURFACE_SAND;
+  } else if (foliage > 0.45 && moisture > 0.42) {
+    surface = SURFACE_GRASS;
+  } else if (moisture > 0.6) {
+    surface = SURFACE_DIRT;
+  } else if (obstacle > 0.5) {
+    surface = SURFACE_GRAVEL;
+  }
+
+  let featureNoise = hash_cell(cell, seed, 0x77abu);
+  var feature = FEATURE_NONE;
+  if (surface == SURFACE_WATER) {
+    feature = FEATURE_WATER_RIPPLE;
+  } else if (surface == SURFACE_ICE && featureNoise > 0.45) {
+    feature = FEATURE_ICE_SPIKE;
+  } else if (
+    surface == SURFACE_ROCK ||
+    surface == SURFACE_GRAVEL ||
+    surface == SURFACE_BASALT
+  ) {
+    feature = FEATURE_ROCK;
+    if (obstacle > 0.85) {
+      feature = FEATURE_BOULDER;
+    }
+  } else if (surface == SURFACE_MUD && featureNoise > 0.75) {
+    feature = FEATURE_REED;
+  } else if (foliage > 0.72 && moisture > 0.55 && featureNoise > 0.35) {
+    feature = FEATURE_TREE;
+  } else if (foliage > 0.5 && featureNoise > 0.28) {
+    feature = FEATURE_BUSH;
+  } else if (surface == SURFACE_GRASS && foliage > 0.3 && featureNoise > 0.15) {
+    feature = FEATURE_GRASS_TUFT;
+  } else if (slopeBand == SLOPE_UPWARD && obstacle > 0.6 && featureNoise > 0.94) {
+    feature = FEATURE_RUIN;
+  }
+
+  var biome = classify_biome(heat, moisture, surface, slopeBand, obstacle, foliage);
+  biome = maybe_settlement(biome, height01, cell, params.seed, obstacle);
+
+  terrain[job_index].height = rawHeight * params.height_scale;
+  terrain[job_index].heat = heat;
+  terrain[job_index].moisture = moisture;
+  terrain[job_index].biome = biome;
+  terrain[job_index].surface = surface;
+  terrain[job_index].feature = feature;
+  terrain[job_index].foliage = foliage;
+  terrain[job_index].slope_band = slopeBand;
+}