refactor: move world concepts into engine

engine/world/Terrain.ts

@@ -0,0 +1,121 @@
+import { STRIDE, type Mesh } from "../scene/Mesh"
+
+/** A bounded ground surface. Implementations may be procedural, sampled, or
+ * loaded; callers only depend on world-space height sampling. */
+export type Terrain = {
+  minX: number
+  minZ: number
+  maxX: number
+  maxZ: number
+  heightAt: (x: number, z: number) => number
+}
+
+/** Parameters for the built-in rolling terrain generator. Values describe the
+ * surface only; level-specific holes and materials belong to level data. */
+export type RollingTerrainConfig = {
+  inner: number
+  outer: number
+  blend: number
+  amplitude: number
+  frequency: number
+  peakHeight: number
+  peakFrequency: number
+  peakStart: number
+}
+
+export namespace Terrain {
+  /** Built-in square world with a flat center, rolling hills, and edge ridges. */
+  export function rolling(config: RollingTerrainConfig): Terrain {
+    return {
+      minX: -config.outer,
+      minZ: -config.outer,
+      maxX: config.outer,
+      maxZ: config.outer,
+      heightAt(x, z) {
+        const r = Math.max(Math.abs(x), Math.abs(z))
+        if (r <= config.inner) {
+          return 0
+        }
+        const rise = smoothstep(config.inner, config.inner + config.blend, r)
+        const hills = config.amplitude * bumps(x, z, config.frequency)
+        const k = Math.min(
+          1,
+          (r - config.inner) / (config.outer - config.inner),
+        )
+        const peaks =
+          config.peakHeight *
+          ridges(x, z, config.peakFrequency) *
+          smoothstep(config.peakStart, 1, k)
+        return rise * (hills + peaks)
+      },
+    }
+  }
+
+  export function height(terrain: Terrain, x: number, z: number): number {
+    return terrain.heightAt(x, z)
+  }
+
+  /** Append one sampled heightfield patch. `include` is level policy evaluated at
+   * each quad center, allowing arbitrary holes without teaching terrain what
+   * occupies them. */
+  export function patch(
+    terrain: Terrain,
+    mesh: Mesh,
+    x0: number,
+    z0: number,
+    x1: number,
+    z1: number,
+    cols: number,
+    rows: number,
+    uvScale: number,
+    include?: (x: number, z: number) => boolean,
+  ): void {
+    const base = mesh.verts.length / STRIDE
+    const dx = (x1 - x0) / cols
+    const dz = (z1 - z0) / rows
+    const rowLength = cols + 1
+    for (let row = 0; row <= rows; row++) {
+      const z = z0 + row * dz
+      for (let col = 0; col <= cols; col++) {
+        const x = x0 + col * dx
+        mesh.verts.push(x, terrain.heightAt(x, z), z, x * uvScale, z * uvScale)
+      }
+    }
+    for (let row = 0; row < rows; row++) {
+      for (let col = 0; col < cols; col++) {
+        const cx = x0 + (col + 0.5) * dx
+        const cz = z0 + (row + 0.5) * dz
+        if (include !== undefined && !include(cx, cz)) {
+          continue
+        }
+        const p = base + row * rowLength + col
+        mesh.indices.push(
+          p,
+          p + rowLength + 1,
+          p + 1,
+          p,
+          p + rowLength,
+          p + rowLength + 1,
+        )
+      }
+    }
+  }
+
+  function bumps(x: number, z: number, frequency: number): number {
+    const a = Math.sin(x * frequency) * Math.cos(z * frequency)
+    const b = Math.sin((x + z) * frequency * 0.5 + 1.7) * 0.5
+    return (a + b + 1.5) / 3
+  }
+
+  function ridges(x: number, z: number, frequency: number): number {
+    const n =
+      Math.sin(x * frequency + 1.3) * Math.cos(z * frequency - 0.7) * 0.7 +
+      Math.sin((x + z) * frequency * 0.6 + 2.5) * 0.3
+    return 1 - Math.abs(n)
+  }
+
+  function smoothstep(a: number, b: number, x: number): number {
+    const t = Math.max(0, Math.min(1, (x - a) / (b - a || 1e-4)))
+    return t * t * (3 - 2 * t)
+  }
+}