scena3d 0.3.0 → 0.4.0

package/dist/index.js

@@ -1261,16 +1261,158 @@ function createVillage(options = {}) {
   };
 }
 
-// src/scatter/scatter.ts
+// src/kits/kit.ts
 import {
-  DynamicDrawUsage,
+  BoxGeometry as BoxGeometry5,
+  CylinderGeometry as CylinderGeometry5,
   Group as Group10,
   InstancedMesh,
   Matrix4,
   Mesh as Mesh13,
-  Quaternion,
+  MeshStandardMaterial as MeshStandardMaterial11,
+  PointLight as PointLight3,
+  SphereGeometry as SphereGeometry3,
   Vector3 as Vector33
 } from "three";
+var KIT_UNIT = 2;
+function assembleKit(rows, options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const unit = options.unit ?? KIT_UNIT;
+  const wallHeight = options.wallHeight ?? 2.6;
+  let torchLights = options.torchLights ?? 4;
+  const height = rows.length;
+  const width = Math.max(...rows.map((r) => r.length), 0);
+  const originX = (-width / 2 + 0.5) * unit;
+  const originZ = (-height / 2 + 0.5) * unit;
+  const worldOf = (col, row) => ({
+    x: originX + col * unit,
+    z: originZ + row * unit
+  });
+  const group = new Group10();
+  group.name = "kit";
+  const obstacles = [];
+  const spawns = [];
+  const torches = [];
+  const floorCells = /* @__PURE__ */ new Set();
+  const wallCells = [];
+  const floorTiles = [];
+  for (let row = 0; row < height; row++) {
+    for (let col = 0; col < (rows[row] ?? "").length; col++) {
+      const cell = rows[row][col];
+      if (cell === " " || cell === void 0) continue;
+      const { x, z } = worldOf(col, row);
+      if (cell === "#") {
+        wallCells.push({ x, z });
+        obstacles.push({ center: new Vector33(x, wallHeight / 2, z), radius: unit * 0.71 });
+        continue;
+      }
+      floorTiles.push({ x, z });
+      floorCells.add(`${col},${row}`);
+      if (cell === "D") {
+        const horizontalRun = rows[row][col - 1] === "#" || rows[row][col + 1] === "#";
+        const lintel = new Mesh13(
+          new BoxGeometry5(
+            horizontalRun ? unit : unit * 0.4,
+            wallHeight * 0.25,
+            horizontalRun ? unit * 0.4 : unit
+          ),
+          new MeshStandardMaterial11({ color: palette.woodDark, flatShading: true })
+        );
+        lintel.position.set(x, wallHeight * 0.875, z);
+        group.add(lintel);
+      } else if (cell === "T") {
+        group.add(createTorch(x, z, palette, rng, torchLights > 0));
+        torchLights--;
+        torches.push(new Vector33(x, 0, z));
+        obstacles.push({ center: new Vector33(x, 0, z), radius: 0.3 });
+      } else if (cell === "S") {
+        spawns.push(new Vector33(x, 0, z));
+      }
+    }
+  }
+  const stone = new MeshStandardMaterial11({ color: rng.pick(palette.rock), flatShading: true });
+  const stoneDark = new MeshStandardMaterial11({ color: palette.cliff, flatShading: true });
+  const matrix = new Matrix4();
+  if (wallCells.length > 0) {
+    const walls = new InstancedMesh(
+      new BoxGeometry5(unit, wallHeight, unit),
+      stone,
+      wallCells.length
+    );
+    wallCells.forEach((cell, i) => {
+      walls.setMatrixAt(i, matrix.makeTranslation(cell.x, wallHeight / 2, cell.z));
+    });
+    walls.instanceMatrix.needsUpdate = true;
+    group.add(walls);
+  }
+  if (floorTiles.length > 0) {
+    const floors = new InstancedMesh(
+      new BoxGeometry5(unit, 0.2, unit),
+      stoneDark,
+      floorTiles.length
+    );
+    floorTiles.forEach((cell, i) => {
+      floors.setMatrixAt(i, matrix.makeTranslation(cell.x, -0.1, cell.z));
+    });
+    floors.instanceMatrix.needsUpdate = true;
+    group.add(floors);
+  }
+  return {
+    group,
+    obstacles,
+    spawns,
+    torches,
+    floorAt(x, z) {
+      const col = Math.round((x - originX) / unit);
+      const row = Math.round((z - originZ) / unit);
+      return floorCells.has(`${col},${row}`);
+    },
+    size: { width: width * unit, depth: height * unit }
+  };
+}
+function createTorch(x, z, palette, rng, light) {
+  const torch = new Group10();
+  torch.name = "torch";
+  const pole = new Mesh13(
+    new CylinderGeometry5(0.04, 0.06, 1.5, 5),
+    new MeshStandardMaterial11({ color: palette.woodDark, flatShading: true })
+  );
+  pole.position.y = 0.75;
+  torch.add(pole);
+  const flame = new Mesh13(
+    new SphereGeometry3(0.1, 6, 5),
+    new MeshStandardMaterial11({
+      color: palette.lampGlow,
+      emissive: palette.lampGlow,
+      emissiveIntensity: 1.8
+    })
+  );
+  flame.position.y = 1.58;
+  flame.scale.y = rng.range(1.2, 1.5);
+  torch.add(flame);
+  if (light) {
+    const point = new PointLight3(palette.lampGlow, 5, 9, 1.9);
+    point.position.y = 1.6;
+    torch.add(point);
+  }
+  torch.position.set(x, 0, z);
+  return torch;
+}
+
+// src/scene/manifest.ts
+import { CylinderGeometry as CylinderGeometry6, Group as Group12, Mesh as Mesh15, MeshStandardMaterial as MeshStandardMaterial12 } from "three";
+
+// src/scatter/scatter.ts
+import {
+  DynamicDrawUsage,
+  Group as Group11,
+  InstancedMesh as InstancedMesh2,
+  Matrix4 as Matrix42,
+  Mesh as Mesh14,
+  Quaternion,
+  Vector3 as Vector34
+} from "three";
 function scatter(options) {
   const seed = options.seed ?? 1;
   const rng = new Rng(seed);
@@ -1325,7 +1467,7 @@ function scatter(options) {
     const itemIndex = pickItem();
     const [minScale, maxScale2] = options.items[itemIndex].scale ?? [0.8, 1.25];
     placements.push({
-      position: new Vector33(x, y, z),
+      position: new Vector34(x, y, z),
       rotationY: rng.range(0, Math.PI * 2),
       scale: rng.range(minScale, maxScale2),
       itemIndex
@@ -1335,18 +1477,59 @@ function scatter(options) {
     if (!bucket) occupied.set(key, bucket = []);
     bucket.push({ x, z });
   }
-  const group = new Group10();
+  const group = new Group11();
   group.name = "scatter";
   const obstacles = [];
-  const placementMatrix = new Matrix4();
-  const composed = new Matrix4();
+  const placementMatrix = new Matrix42();
+  const composed = new Matrix42();
   const quaternion = new Quaternion();
-  const up = new Vector33(0, 1, 0);
-  const scaleVector = new Vector33();
+  const up = new Vector34(0, 1, 0);
+  const scaleVector = new Vector34();
+  const emit = (variant, list, parent) => {
+    variant.object.updateMatrixWorld(true);
+    variant.object.traverse((child) => {
+      if (!(child instanceof Mesh14)) return;
+      const instanced = new InstancedMesh2(child.geometry, child.material, list.length);
+      instanced.instanceMatrix.setUsage(DynamicDrawUsage);
+      list.forEach((placement, index) => {
+        quaternion.setFromAxisAngle(up, placement.rotationY);
+        scaleVector.setScalar(placement.scale);
+        placementMatrix.compose(placement.position, quaternion, scaleVector);
+        composed.multiplyMatrices(placementMatrix, child.matrixWorld);
+        instanced.setMatrixAt(index, composed);
+      });
+      instanced.instanceMatrix.needsUpdate = true;
+      parent.add(instanced);
+    });
+  };
+  const tileSize = options.lod?.tileSize ?? 16;
+  const tileMap = /* @__PURE__ */ new Map();
+  const tileFor = (x, z) => {
+    const tx = Math.floor(x / tileSize);
+    const tz = Math.floor(z / tileSize);
+    const key = `${tx},${tz}`;
+    let tile = tileMap.get(key);
+    if (!tile) {
+      tile = {
+        center: { x: (tx + 0.5) * tileSize, z: (tz + 0.5) * tileSize },
+        near: new Group11(),
+        far: new Group11()
+      };
+      tile.far.visible = false;
+      group.add(tile.near, tile.far);
+      tileMap.set(key, tile);
+    }
+    return tile;
+  };
   options.items.forEach((item, itemIndex) => {
     const variantCount = item.variants ?? 4;
     const variants = [];
     for (let v = 0; v < variantCount; v++) variants.push(item.create(rng.fork()));
+    const useLod = options.lod !== void 0 && item.createFar !== void 0;
+    const farVariants = [];
+    if (useLod) {
+      for (let v = 0; v < variantCount; v++) farVariants.push(item.createFar(rng.fork()));
+    }
     const byVariant = variants.map(() => []);
     for (const placement of placements) {
       if (placement.itemIndex !== itemIndex) continue;
@@ -1356,21 +1539,21 @@ function scatter(options) {
     variants.forEach((variant, v) => {
       const list = byVariant[v];
       if (list.length === 0) return;
-      variant.object.updateMatrixWorld(true);
-      variant.object.traverse((child) => {
-        if (!(child instanceof Mesh13)) return;
-        const instanced = new InstancedMesh(child.geometry, child.material, list.length);
-        instanced.instanceMatrix.setUsage(DynamicDrawUsage);
-        list.forEach((placement, index) => {
-          quaternion.setFromAxisAngle(up, placement.rotationY);
-          scaleVector.setScalar(placement.scale);
-          placementMatrix.compose(placement.position, quaternion, scaleVector);
-          composed.multiplyMatrices(placementMatrix, child.matrixWorld);
-          instanced.setMatrixAt(index, composed);
-        });
-        instanced.instanceMatrix.needsUpdate = true;
-        group.add(instanced);
-      });
+      if (useLod) {
+        const byTile = /* @__PURE__ */ new Map();
+        for (const placement of list) {
+          const tile = tileFor(placement.position.x, placement.position.z);
+          let bucket = byTile.get(tile);
+          if (!bucket) byTile.set(tile, bucket = []);
+          bucket.push(placement);
+        }
+        for (const [tile, bucket] of byTile) {
+          emit(variant, bucket, tile.near);
+          emit(farVariants[v], bucket, tile.far);
+        }
+      } else {
+        emit(variant, list, group);
+      }
       if (variant.obstacleRadius > 0) {
         for (const placement of list) {
           obstacles.push({
@@ -1381,15 +1564,242 @@ function scatter(options) {
       }
     });
   });
-  return { group, placements, obstacles, count: placements.length };
+  const result = { group, placements, obstacles, count: placements.length };
+  if (options.lod) {
+    const tiles = [...tileMap.values()];
+    const swapOut = options.lod.distance * 1.1;
+    const swapIn = options.lod.distance * 0.9;
+    result.tiles = tiles;
+    result.update = (camera) => {
+      for (const tile of tiles) {
+        const dx = camera.position.x - tile.center.x;
+        const dz = camera.position.z - tile.center.z;
+        const distance = Math.hypot(dx, dz);
+        if (tile.near.visible && distance > swapOut) {
+          tile.near.visible = false;
+          tile.far.visible = true;
+        } else if (!tile.near.visible && distance < swapIn) {
+          tile.near.visible = true;
+          tile.far.visible = false;
+        }
+      }
+    };
+  }
+  return result;
+}
+
+// src/scene/manifest.ts
+var PROP_FACTORIES = {
+  tree: (seed, palette) => createTree({ seed, palette }),
+  rock: (seed, palette) => createRock({ seed, palette }),
+  bush: (seed, palette) => createBush({ seed, palette }),
+  grass: (seed, palette) => createGrassTuft({ seed, palette }),
+  crate: (seed, palette) => createCrate({ seed, palette }),
+  fence: (seed, palette) => createFence({ seed, palette }),
+  lamp: (seed, palette) => createLamp({ seed, palette })
+};
+var FAR_FACTORIES = {
+  tree: (seed, palette) => {
+    const rng = new Rng(seed);
+    const group = new Group12();
+    const cone = new Mesh15(
+      new CylinderGeometry6(0, rng.range(1, 1.4), rng.range(2.6, 3.8), 5),
+      new MeshStandardMaterial12({ color: rng.pick(palette.foliage), flatShading: true })
+    );
+    cone.position.y = cone.geometry.parameters.height / 2 + 0.3;
+    group.add(cone);
+    return { object: group, obstacleRadius: 0 };
+  },
+  bush: (seed, palette) => {
+    const rng = new Rng(seed);
+    const group = new Group12();
+    const cone = new Mesh15(
+      new CylinderGeometry6(0.1, rng.range(0.5, 0.7), rng.range(0.5, 0.8), 5),
+      new MeshStandardMaterial12({ color: rng.pick(palette.foliage), flatShading: true })
+    );
+    cone.position.y = 0.3;
+    group.add(cone);
+    return { object: group, obstacleRadius: 0 };
+  },
+  grass: () => ({ object: new Group12(), obstacleRadius: 0 })
+};
+function buildScene(manifest, scene) {
+  const seed = manifest.seed ?? 1;
+  const palette = manifest.palette ? PALETTES[manifest.palette] : DEFAULT_PALETTE;
+  const group = new Group12();
+  group.name = "scena-scene";
+  const updates = [];
+  let terrain;
+  if (manifest.terrain) {
+    terrain = createTerrain({
+      ...manifest.terrain,
+      seed,
+      waterLevel: manifest.water?.level,
+      palette
+    });
+    group.add(terrain.mesh);
+  }
+  const heightAt = terrain ? terrain.heightAt : () => 0;
+  let water;
+  if (manifest.water) {
+    water = createWater({
+      level: manifest.water.level,
+      size: manifest.water.size ?? (terrain ? terrain.size * 1.4 : 200),
+      palette
+    });
+    group.add(water.mesh);
+    updates.push((dt) => water.update(dt));
+  }
+  const dryLand = terrain && water ? aboveWater(terrain, water, 0.3) : () => true;
+  let sky;
+  if (manifest.sky ?? true) {
+    sky = createSky({ palette });
+    group.add(sky.mesh);
+  }
+  const rig = createLightingRig(manifest.lighting ?? "day");
+  group.add(rig.group);
+  if (scene && manifest.fog !== false) applyFog(scene, manifest.fog ?? "haze", palette);
+  const paths = (manifest.paths ?? []).map((spec) => {
+    const path = createPath(spec.points, {
+      surface: heightAt,
+      width: spec.width,
+      loop: spec.loop,
+      palette
+    });
+    group.add(path.mesh);
+    return path;
+  });
+  const onAnyPath = (x, z) => paths.some((p) => p.contains(x, z));
+  let village;
+  if (manifest.village) {
+    village = createVillage({
+      ...manifest.village,
+      seed: seed + 1,
+      surface: heightAt,
+      mask: (x, z) => dryLand(x, z) && !onAnyPath(x, z),
+      palette
+    });
+    group.add(village.group);
+  }
+  const wind = manifest.wind ?? true;
+  const scatters = (manifest.scatters ?? []).map((spec, index) => {
+    const inset = terrain ? terrain.size * 0.45 : 40;
+    const avoidWater = spec.avoidWater ?? true;
+    const avoidPaths = spec.avoidPaths ?? true;
+    const result = scatter({
+      seed: seed + 10 + index,
+      area: spec.area ?? { min: { x: -inset, z: -inset }, max: { x: inset, z: inset } },
+      surface: heightAt,
+      density: spec.density,
+      count: spec.count,
+      minSpacing: spec.minSpacing,
+      clumpScale: spec.clumpScale,
+      lod: spec.lod,
+      items: spec.items.map((item) => {
+        const far = spec.lod ? FAR_FACTORIES[item.type] : void 0;
+        return {
+          create: (rng) => PROP_FACTORIES[item.type](rng.int(1, 1e9), palette),
+          createFar: far && ((rng) => far(rng.int(1, 1e9), palette)),
+          weight: item.weight,
+          variants: item.variants,
+          scale: item.scale
+        };
+      }),
+      mask: (x, z, y) => (spec.maxHeight === void 0 || y < spec.maxHeight) && (!avoidWater || dryLand(x, z)) && (!avoidPaths || !onAnyPath(x, z)),
+      keepOut: [
+        ...avoidPaths ? paths.flatMap((p) => p.keepOut) : [],
+        ...village ? village.keepOut : []
+      ]
+    });
+    group.add(result.group);
+    if (wind !== false) {
+      const sway = applyWind(result.group, {
+        strength: typeof wind === "object" ? wind.strength ?? 0.05 : 0.05
+      });
+      updates.push((dt) => sway.update(dt));
+    }
+    return result;
+  });
+  let cycle;
+  if (manifest.dayCycle) {
+    cycle = createDayCycle({
+      sky,
+      rig,
+      scene,
+      lamps: village?.lamps,
+      palette,
+      dayLength: manifest.dayCycle.dayLength,
+      timeOfDay: manifest.dayCycle.timeOfDay
+    });
+    updates.push((dt) => cycle.update(dt));
+  }
+  scene?.add(group);
+  return {
+    group,
+    palette,
+    terrain,
+    water,
+    sky,
+    rig,
+    cycle,
+    paths,
+    village,
+    scatters,
+    obstacles: [
+      ...village ? village.obstacles : [],
+      ...scatters.flatMap((s) => s.obstacles)
+    ],
+    heightAt,
+    update(dt) {
+      for (const fn of updates) fn(dt);
+    }
+  };
+}
+
+// src/scene/markers.ts
+import { Vector3 as Vector35 } from "three";
+function extractMarkers(root) {
+  root.updateWorldMatrix(true, true);
+  const spawns = {};
+  const routePoints = {};
+  const obstacles = [];
+  const keepOut = [];
+  root.traverse((node) => {
+    const name = node.name.replace(/\.\d+$/, "");
+    const match = /^(spawn|route|obstacle|keepout)_(.+)$/.exec(name);
+    if (!match) return;
+    const [, kind, rest] = match;
+    const position = node.getWorldPosition(new Vector35());
+    const radius = Math.max(node.scale.x, node.scale.z);
+    if (kind === "spawn") {
+      spawns[rest] = position;
+    } else if (kind === "route") {
+      const step = /^(.*)_(\d+)$/.exec(rest);
+      const routeName = step ? step[1] : rest;
+      const index = step ? parseInt(step[2], 10) : 0;
+      (routePoints[routeName] ?? (routePoints[routeName] = [])).push({ index, position });
+    } else if (kind === "obstacle") {
+      obstacles.push({ center: position, radius });
+    } else {
+      keepOut.push({ center: { x: position.x, z: position.z }, radius });
+    }
+  });
+  const routes = {};
+  for (const [name, points] of Object.entries(routePoints)) {
+    routes[name] = points.sort((a, b) => a.index - b.index).map((p) => p.position);
+  }
+  return { spawns, routes, obstacles, keepOut };
 }
 export {
   DEFAULT_PALETTE,
+  KIT_UNIT,
   PALETTES,
   Rng,
   aboveWater,
   applyFog,
   applyWind,
+  assembleKit,
+  buildScene,
   collectObstacles,
   createBush,
   createCrate,
@@ -1409,6 +1819,7 @@ export {
   createVillage,
   createWater,
   createWell,
+  extractMarkers,
   fractalNoise2,
   hash2,
   scatter,