@adatechnology/game-terrain-three 0.0.0-stage → 0.1.0

package/dist/index.global.js

@@ -0,0 +1,682 @@
+"use strict";
+var GameTerrainThree = (() => {
+  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, {
+    TERRAIN_AREA_GROUND: () => TERRAIN_AREA_GROUND,
+    TERRAIN_STRIPS: () => TERRAIN_STRIPS,
+    createSurfaceMaterial: () => createSurfaceMaterial,
+    createTerrainRenderer: () => createTerrainRenderer,
+    createTerrainTestModule: () => createTerrainTestModule
+  });
+
+  // ../game-contracts/dist/index.js
+  var KIT_ORIGIN_KEY = "kitOrigin";
+  function markKitOrigin(object, origin) {
+    const node = object;
+    node.userData = node.userData ?? {};
+    node.userData[KIT_ORIGIN_KEY] = { ...origin };
+    return object;
+  }
+
+  // ../game-terrain/dist/index.js
+  var TERRAIN_PATTERNS = ["plain", "grass", "soil", "sand", "asphalt", "concrete", "tile", "planks", "stone"];
+
+  // src/surface-material.ts
+  var patternIndex = (pattern) => Math.max(0, TERRAIN_PATTERNS.indexOf(pattern ?? "plain"));
+  var SURFACE_GLSL = (
+    /* glsl */
+    `
+float tsHash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+float tsNoise(vec2 p) {
+  vec2 i = floor(p); vec2 f = fract(p); f = f * f * (3.0 - 2.0 * f);
+  return mix(mix(tsHash(i), tsHash(i + vec2(1.0, 0.0)), f.x), mix(tsHash(i + vec2(0.0, 1.0)), tsHash(i + vec2(1.0, 1.0)), f.x), f.y);
+}
+float tsFbm(vec2 p) { return tsNoise(p) * 0.55 + tsNoise(p * 2.3 + 7.1) * 0.3 + tsNoise(p * 5.1 + 3.3) * 0.15; }
+float tsLine(float value, float period, float width) { float d = abs(fract(value / period + 0.5) - 0.5) * period; return 1.0 - smoothstep(width * 0.6, width, d); }
+vec3 terrainSurface(vec3 base, vec2 xz, float kind) {
+  float k = floor(kind + 0.5);
+  if (k < 0.5) return base * (0.86 + 0.28 * tsFbm(xz * 9.0));
+  if (k < 1.5) {
+    float blades = tsNoise(xz * vec2(70.0, 55.0)) * 0.6 + tsNoise(xz * 22.0) * 0.4;
+    float patches = tsFbm(xz * 1.3);
+    return base * (0.55 + 0.8 * blades) * mix(vec3(1.25, 1.05, 0.7), vec3(0.8, 1.1, 0.85), patches);
+  }
+  if (k < 2.5) return base * (0.6 + 0.75 * tsFbm(xz * 6.0)) * (0.82 + 0.36 * tsNoise(xz * 48.0));
+  if (k < 3.5) return base * (0.88 + 0.12 * sin(xz.x * 22.0 + tsFbm(xz * 2.0) * 9.0)) * (0.92 + 0.16 * tsNoise(xz * 90.0));
+  if (k < 4.5) { float grain = tsNoise(xz * 120.0); return base * (0.55 + 1.1 * grain * grain) * (0.85 + 0.3 * tsFbm(xz * 0.8)); }
+  if (k < 5.5) {
+    float joint = max(tsLine(xz.x, 3.0, 0.012), tsLine(xz.y, 3.0, 0.012));
+    return base * (0.82 + 0.3 * tsFbm(xz * 3.5)) * (0.94 + 0.12 * tsNoise(xz * 130.0)) * (1.0 - 0.6 * joint);
+  }
+  if (k < 6.5) {
+    vec2 cell = floor(xz / 0.6);
+    float grout = max(tsLine(xz.x, 0.6, 0.006), tsLine(xz.y, 0.6, 0.006));
+    return mix(base * (0.93 + 0.14 * tsHash(cell)) * (0.97 + 0.06 * tsFbm(xz * 7.0)), vec3(0.14, 0.13, 0.12), grout);
+  }
+  if (k < 7.5) {
+    float row = floor(xz.y / 0.14);
+    float along = xz.x + tsHash(vec2(row, 3.0)) * 2.4;
+    float seam = max(tsLine(xz.y, 0.14, 0.004), tsLine(along, 2.4, 0.004));
+    float grain = tsNoise(vec2(along * 3.0, xz.y * 70.0)) * 0.6 + tsNoise(vec2(along * 11.0, xz.y * 180.0)) * 0.4;
+    return base * (0.72 + 0.56 * tsHash(vec2(row, floor(along / 2.4)))) * (0.75 + 0.5 * grain) * (1.0 - 0.75 * seam);
+  }
+  vec2 cell = floor(xz / 0.22);
+  float seams = max(tsLine(xz.x, 0.22, 0.012), tsLine(xz.y, 0.22, 0.012));
+  return base * (0.7 + 0.6 * tsHash(cell)) * (0.85 + 0.3 * tsFbm(xz * 16.0)) * (1.0 - 0.55 * seams);
+}
+`
+  );
+  function createSurfaceMaterial(THREE) {
+    const material = new THREE.MeshStandardMaterial({ roughness: 0.95, metalness: 0 });
+    material.onBeforeCompile = (shader) => {
+      shader.vertexShader = shader.vertexShader.replace("#include <common>", "#include <common>\nattribute float aPattern;\nattribute vec3 aBase;\nattribute vec2 aShade;\nflat varying float vPattern;\nflat varying vec3 vBase;\nvarying vec2 vShade;\nvarying vec2 vGroundXZ;").replace("#include <begin_vertex>", "#include <begin_vertex>\nvPattern = aPattern;\nvBase = aBase;\nvShade = aShade;\nvGroundXZ = position.xz;");
+      shader.fragmentShader = shader.fragmentShader.replace("#include <common>", `#include <common>
+flat varying float vPattern;
+flat varying vec3 vBase;
+varying vec2 vShade;
+varying vec2 vGroundXZ;
+${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment>\ndiffuseColor.rgb = mix(terrainSurface(vBase, vGroundXZ, vPattern), vec3(0.012, 0.011, 0.01), vShade.y) * vShade.x;");
+    };
+    material.customProgramCacheKey = () => "game-terrain-surface";
+    return material;
+  }
+
+  // src/chunk-geometry.ts
+  var DEPTH_SHADE = 1.6;
+  var MIN_DEPTH_LIGHT = 0.55;
+  var LOOSE_VISIBLE = 4e-3;
+  var THIN_SKIN = 0.1;
+  var SKIRT_QUADS = 4;
+  var BROKEN_DEPTH = 4e-3;
+  var BROKEN_TONE = 0.62;
+  function vertexLook(terrain, column, row, base, shade) {
+    const index = row * terrain.stride + column;
+    let material = terrain.vertexMaterial(column, row);
+    if (terrain.loose[index] > LOOSE_VISIBLE) {
+      const profile = terrain.profileList[terrain.profileIndex[index]];
+      const first = profile.strata[0];
+      material = terrain.material(first.thickness < THIN_SKIN && profile.strata[1] ? profile.strata[1].material : first.material);
+    }
+    const broken = material.pattern === "concrete" && terrain.dug[index] > BROKEN_DEPTH;
+    const tone = broken ? BROKEN_TONE : 1;
+    base[0] = material.color[0] * tone;
+    base[1] = material.color[1] * tone;
+    base[2] = material.color[2] * tone;
+    shade[0] = Math.max(MIN_DEPTH_LIGHT, 1 - terrain.dug[index] / DEPTH_SHADE);
+    shade[1] = terrain.scorch[index];
+    return patternIndex(broken ? "soil" : material.pattern);
+  }
+  function buildChunkGeometry(THREE, terrain, chunk, step) {
+    const [x0, z0] = terrain.bounds;
+    const { cellSize, columns, rows } = terrain;
+    const lastColumn = Math.min(columns, chunk.column + chunk.cells);
+    const lastRow = Math.min(rows, chunk.row + chunk.cells);
+    const across = Math.ceil((lastColumn - chunk.column) / step) + 1;
+    const down = Math.ceil((lastRow - chunk.row) / step) + 1;
+    const positions = new Float32Array(across * down * 3);
+    const normals = new Float32Array(across * down * 3);
+    const bases = new Float32Array(across * down * 3);
+    const shades = new Float32Array(across * down * 2);
+    const patterns = new Float32Array(across * down);
+    const base = [0, 0, 0];
+    const shade = [1, 0];
+    let at = 0;
+    for (let j = 0; j < down; j++) {
+      const row = Math.min(lastRow, chunk.row + j * step);
+      for (let i = 0; i < across; i++) {
+        const column = Math.min(lastColumn, chunk.column + i * step);
+        const height = terrain.vertexHeight(column, row);
+        positions[at * 3] = x0 + column * cellSize;
+        positions[at * 3 + 1] = height;
+        positions[at * 3 + 2] = z0 + row * cellSize;
+        const left = terrain.vertexHeight(Math.max(0, column - 1), row);
+        const right = terrain.vertexHeight(Math.min(columns, column + 1), row);
+        const back = terrain.vertexHeight(column, Math.max(0, row - 1));
+        const front = terrain.vertexHeight(column, Math.min(rows, row + 1));
+        const nx = left - right;
+        const ny = 2 * cellSize;
+        const nz = back - front;
+        const length = Math.hypot(nx, ny, nz);
+        normals[at * 3] = nx / length;
+        normals[at * 3 + 1] = ny / length;
+        normals[at * 3 + 2] = nz / length;
+        patterns[at] = vertexLook(terrain, column, row, base, shade);
+        bases.set(base, at * 3);
+        shades.set(shade, at * 2);
+        at++;
+      }
+    }
+    const indices = new Uint32Array((across - 1) * (down - 1) * 6);
+    let cursor = 0;
+    for (let j = 0; j < down - 1; j++) {
+      for (let i = 0; i < across - 1; i++) {
+        const a = j * across + i;
+        const b = a + 1;
+        const c = a + across;
+        const d = c + 1;
+        indices[cursor++] = a;
+        indices[cursor++] = c;
+        indices[cursor++] = b;
+        indices[cursor++] = c;
+        indices[cursor++] = d;
+        indices[cursor++] = b;
+      }
+    }
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
+    geometry.setAttribute("normal", new THREE.BufferAttribute(normals, 3));
+    geometry.setAttribute("aBase", new THREE.BufferAttribute(bases, 3));
+    geometry.setAttribute("aShade", new THREE.BufferAttribute(shades, 2));
+    geometry.setAttribute("aPattern", new THREE.BufferAttribute(patterns, 1));
+    geometry.setIndex(new THREE.BufferAttribute(indices, 1));
+    return geometry;
+  }
+  function buildPristineGeometry(THREE, terrain, chunks, skirt) {
+    const [x0, z0] = terrain.bounds;
+    const { cellSize, columns, rows } = terrain;
+    const [, , x1, z1] = terrain.bounds;
+    const quads = chunks.length + SKIRT_QUADS;
+    const positions = new Float32Array(quads * 12);
+    const normals = new Float32Array(quads * 12);
+    const bases = new Float32Array(quads * 12);
+    const shades = new Float32Array(quads * 8);
+    const patterns = new Float32Array(quads * 4);
+    const indices = new Uint32Array(quads * 6);
+    const base = [0, 0, 0];
+    const shade = [1, 0];
+    chunks.forEach((chunk, n) => {
+      const lastColumn = Math.min(columns, chunk.column + chunk.cells);
+      const lastRow = Math.min(rows, chunk.row + chunk.cells);
+      const corners = [[chunk.column, chunk.row], [lastColumn, chunk.row], [chunk.column, lastRow], [lastColumn, lastRow]];
+      const pattern = vertexLook(terrain, chunk.column, chunk.row, base, shade);
+      corners.forEach(([column, row], corner) => {
+        const at = n * 4 + corner;
+        positions[at * 3] = x0 + column * cellSize;
+        positions[at * 3 + 1] = terrain.vertexHeight(column, row);
+        positions[at * 3 + 2] = z0 + row * cellSize;
+        normals[at * 3 + 1] = 1;
+        bases.set(base, at * 3);
+        shades.set(shade, at * 2);
+        patterns[at] = pattern;
+      });
+      const first = n * 4;
+      indices.set([first, first + 2, first + 1, first + 2, first + 3, first + 1], n * 6);
+    });
+    const surface = terrain.material(terrain.profileList.find((profile) => profile.id === terrain.layout().surface)?.strata[0]?.material ?? terrain.profileList[terrain.profileIndex[0]].strata[0].material);
+    const rects = [
+      [x0 - skirt, z0 - skirt, x1 + skirt, z0],
+      [x0 - skirt, z1, x1 + skirt, z1 + skirt],
+      [x0 - skirt, z0, x0, z1],
+      [x1, z0, x1 + skirt, z1]
+    ];
+    rects.forEach(([ax, az, bx, bz], r) => {
+      const n = chunks.length + r;
+      const corners = [[ax, az], [bx, az], [ax, bz], [bx, bz]];
+      corners.forEach(([x, z], corner) => {
+        const at = n * 4 + corner;
+        positions[at * 3] = x;
+        positions[at * 3 + 2] = z;
+        normals[at * 3 + 1] = 1;
+        bases.set(surface.color, at * 3);
+        shades[at * 2] = 1;
+        patterns[at] = patternIndex(surface.pattern);
+      });
+      const first = n * 4;
+      indices.set([first, first + 2, first + 1, first + 2, first + 3, first + 1], n * 6);
+    });
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
+    geometry.setAttribute("normal", new THREE.BufferAttribute(normals, 3));
+    geometry.setAttribute("aBase", new THREE.BufferAttribute(bases, 3));
+    geometry.setAttribute("aShade", new THREE.BufferAttribute(shades, 2));
+    geometry.setAttribute("aPattern", new THREE.BufferAttribute(patterns, 1));
+    geometry.setIndex(new THREE.BufferAttribute(indices, 1));
+    return geometry;
+  }
+
+  // src/layers.ts
+  var MARK_LIFT = 6e-3;
+  var MARK_REACH = 1.5;
+  var MARK_TEXTURE_SIZE = 64;
+  var MARK_DARKEN = 0.85;
+  var PIECE_SHAPE = { clods: [1, 0.85, 1], chips: [1, 0.6, 0.8], shards: [1.3, 0.2, 1], splinters: [0.3, 0.25, 2.4], dust: [1, 0.8, 1] };
+  function createMarkTexture(THREE) {
+    const size = MARK_TEXTURE_SIZE;
+    const data = new Uint8Array(size * size * 4);
+    for (let y = 0; y < size; y++) {
+      for (let x = 0; x < size; x++) {
+        const u = (x + 0.5) / size - 0.5;
+        const v = (y + 0.5) / size - 0.5;
+        const angle = Math.atan2(v, u);
+        const lobes = 0.86 + 0.09 * Math.sin(angle * 5) + 0.05 * Math.sin(angle * 13 + 1);
+        const q = Math.hypot(u, v) / (0.5 * lobes);
+        const shade = q < 0.55 ? 0.42 + q * 0.5 : 0.7 + (q - 0.55) * 0.8;
+        const at = (y * size + x) * 4;
+        data[at] = data[at + 1] = data[at + 2] = Math.round(Math.min(1, shade) * 255);
+        data[at + 3] = q < 0.8 ? 255 : q < 1 ? Math.round((1 - (q - 0.8) / 0.2) * 255) : 0;
+      }
+    }
+    const texture = new THREE.DataTexture(data, size, size, THREE.RGBAFormat);
+    texture.magFilter = THREE.LinearFilter;
+    texture.minFilter = THREE.LinearFilter;
+    texture.needsUpdate = true;
+    return texture;
+  }
+  function createMarkLayer(THREE, terrain, drawDistance) {
+    const geometry = new THREE.PlaneGeometry(1, 1);
+    geometry.rotateX(-Math.PI / 2);
+    const texture = createMarkTexture(THREE);
+    const material = new THREE.MeshStandardMaterial({ map: texture, transparent: true, depthWrite: false, roughness: 1, polygonOffset: true, polygonOffsetFactor: -2, polygonOffsetUnits: -2 });
+    const mesh = new THREE.InstancedMesh(geometry, material, terrain.budget.maxMarks);
+    mesh.name = "terrain-marks";
+    mesh.count = 0;
+    mesh.frustumCulled = false;
+    mesh.receiveShadow = true;
+    mesh.renderOrder = 1;
+    const matrix = new THREE.Matrix4();
+    const rotation = new THREE.Matrix4();
+    const scale = new THREE.Matrix4();
+    const colour = new THREE.Color();
+    let seen = "";
+    let cameraX = Infinity;
+    let cameraZ = Infinity;
+    return {
+      mesh,
+      sync(camera) {
+        const marks = terrain.marks();
+        let blows = 0;
+        for (const mark of marks) blows += mark.count;
+        const stamp = `${terrain.marksVersion}:${blows}`;
+        if (stamp === seen && Math.hypot(camera.x - cameraX, camera.z - cameraZ) < 5) return;
+        seen = stamp;
+        cameraX = camera.x;
+        cameraZ = camera.z;
+        let count = 0;
+        for (const mark of marks) {
+          if (Math.hypot(mark.x - camera.x, mark.z - camera.z) > drawDistance) continue;
+          const size = mark.radius * 2 * MARK_REACH;
+          rotation.makeRotationY(mark.id * 2.399);
+          scale.makeScale(size, 1, size);
+          matrix.multiplyMatrices(rotation, scale);
+          matrix.setPosition(mark.x, terrain.heightAt(mark.x, mark.z) + MARK_LIFT, mark.z);
+          mesh.setMatrixAt(count, matrix);
+          const [r, g, b] = terrain.material(mark.material).color;
+          colour.setRGB(r * MARK_DARKEN + 0.04, g * MARK_DARKEN + 0.04, b * MARK_DARKEN + 0.04);
+          mesh.setColorAt(count, colour);
+          count++;
+        }
+        mesh.count = count;
+        mesh.instanceMatrix.needsUpdate = true;
+        if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+      },
+      dispose() {
+        geometry.dispose();
+        material.dispose();
+        texture.dispose();
+        mesh.removeFromParent();
+      }
+    };
+  }
+  function createDebrisLayer(THREE, terrain) {
+    const geometry = new THREE.IcosahedronGeometry(1, 0);
+    const material = new THREE.MeshStandardMaterial({ roughness: 0.95, flatShading: true });
+    const mesh = new THREE.InstancedMesh(geometry, material, terrain.budget.maxDebris);
+    mesh.name = "terrain-debris";
+    mesh.count = 0;
+    mesh.castShadow = true;
+    mesh.frustumCulled = false;
+    const matrix = new THREE.Matrix4();
+    const position = new THREE.Vector3();
+    const scale = new THREE.Vector3();
+    const quaternion = new THREE.Quaternion();
+    const euler = new THREE.Euler();
+    const colour = new THREE.Color();
+    return {
+      mesh,
+      sync() {
+        const pieces = terrain.debris();
+        let count = 0;
+        for (const piece of pieces) {
+          const [x, y, z] = piece.position;
+          const travelled = x * 1.7 + z * 1.3 + y;
+          euler.set(piece.spin[0] * travelled * 0.2 + piece.id, piece.spin[1] * travelled * 0.2, piece.spin[2] * travelled * 0.2);
+          const shape = PIECE_SHAPE[piece.kind];
+          scale.set(shape[0] * piece.radius, shape[1] * piece.radius, shape[2] * piece.radius);
+          matrix.compose(position.set(x, y, z), quaternion.setFromEuler(euler), scale);
+          mesh.setMatrixAt(count, matrix);
+          const [r, g, b] = terrain.material(piece.material).color;
+          const tone = 0.85 + piece.id * 37 % 30 / 100;
+          mesh.setColorAt(count, colour.setRGB(r * tone, g * tone, b * tone));
+          count++;
+        }
+        mesh.count = count;
+        mesh.instanceMatrix.needsUpdate = true;
+        if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+      },
+      dispose() {
+        geometry.dispose();
+        material.dispose();
+        mesh.removeFromParent();
+      }
+    };
+  }
+
+  // src/rebar.ts
+  var BAR_RADIUS = 6e-3;
+  var EXPOSED_MARGIN = 2e-3;
+  var MAX_SAG = 0.07;
+  function buildRebarGeometry(THREE, terrain, chunk) {
+    const [x0, z0] = terrain.bounds;
+    const { cellSize, columns, rows, stride } = terrain;
+    const lastColumn = Math.min(columns, chunk.column + chunk.cells);
+    const lastRow = Math.min(rows, chunk.row + chunk.cells);
+    const boxes = [];
+    const coverOf = (index) => {
+      let top = 0;
+      for (const stratum of terrain.profileList[terrain.profileIndex[index]].strata) {
+        if (stratum.reinforcement) return { depth: top + stratum.reinforcement.cover, spacing: stratum.reinforcement.spacing };
+        top += stratum.thickness;
+      }
+      return null;
+    };
+    const showing = (index, depth) => {
+      const profile = terrain.profileList[terrain.profileIndex[index]];
+      const limit = profile.strata.reduce((sum, stratum) => sum + stratum.thickness, 0);
+      return terrain.dug[index] > depth + EXPOSED_MARGIN && terrain.dug[index] <= limit + EXPOSED_MARGIN;
+    };
+    const onBar = (coordinate, spacing) => Math.floor(coordinate / spacing) !== Math.floor((coordinate + cellSize) / spacing);
+    const addBox = (ax, az, bx, bz, y) => {
+      boxes.push(Math.min(ax, bx) - BAR_RADIUS, y - BAR_RADIUS, Math.min(az, bz) - BAR_RADIUS, Math.max(ax, bx) + BAR_RADIUS, y + BAR_RADIUS, Math.max(az, bz) + BAR_RADIUS);
+    };
+    for (let row = chunk.row; row <= lastRow; row++) {
+      for (let column = chunk.column; column <= lastColumn; column++) {
+        const index = row * stride + column;
+        const cover = coverOf(index);
+        if (!cover || !showing(index, cover.depth)) continue;
+        const x = x0 + column * cellSize;
+        const z = z0 + row * cellSize;
+        const y = -cover.depth - BAR_RADIUS - Math.min(1, terrain.barBend[index]) * MAX_SAG;
+        if (onBar(z, cover.spacing) && column < lastColumn && showing(index + 1, cover.depth)) addBox(x, z, x + cellSize, z, y);
+        if (onBar(x, cover.spacing) && row < lastRow && showing(index + stride, cover.depth)) addBox(x, z, x, z + cellSize, y);
+      }
+    }
+    if (boxes.length === 0) return null;
+    const count = boxes.length / 6;
+    const positions = new Float32Array(count * 24 * 3);
+    const normals = new Float32Array(count * 24 * 3);
+    const indices = new Uint32Array(count * 36);
+    const FACES = [
+      [[0, 4, 2, 0, 4, 5, 3, 4, 5, 3, 4, 2], [0, 1, 0]],
+      [[0, 1, 5, 0, 1, 2, 3, 1, 2, 3, 1, 5], [0, -1, 0]],
+      [[0, 1, 5, 3, 1, 5, 3, 4, 5, 0, 4, 5], [0, 0, 1]],
+      [[3, 1, 2, 0, 1, 2, 0, 4, 2, 3, 4, 2], [0, 0, -1]],
+      [[3, 1, 5, 3, 1, 2, 3, 4, 2, 3, 4, 5], [1, 0, 0]],
+      [[0, 1, 2, 0, 1, 5, 0, 4, 5, 0, 4, 2], [-1, 0, 0]]
+    ];
+    let vertex = 0;
+    let cursor = 0;
+    for (let n = 0; n < count; n++) {
+      const box = boxes.slice(n * 6, n * 6 + 6);
+      for (const [corners, normal] of FACES) {
+        const first = vertex;
+        for (let c = 0; c < 4; c++) {
+          positions[vertex * 3] = box[corners[c * 3]];
+          positions[vertex * 3 + 1] = box[corners[c * 3 + 1]];
+          positions[vertex * 3 + 2] = box[corners[c * 3 + 2]];
+          normals.set(normal, vertex * 3);
+          vertex++;
+        }
+        indices.set([first, first + 1, first + 2, first, first + 2, first + 3], cursor);
+        cursor += 6;
+      }
+    }
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
+    geometry.setAttribute("normal", new THREE.BufferAttribute(normals, 3));
+    geometry.setIndex(new THREE.BufferAttribute(indices, 1));
+    return geometry;
+  }
+
+  // src/renderer.ts
+  var DEFAULT_LOD_DISTANCE = 30;
+  var DEFAULT_MARK_DISTANCE = 45;
+  var DEFAULT_SKIRT = 300;
+  var LOD_CHECK_METRES = 4;
+  var REBAR_COLOUR = 4863272;
+  function createTerrainRenderer(THREE, options) {
+    const { terrain } = options;
+    const lodDistance = options.lodDistance ?? DEFAULT_LOD_DISTANCE;
+    const skirt = options.skirt ?? DEFAULT_SKIRT;
+    const group = markKitOrigin(new THREE.Group(), { owner: "game-terrain-three", kind: "ground" });
+    group.name = "floor";
+    const surface = createSurfaceMaterial(THREE);
+    const rebarMaterial = new THREE.MeshStandardMaterial({ color: REBAR_COLOUR, roughness: 0.75, metalness: 0.35 });
+    const pristineMesh = new THREE.Mesh(new THREE.BufferGeometry(), surface);
+    pristineMesh.receiveShadow = true;
+    pristineMesh.name = "terrain-pristine";
+    pristineMesh.frustumCulled = false;
+    group.add(pristineMesh);
+    const drawn = /* @__PURE__ */ new Map();
+    const marks = createMarkLayer(THREE, terrain, options.markDistance ?? DEFAULT_MARK_DISTANCE);
+    const debris = createDebrisLayer(THREE, terrain);
+    group.add(marks.mesh, debris.mesh);
+    let pristineStale = true;
+    let pristineCount = 0;
+    let lodX = Infinity;
+    let lodZ = Infinity;
+    let firstSync = true;
+    const distanceTo = (chunk, camera) => {
+      const half = chunk.cells * terrain.cellSize / 2;
+      const centreX = terrain.bounds[0] + chunk.column * terrain.cellSize + half;
+      const centreZ = terrain.bounds[1] + chunk.row * terrain.cellSize + half;
+      return Math.hypot(centreX - camera.x, centreZ - camera.z);
+    };
+    const stepFor = (distance) => distance > lodDistance * 2 ? 4 : distance > lodDistance ? 2 : 1;
+    function drop(index) {
+      const entry = drawn.get(index);
+      if (!entry) return;
+      group.remove(entry.mesh);
+      entry.mesh.geometry.dispose();
+      if (entry.rebar) {
+        group.remove(entry.rebar);
+        entry.rebar.geometry.dispose();
+      }
+      drawn.delete(index);
+    }
+    function draw(chunk, camera) {
+      drop(chunk.index);
+      const step = stepFor(distanceTo(chunk, camera));
+      const mesh = new THREE.Mesh(buildChunkGeometry(THREE, terrain, chunk, step), surface);
+      mesh.receiveShadow = true;
+      group.add(mesh);
+      const bars = buildRebarGeometry(THREE, terrain, chunk);
+      let rebar = null;
+      if (bars) {
+        rebar = new THREE.Mesh(bars, rebarMaterial);
+        rebar.castShadow = true;
+        group.add(rebar);
+      }
+      drawn.set(chunk.index, { mesh, rebar, step });
+    }
+    function rebuildPristine() {
+      const chunks = [];
+      for (let index = 0; index < terrain.chunksX * terrain.chunksZ; index++) {
+        const chunk = terrain.chunk(index);
+        if (chunk.pristine) chunks.push(chunk);
+      }
+      pristineMesh.geometry.dispose();
+      pristineMesh.geometry = buildPristineGeometry(THREE, terrain, chunks, skirt);
+      pristineCount = chunks.length;
+      pristineStale = false;
+    }
+    return {
+      group,
+      sync(camera) {
+        const limit = firstSync ? Infinity : void 0;
+        firstSync = false;
+        for (const chunk of terrain.drainDirtyChunks(limit)) {
+          if (chunk.pristine) {
+            if (drawn.has(chunk.index)) drop(chunk.index);
+            pristineStale = true;
+          } else {
+            if (!drawn.has(chunk.index)) pristineStale = true;
+            draw(chunk, camera);
+          }
+        }
+        if (pristineStale) rebuildPristine();
+        if (Math.hypot(camera.x - lodX, camera.z - lodZ) > LOD_CHECK_METRES) {
+          lodX = camera.x;
+          lodZ = camera.z;
+          for (const [index, entry] of drawn) {
+            const chunk = terrain.chunk(index);
+            if (stepFor(distanceTo(chunk, camera)) !== entry.step) draw(chunk, camera);
+          }
+        }
+        marks.sync(camera);
+        debris.sync();
+      },
+      stats: () => ({ chunkMeshes: drawn.size, pristineChunks: pristineCount, marksDrawn: marks.mesh.count, debrisDrawn: debris.mesh.count }),
+      dispose() {
+        for (const index of [...drawn.keys()]) drop(index);
+        pristineMesh.geometry.dispose();
+        surface.dispose();
+        rebarMaterial.dispose();
+        marks.dispose();
+        debris.dispose();
+        group.removeFromParent();
+      }
+    };
+  }
+
+  // src/locale.ts
+  var LOCALES = {
+    en: {
+      name: "Terrain",
+      group: "Terrain",
+      weight: "Concrete block (60 kg)",
+      surfaces: { dirt: "Dirt", lawn: "Lawn", sand: "Sand", road: "Asphalt", concrete_slab: "Concrete slab", suspended_slab: "Slab over a void", wood_floor: "Wood floor", tile_floor: "Tile", stone_paving: "Stone paving" }
+    },
+    "pt-BR": {
+      name: "Terreno",
+      group: "Terreno",
+      weight: "Bloco de concreto (60 kg)",
+      surfaces: { dirt: "Terra", lawn: "Grama", sand: "Areia", road: "Asfalto", concrete_slab: "Laje de concreto", suspended_slab: "Laje sobre v\xE3o", wood_floor: "Assoalho", tile_floor: "Cer\xE2mica", stone_paving: "Pedra" }
+    }
+  };
+  var locale = (id) => LOCALES[id] ?? LOCALES.en;
+
+  // src/test-module.ts
+  var TERRAIN_STRIPS = ["dirt", "lawn", "sand", "road", "concrete_slab", "suspended_slab", "wood_floor", "tile_floor", "stone_paving"];
+  var STRIP_WIDTH = 3;
+  var STRIP_Z0 = 4;
+  var STRIP_Z1 = 13;
+  var stripRect = (index) => {
+    const x0 = (index - TERRAIN_STRIPS.length / 2) * STRIP_WIDTH;
+    return [x0, STRIP_Z0, x0 + STRIP_WIDTH, STRIP_Z1];
+  };
+  var TERRAIN_AREA_GROUND = {
+    surface: "concrete_slab",
+    zones: TERRAIN_STRIPS.map((surface, index) => ({ rect: stripRect(index), surface }))
+  };
+  var WEIGHT_SIDE = 0.32;
+  var WEIGHT_HEIGHT = 4;
+  var LABEL_Y = 0.02;
+  var LABEL_WIDTH = 2.6;
+  var LABEL_HEIGHT = 0.5;
+  function weightSpec() {
+    return { name: "Weight", parts: [{ id: "block", material: "concrete", shape: { kind: "box", size: [WEIGHT_SIDE, WEIGHT_SIDE, WEIGHT_SIDE] }, position: [0, WEIGHT_SIDE / 2, 0] }], joints: [] };
+  }
+  function buildWeight(THREE) {
+    const mesh = new THREE.Mesh(new THREE.BoxGeometry(WEIGHT_SIDE, WEIGHT_SIDE, WEIGHT_SIDE), new THREE.MeshStandardMaterial({ color: 11842734, roughness: 0.9 }));
+    mesh.name = "block";
+    mesh.position.y = WEIGHT_SIDE / 2;
+    mesh.castShadow = true;
+    const root = markKitOrigin(new THREE.Group(), { owner: "game-terrain-three", kind: "item" });
+    root.add(mesh);
+    return root;
+  }
+  function buildLabel(THREE, text, x) {
+    if (typeof document === "undefined") return null;
+    const canvas = document.createElement("canvas");
+    canvas.width = 512;
+    canvas.height = 96;
+    const context = canvas.getContext("2d");
+    if (!context) return null;
+    context.fillStyle = "rgba(0,0,0,0.55)";
+    context.fillRect(0, 0, 512, 96);
+    context.fillStyle = "#fff";
+    context.font = "bold 54px sans-serif";
+    context.textAlign = "center";
+    context.textBaseline = "middle";
+    context.fillText(text, 256, 50);
+    const mesh = new THREE.Mesh(new THREE.PlaneGeometry(LABEL_WIDTH, LABEL_HEIGHT), new THREE.MeshBasicMaterial({ map: new THREE.CanvasTexture(canvas), transparent: true }));
+    markKitOrigin(mesh, { owner: "game-terrain-three", kind: "room" });
+    mesh.rotation.set(-Math.PI / 2, 0, Math.PI);
+    mesh.position.set(x, LABEL_Y, STRIP_Z0 - LABEL_HEIGHT);
+    return mesh;
+  }
+  function createTerrainTestModule(options = {}) {
+    let labels = [];
+    const text = locale(options.locale ?? "en");
+    return {
+      id: "terrain",
+      name: text.name,
+      group: text.group,
+      ground: TERRAIN_AREA_GROUND,
+      items() {
+        return [{ id: "terrain_weight", name: text.weight, build: (THREE) => buildWeight(THREE), spec: weightSpec, movable: true }];
+      },
+      area() {
+        for (const label of labels) label.visible = true;
+        return {
+          placements: TERRAIN_STRIPS.map((_, index) => {
+            const [x0] = stripRect(index);
+            return { item: "terrain_weight", position: [x0 + STRIP_WIDTH / 2, WEIGHT_HEIGHT, STRIP_Z1 - 1.2] };
+          }),
+          view: { eye: [0, 1.7, 1.5], target: [0, 0, 8] }
+        };
+      },
+      attach(host) {
+        const THREE = host.THREE;
+        const scene = host.scene;
+        labels = TERRAIN_STRIPS.flatMap((surface, index) => {
+          const [x0] = stripRect(index);
+          const label = buildLabel(THREE, text.surfaces[surface], x0 + STRIP_WIDTH / 2);
+          if (!label) return [];
+          label.visible = false;
+          scene.add(label);
+          return [label];
+        });
+        const stop = host.onClear?.(() => {
+          for (const label of labels) label.visible = false;
+        });
+        return () => {
+          stop?.();
+          for (const label of labels) label.removeFromParent();
+          labels = [];
+        };
+      }
+    };
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map