@tileflow/dev 0.1.0-alpha.37 → 0.1.0-alpha.38

package/dist/{chunk-5RT4CHSK.js → chunk-54VM4SNV.js}

@@ -958,82 +958,38 @@ import {
 
 // src/building-model-mesh.ts
 import {
-  tileflowModelDefaultLightingRoles,
+  isTileflowModelPartName,
+  tileflowModelDefaultLightingRole,
   tileflowModelLightingRoles,
   tileflowModelLimits,
-  tileflowModelParts
+  tileflowModelSurfaceLimits as tileflowModelSurfaceLimits2,
+  tileflowModelTextureChannels as tileflowModelTextureChannels2
 } from "@tileflow/core";
 
-// src/building-model-materials.ts
-import {
-  checkTileflowModelSurface,
-  tileflowModelTextureChannels
-} from "@tileflow/core";
-function buildingModelSurface(primitives) {
-  if (!primitives.some((primitive) => primitive.surface)) return void 0;
-  const attributes = [];
-  const materials = [];
-  const materialIds = /* @__PURE__ */ new Map();
-  const textures = [];
-  const textureIds = /* @__PURE__ */ new Map();
-  const ranges = [];
-  const emitters = [];
-  let indexCount = 0;
-  for (const primitive of primitives) {
-    const count = primitive.positions.length / 3;
-    const surface = primitive.surface;
-    if (surface) {
-      checkTileflowModelSurface(surface, count, primitive.indices.length);
-      for (const value of surface.attributes) attributes.push(value);
-      emitters.push(...surface.emitters ?? []);
-    } else {
-      for (let vertex = 0; vertex < count; vertex++) attributes.push(0, 0, 0, 0, 1, 1, 1, 1);
-    }
-    const remap = (surface?.materials ?? [{}]).map((material) => {
-      const copy = { ...material };
-      for (const channel of tileflowModelTextureChannels) {
-        const ref = copy[channel];
-        if (!ref) continue;
-        const texture = surface.textures[ref.texture];
-        let id2 = textureIds.get(texture);
-        if (id2 === void 0) {
-          id2 = textures.length;
-          textures.push(texture);
-          textureIds.set(texture, id2);
-        }
-        copy[channel] = { ...ref, texture: id2 };
-      }
-      const key = JSON.stringify(copy);
-      let id = materialIds.get(key);
-      if (id === void 0) {
-        id = materials.length;
-        materials.push(copy);
-        materialIds.set(key, id);
-      }
-      return id;
-    });
-    const sourceRanges = surface?.ranges ?? [
-      { from: 0, count: primitive.indices.length, material: 0 }
-    ];
-    for (const range of sourceRanges) {
-      const material = remap[range.material];
-      const previous = ranges.at(-1);
-      if (previous?.material === material && JSON.stringify(previous.emissiveBounds) === JSON.stringify(range.emissiveBounds))
-        ranges[ranges.length - 1] = { ...previous, count: previous.count + range.count };
-      else ranges.push({ ...range, from: indexCount + range.from, material });
+// src/building-model-occlusion.ts
+function buildingModelAmbientVisibility(mesh, options = {}) {
+  const sampler = buildingModelAmbientSampler(mesh, options);
+  const { positions, normals } = mesh;
+  const values = new Array(positions.length / 3);
+  const cache = /* @__PURE__ */ new Map();
+  for (let vertex = 0; vertex < values.length; vertex += 1) {
+    const at = vertex * 3;
+    const point3 = [positions[at], positions[at + 1], positions[at + 2]];
+    const normal = [normals[at], normals[at + 1], normals[at + 2]];
+    const key = [...point3, ...normal].map((v) => Math.round(v * 1e5)).join(",");
+    let value = cache.get(key);
+    if (value === void 0) {
+      value = sampler.sky(point3, normal);
+      cache.set(key, value);
     }
-    indexCount += primitive.indices.length;
+    values[vertex] = value;
   }
-  const result = { attributes, materials, textures, ranges, ...emitters.length ? { emitters } : {} };
-  checkTileflowModelSurface(result, attributes.length / 8, indexCount);
-  return result;
+  return values;
 }
-
-// src/building-model-occlusion.ts
-function buildingModelAmbientVisibility(mesh, { radius = 2, samples = 48 } = {}) {
+function buildingModelAmbientSampler(mesh, { radius = 2, samples = 48 } = {}) {
   if (!(radius > 0 && Number.isFinite(radius)) || !Number.isInteger(samples) || samples < 1 || samples > 256)
     throw new RangeError("Model ambient visibility needs a positive radius and 1 to 256 samples.");
-  const { positions, normals, indices } = mesh;
+  const { positions, indices } = mesh;
   const count = indices.length / 3;
   const triangles2 = new Float64Array(count * 9);
   const bounds = new Float64Array(count * 6);
@@ -1077,17 +1033,26 @@ function buildingModelAmbientVisibility(mesh, { radius = 2, samples = 48 } = {})
     }
     return index;
   };
-  build(0, count);
-  const hemisphere = Array.from({ length: samples }, (_, i) => {
-    const r = Math.sqrt((i + 0.5) / samples), angle = i * Math.PI * (3 - Math.sqrt(5));
-    return [r * Math.cos(angle), r * Math.sin(angle), Math.sqrt(1 - r * r)];
-  });
+  if (count > 0) build(0, count);
+  const hemispheres = /* @__PURE__ */ new Map();
+  const hemisphere = (count2) => {
+    let pattern = hemispheres.get(count2);
+    if (!pattern) {
+      pattern = Array.from({ length: count2 }, (_, i) => {
+        const r = Math.sqrt((i + 0.5) / count2), angle = i * Math.PI * (3 - Math.sqrt(5));
+        return [r * Math.cos(angle), r * Math.sin(angle), Math.sqrt(1 - r * r)];
+      });
+      hemispheres.set(count2, pattern);
+    }
+    return pattern;
+  };
   const bias = Math.min(2e-3, radius * 1e-3);
   const stack = new Int32Array(64);
   const origin = [0, 0, 0];
   const direction = [0, 0, 0];
   const nearest = () => {
     let best = radius, pending = 1;
+    if (nodes.length === 0) return best;
     stack[0] = 0;
     while (pending > 0) {
       const node = nodes[stack[--pending]];
@@ -1120,43 +1085,40 @@ function buildingModelAmbientVisibility(mesh, { radius = 2, samples = 48 } = {})
     }
     return best;
   };
-  const values = new Array(positions.length / 3);
-  const cache = /* @__PURE__ */ new Map();
-  for (let vertex = 0; vertex < values.length; vertex += 1) {
-    const at = vertex * 3;
-    const nx = normals[at], ny = normals[at + 1], nz = normals[at + 2];
-    const point3 = [positions[at], positions[at + 1], positions[at + 2]];
-    const key = [...point3, nx, ny, nz].map((v) => Math.round(v * 1e5)).join(",");
-    const cached = cache.get(key);
-    if (cached !== void 0) {
-      values[vertex] = cached;
-      continue;
-    }
-    const tangent = Math.abs(nz) < 0.9 ? [-ny, nx, 0] : [nz, 0, -nx];
-    const length = Math.hypot(...tangent);
-    if (length === 0) {
-      values[vertex] = 1;
-      continue;
-    }
-    for (let axis = 0; axis < 3; axis += 1) {
-      tangent[axis] /= length;
-      origin[axis] = point3[axis] + normals[at + axis] * bias;
-    }
-    const bitangent = [
-      ny * tangent[2] - nz * tangent[1],
-      nz * tangent[0] - nx * tangent[2],
-      nx * tangent[1] - ny * tangent[0]
-    ];
-    let visibility = 0;
-    for (const sample of hemisphere) {
-      for (let axis = 0; axis < 3; axis += 1)
-        direction[axis] = sample[0] * tangent[axis] + sample[1] * bitangent[axis] + sample[2] * normals[at + axis];
-      visibility += nearest() / radius;
+  return {
+    radius,
+    sky(point3, normal, rays = samples, turn = 0) {
+      const [nx, ny, nz] = normal;
+      const flat = Math.abs(nz) < 0.9 ? [-ny, nx, 0] : [nz, 0, -nx];
+      const length = Math.hypot(...flat);
+      if (length === 0) return 1;
+      const [c, s] = [Math.cos(turn), Math.sin(turn)];
+      const base = flat.map((value) => value / length);
+      const cross4 = [
+        ny * base[2] - nz * base[1],
+        nz * base[0] - nx * base[2],
+        nx * base[1] - ny * base[0]
+      ];
+      const tangent = base.map((value, axis) => value * c + cross4[axis] * s);
+      const bitangent = cross4.map((value, axis) => value * c - base[axis] * s);
+      for (let axis = 0; axis < 3; axis += 1) origin[axis] = point3[axis] + normal[axis] * bias;
+      let visibility = 0;
+      const pattern = hemisphere(rays);
+      for (const sample of pattern) {
+        for (let axis = 0; axis < 3; axis += 1)
+          direction[axis] = sample[0] * tangent[axis] + sample[1] * bitangent[axis] + sample[2] * normal[axis];
+        visibility += nearest() / radius;
+      }
+      return visibility / pattern.length;
+    },
+    along(point3, towards) {
+      for (let axis = 0; axis < 3; axis += 1) {
+        origin[axis] = point3[axis] + towards[axis] * bias;
+        direction[axis] = towards[axis];
+      }
+      return nearest();
     }
-    values[vertex] = visibility / samples;
-    cache.set(key, values[vertex]);
-  }
-  return values;
+  };
 }
 function hitsBox(box, origin, direction, limit) {
   let low = 0, high = limit;
@@ -1174,6 +1136,460 @@ function hitsBox(box, origin, direction, limit) {
   return true;
 }
 
+// src/building-model-lightmap.ts
+var paletteSide = 16;
+var maximumSide = 4096;
+function bakeBuildingModelLightmap(mesh, { texels: budget, radius = 2, ...options }) {
+  if (options.points !== void 0 && !(options.points >= 1 && options.points <= 4 && Number.isInteger(options.points)))
+    throw new RangeError("A lightmap samples one to four points along each side of a texel.");
+  const { positions, indices } = mesh;
+  const point3 = (vertex) => [
+    positions[vertex * 3],
+    positions[vertex * 3 + 1],
+    positions[vertex * 3 + 2]
+  ];
+  const charts = chartsOf(indices, point3);
+  const palette = {
+    triangles: [],
+    normal: [0, 0, 1],
+    u: [1, 0, 0],
+    v: [0, 1, 0],
+    min: [0, 0],
+    extent: [0, 0],
+    scale: [0, 0],
+    w: 0,
+    h: 0,
+    x: 0,
+    y: 0,
+    palette: true
+  };
+  charts.push(palette);
+  let density = densityFor(charts, budget);
+  if (density === void 0) return void 0;
+  let layout = pack(charts, density);
+  for (let attempt = 0; attempt < 12 && !(layout && layout.width * layout.height <= budget); attempt++) {
+    density *= 0.9;
+    layout = pack(charts, density);
+  }
+  if (!layout || layout.width * layout.height > budget) return void 0;
+  const { width, height } = layout;
+  const points = options.points ?? Math.min(4, Math.max(2, Math.ceil(1 / (density * 0.35))));
+  const rays = options.rays ?? Math.max(4, Math.round(48 / (points * points)));
+  const sampler = buildingModelAmbientSampler(mesh, { radius });
+  const sums = new Float64Array(width * height);
+  const counts = new Uint16Array(width * height);
+  const taken = new Uint16Array(width * height);
+  const hidden = Math.min(0.05, radius * 0.025);
+  for (const chart of charts) {
+    const local2 = (vertex) => {
+      const p = point3(vertex);
+      return [
+        (dot(chart.u, p) - chart.min[0]) * chart.scale[0] + 0.5,
+        (dot(chart.v, p) - chart.min[1]) * chart.scale[1] + 0.5
+      ];
+    };
+    if (chart.tiny || chart.palette) continue;
+    for (const triangle of chart.triangles) {
+      const corners = [0, 1, 2].map((k) => local2(indices[triangle * 3 + k]));
+      const [a, b, c] = corners;
+      const area = cross2(a, b, c);
+      if (Math.abs(area) < 1e-12) continue;
+      const [A, B, C] = [0, 1, 2].map((k) => point3(indices[triangle * 3 + k]));
+      const rawNormal = crossOf(sub(B, A), sub(C, A));
+      const facing = rawNormal.map((value) => value / (Math.hypot(...rawNormal) || 1));
+      const x0 = Math.max(0, Math.floor(Math.min(a[0], b[0], c[0])));
+      const x1 = Math.min(chart.w - 1, Math.floor(Math.max(a[0], b[0], c[0])));
+      const y0 = Math.max(0, Math.floor(Math.min(a[1], b[1], c[1])));
+      const y1 = Math.min(chart.h - 1, Math.floor(Math.max(a[1], b[1], c[1])));
+      for (let y = y0; y <= y1; y++)
+        for (let x = x0; x <= x1; x++) {
+          const texel = (chart.y + y) * width + chart.x + x;
+          for (let j = 0; j < points; j++)
+            for (let i = 0; i < points; i++) {
+              const bit = 1 << j * points + i;
+              if (taken[texel] & bit) continue;
+              const p = [x + (i + 0.5) / points, y + (j + 0.5) / points];
+              const w0 = cross2(b, c, p) / area, w1 = cross2(c, a, p) / area, w2 = 1 - w0 - w1;
+              if (w0 < -1e-9 || w1 < -1e-9 || w2 < -1e-9) continue;
+              taken[texel] |= bit;
+              const world = [0, 1, 2].map((axis) => w0 * A[axis] + w1 * B[axis] + w2 * C[axis]);
+              if (sampler.along(world, facing) < hidden) continue;
+              const turn = ((j * points + i) * 2.399963 + (x * 0.618034 + y * 0.381966) * 6.283185) % 6.283185;
+              sums[texel] += sampler.sky(world, facing, rays, turn);
+              counts[texel] += 1;
+            }
+        }
+    }
+  }
+  const values = new Float32Array(width * height).fill(-1);
+  for (let texel = 0; texel < values.length; texel++)
+    if (counts[texel]) values[texel] = sums[texel] / counts[texel];
+  for (let level = 0; level < paletteSide * paletteSide; level++) {
+    const x = palette.x + level % paletteSide, y = palette.y + Math.floor(level / paletteSide);
+    values[y * width + x] = level / 255;
+  }
+  const levels = /* @__PURE__ */ new Map();
+  for (const chart of charts) {
+    if (!chart.tiny) continue;
+    let sum = 0, weight = 0;
+    for (const triangle of chart.triangles) {
+      const [a, b, c] = [0, 1, 2].map((k) => point3(indices[triangle * 3 + k]));
+      const raw = crossOf(sub(b, a), sub(c, a));
+      const area = Math.hypot(...raw) / 2;
+      if (!(area > 0)) continue;
+      const facing = raw.map((value) => value / (2 * area));
+      const centre = [0, 1, 2].map((axis) => (a[axis] + b[axis] + c[axis]) / 3);
+      if (sampler.along(centre, facing) < hidden) continue;
+      sum += area * sampler.sky(centre, facing, rays * points * points);
+      weight += area;
+    }
+    levels.set(chart, Math.round((weight > 0 ? sum / weight : 1) * 255));
+  }
+  for (let pass = 0; pass < 3; pass++) {
+    const previous = values.slice();
+    for (let y = 0; y < height; y++)
+      for (let x = 0; x < width; x++) {
+        if (previous[y * width + x] >= 0) continue;
+        let sum = 0, count = 0;
+        for (const [dx, dy] of [
+          [1, 0],
+          [-1, 0],
+          [0, 1],
+          [0, -1]
+        ]) {
+          const xx = x + dx, yy = y + dy;
+          if (xx < 0 || yy < 0 || xx >= width || yy >= height) continue;
+          const value = previous[yy * width + xx];
+          if (value >= 0) {
+            sum += value;
+            count++;
+          }
+        }
+        if (count) values[y * width + x] = sum / count;
+      }
+  }
+  const bytes = new Uint8Array(width * height);
+  for (let texel = 0; texel < bytes.length; texel++)
+    bytes[texel] = Math.round(
+      Math.min(1, Math.max(0, values[texel] < 0 ? 1 : values[texel])) * 255
+    );
+  const sources = [];
+  const uvs = [];
+  const out = new Array(indices.length);
+  for (const chart of charts) {
+    const own = /* @__PURE__ */ new Map();
+    for (const triangle of chart.triangles)
+      for (let k = 0; k < 3; k++) {
+        const vertex = indices[triangle * 3 + k];
+        let index = own.get(vertex);
+        if (index === void 0) {
+          index = sources.length;
+          own.set(vertex, index);
+          sources.push(vertex);
+          const level = levels.get(chart);
+          if (level !== void 0)
+            uvs.push(
+              (palette.x + level % paletteSide + 0.5) / width,
+              (palette.y + Math.floor(level / paletteSide) + 0.5) / height
+            );
+          else {
+            const p = point3(vertex);
+            uvs.push(
+              (chart.x + 0.5 + (dot(chart.u, p) - chart.min[0]) * chart.scale[0]) / width,
+              (chart.y + 0.5 + (dot(chart.v, p) - chart.min[1]) * chart.scale[1]) / height
+            );
+          }
+        }
+        out[triangle * 3 + k] = index;
+      }
+  }
+  for (let at = 0; at < uvs.length; at++) uvs[at] = Math.round(uvs[at] * 65536) / 65536;
+  return {
+    sources,
+    indices: out,
+    uvs,
+    width,
+    height,
+    density,
+    texels: bytes
+  };
+}
+var chartCone = Math.cos(20 * Math.PI / 180);
+function chartsOf(indices, point3) {
+  const key = (p) => p.map((value) => Math.round(value * 1e4)).join(",");
+  const count = indices.length / 3;
+  const normals = [];
+  const areas = [];
+  const edges = /* @__PURE__ */ new Map();
+  const edgeKeys = [];
+  for (let triangle = 0; triangle < count; triangle++) {
+    const [a, b, c] = [0, 1, 2].map((k) => point3(indices[triangle * 3 + k]));
+    const normal = crossOf(sub(b, a), sub(c, a));
+    const length = Math.hypot(...normal);
+    areas.push(length / 2);
+    normals.push(length > 1e-12 ? normal.map((value) => value / length) : [0, 0, 1]);
+    for (const [from, to] of [
+      [a, b],
+      [b, c],
+      [c, a]
+    ]) {
+      const [u, v] = [key(from), key(to)];
+      const edge2 = u < v ? `${u}|${v}` : `${v}|${u}`;
+      edgeKeys.push(edge2);
+      const users = edges.get(edge2);
+      if (users) users.push(triangle);
+      else edges.set(edge2, [triangle]);
+    }
+  }
+  const owner = new Int32Array(count).fill(-1);
+  const order = Array.from({ length: count }, (_, i) => i).sort(
+    (a, b) => areas[b] - areas[a] || a - b
+  );
+  const charts = [];
+  for (const seed of order) {
+    if (owner[seed] !== -1) continue;
+    const normal = normals[seed];
+    const group = [seed];
+    owner[seed] = seed;
+    for (let at = 0; at < group.length; at++)
+      for (let e = 0; e < 3; e++)
+        for (const next of edges.get(edgeKeys[group[at] * 3 + e]))
+          if (owner[next] === -1 && dot(normals[next], normal) >= chartCone) {
+            owner[next] = seed;
+            group.push(next);
+          }
+    charts.push(...flatCharts(group, normal, indices, point3));
+  }
+  return charts;
+}
+function flatCharts(group, normal, indices, point3, depth = 0) {
+  let longest = 0;
+  let u = Math.abs(normal[2]) < 0.9 ? [-normal[1], normal[0], 0] : [normal[2], 0, -normal[0]];
+  let area = 0;
+  for (const triangle of group) {
+    const [a, b, c] = [0, 1, 2].map((k) => point3(indices[triangle * 3 + k]));
+    area += Math.hypot(...crossOf(sub(b, a), sub(c, a))) / 2;
+    for (const [from, to] of [
+      [a, b],
+      [b, c],
+      [c, a]
+    ]) {
+      const d = sub(to, from);
+      const along = d.map((value, axis) => value - normal[axis] * dot(d, normal));
+      const length = Math.hypot(...along);
+      if (length > longest) {
+        longest = length;
+        u = along;
+      }
+    }
+  }
+  const size = Math.hypot(...u) || 1;
+  u = u.map((value) => value / size);
+  const v = crossOf(normal, u);
+  let [minU, minV, maxU, maxV] = [Infinity, Infinity, -Infinity, -Infinity];
+  for (const triangle of group)
+    for (let k = 0; k < 3; k++) {
+      const p = point3(indices[triangle * 3 + k]);
+      minU = Math.min(minU, dot(u, p));
+      maxU = Math.max(maxU, dot(u, p));
+      minV = Math.min(minV, dot(v, p));
+      maxV = Math.max(maxV, dot(v, p));
+    }
+  const flip = maxV - minV > maxU - minU;
+  if (group.length > 1 && depth < 16 && area < 0.5 * (maxU - minU) * (maxV - minV)) {
+    const axis = flip ? v : u;
+    const centre = (triangle) => [0, 1, 2].reduce((sum, k) => sum + dot(axis, point3(indices[triangle * 3 + k])), 0) / 3;
+    const sorted = [...group].sort((a, b) => centre(a) - centre(b) || a - b);
+    const half = sorted.length >> 1;
+    return [
+      ...flatCharts(sorted.slice(0, half), normal, indices, point3, depth + 1),
+      ...flatCharts(sorted.slice(half), normal, indices, point3, depth + 1)
+    ];
+  }
+  return [
+    {
+      triangles: group,
+      normal,
+      u: flip ? v : u,
+      v: flip ? u : v,
+      min: flip ? [minV, minU] : [minU, minV],
+      extent: flip ? [maxV - minV, maxU - minU] : [maxU - minU, maxV - minV],
+      scale: [0, 0],
+      w: 0,
+      h: 0,
+      x: 0,
+      y: 0
+    }
+  ];
+}
+function sizeAt(chart, density) {
+  if (chart.palette) return [paletteSide, paletteSide];
+  chart.tiny = chart.extent[0] * density < 2 && chart.extent[1] * density < 2;
+  if (chart.tiny) return [0, 0];
+  const size = chart.extent.map((extent) => Math.max(2, Math.round(extent * density) + 1));
+  chart.scale = [0, 1].map(
+    (axis) => chart.extent[axis] > 0 ? (size[axis] - 1) / chart.extent[axis] : 0
+  );
+  return size;
+}
+function densityFor(charts, budget) {
+  const area = (density) => charts.reduce((sum, chart) => {
+    const [w, h] = sizeAt(chart, density);
+    return sum + w * h;
+  }, 0);
+  let low = 1 / 16, high = 64;
+  if (area(low) / 0.8 > budget) return void 0;
+  for (let step = 0; step < 24; step++) {
+    const middle = Math.sqrt(low * high);
+    if (area(middle) / 0.8 <= budget) low = middle;
+    else high = middle;
+  }
+  return low;
+}
+function pack(charts, density) {
+  for (const chart of charts) [chart.w, chart.h] = sizeAt(chart, density);
+  const order = charts.map((_, i) => i).sort((a, b) => charts[b].h - charts[a].h || charts[b].w - charts[a].w || a - b);
+  let best;
+  for (let width = 64; width <= maximumSide; width *= 2) {
+    let line = [{ x: 0, y: 0, w: width }];
+    const places = new Array(charts.length);
+    let fits = true;
+    for (const index of order) {
+      const chart = charts[index];
+      if (chart.w === 0) {
+        places[index] = [0, 0];
+        continue;
+      }
+      if (chart.w > width) {
+        fits = false;
+        break;
+      }
+      let place;
+      for (let i = 0; i < line.length; i++) {
+        const x = line[i].x;
+        if (x + chart.w > width) break;
+        let y = 0, covered = 0;
+        for (let j = i; j < line.length && covered < chart.w; j++) {
+          y = Math.max(y, line[j].y);
+          covered += line[j].w;
+        }
+        if (covered < chart.w) continue;
+        if (!place || y < place.y) place = { x, y };
+      }
+      if (!place || place.y + chart.h > maximumSide) {
+        fits = false;
+        break;
+      }
+      places[index] = [place.x, place.y];
+      const next = [];
+      for (const segment of line) {
+        const end = segment.x + segment.w;
+        if (end <= place.x || segment.x >= place.x + chart.w) next.push(segment);
+        else {
+          if (segment.x < place.x) next.push({ x: segment.x, y: segment.y, w: place.x - segment.x });
+          if (end > place.x + chart.w)
+            next.push({ x: place.x + chart.w, y: segment.y, w: end - place.x - chart.w });
+        }
+      }
+      next.push({ x: place.x, y: place.y + chart.h, w: chart.w });
+      next.sort((a, b) => a.x - b.x);
+      line = [];
+      for (const segment of next) {
+        const last = line.at(-1);
+        if (last && last.y === segment.y && last.x + last.w === segment.x) last.w += segment.w;
+        else line.push({ ...segment });
+      }
+    }
+    if (!fits) continue;
+    const height = Math.max(...line.map((segment) => segment.y));
+    if (!best || width * height < best.width * best.height) best = { width, height, places };
+  }
+  if (!best) return void 0;
+  charts.forEach((chart, i) => [chart.x, chart.y] = best.places[i]);
+  return { width: best.width, height: best.height };
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function sub(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function crossOf(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+function cross2(a, b, p) {
+  return (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]);
+}
+
+// src/building-model-materials.ts
+import {
+  checkTileflowModelSurface,
+  tileflowModelTextureChannels
+} from "@tileflow/core";
+function buildingModelSurface(primitives) {
+  if (!primitives.some((primitive) => primitive.surface)) return void 0;
+  const attributes = [];
+  const materials = [];
+  const materialIds = /* @__PURE__ */ new Map();
+  const textures = [];
+  const textureIds = /* @__PURE__ */ new Map();
+  const ranges = [];
+  const emitters = [];
+  let indexCount = 0;
+  for (const primitive of primitives) {
+    const count = primitive.positions.length / 3;
+    const surface = primitive.surface;
+    if (surface) {
+      checkTileflowModelSurface(surface, count, primitive.indices.length);
+      for (const value of surface.attributes) attributes.push(value);
+      emitters.push(...surface.emitters ?? []);
+    } else {
+      for (let vertex = 0; vertex < count; vertex++) attributes.push(0, 0, 0, 0, 1, 1, 1, 1);
+    }
+    const remap = (surface?.materials ?? [{}]).map((material) => {
+      const copy = { ...material };
+      for (const channel of tileflowModelTextureChannels) {
+        const ref = copy[channel];
+        if (!ref) continue;
+        const texture = surface.textures[ref.texture];
+        let id2 = textureIds.get(texture);
+        if (id2 === void 0) {
+          id2 = textures.length;
+          textures.push(texture);
+          textureIds.set(texture, id2);
+        }
+        copy[channel] = { ...ref, texture: id2 };
+      }
+      const key = JSON.stringify(copy);
+      let id = materialIds.get(key);
+      if (id === void 0) {
+        id = materials.length;
+        materials.push(copy);
+        materialIds.set(key, id);
+      }
+      return id;
+    });
+    const sourceRanges = surface?.ranges ?? [
+      { from: 0, count: primitive.indices.length, material: 0 }
+    ];
+    for (const range of sourceRanges) {
+      const material = remap[range.material];
+      const previous = ranges.at(-1);
+      if (previous?.material === material && JSON.stringify(previous.emissiveBounds) === JSON.stringify(range.emissiveBounds))
+        ranges[ranges.length - 1] = { ...previous, count: previous.count + range.count };
+      else ranges.push({ ...range, from: indexCount + range.from, material });
+    }
+    indexCount += primitive.indices.length;
+  }
+  const result = { attributes, materials, textures, ranges, ...emitters.length ? { emitters } : {} };
+  checkTileflowModelSurface(result, attributes.length / 8, indexCount);
+  return result;
+}
+
 // src/gltf-materials.ts
 import {
   checkTileflowModelSurface as checkTileflowModelSurface2,
@@ -1282,6 +1698,8 @@ function createGltfMaterialReader(json, bin, accessor2) {
       return value;
     };
     const uv0 = read("TEXCOORD_0", [2]), uv1 = read("TEXCOORD_1", [2]);
+    if (uv1?.values.some((value) => !(value >= 0 && value <= 1)))
+      throw new RangeError("TEXCOORD_1 must lie between zero and one.");
     const colour = read("COLOR_0", [3, 4]);
     for (const key of [
       "baseColorTexture",
@@ -1681,41 +2099,486 @@ function vector(value, fallback) {
   return list2.length === fallback.length && list2.every(Number.isFinite) ? list2 : fallback;
 }
 
-// src/building-model-mesh.ts
-var tileflowBuildingModelPartNames = Object.keys(tileflowModelParts);
-function isTileflowBuildingModel(primitives) {
-  const drawn = primitives.filter((primitive) => !isFootprint(primitive));
-  return drawn.length > 0 && drawn.every((primitive) => partOf(primitive.material) !== void 0);
-}
-function tileflowBuildingModelDeclaredFootprint(primitives) {
-  const positions = [];
-  const indices = [];
-  for (const primitive of primitives) {
-    if (!isFootprint(primitive)) continue;
-    const offset = positions.length / 3;
-    positions.push(...primitive.positions);
-    for (const index of primitive.indices) indices.push(offset + index);
+// src/grey-jpeg.ts
+var zigzag = [
+  0,
+  1,
+  8,
+  16,
+  9,
+  2,
+  3,
+  10,
+  17,
+  24,
+  32,
+  25,
+  18,
+  11,
+  4,
+  5,
+  12,
+  19,
+  26,
+  33,
+  40,
+  48,
+  41,
+  34,
+  27,
+  20,
+  13,
+  6,
+  7,
+  14,
+  21,
+  28,
+  35,
+  42,
+  49,
+  56,
+  57,
+  50,
+  43,
+  36,
+  29,
+  22,
+  15,
+  23,
+  30,
+  37,
+  44,
+  51,
+  58,
+  59,
+  52,
+  45,
+  38,
+  31,
+  39,
+  46,
+  53,
+  60,
+  61,
+  54,
+  47,
+  55,
+  62,
+  63
+];
+var luminance = [
+  16,
+  11,
+  10,
+  16,
+  24,
+  40,
+  51,
+  61,
+  12,
+  12,
+  14,
+  19,
+  26,
+  58,
+  60,
+  55,
+  14,
+  13,
+  16,
+  24,
+  40,
+  57,
+  69,
+  56,
+  14,
+  17,
+  22,
+  29,
+  51,
+  87,
+  80,
+  62,
+  18,
+  22,
+  37,
+  56,
+  68,
+  109,
+  103,
+  77,
+  24,
+  35,
+  55,
+  64,
+  81,
+  104,
+  113,
+  92,
+  49,
+  64,
+  78,
+  87,
+  103,
+  121,
+  120,
+  101,
+  72,
+  92,
+  95,
+  98,
+  112,
+  100,
+  103,
+  99
+];
+function huffman(counts, symbols) {
+  const out = { code: [], size: [] };
+  let code = 0, k = 0;
+  for (let length = 1; length <= 16; length++) {
+    for (let i = 0; i < counts[length - 1]; i++) {
+      out.code[symbols[k]] = code;
+      out.size[symbols[k]] = length;
+      code++;
+      k++;
+    }
+    code <<= 1;
   }
-  return indices.length > 0 ? { positions, indices } : void 0;
+  return out;
 }
-function prepareTileflowBuildingModelMesh(bytes, { ambientOcclusion = true } = {}) {
-  const primitives = bytes instanceof Uint8Array ? readTileflowGltfTriangles(bytes, { materials: true }) : bytes;
-  const drawn = primitives.filter((primitive) => !isFootprint(primitive));
-  const surface = buildingModelSurface(drawn);
-  const positions = [];
-  const normals = [];
-  const parts = [];
-  const lightingRoles = [];
-  const luminance = [];
-  const indices = [];
-  for (const primitive of drawn) {
-    const part = partOf(primitive.material);
-    if (part === void 0)
-      throw new TileflowGltfError(
-        primitive.material === void 0 ? "has a mesh without a material; name each material surface, secondary, glass, accent or roof" : `has a material "${primitive.material}" that names no part of a building; name each material surface, secondary, glass, accent or roof`
-      );
-    const offset = positions.length / 3;
-    const role = primitive.lightingRole === void 0 ? tileflowModelDefaultLightingRoles[part] : typeof primitive.lightingRole === "string" && Object.hasOwn(tileflowModelLightingRoles, primitive.lightingRole) ? tileflowModelLightingRoles[primitive.lightingRole] : void 0;
+var basis = Array.from({ length: 64 }, (_, i) => {
+  const u = i >> 3, x = i & 7;
+  return (u === 0 ? Math.SQRT1_2 : 1) * 0.5 * Math.cos((2 * x + 1) * u * Math.PI / 16);
+});
+function encodeGreyJpeg(pixels, width, height, quality) {
+  if (!(width > 0 && height > 0 && width <= 65535 && height <= 65535))
+    throw new RangeError("A JPEG is 1 to 65,535 pixels on each side.");
+  if (pixels.length !== width * height) throw new RangeError("One byte a pixel is required.");
+  const q = Math.min(100, Math.max(1, Math.round(quality)));
+  const scale = q < 50 ? 5e3 / q : 200 - 2 * q;
+  const table = luminance.map(
+    (value) => Math.min(255, Math.max(1, Math.floor((value * scale + 50) / 100)))
+  );
+  const symbols = [];
+  const extra = [];
+  const frequencies = [new Array(257).fill(0), new Array(257).fill(0)];
+  const emit = (table2, symbol, value = 0, size = 0) => {
+    symbols.push(table2 << 8 | symbol);
+    extra.push(size ? (value < 0 ? value + (1 << size) - 1 : value) << 5 | size : 0);
+    frequencies[table2][symbol] += 1;
+  };
+  const magnitude = (value) => {
+    let size = 0;
+    for (let v = Math.abs(value); v > 0; v >>= 1) size++;
+    return size;
+  };
+  const block = new Float64Array(64);
+  const row = new Float64Array(64);
+  const coefficients = new Int32Array(64);
+  let previous = 0;
+  for (let by = 0; by < height; by += 8)
+    for (let bx = 0; bx < width; bx += 8) {
+      for (let y = 0; y < 8; y++)
+        for (let x = 0; x < 8; x++)
+          block[y * 8 + x] = pixels[Math.min(height - 1, by + y) * width + Math.min(width - 1, bx + x)] - 128;
+      for (let y = 0; y < 8; y++)
+        for (let u = 0; u < 8; u++) {
+          let sum = 0;
+          for (let x = 0; x < 8; x++) sum += block[y * 8 + x] * basis[u * 8 + x];
+          row[y * 8 + u] = sum;
+        }
+      for (let v = 0; v < 8; v++)
+        for (let u = 0; u < 8; u++) {
+          let sum = 0;
+          for (let y = 0; y < 8; y++) sum += row[y * 8 + u] * basis[v * 8 + y];
+          coefficients[v * 8 + u] = Math.round(sum / table[v * 8 + u]);
+        }
+      const dc = coefficients[0] - previous;
+      previous = coefficients[0];
+      const dcSize = magnitude(dc);
+      emit(0, dcSize, dc, dcSize);
+      let zeros = 0;
+      for (let k = 1; k < 64; k++) {
+        const value = coefficients[zigzag[k]];
+        if (value === 0) {
+          zeros++;
+          continue;
+        }
+        for (; zeros > 15; zeros -= 16) emit(1, 240);
+        const size = magnitude(value);
+        emit(1, zeros << 4 | size, value, size);
+        zeros = 0;
+      }
+      if (zeros > 0) emit(1, 0);
+    }
+  const tables = frequencies.map(optimalTable);
+  const codes = tables.map(({ counts, values }) => huffman(counts, values));
+  const out = [];
+  const word = (value) => out.push(value >> 8 & 255, value & 255);
+  word(65496);
+  word(65499);
+  word(67);
+  out.push(0, ...zigzag.map((at) => table[at]));
+  word(65472);
+  word(11);
+  out.push(8);
+  word(height);
+  word(width);
+  out.push(1, 1, 17, 0);
+  for (const [index, { counts, values }] of tables.entries()) {
+    word(65476);
+    word(3 + 16 + values.length);
+    out.push(index << 4, ...counts, ...values);
+  }
+  word(65498);
+  word(8);
+  out.push(1, 1, 0, 0, 63, 0);
+  let bits = 0, count = 0;
+  const put = (code, size) => {
+    bits = bits << size | code & (1 << size) - 1;
+    count += size;
+    while (count >= 8) {
+      const byte = bits >> count - 8 & 255;
+      out.push(byte);
+      if (byte === 255) out.push(0);
+      count -= 8;
+    }
+    bits &= (1 << count) - 1;
+  };
+  for (let i = 0; i < symbols.length; i++) {
+    const own = codes[symbols[i] >> 8];
+    const symbol = symbols[i] & 255;
+    put(own.code[symbol], own.size[symbol]);
+    const size = extra[i] & 31;
+    if (size) put(extra[i] >> 5, size);
+  }
+  if (count > 0) put(127, 8 - count);
+  word(65497);
+  return Uint8Array.from(out);
+}
+function optimalTable(frequencies) {
+  const freq = [...frequencies];
+  freq[256] = 1;
+  const codesize = new Array(257).fill(0);
+  const others = new Array(257).fill(-1);
+  for (; ; ) {
+    let v1 = -1, v2 = -1;
+    for (let i = 0; i <= 256; i++) if (freq[i] > 0 && (v1 < 0 || freq[i] <= freq[v1])) v1 = i;
+    for (let i = 0; i <= 256; i++)
+      if (freq[i] > 0 && i !== v1 && (v2 < 0 || freq[i] <= freq[v2])) v2 = i;
+    if (v2 < 0) break;
+    freq[v1] += freq[v2];
+    freq[v2] = 0;
+    for (codesize[v1]++; others[v1] >= 0; codesize[v1]++) v1 = others[v1];
+    others[v1] = v2;
+    for (codesize[v2]++; others[v2] >= 0; codesize[v2]++) v2 = others[v2];
+  }
+  const bits = new Array(33).fill(0);
+  for (let i = 0; i <= 256; i++) if (codesize[i]) bits[codesize[i]]++;
+  for (let i = 32; i > 16; i--)
+    while (bits[i] > 0) {
+      let j = i - 2;
+      while (bits[j] === 0) j--;
+      bits[i] -= 2;
+      bits[i - 1]++;
+      bits[j + 1] += 2;
+      bits[j]--;
+    }
+  let last = 16;
+  while (bits[last] === 0) last--;
+  bits[last]--;
+  const values = [];
+  for (let length = 1; length <= 32; length++)
+    for (let symbol = 0; symbol < 256; symbol++)
+      if (codesize[symbol] === length) values.push(symbol);
+  return { counts: bits.slice(1, 17), values };
+}
+
+// src/tree-model-mesh.ts
+import {
+  tileflowTreeModelLimits,
+  tileflowTreeParts
+} from "@tileflow/core";
+var tileflowTreeModelPartNames = ["bark", "leaves", "fronds", "stem"];
+function prepareTileflowTreeModelMesh(bytes, level) {
+  const primitives = readTileflowGltfTriangles(bytes);
+  const positions = [];
+  const normals = [];
+  const parts = [];
+  const luminance2 = [];
+  const indices = [];
+  for (const primitive of primitives) {
+    const part = partOf(primitive.material);
+    const offset = positions.length / 3;
+    const count2 = primitive.positions.length / 3;
+    positions.push(...primitive.positions);
+    for (let vertex = 0; vertex < count2; vertex += 1) {
+      parts.push(part);
+      normals.push(primitive.normals?.slice(vertex * 3, vertex * 3 + 3));
+      const [r, g, b] = primitive.colours.slice(vertex * 3, vertex * 3 + 3);
+      luminance2.push(0.2126 * r + 0.7152 * g + 0.0722 * b);
+    }
+    for (const index of primitive.indices) indices.push(offset + index);
+  }
+  const count = positions.length / 3;
+  const triangleCount = indices.length / 3;
+  const limit = level === "near" ? tileflowTreeModelLimits.nearTriangles : tileflowTreeModelLimits.farTriangles;
+  if (triangleCount > limit)
+    throw new TileflowGltfError(
+      `has ${triangleCount.toLocaleString("en")} triangles; a ${level} tree model takes at most ${limit.toLocaleString("en")}. Simplify it (for example with Blender's Decimate modifier) and export it again`
+    );
+  if (count > tileflowTreeModelLimits.vertices)
+    throw new TileflowGltfError(
+      `has ${count.toLocaleString("en")} vertices; a tree model takes at most ${tileflowTreeModelLimits.vertices.toLocaleString("en")}. Merge vertices by distance and export it again`
+    );
+  let height = 0;
+  let reach = 0;
+  const crowned = parts.some((part) => isCrown(part));
+  for (let vertex = 0; vertex < count; vertex += 1) {
+    height = Math.max(height, positions[vertex * 3 + 2]);
+    if (!crowned || isCrown(parts[vertex]))
+      reach = Math.max(reach, Math.hypot(positions[vertex * 3], positions[vertex * 3 + 1]));
+  }
+  if (!(height > 0))
+    throw new TileflowGltfError(
+      "stands below its origin; put the origin where the trunk meets the ground, with the tree above it"
+    );
+  if (!(reach > 0)) throw new TileflowGltfError("has no width round its origin");
+  const across = 2 * reach;
+  const unit = [];
+  for (let vertex = 0; vertex < count; vertex += 1)
+    unit.push(
+      positions[vertex * 3] / across,
+      positions[vertex * 3 + 1] / across,
+      positions[vertex * 3 + 2] / height
+    );
+  const faceSums = new Array(count * 3).fill(0);
+  for (let at = 0; at + 2 < indices.length; at += 3) {
+    const [a, b, c] = [indices[at], indices[at + 1], indices[at + 2]];
+    const n = cross(sub2(point(unit, b), point(unit, a)), sub2(point(unit, c), point(unit, a)));
+    for (const vertex of [a, b, c])
+      for (let axis = 0; axis < 3; axis += 1) faceSums[vertex * 3 + axis] += n[axis];
+  }
+  const outNormals = [];
+  for (let vertex = 0; vertex < count; vertex += 1) {
+    const own = normals[vertex];
+    const n = own ? [own[0] * across, own[1] * across, own[2] * height] : faceSums.slice(vertex * 3, vertex * 3 + 3);
+    const size = Math.hypot(n[0], n[1], n[2]) || 1;
+    outNormals.push(n[0] / size, n[1] / size, n[2] / size);
+  }
+  const shades = new Array(count).fill(0);
+  for (const part of new Set(parts)) {
+    const members = parts.flatMap((value, vertex) => value === part ? [vertex] : []);
+    const mean = members.reduce((sum, vertex) => sum + luminance2[vertex], 0) / members.length;
+    const spread = Math.max(0.06, mean * 0.6);
+    for (const vertex of members)
+      shades[vertex] = clamp((luminance2[vertex] - mean) / spread, -1, 1);
+  }
+  let crownLow = 1;
+  let crownHigh = 0;
+  for (let vertex = 0; vertex < count; vertex += 1)
+    if (isCrown(parts[vertex])) {
+      crownLow = Math.min(crownLow, unit[vertex * 3 + 2]);
+      crownHigh = Math.max(crownHigh, unit[vertex * 3 + 2]);
+    }
+  const occlusion = [];
+  for (let vertex = 0; vertex < count; vertex += 1) {
+    const z = unit[vertex * 3 + 2];
+    if (!isCrown(parts[vertex])) {
+      occlusion.push(z > crownLow ? 0.55 : 0.8);
+      continue;
+    }
+    const up = crownHigh > crownLow ? (z - crownLow) / (crownHigh - crownLow) : 1;
+    const out = Math.min(1, Math.hypot(unit[vertex * 3], unit[vertex * 3 + 1]) / 0.5);
+    occlusion.push(clamp(0.4 + 0.35 * up + 0.3 * out, 0.35, 1));
+  }
+  return {
+    // The author's proportions: the trees it stands keep them around the sizes the data gives.
+    proportion: Math.min(3, Math.max(0.1, across / height)),
+    positions: unit,
+    normals: outNormals,
+    parts,
+    shades,
+    occlusion,
+    indices
+  };
+}
+function partOf(material) {
+  const name = material?.trim().toLowerCase().replace(/\.\d+$/u, "");
+  const part = tileflowTreeModelPartNames.find((candidate) => candidate === name);
+  if (part) return tileflowTreeParts[part];
+  throw new TileflowGltfError(
+    material === void 0 ? "has a mesh without a material; name each material bark, leaves, fronds or stem" : `has a material "${material}" that names no part of a tree; name each material bark, leaves, fronds or stem`
+  );
+}
+function isCrown(part) {
+  return part === tileflowTreeParts.leaves || part === tileflowTreeParts.fronds;
+}
+function point(list2, vertex) {
+  return [list2[vertex * 3], list2[vertex * 3 + 1], list2[vertex * 3 + 2]];
+}
+function sub2(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function cross(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+function clamp(value, low, high) {
+  return Math.min(high, Math.max(low, value));
+}
+
+// src/building-model-mesh.ts
+function isTileflowTreeModel(primitives) {
+  const drawn = primitives.filter((primitive) => !isFootprint(primitive));
+  return drawn.length > 0 && drawn.every(
+    (primitive) => tileflowTreeModelPartNames.includes(
+      partOf2(primitive.material)
+    )
+  );
+}
+function tileflowBuildingModelDeclaredFootprint(primitives) {
+  const positions = [];
+  const indices = [];
+  for (const primitive of primitives) {
+    if (!isFootprint(primitive)) continue;
+    const offset = positions.length / 3;
+    positions.push(...primitive.positions);
+    for (const index of primitive.indices) indices.push(offset + index);
+  }
+  return indices.length > 0 ? { positions, indices } : void 0;
+}
+function prepareTileflowBuildingModelMesh(bytes, {
+  ambientOcclusion = true,
+  lightmapTexels = 0
+} = {}) {
+  const primitives = bytes instanceof Uint8Array ? readTileflowGltfTriangles(bytes, { materials: true }) : bytes;
+  const drawn = primitives.filter((primitive) => !isFootprint(primitive));
+  const surface = buildingModelSurface(drawn);
+  const positions = [];
+  const normals = [];
+  const partNames = [];
+  const parts = [];
+  const lightingRoles = [];
+  const luminance2 = [];
+  const indices = [];
+  for (const primitive of drawn) {
+    const name = partOf2(primitive.material);
+    if (name === void 0)
+      throw new TileflowGltfError(
+        primitive.material === void 0 ? "has a mesh without a material; name each material after its part, such as surface, glass, roof or water" : `has a material "${primitive.material}" that names no part; name each material after its part in lower-case words joined by hyphens, such as surface, glass, roof or water`
+      );
+    if (!partNames.includes(name)) partNames.push(name);
+    if (partNames.length > tileflowModelLimits.parts)
+      throw new TileflowGltfError(
+        `names ${partNames.length} parts in its materials; a building model takes at most ${tileflowModelLimits.parts} a level. Give materials of the same part the same name`
+      );
+    const part = partNames.indexOf(name);
+    const offset = positions.length / 3;
+    const role = primitive.lightingRole === void 0 ? tileflowModelDefaultLightingRole(name) : typeof primitive.lightingRole === "string" && Object.hasOwn(tileflowModelLightingRoles, primitive.lightingRole) ? tileflowModelLightingRoles[primitive.lightingRole] : void 0;
     if (role === void 0)
       throw new TileflowGltfError(
         "has an unknown lighting role; use unclassified, wall, door, roof, window, lamp or logo"
@@ -1727,7 +2590,7 @@ function prepareTileflowBuildingModelMesh(bytes, { ambientOcclusion = true } = {
       lightingRoles.push(role);
       normals.push(primitive.normals?.slice(vertex * 3, vertex * 3 + 3));
       const [r, g, b] = primitive.colours.slice(vertex * 3, vertex * 3 + 3);
-      luminance.push(0.2126 * r + 0.7152 * g + 0.0722 * b);
+      luminance2.push(0.2126 * r + 0.7152 * g + 0.0722 * b);
     }
     for (const index of primitive.indices) indices.push(offset + index);
   }
@@ -1755,9 +2618,9 @@ function prepareTileflowBuildingModelMesh(bytes, { ambientOcclusion = true } = {
   const sums = new Array(count * 3).fill(0);
   for (let at = 0; at + 2 < indices.length; at += 3) {
     const [a, b, c] = [indices[at], indices[at + 1], indices[at + 2]];
-    const n = cross(
-      sub(point(positions, b), point(positions, a)),
-      sub(point(positions, c), point(positions, a))
+    const n = cross3(
+      sub3(point2(positions, b), point2(positions, a)),
+      sub3(point2(positions, c), point2(positions, a))
     );
     for (const vertex of [a, b, c])
       for (let axis = 0; axis < 3; axis += 1) sums[vertex * 3 + axis] += n[axis];
@@ -1771,22 +2634,84 @@ function prepareTileflowBuildingModelMesh(bytes, { ambientOcclusion = true } = {
   const shades = new Array(count).fill(0);
   for (const part of new Set(parts)) {
     const members = parts.flatMap((value, vertex) => value === part ? [vertex] : []);
-    const mean = members.reduce((sum, vertex) => sum + luminance[vertex], 0) / members.length;
+    const mean = members.reduce((sum, vertex) => sum + luminance2[vertex], 0) / members.length;
     const spread = Math.max(0.06, mean * 0.6);
     for (const vertex of members)
-      shades[vertex] = clamp((luminance[vertex] - mean) / spread, -1, 1);
+      shades[vertex] = clamp2((luminance2[vertex] - mean) / spread, -1, 1);
   }
+  const texels = typeof lightmapTexels === "function" ? lightmapTexels(surfaceArea(positions, indices)) : lightmapTexels;
+  const lightmap = ambientOcclusion && texels > 0 && surface && lightmapFits(surface) ? bakeBuildingModelLightmap({ positions, normals: outNormals, indices }, { texels }) : void 0;
+  if (!lightmap)
+    return {
+      positions,
+      normals: outNormals,
+      parts,
+      partNames,
+      lightingRoles,
+      shades,
+      ...surface ? { surface } : {},
+      occlusion: ambientOcclusion ? buildingModelAmbientVisibility({ positions, normals: outNormals, indices }) : new Array(count).fill(1),
+      indices
+    };
+  const { sources } = lightmap;
+  const from = (values, width = 1) => sources.flatMap((source) => values.slice(source * width, source * width + width));
+  const attributes = from([...surface.attributes], 8);
+  for (let vertex = 0; vertex < sources.length; vertex++) {
+    attributes[vertex * 8 + 2] = lightmap.uvs[vertex * 2];
+    attributes[vertex * 8 + 3] = lightmap.uvs[vertex * 2 + 1];
+  }
+  const texture = surface.textures.length;
   return {
-    positions,
-    normals: outNormals,
-    parts,
-    lightingRoles,
-    shades,
-    ...surface ? { surface } : {},
-    occlusion: ambientOcclusion ? buildingModelAmbientVisibility({ positions, normals: outNormals, indices }) : new Array(count).fill(1),
-    indices
+    positions: from(positions, 3),
+    normals: from(outNormals, 3),
+    parts: from(parts),
+    partNames,
+    lightingRoles: from(lightingRoles),
+    shades: from(shades),
+    surface: {
+      ...surface,
+      attributes,
+      materials: surface.materials.map((material) => ({
+        ...material,
+        occlusionTexture: { texture, texCoord: 1 }
+      })),
+      textures: [
+        ...surface.textures,
+        {
+          mimeType: "image/jpeg",
+          bytes: encodeGreyJpeg(lightmap.texels, lightmap.width, lightmap.height, lightmapQuality),
+          width: lightmap.width,
+          height: lightmap.height,
+          wrapS: 33071,
+          wrapT: 33071,
+          minFilter: 9987,
+          magFilter: 9729
+        }
+      ]
+    },
+    occlusion: new Array(sources.length).fill(1),
+    indices: lightmap.indices
   };
 }
+var lightmapQuality = 35;
+function surfaceArea(positions, indices) {
+  let area = 0;
+  for (let at = 0; at + 2 < indices.length; at += 3) {
+    const a = point2(positions, indices[at]);
+    area += Math.hypot(
+      ...cross3(
+        sub3(point2(positions, indices[at + 1]), a),
+        sub3(point2(positions, indices[at + 2]), a)
+      )
+    ) / 2;
+  }
+  return area;
+}
+function lightmapFits(surface) {
+  return surface.textures.length < tileflowModelSurfaceLimits2.textures && surface.materials.every(
+    (material) => !material.occlusionTexture && tileflowModelTextureChannels2.every((channel) => material[channel]?.texCoord !== 1)
+  );
+}
 function tileflowBuildingModelFootprint(mesh) {
   const { positions, indices } = mesh;
   let [minX, minY, maxX, maxY] = [Infinity, Infinity, -Infinity, -Infinity];
@@ -1903,10 +2828,9 @@ function tileflowBuildingModelFootprint(mesh) {
 function isFootprint(primitive) {
   return primitive.material?.trim().toLowerCase().replace(/\.\d+$/u, "") === "footprint";
 }
-function partOf(material) {
+function partOf2(material) {
   const name = material?.trim().toLowerCase().replace(/\.\d+$/u, "");
-  const part = tileflowBuildingModelPartNames.find((candidate) => candidate === name);
-  return part === void 0 ? void 0 : tileflowModelParts[part];
+  return isTileflowModelPartName(name) ? name : void 0;
 }
 function simplify(ring, tolerance) {
   if (ring.length <= 4) return [...ring];
@@ -1943,7 +2867,7 @@ function segmentDistance(p, a, b) {
   const dx = b[0] - a[0];
   const dy = b[1] - a[1];
   const length = dx * dx + dy * dy;
-  const t = length > 0 ? clamp(((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / length, 0, 1) : 0;
+  const t = length > 0 ? clamp2(((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / length, 0, 1) : 0;
   return Math.hypot(p[0] - (a[0] + t * dx), p[1] - (a[1] + t * dy));
 }
 function ringArea(ring) {
@@ -1955,150 +2879,13 @@ function ringArea(ring) {
 function edge(a, b, p) {
   return (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]);
 }
-function point(list2, vertex) {
-  return [list2[vertex * 3], list2[vertex * 3 + 1], list2[vertex * 3 + 2]];
-}
-function sub(a, b) {
-  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-}
-function cross(a, b) {
-  return [
-    a[1] * b[2] - a[2] * b[1],
-    a[2] * b[0] - a[0] * b[2],
-    a[0] * b[1] - a[1] * b[0]
-  ];
-}
-function clamp(value, low, high) {
-  return Math.min(high, Math.max(low, value));
-}
-
-// src/tree-model-mesh.ts
-import {
-  tileflowTreeModelLimits,
-  tileflowTreeParts
-} from "@tileflow/core";
-var tileflowTreeModelPartNames = ["bark", "leaves", "fronds", "stem"];
-function prepareTileflowTreeModelMesh(bytes, level) {
-  const primitives = readTileflowGltfTriangles(bytes);
-  const positions = [];
-  const normals = [];
-  const parts = [];
-  const luminance = [];
-  const indices = [];
-  for (const primitive of primitives) {
-    const part = partOf2(primitive.material);
-    const offset = positions.length / 3;
-    const count2 = primitive.positions.length / 3;
-    positions.push(...primitive.positions);
-    for (let vertex = 0; vertex < count2; vertex += 1) {
-      parts.push(part);
-      normals.push(primitive.normals?.slice(vertex * 3, vertex * 3 + 3));
-      const [r, g, b] = primitive.colours.slice(vertex * 3, vertex * 3 + 3);
-      luminance.push(0.2126 * r + 0.7152 * g + 0.0722 * b);
-    }
-    for (const index of primitive.indices) indices.push(offset + index);
-  }
-  const count = positions.length / 3;
-  const triangleCount = indices.length / 3;
-  const limit = level === "near" ? tileflowTreeModelLimits.nearTriangles : tileflowTreeModelLimits.farTriangles;
-  if (triangleCount > limit)
-    throw new TileflowGltfError(
-      `has ${triangleCount.toLocaleString("en")} triangles; a ${level} tree model takes at most ${limit.toLocaleString("en")}. Simplify it (for example with Blender's Decimate modifier) and export it again`
-    );
-  if (count > tileflowTreeModelLimits.vertices)
-    throw new TileflowGltfError(
-      `has ${count.toLocaleString("en")} vertices; a tree model takes at most ${tileflowTreeModelLimits.vertices.toLocaleString("en")}. Merge vertices by distance and export it again`
-    );
-  let height = 0;
-  let reach = 0;
-  const crowned = parts.some((part) => isCrown(part));
-  for (let vertex = 0; vertex < count; vertex += 1) {
-    height = Math.max(height, positions[vertex * 3 + 2]);
-    if (!crowned || isCrown(parts[vertex]))
-      reach = Math.max(reach, Math.hypot(positions[vertex * 3], positions[vertex * 3 + 1]));
-  }
-  if (!(height > 0))
-    throw new TileflowGltfError(
-      "stands below its origin; put the origin where the trunk meets the ground, with the tree above it"
-    );
-  if (!(reach > 0)) throw new TileflowGltfError("has no width round its origin");
-  const across = 2 * reach;
-  const unit = [];
-  for (let vertex = 0; vertex < count; vertex += 1)
-    unit.push(
-      positions[vertex * 3] / across,
-      positions[vertex * 3 + 1] / across,
-      positions[vertex * 3 + 2] / height
-    );
-  const faceSums = new Array(count * 3).fill(0);
-  for (let at = 0; at + 2 < indices.length; at += 3) {
-    const [a, b, c] = [indices[at], indices[at + 1], indices[at + 2]];
-    const n = cross2(sub2(point2(unit, b), point2(unit, a)), sub2(point2(unit, c), point2(unit, a)));
-    for (const vertex of [a, b, c])
-      for (let axis = 0; axis < 3; axis += 1) faceSums[vertex * 3 + axis] += n[axis];
-  }
-  const outNormals = [];
-  for (let vertex = 0; vertex < count; vertex += 1) {
-    const own = normals[vertex];
-    const n = own ? [own[0] * across, own[1] * across, own[2] * height] : faceSums.slice(vertex * 3, vertex * 3 + 3);
-    const size = Math.hypot(n[0], n[1], n[2]) || 1;
-    outNormals.push(n[0] / size, n[1] / size, n[2] / size);
-  }
-  const shades = new Array(count).fill(0);
-  for (const part of new Set(parts)) {
-    const members = parts.flatMap((value, vertex) => value === part ? [vertex] : []);
-    const mean = members.reduce((sum, vertex) => sum + luminance[vertex], 0) / members.length;
-    const spread = Math.max(0.06, mean * 0.6);
-    for (const vertex of members)
-      shades[vertex] = clamp2((luminance[vertex] - mean) / spread, -1, 1);
-  }
-  let crownLow = 1;
-  let crownHigh = 0;
-  for (let vertex = 0; vertex < count; vertex += 1)
-    if (isCrown(parts[vertex])) {
-      crownLow = Math.min(crownLow, unit[vertex * 3 + 2]);
-      crownHigh = Math.max(crownHigh, unit[vertex * 3 + 2]);
-    }
-  const occlusion = [];
-  for (let vertex = 0; vertex < count; vertex += 1) {
-    const z = unit[vertex * 3 + 2];
-    if (!isCrown(parts[vertex])) {
-      occlusion.push(z > crownLow ? 0.55 : 0.8);
-      continue;
-    }
-    const up = crownHigh > crownLow ? (z - crownLow) / (crownHigh - crownLow) : 1;
-    const out = Math.min(1, Math.hypot(unit[vertex * 3], unit[vertex * 3 + 1]) / 0.5);
-    occlusion.push(clamp2(0.4 + 0.35 * up + 0.3 * out, 0.35, 1));
-  }
-  return {
-    // The author's proportions: the trees it stands keep them around the sizes the data gives.
-    proportion: Math.min(3, Math.max(0.1, across / height)),
-    positions: unit,
-    normals: outNormals,
-    parts,
-    shades,
-    occlusion,
-    indices
-  };
-}
-function partOf2(material) {
-  const name = material?.trim().toLowerCase().replace(/\.\d+$/u, "");
-  const part = tileflowTreeModelPartNames.find((candidate) => candidate === name);
-  if (part) return tileflowTreeParts[part];
-  throw new TileflowGltfError(
-    material === void 0 ? "has a mesh without a material; name each material bark, leaves, fronds or stem" : `has a material "${material}" that names no part of a tree; name each material bark, leaves, fronds or stem`
-  );
-}
-function isCrown(part) {
-  return part === tileflowTreeParts.leaves || part === tileflowTreeParts.fronds;
-}
 function point2(list2, vertex) {
   return [list2[vertex * 3], list2[vertex * 3 + 1], list2[vertex * 3 + 2]];
 }
-function sub2(a, b) {
+function sub3(a, b) {
   return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
 }
-function cross2(a, b) {
+function cross3(a, b) {
   return [
     a[1] * b[2] - a[2] * b[1],
     a[2] * b[0] - a[0] * b[2],
@@ -2170,15 +2957,32 @@ function encodeTileflowLandmarkRegion(region) {
   const bytes = serializeTileflowLandmarkRegion(region);
   return { bytes, sha256: sha256Of(bytes) };
 }
+var nearLightmapTexels = (area) => Math.min(
+  524288,
+  Math.max(65536, Math.round(89 / 0.6 * area ** 0.54), Math.round(1.3 ** 2 * area / 0.6))
+);
+var buildingModelLightmapTexels = {
+  near: nearLightmapTexels,
+  mid: (area) => nearLightmapTexels(area) / 4
+};
 function buildingModelEntry(id, levels) {
   const primitives = readTileflowGltfTriangles(levels.near, { materials: true });
-  if (!isTileflowBuildingModel(primitives))
+  if (isTileflowTreeModel(primitives))
     throw new TileflowGltfError(
-      "is not a building model; name each material surface, secondary, glass, accent or roof"
+      "is not a building model; its materials name only the parts of a tree (bark, leaves, fronds and stem)"
+    );
+  const meshes = [
+    prepareTileflowBuildingModelMesh(primitives, {
+      lightmapTexels: buildingModelLightmapTexels.near
+    })
+  ];
+  if (levels.mid)
+    meshes.push(
+      prepareTileflowBuildingModelMesh(levels.mid, {
+        lightmapTexels: buildingModelLightmapTexels.mid
+      })
     );
-  const meshes = [prepareTileflowBuildingModelMesh(primitives)];
-  for (const level of [levels.mid, levels.far])
-    if (level) meshes.push(prepareTileflowBuildingModelMesh(level));
+  if (levels.far) meshes.push(prepareTileflowBuildingModelMesh(levels.far));
   return {
     id,
     levels: meshes,
@@ -2265,7 +3069,7 @@ async function prepareTileflowMapTreeModels(directories, options) {
       });
       continue;
     }
-    if (isTileflowBuildingModel(primitives)) {
+    if (!isTileflowTreeModel(primitives)) {
       const files2 = { near: nearBytes };
       const sources = [];
       let failing = entry.near;