fix(recast): use chf.areas[] instead of stale spans[].area in contour building

After erode_walkable_area runs, chf.areas[i] is zeroed for eroded spans
but chf.spans[i].area retains the pre-erosion value. The contour building
code used the stale spans[i].area for area border detection, causing
RC_AREA_BORDER (0x20000) to never be set on contour vertices. This
affected simplify_contour anchor selection, changing vertex order,
triangulation, and polygon merge decisions.

Bug #27: polymesh.rs used contour.vertices[0].region instead of
contour.region for polygon region assignment.

Bug #28: merge_holes calculated winding for contours with < 3 vertices;
C++ skips these entirely.

Bug #29: All spans[i].area references in contour.rs replaced with
chf.areas[i] in walk_contour, get_corner_height, build_contours,
build_regions, and flood_fill_region.

Results after fix:
- nav_test: 537 polys, 2228 detail verts (exact C++ match, was 530/2207)
- dungeon: 216 polys (C++ 217), 866 detail verts (C++ 868), 434 tris (exact)
- bridge: exact match

Author: danielsreichenbach

crates/detour/tests/integration.rs

@@ -143,9 +143,9 @@ fn dungeon_find_nearest_poly_center() {
     let (poly_ref, snapped) = result.unwrap();
     assert!(poly_ref.is_valid());
 
-    // After box blur fix
+    // After area border flag fix (Bug #29)
     assert!((snapped.x - 12.1450).abs() < 0.01);
-    assert!((snapped.y - 10.3973).abs() < 0.01);
+    assert!((snapped.y - 10.3074).abs() < 0.01);
     assert!((snapped.z - (-40.5750)).abs() < 0.01);
 }
 

crates/recast/src/contour.rs

@@ -479,9 +479,9 @@ impl ContourSet {
         let mut current_region_id = 1u16;
         let mut regions_created = 0;
 
-        for (span_idx, span) in chf.spans.iter().enumerate() {
+        for span_idx in 0..chf.spans.len() {
             // Skip non-walkable spans or already assigned spans
-            if span.area == 0 || region_ids[span_idx] != 0 {
+            if chf.areas[span_idx] == 0 || region_ids[span_idx] != 0 {
                 continue;
             }
 
@@ -557,10 +557,8 @@ impl ContourSet {
                 continue;
             }
 
-            let span = &chf.spans[span_idx];
-
             // Skip unwalkable spans
-            if span.area == 0 {
+            if chf.areas[span_idx] == 0 {
                 continue;
             }
 
@@ -571,10 +569,8 @@ impl ContourSet {
             // Using 8-direction constants: N=1, E=3, S=5, W=7
             for dir in [1u8, 3u8, 5u8, 7u8] {
                 if let Some(neighbor_idx) = chf.get_neighbor(span_idx, dir) {
-                    let neighbor_span = &chf.spans[neighbor_idx];
-
                     // Add to stack if not assigned and walkable
-                    if region_ids[neighbor_idx] == 0 && neighbor_span.area != 0 {
+                    if region_ids[neighbor_idx] == 0 && chf.areas[neighbor_idx] != 0 {
                         stack.push(neighbor_idx);
                     }
                 }
@@ -731,7 +727,7 @@ impl ContourSet {
                             continue;
                         }
 
-                        let area = chf.spans[span_idx].area;
+                        let area = chf.areas[span_idx];
                         contours_attempted += 1;
 
                         // Trace and simplify contour
@@ -834,7 +830,7 @@ impl ContourSet {
 
         // Combine region and area codes to prevent border vertices between areas
         // from being removed
-        regs[0] = region_ids[i] as u32 | ((span.area as u32) << 16);
+        regs[0] = region_ids[i] as u32 | ((chf.areas[i] as u32) << 16);
 
         // Check neighbor in dir direction
         if span.con[dir as usize] != RC_NOT_CONNECTED {
@@ -844,7 +840,7 @@ impl ContourSet {
                 let ai = base_idx + span.con[dir as usize];
                 let as_ = &chf.spans[ai];
                 ch = ch.max(as_.y);
-                regs[1] = region_ids[ai] as u32 | ((as_.area as u32) << 16);
+                regs[1] = region_ids[ai] as u32 | ((chf.areas[ai] as u32) << 16);
 
                 // Check diagonal neighbor (from ai in dirp)
                 if as_.con[dirp] != RC_NOT_CONNECTED {
@@ -854,7 +850,7 @@ impl ContourSet {
                         let ai2 = base_idx2 + as_.con[dirp];
                         let as2 = &chf.spans[ai2];
                         ch = ch.max(as2.y);
-                        regs[2] = region_ids[ai2] as u32 | ((as2.area as u32) << 16);
+                        regs[2] = region_ids[ai2] as u32 | ((chf.areas[ai2] as u32) << 16);
                     }
                 }
             }
@@ -868,7 +864,7 @@ impl ContourSet {
                 let ai = base_idx + span.con[dirp];
                 let as_ = &chf.spans[ai];
                 ch = ch.max(as_.y);
-                regs[3] = region_ids[ai] as u32 | ((as_.area as u32) << 16);
+                regs[3] = region_ids[ai] as u32 | ((chf.areas[ai] as u32) << 16);
 
                 // Check diagonal neighbor (from ai in dir)
                 if as_.con[dir as usize] != RC_NOT_CONNECTED {
@@ -878,7 +874,7 @@ impl ContourSet {
                         let ai2 = base_idx2 + as_.con[dir as usize];
                         let as2 = &chf.spans[ai2];
                         ch = ch.max(as2.y);
-                        regs[2] = region_ids[ai2] as u32 | ((as2.area as u32) << 16);
+                        regs[2] = region_ids[ai2] as u32 | ((chf.areas[ai2] as u32) << 16);
                     }
                 }
             }
@@ -931,7 +927,7 @@ impl ContourSet {
 
         let start_dir = dir;
         let start_i = i;
-        let area = chf.spans[i].area;
+        let area = chf.areas[i];
 
         let mut iter = 0;
         let mut cur_x = x;
@@ -974,7 +970,7 @@ impl ContourSet {
                 let _span = &chf.spans[cur_i];
                 if let Some(neighbor_idx) = chf.get_neighbor_connection(cur_i, dir as usize) {
                     r = region_ids[neighbor_idx] as i32;
-                    if area != chf.spans[neighbor_idx].area {
+                    if area != chf.areas[neighbor_idx] {
                         is_area_border = true;
                     }
                 }
@@ -1488,10 +1484,14 @@ impl ContourSet {
             return;
         }
 
-        // Calculate winding for each contour
+        // Calculate winding for each contour.
+        // C++ skips contours with nverts < 3 entirely (winding stays 0).
         let windings: Vec<i32> = contours
             .iter()
             .map(|c| {
+                if c.vertices.len() < 3 {
+                    return 0;
+                }
                 if Self::calc_area_of_polygon_2d(&c.vertices) < 0 {
                     -1
                 } else {
@@ -1511,12 +1511,16 @@ impl ContourSet {
             contours.len()
         );
 
-        // Group contours by region: outlines and holes
+        // Group contours by region: outlines and holes.
+        // Only process contours with non-zero winding (matches C++ nverts >= 3 check).
         let nregions = max_regions as usize + 1;
         let mut region_outlines: Vec<Option<usize>> = vec![None; nregions];
         let mut region_holes: Vec<Vec<usize>> = vec![Vec::new(); nregions];
 
         for (i, contour) in contours.iter().enumerate() {
+            if windings[i] == 0 {
+                continue;
+            }
             let reg = contour.region as usize;
             if reg >= nregions {
                 continue;

crates/recast/src/polymesh.rs

@@ -300,7 +300,7 @@ impl PolyMesh {
 
                 p[..nvp].copy_from_slice(q);
 
-                mesh.regs[mesh.npolys] = (contour.vertices[0].region & 0xffff) as u16;
+                mesh.regs[mesh.npolys] = contour.region;
                 mesh.areas[mesh.npolys] = contour.area;
                 mesh.npolys += 1;
 

crates/recast/tests/integration.rs

@@ -112,11 +112,11 @@ fn dungeon_generation_rust_output() {
     let (_, poly_mesh, detail_mesh, _) = build_mesh("dungeon.obj");
 
     // Current Rust output (regression test)
-    // After hole merging fix
+    // After area border flag fix (Bug #29)
     assert_eq!(poly_mesh.poly_count(), 216); // C++ 217 (0.995x)
     assert_eq!(poly_mesh.vert_count(), 452); // C++ 452 (exact)
-    assert_eq!(detail_mesh.vert_count(), 874); // C++ 868 (1.007x)
-    assert_eq!(detail_mesh.tri_count(), 447); // C++ 434 (1.03x)
+    assert_eq!(detail_mesh.vert_count(), 866); // C++ 868 (0.998x)
+    assert_eq!(detail_mesh.tri_count(), 434); // C++ 434 (exact)
 }
 
 #[test]

crates/recast/tests/pipeline_diagnostic.rs

@@ -218,6 +218,17 @@ fn run_pipeline_diagnostic(obj_name: &str) {
             sizes.iter().sum::<u32>()
         );
     }
+    // Per-region span counts
+    let mut reg_sizes: Vec<(u16, u32)> = region_span_counts
+        .iter()
+        .filter(|&(r, _)| *r > 0 && *r < 0x8000)
+        .map(|(&r, &c)| (r, c))
+        .collect();
+    reg_sizes.sort_by_key(|&(r, _)| r);
+    println!("  Per-region span counts:");
+    for &(reg, count) in &reg_sizes {
+        println!("    region {}: {} spans", reg, count);
+    }
     println!();
 
     // Stage 5: Contours
@@ -257,6 +268,20 @@ fn run_pipeline_diagnostic(obj_name: &str) {
         }
     );
 
+    // Dump all contour vertices for comparison with C++
+    for (i, c) in contour_set.contours.iter().enumerate() {
+        print!(
+            "contour[{}] reg={} nverts={}: ",
+            i,
+            c.region,
+            c.vertices.len()
+        );
+        for v in &c.vertices {
+            print!("({},{},{},{}) ", v.x, v.y, v.z, v.region);
+        }
+        println!();
+    }
+
     // Per-contour vertex counts (sorted) for C++ comparison
     let mut vert_counts: Vec<usize> = contour_set
         .contours
@@ -279,6 +304,58 @@ fn run_pipeline_diagnostic(obj_name: &str) {
     println!("  nverts: {}", poly_mesh.vert_count());
     println!("  npolys: {}", poly_mesh.poly_count());
     println!("  maxpolys: {}", poly_mesh.max_polys());
+
+    // Per-contour info for C++ comparison
+    println!("\n  Per-contour data (index, region, nverts):");
+    for (i, c) in contour_set.contours.iter().enumerate() {
+        println!(
+            "    cont[{}]: reg={} nverts={}",
+            i,
+            c.region,
+            c.vertices.len()
+        );
+    }
+
+    // Polys per region
+    let nvp = config.max_vertices_per_polygon as usize;
+    let mut polys_per_reg = std::collections::HashMap::new();
+    let regs = poly_mesh.regs();
+    for i in 0..poly_mesh.poly_count() {
+        *polys_per_reg.entry(regs[i]).or_insert(0u32) += 1;
+    }
+    let mut reg_list: Vec<_> = polys_per_reg.iter().collect();
+    reg_list.sort_by_key(|&(r, _)| *r);
+    println!("\n  Polys per region:");
+    for &(reg, count) in &reg_list {
+        println!("    region {}: {} polys", reg, count);
+    }
+
+    // Poly vertex count distribution
+    let polys_data = poly_mesh.polys();
+    let mut count3 = 0u32;
+    let mut count4 = 0u32;
+    let mut count5 = 0u32;
+    let mut count6 = 0u32;
+    for i in 0..poly_mesh.poly_count() {
+        let mut nv = 0;
+        for j in 0..nvp {
+            if polys_data[i * nvp * 2 + j] == 0xffff {
+                break;
+            }
+            nv += 1;
+        }
+        match nv {
+            3 => count3 += 1,
+            4 => count4 += 1,
+            5 => count5 += 1,
+            6 => count6 += 1,
+            _ => {}
+        }
+    }
+    println!(
+        "\n  Poly vertex counts: 3-vert: {}, 4-vert: {}, 5-vert: {}, 6-vert: {}",
+        count3, count4, count5, count6
+    );
     println!();
 
     // Stage 7: PolyMeshDetail