leaflet-city-mapper 0.0.8 → 0.1.0

package/README.md

@@ -24,7 +24,7 @@ Just load Leaflet before this plugin:
 ```html
 <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9/dist/leaflet.css">
 <script src="https://unpkg.com/leaflet@1.9/dist/leaflet.js"></script>
-<script src="https://unpkg.com/leaflet-city-mapper@0.0.8/dist/leaflet-city-mapper.js"></script>
+<script src="https://unpkg.com/leaflet-city-mapper@0.1.0/dist/leaflet-city-mapper.js"></script>
 ```
 
 And then create a native `L.Layer`:
@@ -88,51 +88,11 @@ npm run test  # build and run browser tests
 
 After that you can start developing inside the `src` folder (eg. open "http://localhost:8080/examples" in your browser to preview changes).
 
-### Source layout
-
-```text
-src/
-  index.js           Public entry point and source registration
-  globals/           One shared constant or mutable cell per module
-  weakmaps/          One private WeakMap per map/layer state field
-  mvt/               PBF vector tile decoding and tessellation
-  vector-style/      Safe vector style parsing and expressions
-  vector-tiles/      Native vector tile lifecycle and worker preparation
-  camera/            Leaflet camera API and scene camera state
-  controls/          Compass, dragging, touch and resizing
-  core/              Leaflet hooks, camera-aware overlays and readiness
-  native/            Native Leaflet layers rendered through WebGPU
-  layer-controls/    Layer entry placement and progress indicators
-  scene/             Source routing, lifecycle and graph nodes
-  sources/           GeoJSON and streamed source loading and assembly
-  workers/           Geometry, MVT, COG and model tasks sharing one CDN-compatible worker
-  picking/           Raycasting, highlighting and feature interaction
-  rendering/         Frame stages, draw pipelines and mesh lifecycle
-  gpu/               Device initialization, renderer resources and diagnostics
-  materials/         Material programs, uniforms, glTF materials and cutouts
-  textures/          Image loading, texture upload/binding and roof atlases
-  animations/        Camera transitions, zoom synchronization and tile fading
-  shadows/           Directional shadow maps and cache
-  lighting/          Point lights and spatial light grids
-  shaders/           Material shader generation
-  geometry/          Mesh construction, bounds, grids, vectors and route geometry
-  projections/       Map, screen and local coordinate conversion
-  transforms/        Local/world matrices and glTF node transforms
-  triangulation/     Polygon triangulation and ring operations
-  collision/         Mesh intersection and collision queries
-  models/            glTF loading, decoding and scene assembly
-  archives/          PMTiles archive reading and decompression
-  cog/               Supported GeoTIFF directories, byte ranges and tile decoding
-  raster/            Raster tile loading, attachment and lifecycle
-  traffic/           Routes, scheduling, simulation, loading and rendering
-  vehicles/          Vehicle model geometry
-  terrain/           Terrain loading and sampling
-  astronomy/         Sun/moon position and observer/date validation
-  sunlight/          Sky, celestial display and time controls
-  walk/              First-person walking
-  colors/            Colour parsing, conversion, interpolation and formatting
-  utils/             Shared numeric and no-op helpers
-```
+### Repository guidance
+
+Folders structure and other conventions are documented in [here](.github/copilot-instructions.md).
+
+---
 
 **Compatibile with:**
 [![Leaflet 1.9.4 compatible!](https://img.shields.io/badge/Leaflet-1.9.4-1EB300.svg?style=flat)](http://leafletjs.com/reference.html) [![Leaflet 2.x compatible!](https://img.shields.io/badge/Leaflet-2.0.0--beta.3-1EB300.svg?style=flat)](http://leafletjs.com/reference.html)

package/dist/README.md

@@ -0,0 +1,18 @@
+# Distribution bundles
+
+[Project README](../README.md) | [Build guide](../build/README.md) | [Source guide](../src/README.md)
+
+```mermaid
+flowchart LR
+  Source["src/index.js"] --> Build["npm run build"]
+  Worker["src/workers/geometryWorker.js"] --> Build
+  Build --> Main["Main bundle: minified + source"]
+  Build --> WorkerBundle["Worker bundle: minified + source"]
+  Build --> Maps["Source maps"]
+  Main --> Browser["Leaflet application"]
+  WorkerBundle --> Browser
+```
+
+These are tracked build outputs, not the source of truth. Edit [src](../src/README.md)
+and regenerate with [build.js](../build/build.js), rather than hand-editing
+bundles. The main entry is configured in [package.json](../package.json).

package/dist/leaflet-city-mapper-src.js

@@ -4573,14 +4573,10 @@
       skyDirection: vec4<f32>,
       atmosphereTint: vec4<f32>,
     };
-    @group(0) @binding(0) var<uniform> u: Mesh;
-    @group(0) @binding(1) var<uniform> frame: Frame;
-    struct Solar { matrix: mat4x4<f32>, params: vec4<f32> };
-    @group(1) @binding(0) var<uniform> solar: Solar;
-    ${hasTerrain ? (
-        /* wgsl */
-        `@group(0) @binding(2) var dem: texture_2d<f32>;${elevationWGSL2}`
-      ) : ""}
+    struct Solar {
+      matrix: mat4x4<f32>,
+      params: vec4<f32>
+    };
     struct VertexInput {
       @location(0) position: vec3<f32>,
       @location(1) normal: vec3<f32>,
@@ -4599,6 +4595,13 @@
       ${textured ? "@location(3) uv: vec2<f32>," : ""}
       ${hasRoof ? "@location(4) roofUv: vec2<f32>, @location(5) roof: f32," : ""}
     };
+    @group(0) @binding(0) var<uniform> u: Mesh;
+    @group(0) @binding(1) var<uniform> frame: Frame;
+    @group(1) @binding(0) var<uniform> solar: Solar;
+    ${hasTerrain ? (
+        /* wgsl */
+        `@group(0) @binding(2) var dem: texture_2d<f32>;${elevationWGSL2}`
+      ) : ""}
     @vertex fn vertexMain(input: VertexInput, @builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
       var output: VertexOutput;
       var position = input.position${instanceOffset};
@@ -4610,8 +4613,7 @@
       // Inverse-transpose from cofactors; the camera view matrix is orthonormal.
       let m = mat3x3<f32>(u.worldMatrix[0].xyz, u.worldMatrix[1].xyz, u.worldMatrix[2].xyz);
       ${stroke.normal}
-      let normal = (cross(m[1], m[2]) * sourceNormal.x + cross(m[2], m[0]) * sourceNormal.y +
-        cross(m[0], m[1]) * sourceNormal.z) / determinant(m);
+      let normal = (cross(m[1], m[2]) * sourceNormal.x + cross(m[2], m[0]) * sourceNormal.y + cross(m[0], m[1]) * sourceNormal.z) / determinant(m);
       output.normal = (frame.viewMatrix * vec4<f32>(normal, 0.0)).xyz;
       let world = u.worldMatrix * vec4<f32>(position, 1.0);
       output.shadowPosition = solar.matrix * world;
@@ -8687,6 +8689,11 @@
   var TimeControl = class extends extendLeafletClass(L.Control) {
     static initHooks = true;
     static defaultOptions = { position: "bottomright" };
+    /**
+     * Initialize the time control and its hooks explicitly when using Leaflet 2.
+     *
+     * @param {Object} options Time control options.
+     */
     constructor(options) {
       super(options);
       if (L.version.startsWith("2.")) {
@@ -9724,7 +9731,8 @@
       {
         id: feature.id ?? feature.properties?.objectid ?? JSON.stringify(geometry),
         properties: feature.properties,
-        baseColor
+        baseColor,
+        polygon: geometry.type === "Polygon" || geometry.type === "MultiPolygon"
       }
     );
   }
@@ -11388,6 +11396,28 @@
   // src/weakmaps/colliders.js
   var colliders = /* @__PURE__ */ new WeakMap();
 
+  // src/collision/advanceFeature.js
+  function advanceFeature(ranges, feature, face) {
+    while (ranges && feature < ranges.length && face >= ranges[feature].faceEnd) feature++;
+    return feature;
+  }
+
+  // src/collision/cachedCollider.js
+  function cachedCollider(mesh) {
+    const c = colliders.get(mesh), m = mesh.worldMatrix;
+    if (!c || c.geometry !== mesh.geometry) return void 0;
+    let i;
+    for (i = 0; i < 12; i++) {
+      if (i % 4 !== 3 && c.matrix[i] !== m[i]) return void 0;
+    }
+    return c;
+  }
+
+  // src/collision/flipsNormal.js
+  function flipsNormal(m, data, j, nx, nz) {
+    return (m[0] * data[j] + m[4] * data[j + 1] + m[8] * data[j + 2]) * nx + (m[2] * data[j] + m[6] * data[j + 1] + m[10] * data[j + 2]) * nz < 0;
+  }
+
   // src/collision/indexTriangle.js
   function indexTriangle(cells, v, t) {
     let ix, iz, key;
@@ -11403,11 +11433,23 @@
       }
   }
 
+  // src/collision/transformVertices.js
+  function transformVertices(v, a, b, d, m) {
+    let k, p;
+    for (k = 0; k < 3; k++) {
+      p = k === 0 ? a : k === 1 ? b : d;
+      v[k * 3] = m[0] * p[0] + m[4] * p[1] + m[8] * p[2] + m[12];
+      v[k * 3 + 1] = m[1] * p[0] + m[5] * p[1] + m[9] * p[2] + m[13];
+      v[k * 3 + 2] = m[2] * p[0] + m[6] * p[1] + m[10] * p[2] + m[14];
+    }
+  }
+
   // src/collision/collider.js
   function collider(mesh) {
-    let c = colliders.get(mesh.geometry);
-    if (c) return c;
-    const m = mesh.worldMatrix, { position, index, normal, uv, instanceOffset } = mesh.geometry.attributes;
+    const m = mesh.worldMatrix;
+    const cached = cachedCollider(mesh);
+    if (cached) return cached;
+    const { position, index, normal, uv, instanceOffset } = mesh.geometry.attributes;
     const vertices = vertexCount(position, index);
     const count = vertices * (instanceOffset?.count ?? 1);
     const tri = (
@@ -11418,6 +11460,10 @@
       /* alloc */
       []
     );
+    const features = (
+      /* alloc */
+      []
+    );
     const cells = (
       /* alloc */
       /* @__PURE__ */ new Map()
@@ -11436,22 +11482,16 @@
       /* alloc */
       []
     );
-    let i, first, j, ex, ey, ez, fx, fy, fz, nx, nz, ny, length, h, t, maxX = -Infinity;
+    const ranges = mesh.extras?.featureFaces;
+    let i, first, j, ex, ey, ez, fx, fy, fz, nx, nz, ny, length, h, t, feature = 0, maxX = -Infinity;
     for (i = 0; i < count; i += 3) {
+      feature = advanceFeature(ranges, feature, i / 3);
       first = index ? index.data[i % vertices] : i % vertices;
       if (mesh.program.nightLight && uv && uv.data[first * 2] <= 2) {
         continue;
       }
       readTriangle(mesh, i, a, b, d);
-      v[0] = m[0] * a[0] + m[4] * a[1] + m[8] * a[2] + m[12];
-      v[1] = m[1] * a[0] + m[5] * a[1] + m[9] * a[2] + m[13];
-      v[2] = m[2] * a[0] + m[6] * a[1] + m[10] * a[2] + m[14];
-      v[3] = m[0] * b[0] + m[4] * b[1] + m[8] * b[2] + m[12];
-      v[4] = m[1] * b[0] + m[5] * b[1] + m[9] * b[2] + m[13];
-      v[5] = m[2] * b[0] + m[6] * b[1] + m[10] * b[2] + m[14];
-      v[6] = m[0] * d[0] + m[4] * d[1] + m[8] * d[2] + m[12];
-      v[7] = m[1] * d[0] + m[5] * d[1] + m[9] * d[2] + m[13];
-      v[8] = m[2] * d[0] + m[6] * d[1] + m[10] * d[2] + m[14];
+      transformVertices(v, a, b, d, m);
       ex = v[3] - v[0], ey = v[4] - v[1], ez = v[5] - v[2], fx = v[6] - v[0], fy = v[7] - v[1], fz = v[8] - v[2];
       nx = ey * fz - ez * fy, nz = ex * fy - ey * fx;
       ny = ez * fx - ex * fz, length = Math.hypot(nx, ny, nz);
@@ -11460,7 +11500,7 @@
       }
       if (normal) {
         j = first * 3;
-        if ((m[0] * normal.data[j] + m[4] * normal.data[j + 1] + m[8] * normal.data[j + 2]) * nx + (m[2] * normal.data[j] + m[6] * normal.data[j + 1] + m[10] * normal.data[j + 2]) * nz < 0) {
+        if (flipsNormal(m, normal.data, j, nx, nz)) {
           nx = -nx;
           nz = -nz;
         }
@@ -11469,20 +11509,27 @@
       tri.push(...v);
       maxX = Math.max(maxX, v[0], v[3], v[6]);
       nrm.push(nx / h, nz / h);
+      features.push(ranges ? feature : instanceOffset ? Math.floor(i / vertices) : 0);
       indexTriangle(cells, v, t);
     }
-    c = /* alloc */
-    {
-      tri: Float32Array.from(tri),
-      nrm: Float32Array.from(nrm),
-      cells,
-      maxX,
-      origin: (
-        /* alloc */
-        [m[12], m[13], m[14]]
-      )
-    };
-    colliders.set(mesh.geometry, c);
+    const c = (
+      /* alloc */
+      {
+        tri: Float32Array.from(tri),
+        nrm: Float32Array.from(nrm),
+        features: Uint32Array.from(features),
+        ranges,
+        cells,
+        maxX,
+        geometry: mesh.geometry,
+        matrix: Array.from(m),
+        origin: (
+          /* alloc */
+          [m[12], m[13], m[14]]
+        )
+      }
+    );
+    colliders.set(mesh, c);
     return c;
   }
 
@@ -11501,34 +11548,74 @@
 
   // src/collision/collectIntersections.js
   function collectIntersections(shape, x, y, z, seen, hits, end, iz) {
-    let ix, cell, triangle3, distance;
+    const { tri, features, ranges } = shape;
+    let ix, cell, triangle3, distance, feature, i, ax, az, bx, bz, cx, cz, ab, ac, bc;
     for (ix = Math.floor(x / CELL); ix <= end; ix++) {
       cell = shape.cells.get(`${ix},${iz}`);
       if (!cell) continue;
       for (triangle3 of cell) {
         if (seen.has(triangle3)) continue;
         seen.add(triangle3);
-        distance = horizontalRay(shape.tri, triangle3, x, y, z, 1, 0);
-        if (distance > 1e-4) hits.push(distance);
+        feature = features[triangle3];
+        distance = horizontalRay(tri, triangle3, x, y, z, 1, 0);
+        if (distance > 1e-4) hits.push(feature * 2, distance);
+        if (!ranges?.[feature]?.polygon) continue;
+        i = triangle3 * 9;
+        ax = tri[i], az = tri[i + 2], bx = tri[i + 3], bz = tri[i + 5], cx = tri[i + 6], cz = tri[i + 8];
+        ab = (ax - bx) ** 2 + (az - bz) ** 2;
+        ac = (ax - cx) ** 2 + (az - cz) ** 2;
+        bc = (bx - cx) ** 2 + (bz - cz) ** 2;
+        if (ac > ab && ac >= bc) bx = cx, bz = cz;
+        else if (bc > ab && bc > ac) ax = bx, az = bz, bx = cx, bz = cz;
+        if (az > z === bz > z) continue;
+        distance = ax + (z - az) * (bx - ax) / (bz - az) - x;
+        if (distance > 1e-4) hits.push(feature * 2 + 1, distance);
       }
     }
   }
 
+  // src/collision/enclosesOrigin.js
+  function enclosesOrigin(height, footprint, ranges, feature) {
+    return Boolean(height && (!ranges?.[feature]?.polygon || footprint));
+  }
+
+  // src/collision/sortCrossings.js
+  function sortCrossings(hits) {
+    let ix, j, feature, distance;
+    for (ix = 2; ix < hits.length; ix += 2) {
+      feature = hits[ix], distance = hits[ix + 1];
+      j = ix - 2;
+      while (j >= 0 && (hits[j] > feature || hits[j] === feature && hits[j + 1] > distance)) {
+        hits[j + 2] = hits[j], hits[j + 3] = hits[j + 1];
+        j -= 2;
+      }
+      hits[j + 2] = feature, hits[j + 3] = distance;
+    }
+  }
+
   // src/collision/countCrossings.js
-  function countCrossings(hits) {
-    let ix, j, distance;
-    for (ix = 1; ix < hits.length; ix++) {
-      distance = hits[ix];
-      j = ix - 1;
-      while (j >= 0 && hits[j] > distance) hits[j + 1] = hits[j--];
-      hits[j + 1] = distance;
-    }
-    let crossings = 0, previous = -Infinity;
-    for (distance of hits) {
-      if (distance - previous > 1e-4) crossings++;
+  function countCrossings(hits, ranges) {
+    sortCrossings(hits);
+    let crossings = 0, enclosed = 0, previous = -Infinity, previousKey = -1, previousFeature = -1, height = 0, footprint = 0;
+    let ix, key, feature, distance;
+    for (ix = 0; ix <= hits.length; ix += 2) {
+      key = ix < hits.length ? hits[ix] : -1;
+      feature = Math.floor(key / 2);
+      if (key !== previousKey && previousKey >= 0) {
+        if (previousKey % 2) footprint = crossings % 2;
+        else height = crossings % 2;
+      }
+      if (key !== previousKey && previousKey >= 0 && feature !== previousFeature) {
+        enclosed += Number(enclosesOrigin(height, footprint, ranges, previousFeature));
+        height = 0, footprint = 0;
+      }
+      if (key !== previousKey) crossings = 0, previous = -Infinity, previousKey = key, previousFeature = feature;
+      if (ix === hits.length) break;
+      distance = hits[ix + 1];
+      if (distance - previous > (key % 2 ? 1e-3 : 1e-4)) crossings++;
       previous = distance;
     }
-    return crossings;
+    return enclosed;
   }
 
   // src/collision/insideMesh.js
@@ -11549,6 +11636,9 @@
     );
     if (Math.hypot(cx - x, cy - y, cz - z) > radius) return false;
     const shape = collider(mesh);
+    x += shape.origin[0] - world[12];
+    y += shape.origin[1] - world[13];
+    z += shape.origin[2] - world[14];
     const end = Math.floor(shape.maxX / CELL);
     if (x >= shape.maxX) return false;
     const iz = Math.floor(z / CELL);
@@ -11556,69 +11646,131 @@
     hits.length = 0;
     seen.clear();
     collectIntersections(shape, x, y, z, seen, hits, end, iz);
-    return countCrossings(hits) % 2 === 1;
+    return countCrossings(hits, shape.ranges) > 0;
   }
 
-  // src/collision/setTrafficNormal.js
-  function setTrafficNormal(data, x, z, distance, dx, dz) {
-    if (distance < 1e-6) {
-      data.normal[0] = -dx;
-      data.normal[1] = -dz;
-    } else {
-      data.normal[0] = x / distance;
-      data.normal[1] = z / distance;
+  // src/collision/boxNormal.js
+  function boxNormal(entry, xFirst, ox, oz, ux, uz, bounds, margin, out) {
+    if (entry >= 0) {
+      out[0] = xFirst ? -Math.sign(ux) : 0;
+      out[1] = xFirst ? 0 : -Math.sign(uz);
+      return;
+    }
+    let nearest = ox - (bounds.minX - margin);
+    out[0] = -1;
+    out[1] = 0;
+    if (bounds.maxX + margin - ox < nearest) {
+      nearest = bounds.maxX + margin - ox;
+      out[0] = 1;
+    }
+    if (oz - (bounds.minZ - margin) < nearest) {
+      nearest = oz - (bounds.minZ - margin);
+      out[0] = 0;
+      out[1] = -1;
+    }
+    if (bounds.maxZ + margin - oz < nearest) {
+      out[0] = 0;
+      out[1] = 1;
+    }
+  }
+
+  // src/collision/trafficRay.js
+  function trafficRay(root, position, x, z, dx, dz, px, pz, out) {
+    const rx = (x - root.position[0]) / root.scale[0] - px;
+    const rz = (z - root.position[2]) / root.scale[2] - pz;
+    out[0] = -rx * position.dz + rz * position.dx;
+    out[1] = -rx * position.dx - rz * position.dz;
+    out[2] = -dx / root.scale[0] * position.dz + dz / root.scale[2] * position.dx;
+    out[3] = -dx / root.scale[0] * position.dx - dz / root.scale[2] * position.dz;
+  }
+
+  // src/collision/missesBox.js
+  function missesBox(entry, exit, reach, best) {
+    return entry > exit || exit < 0 || entry > reach || reach && Math.max(0, entry) >= best;
+  }
+
+  // src/collision/slabDistance.js
+  function slabDistance(origin, velocity, low, high, parallel) {
+    return velocity ? ((velocity > 0 ? low : high) - origin) / velocity : parallel;
+  }
+
+  // src/collision/slabMiss.js
+  function slabMiss(origin, velocity, min, max, margin) {
+    return !velocity && (origin <= min - margin || origin >= max + margin);
+  }
+
+  // src/collision/collideTrip.js
+  function collideTrip(state, trip, root, bounds, x, y, z, dx, dz, reach, data) {
+    const position = state.position ||= /* alloc */
+    {};
+    const ray = state.ray ||= /* alloc */
+    [0, 0, 0, 0];
+    const normal = state.localNormal ||= /* alloc */
+    [0, 0];
+    const scale = Math.max(root.scale[0], root.scale[1], root.scale[2]);
+    const margin = 0.35 / scale;
+    const { x: px, y: py, z: pz } = locateTraffic(state, trip, position);
+    const bottom = root.position[1] + (py + bounds.minY) * root.scale[1];
+    const top = root.position[1] + (position.y + bounds.maxY) * root.scale[1];
+    if (bottom > y + 1.7 * scale || top < y + 0.2 * scale) return;
+    trafficRay(root, position, x, z, dx, dz, px, pz, ray);
+    const ox = ray[0], oz = ray[1], ux = ray[2], uz = ray[3];
+    if (slabMiss(ox, ux, bounds.minX, bounds.maxX, margin) || slabMiss(oz, uz, bounds.minZ, bounds.maxZ, margin)) return;
+    const nearX = slabDistance(ox, ux, bounds.minX - margin, bounds.maxX + margin, -Infinity);
+    const farX = slabDistance(ox, ux, bounds.maxX + margin, bounds.minX - margin, Infinity);
+    const nearZ = slabDistance(oz, uz, bounds.minZ - margin, bounds.maxZ + margin, -Infinity);
+    const farZ = slabDistance(oz, uz, bounds.maxZ + margin, bounds.minZ - margin, Infinity);
+    const entry = Math.max(nearX, nearZ);
+    if (missesBox(entry, Math.min(farX, farZ), reach, data.best)) return;
+    if (!reach) {
+      data.found = true;
+      return;
     }
+    boxNormal(entry, nearX > nearZ, ox, oz, ux, uz, bounds, margin, normal);
+    const worldX = (-normal[0] * position.dz - normal[1] * position.dx) / root.scale[0];
+    const worldZ = (normal[0] * position.dx - normal[1] * position.dz) / root.scale[2];
+    if (entry < 0 && dx * worldX + dz * worldZ >= 0) return;
+    const length = Math.hypot(worldX, worldZ);
+    data.best = Math.max(0, entry);
+    data.found = true;
+    data.normal[0] = worldX / length;
+    data.normal[1] = worldZ / length;
+  }
+
+  // src/collision/trafficBounds.js
+  function trafficBounds(state) {
+    if (state.collisionBounds) return state.collisionBounds;
+    const bounds = state.collisionBounds = /* alloc */
+    {
+      minX: Infinity,
+      maxX: -Infinity,
+      minY: Infinity,
+      maxY: -Infinity,
+      minZ: Infinity,
+      maxZ: -Infinity
+    };
+    const position = state.template.position;
+    let i;
+    for (i = 0; i < position.length; i += 3) {
+      bounds.minX = Math.min(bounds.minX, position[i]);
+      bounds.maxX = Math.max(bounds.maxX, position[i]);
+      bounds.minY = Math.min(bounds.minY, position[i + 1]);
+      bounds.maxY = Math.max(bounds.maxY, position[i + 1]);
+      bounds.minZ = Math.min(bounds.minZ, position[i + 2]);
+      bounds.maxZ = Math.max(bounds.maxZ, position[i + 2]);
+    }
+    return bounds;
   }
 
   // src/collision/trafficCollision.js
   function trafficCollision(layer, x, y, z, dx, dz, reach, data) {
     const state = trafficByLayer.get(layer);
     if (!state?.mesh || !state.trips.length) return false;
-    let bounds = state.collisionBounds;
-    if (!bounds) {
-      bounds = state.collisionBounds = /* alloc */
-      { radius: 0, minY: Infinity, maxY: -Infinity };
-      let i, px2, py, pz2;
-      for (i = 0; i < state.template.position.length; i += 3) {
-        px2 = state.template.position[i];
-        py = state.template.position[i + 1];
-        pz2 = state.template.position[i + 2];
-        bounds.radius = Math.max(bounds.radius, Math.hypot(px2, pz2));
-        bounds.minY = Math.min(bounds.minY, py);
-        bounds.maxY = Math.max(bounds.maxY, py);
-      }
-    }
-    const root = rootByLayer.get(layer), position = state.position ||= /* alloc */
-    {};
-    const scale = Math.max(root.scale[0], root.scale[1], root.scale[2]);
-    const radius = bounds.radius * scale + 0.35;
-    let trip, projection, closest, rx, rz, perpendicular, entry, distance, bottom, top, px, pz;
+    const root = rootByLayer.get(layer), bounds = trafficBounds(state);
+    let trip;
     for (trip of state.trips) {
-      ({ x: px, y: bottom, z: pz } = locateTraffic(state, trip, position));
-      bottom = root.position[1] + (bottom + bounds.minY) * root.scale[1];
-      top = root.position[1] + (position.y + bounds.maxY) * root.scale[1];
-      if (bottom > y + 1.7 * scale || top < y + 0.2 * scale) continue;
-      px = root.position[0] + px * root.scale[0];
-      pz = root.position[2] + pz * root.scale[2];
-      projection = (px - x) * dx + (pz - z) * dz;
-      closest = Math.max(0, Math.min(reach, projection));
-      rx = x + closest * dx - px;
-      rz = z + closest * dz - pz;
-      perpendicular = rx * rx + rz * rz;
-      if (perpendicular >= radius * radius) continue;
-      if (reach === 0) {
-        data.found = true;
-        distance = Math.hypot(x - px, z - pz);
-        data.normal[0] = distance ? (x - px) / distance : 0;
-        data.normal[1] = distance ? (z - pz) / distance : 0;
-        continue;
-      }
-      entry = Math.max(0, projection - Math.sqrt(radius * radius - perpendicular));
-      if (entry > reach || entry >= data.best) continue;
-      data.best = entry;
-      data.found = true;
-      distance = Math.hypot(x + entry * dx - px, z + entry * dz - pz);
-      setTrafficNormal(data, x + entry * dx - px, z + entry * dz - pz, distance, dx, dz);
+      collideTrip(state, trip, root, bounds, x, y, z, dx, dz, reach, data);
+      if (!reach && data.found) break;
     }
     return data.found;
   }
@@ -11806,10 +11958,22 @@
     for (i = 0; i < feet.length; i++) feet[i] = position[i] + scale[i] * feet[i];
     const wall = blocked.call(this, east, north, feet);
     if (wall) {
-      const into = east * wall[0] - north * wall[1];
+      const fraction = Math.max(0, Math.min(1, (this.hitData.best - 0.3) / Math.hypot(east, north)));
+      const movedEast = east * fraction, movedNorth = north * fraction;
+      feet[0] += movedEast;
+      feet[2] -= movedNorth;
+      east -= movedEast;
+      north -= movedNorth;
+      const into = Math.min(0, east * wall[0] - north * wall[1]);
       east -= into * wall[0];
       north += into * wall[1];
-      if (blocked.call(this, east, north, feet)) east = north = 0;
+      if (blocked.call(this, east, north, feet)) {
+        const slide = Math.max(0, Math.min(1, (this.hitData.best - 0.3) / Math.hypot(east, north)));
+        east *= slide;
+        north *= slide;
+      }
+      east += movedEast;
+      north += movedNorth;
     }
     this.state.latlng = /* alloc */
     new L.LatLng(lat + north / 111320, lng + east / (111320 * Math.cos(lat * radians)));
@@ -12087,6 +12251,11 @@
   var WalkControl = class extends extendLeafletClass(L.Control) {
     static initHooks = true;
     static defaultOptions = { position: "bottomright", speed: 70, distance: 20 };
+    /**
+     * Initialize the control and its hooks explicitly when using Leaflet 2.
+     *
+     * @param {Object} options Walk control options.
+     */
     constructor(options) {
       super(options);
       if (L.version.startsWith("2.")) {
@@ -16093,7 +16262,7 @@
   }
 
   // src/traffic/trafficBounds.js
-  function trafficBounds(state) {
+  function trafficBounds2(state) {
     let radius = 20, height = 5;
     let i, lane, x, z, y;
     for (i = 0; i < state.template.position.length; i += 3) {
@@ -16176,7 +16345,7 @@
     );
     state.mesh.geometry.drawRange.count = count;
     state.mesh.extras.dynamicLights = true;
-    trafficBounds(state);
+    trafficBounds2(state);
   }
 
   // src/traffic/trafficStorage.js
@@ -16582,7 +16751,7 @@
     groundTraffic(state);
     disposeTrafficObject(state, state.route);
     state.route = null;
-    if (state.mesh) trafficBounds(state);
+    if (state.mesh) trafficBounds2(state);
     if (!state.frame) state.tick();
   }