leaflet-city-mapper 0.0.2 → 0.0.3

package/src/geometry/below.js

@@ -0,0 +1,3 @@
+export function below(p) {
+  return [p[0], p[1] - 1.2, p[2]];
+}

package/src/geometry/box.js

@@ -0,0 +1,3 @@
+export function box(x0, x1, z0, z1) {
+  return [[x0, z0], [x1, z0], [x1, z1], [x0, z1]];
+}

package/src/geometry/bridgeElevation.js

@@ -0,0 +1,19 @@
+/** Height inside a bridge deck, or null outside its triangles. */
+export function bridgeElevation(point, bridges) {
+  // Bridges bucketed by 64 DEM pixels.
+  let bridge, a, b, c, d, u, v;
+  for (bridge of bridges?.get(`${Math.floor(point.x / 64)}/${Math.floor(point.y / 64)}`) || []) {
+    if (point.x < bridge.min[0] || point.x > bridge.max[0] || point.y < bridge.min[1] || point.y > bridge.max[1]) {
+      continue;
+    }
+    for ([a, b, c] of bridge.triangles) {
+      d = (b[1] - c[1]) * (a[0] - c[0]) + (c[0] - b[0]) * (a[1] - c[1]);
+      u = ((b[1] - c[1]) * (point.x - c[0]) + (c[0] - b[0]) * (point.y - c[1])) / d;
+      v = ((c[1] - a[1]) * (point.x - c[0]) + (a[0] - c[0]) * (point.y - c[1])) / d;
+      if (u >= 0 && v >= 0 && u + v <= 1) {
+        return u * a[2] + v * b[2] + (1 - u - v) * c[2];
+      }
+    }
+  }
+  return null;
+}

package/src/geometry/bridgeLocal.js

@@ -0,0 +1,4 @@
+export function local([lng, lat, z], crs, origin, metres, base) {
+  const p = crs.project(new L.LatLng(lat, lng));
+  return [(p.x - origin.x) * metres, z - base, -(p.y - origin.y) * metres];
+}

package/src/geometry/build.js

@@ -0,0 +1,19 @@
+import { triangle } from './triangle.js';
+
+export function build(parts) {
+  const position = [], normal = [], color = [];
+  let ring, bottom, top, tint, topRing, low, high, x, z, i, j;
+  for ([ring, bottom, top, tint, topRing = ring] of parts) {
+    low = [], high = [];
+    for ([x, z] of ring) low.push([x, bottom, z]);
+    for ([x, z] of topRing) high.push([x, top, z]);
+    for (i = 0; i < ring.length; i++) {
+      j = (i + 1) % ring.length;
+      triangle(position, normal, color, low[i], low[j], high[j], tint); triangle(position, normal, color, low[i], high[j], high[i], tint);
+    }
+    for (i = 1; i < ring.length - 1; i++) {
+      triangle(position, normal, color, high[0], high[i], high[i + 1], tint); triangle(position, normal, color, low[0], low[i + 1], low[i], tint);
+    }
+  }
+  return { position, normal, color };
+}

package/src/geometry/circleAt.js

@@ -0,0 +1,5 @@
+export function circleAt(center, radius, radiusY, count, index, offset = 0) {
+  const angle = index * Math.PI * 2 / count;
+  return new L.Point(center.x + Math.max(0, radius + offset) * Math.cos(angle),
+    center.y + Math.max(0, radiusY + offset) * Math.sin(angle));
+}

package/src/geometry/clipLine.js

@@ -0,0 +1,23 @@
+import { samePoint } from './samePoint.js';
+import { clipSegment } from './clipSegment.js';
+
+/** Clip a geographic line to [west, south, east, north] without joining disjoint pieces. */
+export function clipLine(line, bounds) {
+  const pieces = [];
+  let current;
+  let i, segment;
+  for (i = 1; i < line.length; i++) {
+    if (samePoint(line[i - 1], line[i])) continue;
+    segment = clipSegment(line[i - 1], line[i], bounds);
+    if (!segment) {
+      current = null;
+      continue;
+    }
+    if (current && samePoint(current.at(-1), segment[0])) current.push(segment[1]);
+    else {
+      current = segment;
+      pieces.push(current);
+    }
+  }
+  return pieces;
+}

package/src/geometry/clipSegment.js

@@ -0,0 +1,19 @@
+export function clipSegment(a, b, bounds) {
+  const [west, south, east, north] = bounds;
+  const dx = b[0] - a[0], dy = b[1] - a[1];
+  const p = [-dx, dx, -dy, dy], q = [a[0] - west, east - a[0], a[1] - south, north - a[1]];
+  let start = 0, end = 1;
+  let i, t;
+  for (i = 0; i < 4; i++) {
+    if (p[i] === 0) {
+      if (q[i] < 0) return null;
+    } else {
+      t = q[i] / p[i];
+      if (p[i] < 0) start = Math.max(start, t);
+      else end = Math.min(end, t);
+      if (start > end) return null;
+    }
+  }
+  if (start === end || dx === 0 && dy === 0) return null;
+  return [[a[0] + start * dx, a[1] + start * dy], [a[0] + end * dx, a[1] + end * dy]];
+}

package/src/geometry/computeBounds.js

@@ -0,0 +1,33 @@
+/** Cache local AABB and center for ray picking and transparent mesh sorting. */
+
+export function computeBounds(geometry) {
+  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity], data = geometry.attributes.position.data;
+  let i;
+  for (i = 0; i < data.length; i++) {
+    min[i % 3] = Math.min(min[i % 3], data[i]);
+    max[i % 3] = Math.max(max[i % 3], data[i]);
+  }
+  const instances = geometry.attributes.instanceOffset;
+  if (instances) {
+    let axis, offset, low, high;
+    for (axis = 0; axis < 3; axis++) {
+      low = Infinity;
+      high = -Infinity;
+      for (offset = axis; offset < instances.data.length; offset += instances.size) {
+        low = Math.min(low, instances.data[offset]);
+        high = Math.max(high, instances.data[offset]);
+      }
+      min[axis] = Math.fround(min[axis] + low);
+      max[axis] = Math.fround(max[axis] + high);
+    }
+  }
+  const center = [];
+  for (i = 0; i < min.length; i++) center.push((min[i] + max[i]) / 2);
+  let radius = instances ? Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]) / 2 : 0;
+  for (i = 0; !instances && i < data.length; i += 3) {
+    radius = Math.max(radius, Math.hypot(
+      data[i] - center[0], data[i + 1] - center[1], data[i + 2] - center[2]
+    ));
+  }
+  geometry.bounds = { min, max, center, radius };
+}

package/src/geometry/conformModelToTerrain.js

@@ -0,0 +1,67 @@
+import { computeBounds } from './computeBounds.js';
+import { getElevation } from '../terrain/getElevation.js';
+import { update } from '../scene/update.js';
+import { updateWorldMatrix } from '../scene/updateWorldMatrix.js';
+import { vertexNormals } from './vertexNormals.js';
+import { collectMeshes } from '../collision/collectMeshes.js';
+import { HEIGHT } from '../constants/HEIGHT.js';
+
+export function conformModelToTerrain(layer, terrain) {
+  if (!layer.model) return;
+  const meshes = [];
+  collectMeshes(layer.model, meshes);
+  let mesh, positions, geometry, position, normals, attribute, normal, world, inverse, i, x, y, z;
+  let worldY, weight, worldX, worldZ, point, elevation, offset;
+  if (!terrain?._terrainReady || !layer.options.terrainConform) {
+    for (mesh of meshes) {
+      positions = mesh.geometry._terrainBasePositions;
+      if (!positions) continue;
+      geometry = mesh.geometry, position = geometry.attributes.position;
+      position.data.set(positions);
+      mesh.device.queue.writeBuffer(position.buffer, 0, positions);
+      normals = geometry._terrainBaseNormals;
+      if (normals) {
+        geometry.attributes.normal.data.set(normals);
+        mesh.device.queue.writeBuffer(geometry.attributes.normal.buffer, 0, normals);
+      }
+      computeBounds(geometry);
+    }
+    return;
+  }
+
+  updateWorldMatrix(layer.root);
+  const map = layer._map, crs = map.options.crs;
+  const origin = crs.project(layer._shared._sceneOrigin);
+  const metres = Math.cos(layer._shared._sceneOrigin.lat * Math.PI / 180);
+  const pixelScale = crs.scale(terrain._terrainZoom);
+
+  for (mesh of meshes) {
+    geometry = mesh.geometry, attribute = geometry.attributes.position;
+    geometry._terrainBasePositions ||= attribute.data.slice();
+    normal = geometry.attributes.normal;
+    geometry._terrainBaseNormals ||= normal.data.slice();
+    attribute.data.set(geometry._terrainBasePositions);
+    world = mesh.worldMatrix, inverse = new DOMMatrix(world).inverse().toFloat64Array();
+    for (i = 0; i < attribute.data.length; i += 3) {
+      x = attribute.data[i], y = attribute.data[i + 1], z = attribute.data[i + 2];
+      worldY = world[1] * x + world[5] * y + world[9] * z + world[13];
+      weight = Math.max(0, Math.min(1, 1 - (worldY - layer.root.position[1]) / HEIGHT));
+      if (!weight) continue;
+      worldX = world[0] * x + world[4] * y + world[8] * z + world[12];
+      worldZ = world[2] * x + world[6] * y + world[10] * z + world[14];
+      point = crs.transformation.transform(new L.Point(
+        origin.x + worldX / metres, origin.y - worldZ / metres), pixelScale);
+      elevation = getElevation(terrain, point);
+      if (!Number.isFinite(elevation)) continue;
+      offset = (elevation - worldY) * weight;
+      attribute.data[i] += inverse[4] * offset;
+      attribute.data[i + 1] += inverse[5] * offset;
+      attribute.data[i + 2] += inverse[6] * offset;
+    }
+    mesh.device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
+    normal.data.set(vertexNormals(attribute.data, geometry.attributes.index?.data));
+    mesh.device.queue.writeBuffer(normal.buffer, 0, normal.data);
+    computeBounds(geometry);
+  }
+  update(layer);
+}

package/src/geometry/cross.js

@@ -0,0 +1,3 @@
+export 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]];
+}

package/src/geometry/disk.js

@@ -0,0 +1,11 @@
+import { triangle } from './nativeTriangle.js';
+import { diskAt } from './diskAt.js';
+
+export function disk(point, center, radius, target, radiusY = radius) {
+  if (!(radius > 0) || !(radiusY > 0)) return;
+  const count = Math.max(12, Math.min(128, Math.ceil(Math.PI * Math.sqrt(radius))));
+  let i;
+  for (i = 0; i < count; i++) {
+    triangle(point, target, center, diskAt(center, radius, radiusY, count, i), diskAt(center, radius, radiusY, count, i + 1));
+  }
+}

package/src/geometry/diskAt.js

@@ -0,0 +1,4 @@
+export function diskAt(center, radius, radiusY, count, index) {
+  return new L.Point(center.x + radius * Math.cos(index * 2 * Math.PI / count),
+    center.y + radiusY * Math.sin(index * 2 * Math.PI / count));
+}

package/src/geometry/dot.js

@@ -0,0 +1,6 @@
+export function dot(a, b) {
+  let sum = 0;
+  let i;
+  for (i = 0; i < a.length; i++) sum += a[i] * b[i];
+  return sum;
+}

package/src/geometry/emitter.js

@@ -0,0 +1,8 @@
+export function emitter(point, u, v, axis) {
+  const r = 0.65;
+  return {
+    x: point.x + (axis === 2 ? 0 : u * r),
+    y: point.y + (axis === 1 ? 0 : axis === 2 ? u * r : v * r),
+    ground: point.ground + (axis === 0 ? 0 : v * r), uv: [u, v],
+  };
+}

package/src/geometry/lampPostGeometry.js

@@ -0,0 +1,24 @@
+import { parseColor } from "../utils/parseColor.js";
+import { ring } from './lampRing.js';
+
+/** Schematic support and lamp head; wall-mounted fixtures do not get an invented pole. */
+
+export function lampPostGeometry(point, style, addTriangle) {
+  const color = parseColor(0x50565a), radius = style.poleRadius;
+  if (!Number.isFinite(radius) || radius <= 0) {
+    throw new Error('Invalid lamp pole radius');
+  }
+  const center = { ...point, uv: [3, 3] };
+  let r, low, high, points, i, a, b, angle, nx, nz;
+  for ([r, low, high] of [[radius, 0, style.top], [radius * 2.5, style.top - 0.25, style.top + 0.15]]) {
+    points = ring(point, r);
+    for (i = 0; i < 6; i++) {
+      a = points[i], b = points[(i + 1) % 6], angle = (i + 0.5) * Math.PI / 3;
+      nx = Math.cos(angle), nz = -Math.sin(angle);
+      addTriangle(a, low, b, low, b, high, nx, 0, nz, color);
+      addTriangle(a, low, b, high, a, high, nx, 0, nz, color);
+      addTriangle(center, high, a, high, b, high, 0, 1, 0, color);
+      addTriangle(center, low, b, low, a, low, 0, -1, 0, color);
+    }
+  }
+}

package/src/geometry/lampRing.js

@@ -0,0 +1,11 @@
+export function ring(point, radius) {
+  const points = [];
+  let i;
+  for (i = 0; i < 6; i++) {
+    points.push({
+      x: point.x + Math.cos(i * Math.PI / 3) * radius,
+      y: point.y + Math.sin(i * Math.PI / 3) * radius, ground: point.ground, uv: [3, 3],
+    });
+  }
+  return points;
+}

package/src/geometry/lightGeometry.js

@@ -0,0 +1,15 @@
+import { parseColor } from "../utils/parseColor.js";
+import { quad } from './quad.js';
+import { emitter } from './emitter.js';
+
+/** Three crossed emitter discs; illumination itself is evaluated on receiving surfaces. */
+
+export function lightGeometry(point, style, addTriangle) {
+  if (!Number.isFinite(style.lightRadius) || style.lightRadius <= 0) throw new Error('Invalid light radius');
+  const color = parseColor(style.color);
+  let axis;
+  for (axis = 0; axis < 3; axis++) {
+    quad(addTriangle, color, emitter(point, -1, -1, axis), emitter(point, 1, -1, axis), emitter(point, 1, 1, axis), emitter(point, -1, 1, axis),
+      style.top, axis === 0 ? [0, 1, 0] : axis === 1 ? [0, 0, 1] : [1, 0, 0]);
+  }
+}

package/src/geometry/line.js

@@ -0,0 +1,54 @@
+import { triangle } from './nativeTriangle.js';
+import { disk } from './disk.js';
+import { segment } from './segment.js';
+
+export function line(context, points, closed) {
+  const { options, width, dash, stroke, point } = context;
+  if (!options.stroke || width <= 0 || points.length < 2) return;
+  const radius = width / 2;
+  let distance = Number(options.dashOffset) || 0;
+  let period = 0;
+  let value, i, a, b, length, previous, previousLength, incoming, outgoing, side, n1, n2, from, to;
+  let denominator, miter, offset, phase, index, end, delta;
+  for (value of dash) period += value;
+  for (i = 0; i < points.length - (closed ? 0 : 1); i++) {
+    a = points[i], b = points[(i + 1) % points.length], length = a.distanceTo(b);
+    if (!dash.length) {
+      segment(context, a, b, !closed && i === 0, !closed && i === points.length - 2);
+      if (closed || i > 0) {
+        if (options.lineJoin === 'round') disk(point, a, radius, stroke);
+        else {
+          previous = a.subtract(points[(i + points.length - 1) % points.length]);
+          previousLength = Math.hypot(previous.x, previous.y);
+          if (previousLength && length) {
+            incoming = previous.divideBy(previousLength);
+            outgoing = b.subtract(a).divideBy(length);
+            side = incoming.x * outgoing.y - incoming.y * outgoing.x > 0 ? -1 : 1;
+            n1 = new L.Point(-incoming.y * side, incoming.x * side);
+            n2 = new L.Point(-outgoing.y * side, outgoing.x * side);
+            from = a.add(n1.multiplyBy(radius)), to = a.add(n2.multiplyBy(radius));
+            denominator = 1 + n1.x * n2.x + n1.y * n2.y;
+            miter = denominator > 0 ? n1.add(n2).multiplyBy(radius / denominator) : null;
+            triangle(point, stroke, from, a, to);
+            if (options.lineJoin === 'miter' && miter && Math.hypot(miter.x, miter.y) <= radius * 4) {
+              triangle(point, stroke, from, a.add(miter), to);
+            }
+          }
+        }
+      }
+    } else {
+      offset = 0;
+      while (offset < length) {
+        phase = ((distance + offset) % period + period) % period, index = 0;
+        while (phase >= dash[index]) phase -= dash[index++];
+        end = Math.min(length, offset + dash[index] - phase);
+        if (index % 2 === 0) {
+          delta = b.subtract(a).divideBy(length);
+          segment(context, a.add(delta.multiplyBy(offset)), a.add(delta.multiplyBy(end)), true, true);
+        }
+        offset = end;
+      }
+    }
+    distance += length;
+  }
+}

package/src/geometry/nativeGeometry.js

@@ -0,0 +1,55 @@
+import { triangulate } from '../triangulation/triangulate.js';
+import { disk } from './disk.js';
+import { circleAt } from './circleAt.js';
+import { line } from './line.js';
+import { visit } from './visit.js';
+
+/** Leaflet paths become flat triangles; pixel-sized strokes are rebuilt on zoom. */
+export function nativeGeometry(source, map, point) {
+  const fill = [], stroke = [], options = source.options;
+  const width = Number(options.weight) || 0;
+  const values = Array.isArray(options.dashArray) ? options.dashArray :
+    String(options.dashArray || '').trim().split(/[ ,]+/);
+  const dash = [];
+  let value, index, i;
+  for (value of values) dash.push(Number(value));
+  let allZero = true;
+  for (value of dash) {
+    if (!Number.isFinite(value) || value < 0) throw new Error('Invalid Leaflet dashArray');
+    if (value !== 0) allZero = false;
+  }
+  if (allZero) dash.length = 0;
+  if (dash.length % 2) dash.push(...dash);
+  const context = { fill, stroke, options, width, dash, point, map };
+  if (source instanceof L.CircleMarker) {
+    const center = map.project(source.getLatLng());
+    let radius = source.getRadius(), radiusY = radius;
+    if (source instanceof L.Circle) {
+      source._project();
+      const projected = source._point.add(map.getPixelOrigin());
+      center.x = projected.x;
+      center.y = projected.y;
+      radius = source._radius;
+      radiusY = source._radiusY || radius;
+    }
+    if (options.fill) disk(point, center, radius, fill, radiusY);
+    const count = Math.max(12, Math.min(128, Math.ceil(Math.PI * Math.sqrt(Math.max(radius, radiusY)))));
+    if (dash.length) {
+      const points = [];
+      for (index = 0; index < count; index++) points.push(circleAt(center, radius, radiusY, count, index));
+      line(context, points, true);
+    }
+    else if (options.stroke && width > 0) {
+      for (i = 0; i < count; i++) {
+        triangle(point, stroke, circleAt(center, radius, radiusY, count, i, width / 2),
+          circleAt(center, radius, radiusY, count, i, -width / 2), circleAt(center, radius, radiusY, count, i + 1, width / 2));
+        triangle(point, stroke, circleAt(center, radius, radiusY, count, i + 1, width / 2),
+          circleAt(center, radius, radiusY, count, i, -width / 2), circleAt(center, radius, radiusY, count, i + 1, -width / 2));
+      }
+    }
+  } else {
+    const closed = source instanceof L.Polygon;
+    visit(context, source.getLatLngs(), closed);
+  }
+  return { fill, stroke };
+}

package/src/geometry/nativeTriangle.js

@@ -0,0 +1,3 @@
+export function triangle(point, target, a, b, c) {
+  return target.push(...point(a), ...point(b), ...point(c));
+}

package/src/geometry/polygon.js

@@ -0,0 +1,22 @@
+import { triangle } from './nativeTriangle.js';
+import { line } from './line.js';
+import { triangulate } from '../triangulation/triangulate.js';
+
+export function polygon(context, rings, closed) {
+  const { options, fill, point, map } = context, projected = [];
+  let ring, path, latlng, indices;
+  for (ring of rings) {
+    path = [];
+    for (latlng of ring) path.push(map.project(latlng));
+    projected.push(path);
+  }
+  if (closed && options.fill && projected[0]?.length >= 3) {
+    const valid = [];
+    for (ring of projected) if (ring.length >= 3) valid.push(ring);
+    const vertices = valid.flat();
+    for (indices of triangulate(valid[0], valid.slice(1))) {
+      triangle(point, fill, vertices[indices[0]], vertices[indices[1]], vertices[indices[2]]);
+    }
+  }
+  for (ring of projected) line(context, ring, closed);
+}

package/src/geometry/push.js

@@ -0,0 +1,3 @@
+export function push(position, normal, color, p, n) {
+  position.push(...p); normal.push(...n); color.push(0.6, 0.58, 0.54);
+}

package/src/geometry/quad.js

@@ -0,0 +1,4 @@
+export function quad(addTriangle, color, a, b, c, d, height, normal) {
+  addTriangle(a, height, b, height, c, height, ...normal, color);
+  addTriangle(a, height, c, height, d, height, ...normal, color);
+}

package/src/geometry/roofCoverage.js

@@ -0,0 +1,52 @@
+/** Test the mesh's ground footprint against loaded imagery, including coarse parent tiles. */
+export function roofCoverage(mesh, backend, rasters) {
+  const map = backend._map, bounds = mesh.geometry.bounds, world = mesh.worldMatrix;
+  let intersectsArchive = false;
+  let layer, zoom, origin, scale, min, max, i, x, y, z, px, py, nw, se, remaining, tile, size, left;
+  let top, pieces, x0, y0, x1, y1, l, t, r, b;
+  for (layer of rasters) {
+    zoom = layer._tileZoom, origin = map.project(backend._sceneOrigin, zoom);
+    scale = map.options.crs.scale(zoom) / (40075016.68557849 * Math.cos(backend._sceneOrigin.lat * Math.PI / 180));
+    min = [Infinity, Infinity], max = [-Infinity, -Infinity];
+    for (i = 0; i < 8; i++) {
+      x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];
+      z = i & 4 ? bounds.max[2] : bounds.min[2];
+      px = origin.x + (world[0] * x + world[4] * y + world[8] * z + world[12]) * scale;
+      py = origin.y + (world[2] * x + world[6] * y + world[10] * z + world[14]) * scale;
+      min[0] = Math.min(min[0], px); min[1] = Math.min(min[1], py);
+      max[0] = Math.max(max[0], px); max[1] = Math.max(max[1], py);
+    }
+    if (layer.header.maxLat !== undefined && layer.header.minLon !== undefined &&
+      layer.header.minLat !== undefined && layer.header.maxLon !== undefined) {
+      nw = map.project([layer.header.maxLat, layer.header.minLon], zoom);
+      se = map.project([layer.header.minLat, layer.header.maxLon], zoom);
+      min[0] = Math.max(min[0], nw.x); min[1] = Math.max(min[1], nw.y);
+      max[0] = Math.min(max[0], se.x); max[1] = Math.min(max[1], se.y);
+      if (min[0] >= max[0] || min[1] >= max[1]) continue;
+    }
+    intersectsArchive = true;
+    remaining = [[min[0], min[1], max[0], max[1]]];
+    for (tile of layer._rasterTiles.values()) {
+      // Failed imagery already reports an error; do not hide the building indefinitely.
+      if (!tile.done && !tile.error) continue;
+      size = 256 * 2 ** (zoom - tile.coords.z);
+      left = tile.coords.x * size, top = tile.coords.y * size;
+      pieces = [];
+      for ([x0, y0, x1, y1] of remaining) {
+        l = Math.max(x0, left), t = Math.max(y0, top);
+        r = Math.min(x1, left + size), b = Math.min(y1, top + size);
+        if (l >= r || t >= b) {
+          pieces.push([x0, y0, x1, y1]);
+          continue;
+        }
+        if (y0 < t) pieces.push([x0, y0, x1, t]);
+        if (b < y1) pieces.push([x0, b, x1, y1]);
+        if (x0 < l) pieces.push([x0, t, l, b]);
+        if (r < x1) pieces.push([r, t, x1, b]);
+      }
+      remaining = pieces;
+      if (!remaining.length) return true;
+    }
+  }
+  return !intersectsArchive;
+}

package/src/geometry/samePoint.js

@@ -0,0 +1,3 @@
+export function samePoint(a, b) {
+  return Math.abs(a[0] - b[0]) < 1e-10 && Math.abs(a[1] - b[1]) < 1e-10;
+}

package/src/geometry/segment.js

@@ -0,0 +1,21 @@
+import { triangle } from './nativeTriangle.js';
+import { disk } from './disk.js';
+
+export function segment(context, a, b, startCap, endCap) {
+  const { options, width, stroke, point } = context;
+  const radius = width / 2;
+  const length = a.distanceTo(b);
+  if (!length) return;
+  const direction = b.subtract(a).divideBy(length);
+  const normal = new L.Point(-direction.y * radius, direction.x * radius);
+  if (options.lineCap === 'square') {
+    if (startCap) a = a.subtract(direction.multiplyBy(radius));
+    if (endCap) b = b.add(direction.multiplyBy(radius));
+  }
+  triangle(point, stroke, a.add(normal), a.subtract(normal), b.add(normal));
+  triangle(point, stroke, b.add(normal), a.subtract(normal), b.subtract(normal));
+  if (options.lineCap === 'round') {
+    if (startCap) disk(point, a, radius, stroke);
+    if (endCap) disk(point, b, radius, stroke);
+  }
+}

package/src/geometry/setVertexColor.js

@@ -0,0 +1,15 @@
+/**
+ * Paints the vertices `[start, end)` of a mesh and marks its color buffer dirty.
+ * @param {Object} mesh Layer-created mesh with a color attribute.
+ * @param {number} start Inclusive vertex index, not an offset into the RGB array.
+ * @param {number} end Exclusive vertex index.
+ * @param {Object} color sRGB {r,g,b}, typically from parseColor().
+ */
+
+export function setVertexColor(mesh, start, end, color) {
+  let i;
+  for (i = start; i < end; i++) {
+    mesh.geometry.attributes.color.data.set([color.r, color.g, color.b], i * 3);
+  }
+  mesh.geometry.attributes.color.needsUpdate = true;
+}

package/src/geometry/sub.js

@@ -0,0 +1,6 @@
+export function sub(a, b) {
+  const result = [];
+  let i;
+  for (i = 0; i < a.length; i++) result.push(a[i] - b[i]);
+  return result;
+}

package/src/geometry/surface.js

@@ -0,0 +1,17 @@
+import { ring } from './treeRing.js';
+import { ringDirections } from '../constants/ringDirections.js';
+
+export function surface(point, addTriangle, lowRadius, low, highRadius, high, color) {
+  const lower = ring(point, lowRadius), upper = ring(point, highRadius);
+  let i, next, slope, length, nx, nz, ny, normalX, normalZ;
+  for (i = 0; i < 8; i++) {
+    next = (i + 1) % 8;
+    slope = (lowRadius - highRadius) / (high - low);
+    length = Math.hypot(1, slope);
+    ({ nx, nz } = ringDirections[i]);
+    ny = slope / length;
+    normalX = nx / length, normalZ = nz / length;
+    if (lowRadius) addTriangle(lower[i], low, lower[next], low, upper[next], high, normalX, ny, normalZ, color);
+    if (highRadius) addTriangle(lower[i], low, upper[next], high, upper[i], high, normalX, ny, normalZ, color);
+  }
+}

package/src/geometry/treeGeometry.js

@@ -0,0 +1,31 @@
+import { roundProfile } from '../constants/roundProfile.js';
+import { parseColor } from "../utils/parseColor.js";
+import { ring } from './treeRing.js';
+import { surface } from './surface.js';
+
+/** Low-poly tree, sharing the source block's buffers, picking and terrain offset. */
+
+export function treeGeometry(point, style, addTriangle) {
+  const { top, bottom = 0, trunkRadius, crownRadius, crownBottom, crownShape = 'round' } = style;
+  if (!Number.isFinite(trunkRadius) || !Number.isFinite(crownRadius) || !Number.isFinite(crownBottom) ||
+    trunkRadius <= 0 || crownRadius < trunkRadius || crownBottom <= bottom || crownBottom >= top ||
+    !['round', 'cone'].includes(crownShape)) {
+    throw new Error('Invalid tree dimensions or crown shape');
+  }
+  const trunk = parseColor(style.trunkColor ?? 0x72513a);
+  const crown = parseColor(style.color ?? 0x4f823b);
+  surface(point, addTriangle, trunkRadius, bottom, trunkRadius, crownBottom + (top - crownBottom) * 0.25, trunk);
+  let i, low, lr, high, hr;
+  if (crownShape === 'cone') {
+    const base = ring(point, crownRadius);
+    for (i = 0; i < 8; i++) addTriangle(point, crownBottom, base[i], crownBottom,
+      base[(i + 1) % 8], crownBottom, 0, -1, 0, crown);
+    surface(point, addTriangle, crownRadius, crownBottom, 0, top, crown);
+  } else {
+    for (i = 1; i < roundProfile.length; i++) {
+      [low, lr] = roundProfile[i - 1], [high, hr] = roundProfile[i];
+      surface(point, addTriangle, lr * crownRadius, crownBottom + low * (top - crownBottom),
+        hr * crownRadius, crownBottom + high * (top - crownBottom), crown);
+    }
+  }
+}

package/src/geometry/treeRing.js

@@ -0,0 +1,14 @@
+import { ringDirections } from '../constants/ringDirections.js';
+
+export function ring(point, radius) {
+  const result = [];
+  let direction;
+  for (direction of ringDirections) {
+    result.push({
+      x: point.x + direction.x * radius,
+      y: point.y + direction.y * radius,
+      ground: point.ground,
+    });
+  }
+  return result;
+}

package/src/geometry/triangle.js

@@ -0,0 +1,12 @@
+export function triangle(position, normal, color, a, b, c, tint) {
+  const u = [], v = [];
+  let i, point, value;
+  for (i = 0; i < b.length; i++) u.push(b[i] - a[i]);
+  for (i = 0; i < c.length; i++) v.push(c[i] - a[i]);
+  const n = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]], length = Math.hypot(...n);
+  for (point of [a, b, c]) {
+    position.push(...point);
+    for (value of n) normal.push(value / length);
+    color.push(...tint);
+  }
+}