scena3d 0.1.0

package/dist/index.cjs

@@ -0,0 +1,662 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_PALETTE: () => DEFAULT_PALETTE,
+  PALETTES: () => PALETTES,
+  Rng: () => Rng,
+  applyFog: () => applyFog,
+  collectObstacles: () => collectObstacles,
+  createCrate: () => createCrate,
+  createFence: () => createFence,
+  createLamp: () => createLamp,
+  createLightingRig: () => createLightingRig,
+  createRock: () => createRock,
+  createSky: () => createSky,
+  createTerrain: () => createTerrain,
+  createTree: () => createTree,
+  fractalNoise2: () => fractalNoise2,
+  hash2: () => hash2,
+  scatter: () => scatter,
+  valueNoise2: () => valueNoise2
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/random.ts
+var Rng = class _Rng {
+  constructor(seed = 1) {
+    this.state = seed >>> 0 || 1;
+  }
+  /** Next float in [0, 1) (mulberry32). */
+  next() {
+    this.state = this.state + 1831565813 >>> 0;
+    let t = this.state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+  /** Float in [min, max). */
+  range(min, max) {
+    return min + this.next() * (max - min);
+  }
+  /** Integer in [min, max] inclusive. */
+  int(min, max) {
+    return min + Math.floor(this.next() * (max - min + 1));
+  }
+  /** Random element of a non-empty array. */
+  pick(items) {
+    return items[Math.floor(this.next() * items.length)];
+  }
+  /** value ± spread (uniform). */
+  jitter(value, spread) {
+    return value + (this.next() * 2 - 1) * spread;
+  }
+  /** A new independent Rng derived from this one. */
+  fork() {
+    return new _Rng(Math.floor(this.next() * 4294967295) || 1);
+  }
+};
+function hash2(ix, iz, seed) {
+  let h = ix * 374761393 + iz * 668265263 + seed * 2246822519 >>> 0;
+  h = Math.imul(h ^ h >>> 13, 1274126177) >>> 0;
+  return ((h ^ h >>> 16) >>> 0) / 4294967296;
+}
+var smooth = (t) => t * t * (3 - 2 * t);
+function valueNoise2(x, z, seed) {
+  const ix = Math.floor(x);
+  const iz = Math.floor(z);
+  const fx = smooth(x - ix);
+  const fz = smooth(z - iz);
+  const a = hash2(ix, iz, seed);
+  const b = hash2(ix + 1, iz, seed);
+  const c = hash2(ix, iz + 1, seed);
+  const d = hash2(ix + 1, iz + 1, seed);
+  return a + (b - a) * fx + (c - a) * fz + (a - b - c + d) * fx * fz;
+}
+function fractalNoise2(x, z, seed, octaves = 4, lacunarity = 2, gain = 0.5) {
+  let amplitude = 1;
+  let frequency = 1;
+  let sum = 0;
+  let total = 0;
+  for (let i = 0; i < octaves; i++) {
+    sum += valueNoise2(x * frequency, z * frequency, seed + i * 101) * amplitude;
+    total += amplitude;
+    amplitude *= gain;
+    frequency *= lacunarity;
+  }
+  return sum / total;
+}
+
+// src/core/palette.ts
+var PALETTES = {
+  meadow: {
+    foliage: [3120727, 3650154, 2789199, 4569208],
+    trunk: 7031347,
+    rock: [9080728, 7765126, 10133672],
+    wood: 9070146,
+    woodDark: 7031347,
+    metal: 4015185,
+    lampGlow: 16767113,
+    grassLow: 4169050,
+    grassHigh: 7319142,
+    cliff: 8223346,
+    peak: 15265007,
+    skyTop: 4026552,
+    skyBottom: 12573160,
+    fog: 12111837
+  },
+  autumn: {
+    foliage: [13202735, 14257722, 11754538, 14722373],
+    trunk: 6111280,
+    rock: [9274744, 7827299, 10261642],
+    wood: 8215098,
+    woodDark: 6111280,
+    metal: 4603706,
+    lampGlow: 16762225,
+    grassLow: 10324543,
+    grassHigh: 11901770,
+    cliff: 8549482,
+    peak: 14933716,
+    skyTop: 9333928,
+    skyBottom: 15255976,
+    fog: 14270888
+  },
+  dusk: {
+    foliage: [2055750, 2385999, 1724992, 2978904],
+    trunk: 4272455,
+    rock: [5658226, 4737121, 6579332],
+    wood: 6113891,
+    woodDark: 4272455,
+    metal: 2829117,
+    lampGlow: 16757596,
+    grassLow: 2976594,
+    grassHigh: 4029022,
+    cliff: 5394795,
+    peak: 12105945,
+    skyTop: 1909061,
+    skyBottom: 13199946,
+    fog: 6969978
+  }
+};
+var DEFAULT_PALETTE = PALETTES.meadow;
+
+// src/core/types.ts
+var import_three = require("three");
+function collectObstacles(props) {
+  const obstacles = [];
+  for (const prop of props) {
+    if (prop.obstacleRadius <= 0) continue;
+    prop.object.updateWorldMatrix(true, false);
+    obstacles.push({
+      center: prop.object.getWorldPosition(new import_three.Vector3()),
+      radius: prop.obstacleRadius * maxScale(prop.object)
+    });
+  }
+  return obstacles;
+}
+function maxScale(object) {
+  return Math.max(object.scale.x, object.scale.z);
+}
+
+// src/props/tree.ts
+var import_three2 = require("three");
+function createTree(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const style = options.style ?? (rng.next() < 0.6 ? "pine" : "oak");
+  const height = options.height ?? rng.range(3.2, 5.2);
+  const group = new import_three2.Group();
+  group.name = `tree-${style}`;
+  const trunkMaterial = new import_three2.MeshStandardMaterial({ color: palette.trunk, flatShading: true });
+  const foliageMaterial = new import_three2.MeshStandardMaterial({
+    color: rng.pick(palette.foliage),
+    flatShading: true
+  });
+  if (style === "pine") {
+    const trunkHeight = height * 0.25;
+    const trunk = new import_three2.Mesh(new import_three2.CylinderGeometry(0.09, 0.14, trunkHeight, 6), trunkMaterial);
+    trunk.position.y = trunkHeight / 2;
+    group.add(trunk);
+    const tiers = rng.int(3, 4);
+    let y = trunkHeight;
+    let radius = height * rng.range(0.24, 0.3);
+    const tierHeight = (height - trunkHeight) / tiers + 0.15;
+    for (let i = 0; i < tiers; i++) {
+      const cone = new import_three2.Mesh(new import_three2.ConeGeometry(radius, tierHeight * 1.35, 7), foliageMaterial);
+      cone.position.y = y + tierHeight * 0.55;
+      cone.rotation.y = rng.range(0, Math.PI);
+      group.add(cone);
+      y += tierHeight * 0.8;
+      radius *= 0.72;
+    }
+  } else {
+    const trunkHeight = height * 0.45;
+    const trunk = new import_three2.Mesh(new import_three2.CylinderGeometry(0.12, 0.2, trunkHeight, 6), trunkMaterial);
+    trunk.position.y = trunkHeight / 2;
+    trunk.rotation.z = rng.range(-0.08, 0.08);
+    group.add(trunk);
+    const blobs = rng.int(2, 4);
+    for (let i = 0; i < blobs; i++) {
+      const radius = height * rng.range(0.18, 0.28);
+      const blob = new import_three2.Mesh(new import_three2.IcosahedronGeometry(radius, 0), foliageMaterial);
+      blob.position.set(
+        rng.jitter(0, height * 0.16),
+        trunkHeight + radius * rng.range(0.5, 0.9) + i * radius * 0.35,
+        rng.jitter(0, height * 0.16)
+      );
+      blob.rotation.set(rng.range(0, Math.PI), rng.range(0, Math.PI), 0);
+      group.add(blob);
+    }
+  }
+  return { object: group, obstacleRadius: style === "pine" ? 0.5 : 0.6 };
+}
+
+// src/props/rock.ts
+var import_three3 = require("three");
+function createRock(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const size = options.size ?? rng.range(0.4, 1.1);
+  const geometry = new import_three3.IcosahedronGeometry(size, 0);
+  const positions = geometry.getAttribute("position");
+  const seen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < positions.count; i++) {
+    const key = `${positions.getX(i).toFixed(4)},${positions.getY(i).toFixed(4)},${positions.getZ(i).toFixed(4)}`;
+    let offset = seen.get(key);
+    if (!offset) {
+      offset = [rng.jitter(0, size * 0.22), rng.jitter(0, size * 0.16), rng.jitter(0, size * 0.22)];
+      seen.set(key, offset);
+    }
+    positions.setXYZ(
+      i,
+      positions.getX(i) + offset[0],
+      Math.max(positions.getY(i) + offset[1], -size * 0.15),
+      // flatten the bottom
+      positions.getZ(i) + offset[2]
+    );
+  }
+  geometry.computeVertexNormals();
+  const rock = new import_three3.Mesh(
+    geometry,
+    new import_three3.MeshStandardMaterial({ color: rng.pick(palette.rock), flatShading: true })
+  );
+  rock.position.y = size * 0.15;
+  rock.scale.y = rng.range(0.6, 0.9);
+  const group = new import_three3.Group();
+  group.name = "rock";
+  group.add(rock);
+  return { object: group, obstacleRadius: size * 1.05 };
+}
+
+// src/props/crate.ts
+var import_three4 = require("three");
+function createCrate(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const size = options.size ?? 1;
+  const wear = options.weathering ?? 0.3;
+  const group = new import_three4.Group();
+  group.name = "crate";
+  const panelMaterial = new import_three4.MeshStandardMaterial({ color: palette.wood, flatShading: true });
+  panelMaterial.color.offsetHSL(0, 0, -rng.range(0, wear * 0.18));
+  const frameMaterial = new import_three4.MeshStandardMaterial({ color: palette.woodDark, flatShading: true });
+  const body = new import_three4.Mesh(new import_three4.BoxGeometry(size * 0.92, size * 0.92, size * 0.92), panelMaterial);
+  body.position.y = size / 2;
+  group.add(body);
+  const beam = size * 0.12;
+  const long = size * 1;
+  for (const y of [beam / 2, size - beam / 2]) {
+    for (const [rx, rz, w, d] of [
+      [0, size / 2 - beam / 2, long, beam],
+      [0, -(size / 2 - beam / 2), long, beam],
+      [size / 2 - beam / 2, 0, beam, long],
+      [-(size / 2 - beam / 2), 0, beam, long]
+    ]) {
+      const rail = new import_three4.Mesh(new import_three4.BoxGeometry(w, beam, d), frameMaterial);
+      rail.position.set(rx, y, rz);
+      group.add(rail);
+    }
+  }
+  for (const x of [-1, 1]) {
+    for (const z of [-1, 1]) {
+      const post = new import_three4.Mesh(new import_three4.BoxGeometry(beam, size, beam), frameMaterial);
+      post.position.set(x * (size / 2 - beam / 2), size / 2, z * (size / 2 - beam / 2));
+      group.add(post);
+    }
+  }
+  group.rotation.y = rng.range(0, Math.PI / 2);
+  return { object: group, obstacleRadius: size * 0.75 };
+}
+
+// src/props/fence.ts
+var import_three5 = require("three");
+function createFence(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const length = options.length ?? 6;
+  const spacing = options.postSpacing ?? 1.5;
+  const height = options.height ?? 1.1;
+  const group = new import_three5.Group();
+  group.name = "fence";
+  const postMaterial = new import_three5.MeshStandardMaterial({ color: palette.woodDark, flatShading: true });
+  const railMaterial = new import_three5.MeshStandardMaterial({ color: palette.wood, flatShading: true });
+  const posts = Math.max(2, Math.round(length / spacing) + 1);
+  const step = length / (posts - 1);
+  for (let i = 0; i < posts; i++) {
+    const post = new import_three5.Mesh(new import_three5.CylinderGeometry(0.06, 0.075, height, 5), postMaterial);
+    post.position.set(-length / 2 + i * step, height / 2, rng.jitter(0, 0.03));
+    post.rotation.z = rng.range(-0.04, 0.04);
+    group.add(post);
+  }
+  for (const railY of [height * 0.55, height * 0.85]) {
+    const rail = new import_three5.Mesh(new import_three5.BoxGeometry(length, 0.07, 0.05), railMaterial);
+    rail.position.y = rng.jitter(railY, 0.02);
+    rail.rotation.x = rng.range(-0.02, 0.02);
+    group.add(rail);
+  }
+  return { object: group, obstacleRadius: length / 2 };
+}
+
+// src/props/lamp.ts
+var import_three6 = require("three");
+function createLamp(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const height = options.height ?? rng.range(2.6, 3.1);
+  const group = new import_three6.Group();
+  group.name = "lamp";
+  const metal = new import_three6.MeshStandardMaterial({ color: palette.metal, flatShading: true });
+  const post = new import_three6.Mesh(new import_three6.CylinderGeometry(0.05, 0.08, height, 6), metal);
+  post.position.y = height / 2;
+  group.add(post);
+  const head = new import_three6.Mesh(new import_three6.BoxGeometry(0.34, 0.26, 0.34), metal);
+  head.position.y = height + 0.1;
+  group.add(head);
+  const bulb = new import_three6.Mesh(
+    new import_three6.SphereGeometry(0.11, 8, 6),
+    new import_three6.MeshStandardMaterial({
+      color: palette.lampGlow,
+      emissive: palette.lampGlow,
+      emissiveIntensity: 1.6
+    })
+  );
+  bulb.position.y = height - 0.03;
+  group.add(bulb);
+  if (options.light) {
+    const light = new import_three6.PointLight(palette.lampGlow, options.lightIntensity ?? 6, 12, 1.8);
+    light.position.y = height - 0.05;
+    group.add(light);
+  }
+  return { object: group, obstacleRadius: 0.25 };
+}
+
+// src/environment/terrain.ts
+var import_three7 = require("three");
+function createTerrain(options = {}) {
+  const seed = options.seed ?? 1;
+  const size = options.size ?? 80;
+  const resolution = options.resolution ?? 96;
+  const amplitude = options.amplitude ?? 6;
+  const noiseScale = options.noiseScale ?? 28;
+  const octaves = options.octaves ?? 4;
+  const flatness = options.valleyFlatness ?? 0.55;
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const heightAt = (x, z) => {
+    const n = fractalNoise2(x / noiseScale, z / noiseScale, seed, octaves);
+    const shaped = Math.pow(n, 1 + flatness * 2);
+    return shaped * amplitude;
+  };
+  const geometry = new import_three7.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++) {
+    positions.setY(i, heightAt(positions.getX(i), positions.getZ(i)));
+  }
+  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();
+  for (let i = 0; i < positions.count; i++) {
+    const h = positions.getY(i) / 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));
+    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,
+    new import_three7.MeshStandardMaterial({ vertexColors: true, flatShading: true })
+  );
+  mesh.name = "terrain";
+  return { mesh, heightAt, size, seed };
+}
+
+// src/environment/sky.ts
+var import_three8 = require("three");
+function createSky(options = {}) {
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const material = new import_three8.ShaderMaterial({
+    side: import_three8.BackSide,
+    depthWrite: false,
+    uniforms: {
+      topColor: { value: new import_three8.Color(options.topColor ?? palette.skyTop) },
+      bottomColor: { value: new import_three8.Color(options.bottomColor ?? palette.skyBottom) }
+    },
+    vertexShader: (
+      /* glsl */
+      `
+      varying vec3 vWorld;
+      void main() {
+        vWorld = (modelMatrix * vec4(position, 1.0)).xyz;
+        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+      }`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+      uniform vec3 topColor;
+      uniform vec3 bottomColor;
+      varying vec3 vWorld;
+      void main() {
+        float t = clamp(normalize(vWorld).y * 0.5 + 0.5, 0.0, 1.0);
+        gl_FragColor = vec4(mix(bottomColor, topColor, pow(t, 0.8)), 1.0);
+      }`
+    )
+  });
+  const mesh = new import_three8.Mesh(new import_three8.SphereGeometry(options.radius ?? 400, 16, 12), material);
+  mesh.name = "sky";
+  return {
+    mesh,
+    setColors(top, bottom) {
+      material.uniforms.topColor.value.setHex(top);
+      material.uniforms.bottomColor.value.setHex(bottom);
+    }
+  };
+}
+
+// src/environment/lighting.ts
+var import_three9 = require("three");
+var PRESETS = {
+  day: {
+    sun: 16774368,
+    sunIntensity: 1.6,
+    sunPos: [30, 45, 20],
+    ambient: 14674687,
+    ambientIntensity: 0.35,
+    skyTint: 12376319,
+    groundTint: 6978918
+  },
+  "golden-hour": {
+    sun: 16758881,
+    sunIntensity: 1.7,
+    sunPos: [40, 14, -12],
+    ambient: 16768192,
+    ambientIntensity: 0.3,
+    skyTint: 16764830,
+    groundTint: 8022616
+  },
+  overcast: {
+    sun: 14212840,
+    sunIntensity: 0.7,
+    sunPos: [12, 40, 8],
+    ambient: 13620960,
+    ambientIntensity: 0.65,
+    skyTint: 13160668,
+    groundTint: 7371384
+  },
+  night: {
+    sun: 9348824,
+    sunIntensity: 0.35,
+    sunPos: [-20, 30, -25],
+    ambient: 3818600,
+    ambientIntensity: 0.35,
+    skyTint: 2897248,
+    groundTint: 1975344
+  }
+};
+function createLightingRig(preset = "day") {
+  const config = PRESETS[preset];
+  const group = new import_three9.Group();
+  group.name = `lighting-${preset}`;
+  const sun = new import_three9.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);
+  group.add(sun, ambient, hemisphere);
+  return { group, sun, ambient, hemisphere };
+}
+var FOG = {
+  haze: { near: 45, far: 160 },
+  thick: { near: 12, far: 70 },
+  eerie: { near: 6, far: 42 }
+};
+function applyFog(scene, preset, palette = DEFAULT_PALETTE) {
+  if (preset === "clear") {
+    scene.fog = null;
+    return;
+  }
+  const { near, far } = FOG[preset];
+  scene.fog = new import_three9.Fog(palette.fog, near, far);
+}
+
+// src/scatter/scatter.ts
+var import_three10 = require("three");
+function scatter(options) {
+  const seed = options.seed ?? 1;
+  const rng = new Rng(seed);
+  const { area } = options;
+  const width = area.max.x - area.min.x;
+  const depth = area.max.z - area.min.z;
+  const surface = options.surface ?? 0;
+  const heightAt = typeof surface === "number" ? () => surface : (x, z) => surface(x, z);
+  const minSpacing = options.minSpacing ?? 1.2;
+  const clumpScale = options.clumpScale ?? 18;
+  const attempts = options.count ?? Math.round(width * depth * (options.density ?? 0.03));
+  const keepOut = (options.keepOut ?? []).map((k) => ({
+    x: k.center.x,
+    z: "z" in k.center ? k.center.z : k.center.z,
+    radius: k.radius
+  }));
+  const weights = options.items.map((i) => i.weight ?? 1);
+  const totalWeight = weights.reduce((a, b) => a + b, 0);
+  const pickItem = () => {
+    let r = rng.next() * totalWeight;
+    for (let i = 0; i < weights.length; i++) {
+      r -= weights[i];
+      if (r <= 0) return i;
+    }
+    return weights.length - 1;
+  };
+  const cell = Math.max(minSpacing, 1e-3);
+  const occupied = /* @__PURE__ */ new Map();
+  const tooClose = (x, z) => {
+    const cx = Math.floor(x / cell);
+    const cz = Math.floor(z / cell);
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dz = -1; dz <= 1; dz++) {
+        const bucket = occupied.get(`${cx + dx},${cz + dz}`);
+        if (!bucket) continue;
+        for (const p of bucket) {
+          if ((p.x - x) ** 2 + (p.z - z) ** 2 < minSpacing * minSpacing) return true;
+        }
+      }
+    }
+    return false;
+  };
+  const placements = [];
+  for (let i = 0; i < attempts; i++) {
+    const x = rng.range(area.min.x, area.max.x);
+    const z = rng.range(area.min.z, area.max.z);
+    if (valueNoise2(x / clumpScale, z / clumpScale, seed + 77) < rng.range(0.15, 0.55)) continue;
+    if (keepOut.some((k) => (k.x - x) ** 2 + (k.z - z) ** 2 < k.radius * k.radius)) continue;
+    if (tooClose(x, z)) continue;
+    const y = heightAt(x, z);
+    if (options.mask && !options.mask(x, z, y)) continue;
+    const itemIndex = pickItem();
+    const [minScale, maxScale2] = options.items[itemIndex].scale ?? [0.8, 1.25];
+    placements.push({
+      position: new import_three10.Vector3(x, y, z),
+      rotationY: rng.range(0, Math.PI * 2),
+      scale: rng.range(minScale, maxScale2),
+      itemIndex
+    });
+    const key = `${Math.floor(x / cell)},${Math.floor(z / cell)}`;
+    let bucket = occupied.get(key);
+    if (!bucket) occupied.set(key, bucket = []);
+    bucket.push({ x, z });
+  }
+  const group = new import_three10.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();
+  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 byVariant = variants.map(() => []);
+    for (const placement of placements) {
+      if (placement.itemIndex !== itemIndex) continue;
+      const v = Math.abs(Math.floor(placement.position.x * 31 + placement.position.z * 17)) % variantCount;
+      byVariant[v].push(placement);
+    }
+    variants.forEach((variant, v) => {
+      const list = byVariant[v];
+      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);
+        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 (variant.obstacleRadius > 0) {
+        for (const placement of list) {
+          obstacles.push({
+            center: placement.position.clone(),
+            radius: variant.obstacleRadius * placement.scale
+          });
+        }
+      }
+    });
+  });
+  return { group, placements, obstacles, count: placements.length };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PALETTE,
+  PALETTES,
+  Rng,
+  applyFog,
+  collectObstacles,
+  createCrate,
+  createFence,
+  createLamp,
+  createLightingRig,
+  createRock,
+  createSky,
+  createTerrain,
+  createTree,
+  fractalNoise2,
+  hash2,
+  scatter,
+  valueNoise2
+});
+//# sourceMappingURL=index.cjs.map