scena3d 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -23,16 +23,28 @@ __export(index_exports, {
   DEFAULT_PALETTE: () => DEFAULT_PALETTE,
   PALETTES: () => PALETTES,
   Rng: () => Rng,
+  aboveWater: () => aboveWater,
   applyFog: () => applyFog,
+  applyWind: () => applyWind,
   collectObstacles: () => collectObstacles,
+  createBush: () => createBush,
   createCrate: () => createCrate,
+  createDayCycle: () => createDayCycle,
   createFence: () => createFence,
+  createGrassTuft: () => createGrassTuft,
+  createHouse: () => createHouse,
   createLamp: () => createLamp,
   createLightingRig: () => createLightingRig,
+  createPath: () => createPath,
   createRock: () => createRock,
+  createRuin: () => createRuin,
   createSky: () => createSky,
   createTerrain: () => createTerrain,
+  createTower: () => createTower,
   createTree: () => createTree,
+  createVillage: () => createVillage,
+  createWater: () => createWater,
+  createWell: () => createWell,
   fractalNoise2: () => fractalNoise2,
   hash2: () => hash2,
   scatter: () => scatter,
@@ -121,7 +133,12 @@ var PALETTES = {
     peak: 15265007,
     skyTop: 4026552,
     skyBottom: 12573160,
-    fog: 12111837
+    fog: 12111837,
+    water: 4161454,
+    sand: 13220234,
+    path: 10125663,
+    wall: 14273712,
+    roof: 11032126
   },
   autumn: {
     foliage: [13202735, 14257722, 11754538, 14722373],
@@ -137,7 +154,12 @@ var PALETTES = {
     peak: 14933716,
     skyTop: 9333928,
     skyBottom: 15255976,
-    fog: 14270888
+    fog: 14270888,
+    water: 4881042,
+    sand: 13348995,
+    path: 9270356,
+    wall: 13416596,
+    roof: 9062960
   },
   dusk: {
     foliage: [2055750, 2385999, 1724992, 2978904],
@@ -153,7 +175,33 @@ var PALETTES = {
     peak: 12105945,
     skyTop: 1909061,
     skyBottom: 13199946,
-    fog: 6969978
+    fog: 6969978,
+    water: 2968168,
+    sand: 9075306,
+    path: 6969938,
+    wall: 9274009,
+    roof: 4535640
+  },
+  winter: {
+    foliage: [3038280, 3696986, 5405288, 8889750],
+    trunk: 4864563,
+    rock: [10134701, 8687256, 11581632],
+    wood: 7823433,
+    woodDark: 5522746,
+    metal: 3752013,
+    lampGlow: 16767113,
+    grassLow: 13621726,
+    grassHigh: 15002606,
+    cliff: 7764349,
+    peak: 16054266,
+    skyTop: 5929894,
+    skyBottom: 14214380,
+    fog: 13424864,
+    water: 4878470,
+    sand: 12108486,
+    path: 9143160,
+    wall: 13814203,
+    roof: 7030328
   }
 };
 var DEFAULT_PALETTE = PALETTES.meadow;
@@ -368,8 +416,321 @@ function createLamp(options = {}) {
   return { object: group, obstacleRadius: 0.25 };
 }
 
-// src/environment/terrain.ts
+// src/props/grass.ts
 var import_three7 = require("three");
+function createGrassTuft(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const blades = options.blades ?? rng.int(4, 6);
+  const group = new import_three7.Group();
+  group.name = "grass";
+  const material = new import_three7.MeshStandardMaterial({
+    color: rng.next() < 0.5 ? palette.grassHigh : rng.pick(palette.foliage),
+    flatShading: true
+  });
+  for (let i = 0; i < blades; i++) {
+    const height = rng.range(0.25, 0.5);
+    const blade = new import_three7.Mesh(new import_three7.ConeGeometry(0.035, height, 3), material);
+    blade.position.set(rng.jitter(0, 0.12), height / 2, rng.jitter(0, 0.12));
+    blade.rotation.set(rng.range(-0.25, 0.25), rng.range(0, Math.PI), rng.range(-0.25, 0.25));
+    group.add(blade);
+  }
+  return { object: group, obstacleRadius: 0 };
+}
+function createBush(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const size = options.size ?? rng.range(0.4, 0.7);
+  const group = new import_three7.Group();
+  group.name = "bush";
+  const material = new import_three7.MeshStandardMaterial({ color: rng.pick(palette.foliage), flatShading: true });
+  const blobs = rng.int(2, 3);
+  for (let i = 0; i < blobs; i++) {
+    const radius = size * rng.range(0.55, 0.85);
+    const blob = new import_three7.Mesh(new import_three7.IcosahedronGeometry(radius, 0), material);
+    blob.position.set(rng.jitter(0, size * 0.4), radius * 0.7, rng.jitter(0, size * 0.4));
+    blob.scale.y = rng.range(0.7, 0.85);
+    blob.rotation.y = rng.range(0, Math.PI);
+    group.add(blob);
+  }
+  return { object: group, obstacleRadius: size * 0.6 };
+}
+
+// src/props/building.ts
+var import_three8 = require("three");
+function prismGeometry(width, height, depth) {
+  const w = width / 2;
+  const d = depth / 2;
+  const positions = new Float32Array([
+    // front gable (z = +d)
+    -w,
+    0,
+    d,
+    w,
+    0,
+    d,
+    0,
+    height,
+    d,
+    // back gable (z = -d)
+    w,
+    0,
+    -d,
+    -w,
+    0,
+    -d,
+    0,
+    height,
+    -d,
+    // left slope
+    -w,
+    0,
+    -d,
+    -w,
+    0,
+    d,
+    0,
+    height,
+    d,
+    -w,
+    0,
+    -d,
+    0,
+    height,
+    d,
+    0,
+    height,
+    -d,
+    // right slope
+    w,
+    0,
+    d,
+    w,
+    0,
+    -d,
+    0,
+    height,
+    -d,
+    w,
+    0,
+    d,
+    0,
+    height,
+    -d,
+    0,
+    height,
+    d,
+    // bottom
+    -w,
+    0,
+    -d,
+    w,
+    0,
+    -d,
+    w,
+    0,
+    d,
+    -w,
+    0,
+    -d,
+    w,
+    0,
+    d,
+    -w,
+    0,
+    d
+  ]);
+  const geometry = new import_three8.BufferGeometry();
+  geometry.setAttribute("position", new import_three8.BufferAttribute(positions, 3));
+  geometry.computeVertexNormals();
+  return geometry;
+}
+function createHouse(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const width = options.width ?? rng.range(3.2, 4.2);
+  const depth = options.depth ?? width * rng.range(0.75, 0.9);
+  const wallHeight = options.wallHeight ?? rng.range(2.1, 2.4);
+  const group = new import_three8.Group();
+  group.name = "house";
+  const wall = new import_three8.MeshStandardMaterial({ color: palette.wall, flatShading: true });
+  wall.color.offsetHSL(0, 0, rng.range(-0.03, 0.03));
+  const roof = new import_three8.MeshStandardMaterial({ color: palette.roof, flatShading: true });
+  roof.color.offsetHSL(0, 0, rng.range(-0.04, 0.04));
+  const stone = new import_three8.MeshStandardMaterial({ color: palette.rock[0], flatShading: true });
+  const wood = new import_three8.MeshStandardMaterial({ color: palette.woodDark, flatShading: true });
+  const foundation = new import_three8.Mesh(new import_three8.BoxGeometry(width + 0.3, 1.6, depth + 0.3), stone);
+  foundation.position.y = -0.55;
+  group.add(foundation);
+  const body = new import_three8.Mesh(new import_three8.BoxGeometry(width, wallHeight, depth), wall);
+  body.position.y = wallHeight / 2;
+  group.add(body);
+  const ridgeHeight = width * rng.range(0.32, 0.4);
+  const roofMesh = new import_three8.Mesh(prismGeometry(width + 0.5, ridgeHeight, depth + 0.6), roof);
+  roofMesh.position.y = wallHeight - 0.02;
+  group.add(roofMesh);
+  const chimney = new import_three8.Mesh(new import_three8.BoxGeometry(0.34, ridgeHeight + 0.8, 0.34), stone);
+  chimney.position.set(rng.pick([-1, 1]) * width * 0.22, wallHeight + ridgeHeight * 0.45, depth * 0.12);
+  group.add(chimney);
+  const door = new import_three8.Mesh(new import_three8.BoxGeometry(0.85, 1.5, 0.08), wood);
+  door.position.set(rng.range(-0.4, 0.4), 0.75, depth / 2 + 0.02);
+  group.add(door);
+  const glass = new import_three8.MeshStandardMaterial({
+    color: palette.lampGlow,
+    emissive: palette.lampGlow,
+    emissiveIntensity: 1
+  });
+  const windowGeometry = new import_three8.BoxGeometry(0.6, 0.62, 0.08);
+  const front = new import_three8.Mesh(windowGeometry, glass);
+  front.position.set(door.position.x < 0 ? width * 0.28 : -width * 0.28, 1.35, depth / 2 + 0.02);
+  group.add(front);
+  for (const side of [-1, 1]) {
+    if (rng.next() < 0.35) continue;
+    const pane = new import_three8.Mesh(windowGeometry, glass);
+    pane.position.set(side * (width / 2 + 0.02), 1.35, rng.range(-0.3, 0.3) * depth);
+    pane.rotation.y = Math.PI / 2;
+    group.add(pane);
+  }
+  return { object: group, obstacleRadius: Math.hypot(width + 0.5, depth + 0.5) / 2 };
+}
+function createTower(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const height = options.height ?? rng.range(4.2, 5.2);
+  const group = new import_three8.Group();
+  group.name = "tower";
+  const wood = new import_three8.MeshStandardMaterial({ color: palette.wood, flatShading: true });
+  const woodDark = new import_three8.MeshStandardMaterial({ color: palette.woodDark, flatShading: true });
+  const roof = new import_three8.MeshStandardMaterial({ color: palette.roof, flatShading: true });
+  const spread = 1;
+  for (const x of [-1, 1]) {
+    for (const z of [-1, 1]) {
+      const leg = new import_three8.Mesh(new import_three8.CylinderGeometry(0.09, 0.12, height, 6), woodDark);
+      leg.position.set(x * spread * 0.75, height / 2 - 0.6, z * spread * 0.75);
+      leg.rotation.z = -x * 0.1;
+      leg.rotation.x = z * 0.1;
+      group.add(leg);
+    }
+  }
+  for (const level of [0.3, 0.62]) {
+    const brace = new import_three8.Mesh(new import_three8.BoxGeometry(spread * 2.1, 0.09, 0.07), wood);
+    brace.position.set(0, height * level, spread * 0.82 * (1 - level * 0.35));
+    brace.rotation.z = rng.pick([-0.5, 0.5]);
+    group.add(brace);
+    const braceSide = new import_three8.Mesh(new import_three8.BoxGeometry(0.07, 0.09, spread * 2.1), wood);
+    braceSide.position.set(spread * 0.82 * (1 - level * 0.35), height * level, 0);
+    braceSide.rotation.x = rng.pick([-0.5, 0.5]);
+    group.add(braceSide);
+  }
+  const platform = new import_three8.Mesh(new import_three8.BoxGeometry(spread * 2.2, 0.14, spread * 2.2), wood);
+  platform.position.y = height - 0.5;
+  group.add(platform);
+  for (const x of [-1, 1]) {
+    for (const z of [-1, 1]) {
+      const post = new import_three8.Mesh(new import_three8.BoxGeometry(0.08, 0.9, 0.08), woodDark);
+      post.position.set(x * spread * 1, height - 0.05, z * spread * 1);
+      group.add(post);
+    }
+  }
+  for (const [rx, rz, w, d] of [
+    [0, 1, spread * 2.1, 0.06],
+    [0, -1, spread * 2.1, 0.06],
+    [1, 0, 0.06, spread * 2.1],
+    [-1, 0, 0.06, spread * 2.1]
+  ]) {
+    const rail = new import_three8.Mesh(new import_three8.BoxGeometry(w, 0.07, d), wood);
+    rail.position.set(rx * spread, height + 0.28, rz * spread);
+    group.add(rail);
+  }
+  const cap = new import_three8.Mesh(new import_three8.CylinderGeometry(0, spread * 1.55, 1, 4), roof);
+  cap.position.y = height + 1.15;
+  cap.rotation.y = Math.PI / 4;
+  group.add(cap);
+  return { object: group, obstacleRadius: spread * 1.35 };
+}
+function createWell(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const group = new import_three8.Group();
+  group.name = "well";
+  const stone = new import_three8.MeshStandardMaterial({ color: rng.pick(palette.rock), flatShading: true });
+  const wood = new import_three8.MeshStandardMaterial({ color: palette.woodDark, flatShading: true });
+  const roof = new import_three8.MeshStandardMaterial({ color: palette.roof, flatShading: true });
+  const ring = new import_three8.Mesh(new import_three8.CylinderGeometry(0.85, 0.95, 0.75, 10), stone);
+  ring.position.y = 0.375;
+  group.add(ring);
+  const inner = new import_three8.Mesh(
+    new import_three8.CylinderGeometry(0.62, 0.62, 0.05, 10),
+    new import_three8.MeshStandardMaterial({ color: 1450542 })
+  );
+  inner.position.y = 0.76;
+  group.add(inner);
+  for (const side of [-1, 1]) {
+    const post = new import_three8.Mesh(new import_three8.CylinderGeometry(0.06, 0.075, 1.9, 5), wood);
+    post.position.set(side * 0.72, 0.95, 0);
+    group.add(post);
+  }
+  const bar = new import_three8.Mesh(new import_three8.CylinderGeometry(0.045, 0.045, 1.5, 5), wood);
+  bar.rotation.z = Math.PI / 2;
+  bar.position.y = 1.72;
+  group.add(bar);
+  const cap = new import_three8.Mesh(prismGeometry(2, 0.55, 0.65), roof);
+  cap.position.y = 1.86;
+  cap.rotation.y = Math.PI / 2;
+  group.add(cap);
+  const rope = new import_three8.Mesh(new import_three8.CylinderGeometry(0.012, 0.012, 0.6, 4), wood);
+  rope.position.y = 1.42;
+  group.add(rope);
+  const bucket = new import_three8.Mesh(new import_three8.CylinderGeometry(0.13, 0.1, 0.2, 7), wood);
+  bucket.position.y = 1.05;
+  group.add(bucket);
+  return { object: group, obstacleRadius: 1 };
+}
+function createRuin(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const size = options.size ?? rng.range(3.5, 5);
+  const depth = size * rng.range(0.7, 0.9);
+  const group = new import_three8.Group();
+  group.name = "ruin";
+  const stone = new import_three8.MeshStandardMaterial({ color: rng.pick(palette.rock), flatShading: true });
+  stone.color.offsetHSL(0, 0, rng.range(-0.04, 0.02));
+  const thickness = 0.35;
+  const runs = [
+    [0, -depth / 2, size, true],
+    [-size / 2, 0, depth, false],
+    [size / 2, 0, depth, false],
+    [size * 0.3, depth / 2, size * 0.35, true]
+  ];
+  for (const [cx, cz, length, alongX] of runs) {
+    const segments = Math.max(2, Math.round(length / 1.1));
+    const step = length / segments;
+    for (let i = 0; i < segments; i++) {
+      if (rng.next() < 0.22) continue;
+      const height = rng.range(0.5, 2.2);
+      const wall = new import_three8.Mesh(
+        new import_three8.BoxGeometry(alongX ? step * 0.96 : thickness, height, alongX ? thickness : step * 0.96),
+        stone
+      );
+      const offset = -length / 2 + step * (i + 0.5);
+      wall.position.set(alongX ? cx + offset : cx, height / 2, alongX ? cz : cz + offset);
+      wall.rotation.y = rng.range(-0.03, 0.03);
+      group.add(wall);
+    }
+  }
+  const blocks = rng.int(4, 7);
+  for (let i = 0; i < blocks; i++) {
+    const s = rng.range(0.25, 0.55);
+    const block = new import_three8.Mesh(new import_three8.BoxGeometry(s, s * rng.range(0.6, 1), s * rng.range(0.7, 1.2)), stone);
+    block.position.set(rng.range(-size * 0.6, size * 0.6), s * 0.3, rng.range(-depth * 0.6, depth * 0.7));
+    block.rotation.set(rng.range(-0.3, 0.3), rng.range(0, Math.PI), rng.range(-0.3, 0.3));
+    group.add(block);
+  }
+  return { object: group, obstacleRadius: Math.hypot(size, depth) / 2 };
+}
+
+// src/environment/terrain.ts
+var import_three9 = require("three");
 function createTerrain(options = {}) {
   const seed = options.seed ?? 1;
   const size = options.size ?? 80;
@@ -384,7 +745,7 @@ function createTerrain(options = {}) {
     const shaped = Math.pow(n, 1 + flatness * 2);
     return shaped * amplitude;
   };
-  const geometry = new import_three7.PlaneGeometry(size, size, resolution - 1, resolution - 1);
+  const geometry = new import_three9.PlaneGeometry(size, size, resolution - 1, resolution - 1);
   geometry.rotateX(-Math.PI / 2);
   const positions = geometry.getAttribute("position");
   for (let i = 0; i < positions.count; i++) {
@@ -393,40 +754,46 @@ function createTerrain(options = {}) {
   geometry.computeVertexNormals();
   const normals = geometry.getAttribute("normal");
   const colors = new Float32Array(positions.count * 3);
-  const grassLow = new import_three7.Color(palette.grassLow);
-  const grassHigh = new import_three7.Color(palette.grassHigh);
-  const cliff = new import_three7.Color(palette.cliff);
-  const peak = new import_three7.Color(palette.peak);
-  const scratch = new import_three7.Color();
+  const grassLow = new import_three9.Color(palette.grassLow);
+  const grassHigh = new import_three9.Color(palette.grassHigh);
+  const cliff = new import_three9.Color(palette.cliff);
+  const peak = new import_three9.Color(palette.peak);
+  const sand = new import_three9.Color(palette.sand);
+  const waterLevel = options.waterLevel;
+  const scratch = new import_three9.Color();
   for (let i = 0; i < positions.count; i++) {
-    const h = positions.getY(i) / amplitude;
+    const y = positions.getY(i);
+    const h = y / amplitude;
     const slope = 1 - normals.getY(i);
     scratch.copy(grassLow).lerp(grassHigh, Math.min(1, h * 1.6));
     if (h > 0.75) scratch.lerp(peak, (h - 0.75) * 4);
     if (slope > 0.15) scratch.lerp(cliff, Math.min(1, (slope - 0.15) * 4));
+    if (waterLevel !== void 0 && y < waterLevel + 0.5) {
+      scratch.lerp(sand, Math.min(1, (waterLevel + 0.5 - y) * 1.6));
+    }
     colors[i * 3] = scratch.r;
     colors[i * 3 + 1] = scratch.g;
     colors[i * 3 + 2] = scratch.b;
   }
-  geometry.setAttribute("color", new import_three7.BufferAttribute(colors, 3));
-  const mesh = new import_three7.Mesh(
+  geometry.setAttribute("color", new import_three9.BufferAttribute(colors, 3));
+  const mesh = new import_three9.Mesh(
     geometry,
-    new import_three7.MeshStandardMaterial({ vertexColors: true, flatShading: true })
+    new import_three9.MeshStandardMaterial({ vertexColors: true, flatShading: true })
   );
   mesh.name = "terrain";
   return { mesh, heightAt, size, seed };
 }
 
 // src/environment/sky.ts
-var import_three8 = require("three");
+var import_three10 = require("three");
 function createSky(options = {}) {
   const palette = options.palette ?? DEFAULT_PALETTE;
-  const material = new import_three8.ShaderMaterial({
-    side: import_three8.BackSide,
+  const material = new import_three10.ShaderMaterial({
+    side: import_three10.BackSide,
     depthWrite: false,
     uniforms: {
-      topColor: { value: new import_three8.Color(options.topColor ?? palette.skyTop) },
-      bottomColor: { value: new import_three8.Color(options.bottomColor ?? palette.skyBottom) }
+      topColor: { value: new import_three10.Color(options.topColor ?? palette.skyTop) },
+      bottomColor: { value: new import_three10.Color(options.bottomColor ?? palette.skyBottom) }
     },
     vertexShader: (
       /* glsl */
@@ -449,7 +816,7 @@ function createSky(options = {}) {
       }`
     )
   });
-  const mesh = new import_three8.Mesh(new import_three8.SphereGeometry(options.radius ?? 400, 16, 12), material);
+  const mesh = new import_three10.Mesh(new import_three10.SphereGeometry(options.radius ?? 400, 16, 12), material);
   mesh.name = "sky";
   return {
     mesh,
@@ -461,7 +828,7 @@ function createSky(options = {}) {
 }
 
 // src/environment/lighting.ts
-var import_three9 = require("three");
+var import_three11 = require("three");
 var PRESETS = {
   day: {
     sun: 16774368,
@@ -502,12 +869,12 @@ var PRESETS = {
 };
 function createLightingRig(preset = "day") {
   const config = PRESETS[preset];
-  const group = new import_three9.Group();
+  const group = new import_three11.Group();
   group.name = `lighting-${preset}`;
-  const sun = new import_three9.DirectionalLight(config.sun, config.sunIntensity);
+  const sun = new import_three11.DirectionalLight(config.sun, config.sunIntensity);
   sun.position.set(...config.sunPos);
-  const ambient = new import_three9.AmbientLight(config.ambient, config.ambientIntensity);
-  const hemisphere = new import_three9.HemisphereLight(config.skyTint, config.groundTint, 0.5);
+  const ambient = new import_three11.AmbientLight(config.ambient, config.ambientIntensity);
+  const hemisphere = new import_three11.HemisphereLight(config.skyTint, config.groundTint, 0.5);
   group.add(sun, ambient, hemisphere);
   return { group, sun, ambient, hemisphere };
 }
@@ -522,11 +889,381 @@ function applyFog(scene, preset, palette = DEFAULT_PALETTE) {
     return;
   }
   const { near, far } = FOG[preset];
-  scene.fog = new import_three9.Fog(palette.fog, near, far);
+  scene.fog = new import_three11.Fog(palette.fog, near, far);
+}
+
+// src/environment/water.ts
+var import_three12 = require("three");
+function createWater(options = {}) {
+  const level = options.level ?? 0.8;
+  const size = options.size ?? 200;
+  const resolution = options.resolution ?? 40;
+  const amplitude = options.amplitude ?? 0.06;
+  const speed = options.speed ?? 1;
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const geometry = new import_three12.PlaneGeometry(size, size, resolution, resolution);
+  geometry.rotateX(-Math.PI / 2);
+  const positions = geometry.getAttribute("position");
+  const mesh = new import_three12.Mesh(
+    geometry,
+    new import_three12.MeshStandardMaterial({
+      color: palette.water,
+      transparent: true,
+      opacity: 0.85,
+      flatShading: true,
+      metalness: 0.35,
+      roughness: 0.4
+    })
+  );
+  mesh.name = "water";
+  mesh.position.y = level;
+  let time = 0;
+  const update = (dt) => {
+    time += dt * speed;
+    for (let i = 0; i < positions.count; i++) {
+      const x = positions.getX(i);
+      const z = positions.getZ(i);
+      positions.setY(
+        i,
+        Math.sin(x * 0.35 + time) * Math.cos(z * 0.3 + time * 0.8) * amplitude
+      );
+    }
+    positions.needsUpdate = true;
+    geometry.computeVertexNormals();
+  };
+  update(0);
+  return {
+    mesh,
+    level,
+    update,
+    isUnderwater: (groundHeight) => groundHeight < level
+  };
+}
+function aboveWater(terrain, water, margin = 0.25) {
+  return (x, z) => terrain.heightAt(x, z) > water.level + margin;
+}
+
+// src/environment/dayCycle.ts
+var import_three13 = require("three");
+function createDayCycle(options = {}) {
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const dayLength = options.dayLength ?? 60;
+  const frames = [
+    { t: 0, skyTop: 725030, skyBottom: 1712960, sun: 9348824, sunIntensity: 0.03, ambientIntensity: 0.06, fog: 1317422 },
+    { t: 0.23, skyTop: 2569052, skyBottom: 6968432, sun: 13605490, sunIntensity: 0.3, ambientIntensity: 0.12, fog: 4866648 },
+    { t: 0.3, skyTop: 4877216, skyBottom: 15247738, sun: 16758881, sunIntensity: 1, ambientIntensity: 0.26, fog: 11569778 },
+    { t: 0.5, skyTop: palette.skyTop, skyBottom: palette.skyBottom, sun: 16774368, sunIntensity: 1.9, ambientIntensity: 0.45, fog: palette.fog },
+    { t: 0.7, skyTop: 4872852, skyBottom: 14718302, sun: 16752720, sunIntensity: 1, ambientIntensity: 0.26, fog: 10517096 },
+    { t: 0.78, skyTop: 2304594, skyBottom: 9065824, sun: 14191194, sunIntensity: 0.25, ambientIntensity: 0.11, fog: 4603476 },
+    { t: 1, skyTop: 725030, skyBottom: 1712960, sun: 9348824, sunIntensity: 0.03, ambientIntensity: 0.06, fog: 1317422 }
+  ];
+  const lampLights = [];
+  const lampBulbs = [];
+  for (const entry of options.lamps ?? []) {
+    const root = entry.isObject3D ? entry : entry.object;
+    root.traverse((child) => {
+      if (child instanceof import_three13.PointLight) {
+        lampLights.push({ light: child, base: child.intensity || 6 });
+      }
+      const material = child.material;
+      if (material?.emissive && material.emissiveIntensity > 0.5) {
+        lampBulbs.push({ material, base: material.emissiveIntensity });
+      }
+    });
+  }
+  const colorA = new import_three13.Color();
+  const colorB = new import_three13.Color();
+  let timeOfDay = options.timeOfDay ?? 0.5;
+  let sunElevation = 0;
+  const sample = (t) => {
+    let a = frames[0];
+    let b = frames[frames.length - 1];
+    for (let i = 0; i < frames.length - 1; i++) {
+      if (t >= frames[i].t && t <= frames[i + 1].t) {
+        a = frames[i];
+        b = frames[i + 1];
+        break;
+      }
+    }
+    const f = b.t === a.t ? 0 : (t - a.t) / (b.t - a.t);
+    const lerpHex = (ha, hb) => colorA.setHex(ha).lerp(colorB.setHex(hb), f).getHex();
+    return {
+      t,
+      skyTop: lerpHex(a.skyTop, b.skyTop),
+      skyBottom: lerpHex(a.skyBottom, b.skyBottom),
+      sun: lerpHex(a.sun, b.sun),
+      sunIntensity: a.sunIntensity + (b.sunIntensity - a.sunIntensity) * f,
+      ambientIntensity: a.ambientIntensity + (b.ambientIntensity - a.ambientIntensity) * f,
+      fog: lerpHex(a.fog, b.fog)
+    };
+  };
+  const apply = () => {
+    const t = timeOfDay;
+    const frame = sample(t);
+    const sunAngle = (t - 0.25) * Math.PI * 2;
+    sunElevation = Math.sin(sunAngle);
+    options.sky?.setColors(frame.skyTop, frame.skyBottom);
+    if (options.rig) {
+      const { sun, ambient, hemisphere } = options.rig;
+      sun.color.setHex(frame.sun);
+      sun.intensity = frame.sunIntensity;
+      sun.position.set(Math.cos(sunAngle) * 40, Math.max(sunElevation, -0.2) * 45 + 6, 16);
+      ambient.intensity = frame.ambientIntensity;
+      hemisphere.intensity = frame.ambientIntensity * 1.4;
+    }
+    if (options.scene?.fog && "color" in options.scene.fog) {
+      options.scene.fog.color.setHex(frame.fog);
+    }
+    const night = Math.min(1, Math.max(0, (0.06 - sunElevation) / 0.16));
+    for (const { light, base } of lampLights) light.intensity = base * night;
+    for (const { material, base } of lampBulbs) {
+      material.emissiveIntensity = 0.15 * base + 0.85 * base * night;
+    }
+  };
+  apply();
+  return {
+    get timeOfDay() {
+      return timeOfDay;
+    },
+    set timeOfDay(t) {
+      timeOfDay = (t % 1 + 1) % 1;
+      apply();
+    },
+    get sunElevation() {
+      return sunElevation;
+    },
+    get isNight() {
+      return sunElevation < 0;
+    },
+    update(dt) {
+      timeOfDay = (timeOfDay + dt / dayLength) % 1;
+      apply();
+    },
+    set(t) {
+      timeOfDay = (t % 1 + 1) % 1;
+      apply();
+    }
+  };
+}
+
+// src/environment/wind.ts
+var import_three14 = require("three");
+function applyWind(target, options = {}) {
+  const strength = options.strength ?? 0.06;
+  const frequency = options.frequency ?? 1.2;
+  const anchor = options.anchorHeight ?? 0.6;
+  const time = { value: 0 };
+  const patched = /* @__PURE__ */ new Set();
+  target.traverse((child) => {
+    if (!(child instanceof import_three14.Mesh)) return;
+    const materials = Array.isArray(child.material) ? child.material : [child.material];
+    for (const material of materials) {
+      if (patched.has(material)) continue;
+      patched.add(material);
+      material.onBeforeCompile = (shader) => {
+        shader.uniforms.uWindTime = time;
+        shader.vertexShader = shader.vertexShader.replace(
+          "#include <common>",
+          `#include <common>
+             uniform float uWindTime;`
+        ).replace(
+          "#include <begin_vertex>",
+          `#include <begin_vertex>
+             {
+               float sway = max(position.y - ${anchor.toFixed(3)}, 0.0);
+               float phase = 0.0;
+               #ifdef USE_INSTANCING
+                 phase = instanceMatrix[3].x * 0.7 + instanceMatrix[3].z * 1.3;
+               #endif
+               float w = sin(uWindTime * ${(frequency * 2).toFixed(3)} + phase + position.y * 0.8);
+               transformed.x += w * sway * ${strength.toFixed(4)} * 4.0;
+               transformed.z += cos(uWindTime * ${(frequency * 1.4).toFixed(3)} + phase) * sway * ${strength.toFixed(4)} * 2.0;
+             }`
+        );
+      };
+      material.needsUpdate = true;
+    }
+  });
+  return {
+    update(dt) {
+      time.value += dt;
+    },
+    materials: [...patched]
+  };
+}
+
+// src/environment/path.ts
+var import_three15 = require("three");
+function createPath(points, options = {}) {
+  const width = options.width ?? 1.8;
+  const surface = options.surface ?? 0;
+  const heightAt = typeof surface === "number" ? () => surface : (x, z) => surface(x, z);
+  const loop = options.loop ?? false;
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const controls = points.map((p) => new import_three15.Vector3(p.x, 0, "z" in p ? p.z : 0));
+  const curve = new import_three15.CatmullRomCurve3(controls, loop, "centripetal");
+  const length = curve.getLength();
+  const samples = Math.max(8, Math.ceil(length * (options.samplesPerUnit ?? 1)));
+  const route = [];
+  for (let i = 0; i <= samples; i++) {
+    if (loop && i === samples) break;
+    const p = curve.getPoint(i / samples);
+    route.push(new import_three15.Vector3(p.x, heightAt(p.x, p.z), p.z));
+  }
+  const edgeCount = loop ? route.length + 1 : route.length;
+  const positions = new Float32Array(edgeCount * 2 * 3);
+  const direction = new import_three15.Vector3();
+  const perp = new import_three15.Vector3();
+  for (let i = 0; i < edgeCount; i++) {
+    const current = route[i % route.length];
+    const previous = route[(i - 1 + route.length) % route.length];
+    const next = route[(i + 1) % route.length];
+    if (!loop && i === 0) direction.subVectors(next, current);
+    else if (!loop && i === edgeCount - 1) direction.subVectors(current, previous);
+    else direction.subVectors(next, previous);
+    perp.set(-direction.z, 0, direction.x).normalize().multiplyScalar(width / 2);
+    const left = i * 6;
+    positions[left] = current.x - perp.x;
+    positions[left + 1] = heightAt(current.x - perp.x, current.z - perp.z) + 0.05;
+    positions[left + 2] = current.z - perp.z;
+    positions[left + 3] = current.x + perp.x;
+    positions[left + 4] = heightAt(current.x + perp.x, current.z + perp.z) + 0.05;
+    positions[left + 5] = current.z + perp.z;
+  }
+  const indices = [];
+  for (let i = 0; i < edgeCount - 1; i++) {
+    const a = i * 2;
+    indices.push(a, a + 1, a + 2, a + 1, a + 3, a + 2);
+  }
+  const geometry = new import_three15.BufferGeometry();
+  geometry.setAttribute("position", new import_three15.BufferAttribute(positions, 3));
+  geometry.setIndex(indices);
+  geometry.computeVertexNormals();
+  const mesh = new import_three15.Mesh(
+    geometry,
+    new import_three15.MeshStandardMaterial({
+      color: palette.path,
+      flatShading: true,
+      polygonOffset: true,
+      polygonOffsetFactor: -1
+    })
+  );
+  mesh.name = "path";
+  const keepOutMargin = options.keepOutMargin ?? 0.6;
+  const keepOut = route.filter((_p, i) => i % 2 === 0 || i === route.length - 1).map((p) => ({ center: { x: p.x, z: p.z }, radius: width / 2 + keepOutMargin }));
+  const half = width / 2;
+  const contains = (x, z) => {
+    const count = loop ? route.length : route.length - 1;
+    for (let i = 0; i < count; i++) {
+      const a = route[i];
+      const b = route[(i + 1) % route.length];
+      const abx = b.x - a.x;
+      const abz = b.z - a.z;
+      const lengthSq = abx * abx + abz * abz || 1e-9;
+      const t = Math.max(0, Math.min(1, ((x - a.x) * abx + (z - a.z) * abz) / lengthSq));
+      const dx = x - (a.x + abx * t);
+      const dz = z - (a.z + abz * t);
+      if (dx * dx + dz * dz <= half * half) return true;
+    }
+    return false;
+  };
+  return { mesh, route, keepOut, contains, loop };
+}
+
+// src/generators/village.ts
+var import_three16 = require("three");
+function createVillage(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const center = options.center ?? { x: 0, z: 0 };
+  const radius = options.radius ?? 12;
+  const houseCount = options.houses ?? 5;
+  const surface = options.surface ?? 0;
+  const heightAt = typeof surface === "number" ? () => surface : (x, z) => surface(x, z);
+  const group = new import_three16.Group();
+  group.name = "village";
+  const props = [];
+  const lamps = [];
+  const place = (prop, x, z, rotY) => {
+    prop.object.position.set(x, heightAt(x, z), z);
+    prop.object.rotation.y = rotY;
+    group.add(prop.object);
+    props.push(prop);
+    return prop;
+  };
+  const findSpot = (angle, distance, footprint) => {
+    let x = center.x;
+    let z = center.z;
+    for (let attempt = 0; attempt < 10; attempt++) {
+      const a = angle + rng.range(-0.25, 0.25) * (attempt > 0 ? 1 : 0.3);
+      const d = distance * rng.range(attempt > 0 ? 0.8 : 0.95, 1.1);
+      x = center.x + Math.cos(a) * d;
+      z = center.z + Math.sin(a) * d;
+      const y = heightAt(x, z);
+      if (options.mask && !options.mask(x, z, y)) continue;
+      let min = y;
+      let max = y;
+      for (const [dx, dz] of [[footprint, 0], [-footprint, 0], [0, footprint], [0, -footprint]]) {
+        const h = heightAt(x + dx, z + dz);
+        min = Math.min(min, h);
+        max = Math.max(max, h);
+      }
+      if (max - min <= Math.max(0.9, footprint * 0.35)) break;
+    }
+    return { x, z };
+  };
+  const well = createWell({ seed: rng.int(1, 1e9), palette });
+  place(well, center.x, center.z, rng.range(0, Math.PI * 2));
+  let lightBudget = options.lampLights ?? 3;
+  for (let i = 0; i < houseCount; i++) {
+    const angle = i / houseCount * Math.PI * 2 + rng.range(-0.15, 0.15);
+    const house = createHouse({ seed: rng.int(1, 1e9), palette });
+    const spot = findSpot(angle, radius * rng.range(0.7, 0.95), house.obstacleRadius);
+    const facing = Math.atan2(center.x - spot.x, center.z - spot.z);
+    place(house, spot.x, spot.z, facing);
+    lamps.push(house);
+    if (rng.next() < 0.7) {
+      const crateAngle = angle + rng.range(-0.5, 0.5);
+      const crateDistance = Math.hypot(spot.x - center.x, spot.z - center.z) - house.obstacleRadius - 0.7;
+      place(
+        createCrate({ seed: rng.int(1, 1e9), size: rng.range(0.7, 1), palette }),
+        center.x + Math.cos(crateAngle) * crateDistance,
+        center.z + Math.sin(crateAngle) * crateDistance,
+        rng.range(0, Math.PI)
+      );
+    }
+    if (i % 2 === 0) {
+      const lampDistance = Math.hypot(spot.x - center.x, spot.z - center.z) * 0.55;
+      const lamp = createLamp({ seed: rng.int(1, 1e9), light: lightBudget > 0, palette });
+      lightBudget--;
+      place(lamp, center.x + Math.cos(angle) * lampDistance, center.z + Math.sin(angle) * lampDistance, 0);
+      lamps.push(lamp);
+    }
+  }
+  if (options.tower ?? true) {
+    const angle = rng.range(0, Math.PI * 2);
+    const tower = createTower({ seed: rng.int(1, 1e9), palette });
+    const spot = findSpot(angle, radius * 1.05, tower.obstacleRadius);
+    place(tower, spot.x, spot.z, rng.range(0, Math.PI * 2));
+  }
+  if (options.ruin ?? true) {
+    const angle = rng.range(0, Math.PI * 2);
+    const ruin = createRuin({ seed: rng.int(1, 1e9), palette });
+    const spot = findSpot(angle, radius * 1.35, ruin.obstacleRadius);
+    place(ruin, spot.x, spot.z, rng.range(0, Math.PI * 2));
+  }
+  return {
+    group,
+    props,
+    obstacles: collectObstacles(props),
+    lamps,
+    keepOut: [{ center: { ...center }, radius: radius * 1.5 }],
+    center
+  };
 }
 
 // src/scatter/scatter.ts
-var import_three10 = require("three");
+var import_three17 = require("three");
 function scatter(options) {
   const seed = options.seed ?? 1;
   const rng = new Rng(seed);
@@ -581,7 +1318,7 @@ function scatter(options) {
     const itemIndex = pickItem();
     const [minScale, maxScale2] = options.items[itemIndex].scale ?? [0.8, 1.25];
     placements.push({
-      position: new import_three10.Vector3(x, y, z),
+      position: new import_three17.Vector3(x, y, z),
       rotationY: rng.range(0, Math.PI * 2),
       scale: rng.range(minScale, maxScale2),
       itemIndex
@@ -591,14 +1328,14 @@ function scatter(options) {
     if (!bucket) occupied.set(key, bucket = []);
     bucket.push({ x, z });
   }
-  const group = new import_three10.Group();
+  const group = new import_three17.Group();
   group.name = "scatter";
   const obstacles = [];
-  const placementMatrix = new import_three10.Matrix4();
-  const composed = new import_three10.Matrix4();
-  const quaternion = new import_three10.Quaternion();
-  const up = new import_three10.Vector3(0, 1, 0);
-  const scaleVector = new import_three10.Vector3();
+  const placementMatrix = new import_three17.Matrix4();
+  const composed = new import_three17.Matrix4();
+  const quaternion = new import_three17.Quaternion();
+  const up = new import_three17.Vector3(0, 1, 0);
+  const scaleVector = new import_three17.Vector3();
   options.items.forEach((item, itemIndex) => {
     const variantCount = item.variants ?? 4;
     const variants = [];
@@ -614,9 +1351,9 @@ function scatter(options) {
       if (list.length === 0) return;
       variant.object.updateMatrixWorld(true);
       variant.object.traverse((child) => {
-        if (!(child instanceof import_three10.Mesh)) return;
-        const instanced = new import_three10.InstancedMesh(child.geometry, child.material, list.length);
-        instanced.instanceMatrix.setUsage(import_three10.DynamicDrawUsage);
+        if (!(child instanceof import_three17.Mesh)) return;
+        const instanced = new import_three17.InstancedMesh(child.geometry, child.material, list.length);
+        instanced.instanceMatrix.setUsage(import_three17.DynamicDrawUsage);
         list.forEach((placement, index) => {
           quaternion.setFromAxisAngle(up, placement.rotationY);
           scaleVector.setScalar(placement.scale);
@@ -644,16 +1381,28 @@ function scatter(options) {
   DEFAULT_PALETTE,
   PALETTES,
   Rng,
+  aboveWater,
   applyFog,
+  applyWind,
   collectObstacles,
+  createBush,
   createCrate,
+  createDayCycle,
   createFence,
+  createGrassTuft,
+  createHouse,
   createLamp,
   createLightingRig,
+  createPath,
   createRock,
+  createRuin,
   createSky,
   createTerrain,
+  createTower,
   createTree,
+  createVillage,
+  createWater,
+  createWell,
   fractalNoise2,
   hash2,
   scatter,