Merge pull request #1054 from louis-e/feat/water-depth

feat(water): per-cell water depth carving

Author: louis-e

.gitignore

@@ -30,8 +30,7 @@ Thumbs.db
 # Generated files
 /export.json
 /parsed_osm_data.txt
-/elevation_debug.png
-/landcover_debug*.png
+/*debug*.png
 /terrain-tile-cache
 /arnis-tile-cache
 

src/data_processing.rs

@@ -68,6 +68,9 @@ pub fn generate_world_with_options(
     };
     let ground = Arc::new(ground);
 
+    // Per-cell water depth field from the LC_WATER mask; empty without land cover.
+    let big_water_field = crate::water_depth::compute_big_water_field(&ground, &xzbbox);
+
     println!("{} Processing data...", "[4/7]".bold());
 
     // Build highway connectivity map once before processing
@@ -250,7 +253,13 @@ pub fn generate_world_with_options(
                 } else if let Some(val) = way.tags.get("waterway") {
                     if val == "dock" {
                         // docks count as water areas
-                        water_areas::generate_water_area_from_way(&mut editor, way, &xzbbox);
+                        water_areas::generate_water_area_from_way(
+                            &mut editor,
+                            way,
+                            &xzbbox,
+                            &big_water_field,
+                            &road_mask,
+                        );
                     } else {
                         waterways::generate_waterways(&mut editor, way);
                     }
@@ -349,7 +358,13 @@ pub fn generate_world_with_options(
                         .map(|val| val == "water" || val == "bay")
                         .unwrap_or(false)
                 {
-                    water_areas::generate_water_areas_from_relation(&mut editor, rel, &xzbbox);
+                    water_areas::generate_water_areas_from_relation(
+                        &mut editor,
+                        rel,
+                        &xzbbox,
+                        &big_water_field,
+                        &road_mask,
+                    );
                 } else if rel.tags.contains_key("natural") {
                     natural::generate_natural_from_relation(
                         &mut editor,
@@ -388,10 +403,9 @@ pub fn generate_world_with_options(
     process_pb.inc(element_counter % pb_batch_size);
     process_pb.finish();
 
-    // Drop remaining caches
+    // Keep road_mask alive for the LC_WATER carve below.
     drop(highway_connectivity);
     drop(flood_fill_cache);
-    drop(road_mask);
 
     // Generate ground layer (surface blocks, vegetation, shorelines, underground fill)
     ground_generation::generate_ground_layer(
@@ -402,6 +416,17 @@ pub fn generate_world_with_options(
         &building_footprints,
     )?;
 
+    // Carve depth into ESA water cells (water_areas.rs only covers OSM polygons).
+    crate::water_depth::carve_lc_water_pass(
+        &mut editor,
+        ground.as_ref(),
+        &xzbbox,
+        &big_water_field,
+        &road_mask,
+    );
+
+    drop(road_mask);
+
     // Carve subway tunnel interiors now that underground is filled with stone.
     // This must happen after ground generation so AIR blocks are not overwritten.
     if !subway_points.is_empty() {

src/element_processing/water_areas.rs

@@ -1,5 +1,6 @@
-use crate::block_definitions::WATER;
 use crate::clipping::clip_water_ring_to_bbox;
+use crate::floodfill_cache::RoadMaskBitmap;
+use crate::water_depth::{carve_water_column, BigWaterField};
 use crate::{
     coordinate_system::cartesian::{XZBBox, XZPoint},
     osm_parser::{ProcessedMemberRole, ProcessedNode, ProcessedRelation, ProcessedWay},
@@ -10,20 +11,24 @@ pub fn generate_water_area_from_way(
     editor: &mut WorldEditor,
     element: &ProcessedWay,
     _xzbbox: &XZBBox,
+    bwf: &BigWaterField,
+    road_mask: &RoadMaskBitmap,
 ) {
     let outers = [element.nodes.clone()];
     if !verify_closed_rings(&outers) {
         println!("Skipping way {} due to invalid polygon", element.id);
         return;
     }
 
-    generate_water_areas(editor, &outers, &[]);
+    generate_water_areas(editor, &outers, &[], bwf, road_mask);
 }
 
 pub fn generate_water_areas_from_relation(
     editor: &mut WorldEditor,
     element: &ProcessedRelation,
     xzbbox: &XZBBox,
+    bwf: &BigWaterField,
+    road_mask: &RoadMaskBitmap,
 ) {
     // Check if this is a water relation (either with water tag or natural=water)
     let is_water = element.tags.contains_key("water")
@@ -116,13 +121,15 @@ pub fn generate_water_areas_from_relation(
         return;
     }
 
-    generate_water_areas(editor, &outers, &inners);
+    generate_water_areas(editor, &outers, &inners, bwf, road_mask);
 }
 
 fn generate_water_areas(
     editor: &mut WorldEditor,
     outers: &[Vec<ProcessedNode>],
     inners: &[Vec<ProcessedNode>],
+    bwf: &BigWaterField,
+    road_mask: &RoadMaskBitmap,
 ) {
     // Calculate polygon bounding box to limit fill area
     let mut poly_min_x = i32::MAX;
@@ -161,7 +168,9 @@ fn generate_water_areas(
         .map(|x| x.iter().map(|y| y.xz()).collect::<Vec<_>>())
         .collect();
 
-    scanline_fill_water(min_x, min_z, max_x, max_z, &outers_xz, &inners_xz, editor);
+    scanline_fill_water(
+        min_x, min_z, max_x, max_z, &outers_xz, &inners_xz, editor, bwf, road_mask,
+    );
 }
 
 /// Verifies all rings are properly closed (first node matches last).
@@ -391,6 +400,8 @@ fn scanline_fill_water(
     outers: &[Vec<XZPoint>],
     inners: &[Vec<XZPoint>],
     editor: &mut WorldEditor,
+    bwf: &BigWaterField,
+    road_mask: &RoadMaskBitmap,
 ) {
     // Collect edges per outer ring so we can union their spans correctly,
     // even if multiple outer rings happen to overlap (invalid OSM, but
@@ -427,14 +438,18 @@ fn scanline_fill_water(
 
         for (start, end) in fill_spans {
             for x in start..=end {
+                // Keep road/bridge surfaces (carve would overwrite them).
+                if road_mask.contains(x, z) {
+                    continue;
+                }
                 let water_y = editor.get_water_level(x, z);
                 let ground_y = editor.get_ground_level(x, z);
-                // Only place water where terrain is at or below the water
-                // surface — skip hillside blocks where the polygon extends
-                // above the actual waterline.
-                if ground_y <= water_y {
-                    editor.set_block_absolute(WATER, x, water_y, z, None, None);
+                // Skip hillside blocks the polygon claims above the waterline.
+                if ground_y > water_y {
+                    continue;
                 }
+                // depth_at gives the carved depth (0 without land-cover water data).
+                carve_water_column(editor, x, z, water_y, bwf.depth_at(x, z));
             }
         }
     }

src/ground.rs

@@ -65,7 +65,7 @@ impl Ground {
         // post-processing pipeline for land-cover-aware artifact repair.
         // The elevation grid is built from the same (bbox, scale) so both
         // grids share dimensions (both use compute_grid_dims).
-        let (_, _, grid_w, grid_h) = compute_grid_dims(bbox, scale);
+        let (world_w, world_h, grid_w, grid_h) = compute_grid_dims(bbox, scale);
         let mut land_cover = if fetch_land_cover {
             let lc = land_cover::fetch_land_cover_data(bbox, grid_w, grid_h);
             if lc.is_some() {
@@ -78,18 +78,28 @@ impl Ground {
             None
         };
 
+        // Raise the floor for the deepest water carve (elevation path only).
+        let water_floor = match &land_cover {
+            Some(lc) => {
+                let max_depth =
+                    crate::water_depth::estimate_max_carve_depth(&lc.grid, world_w, world_h);
+                ground_level.max(crate::world_editor::MIN_Y + max_depth + 2)
+            }
+            None => ground_level,
+        };
+
         match fetch_elevation_data(
             bbox,
             scale,
-            ground_level,
+            water_floor,
             disable_height_limit,
             extended_max_y,
             land_cover.as_mut(),
             aws_only_elevation,
         ) {
             Ok(elevation_data) => Self {
                 elevation_enabled: true,
-                ground_level,
+                ground_level: water_floor,
                 elevation_data: Some(elevation_data),
                 land_cover,
                 rotation_mask: None,
@@ -165,6 +175,36 @@ impl Ground {
         );
     }
 
+    /// Local block bbox (min_x, min_z, max_x, max_z) covering all LC_WATER cells,
+    /// derived from the land-cover grid; None if no land cover or no water.
+    pub fn lc_water_block_bounds(&self) -> Option<(i32, i32, i32, i32)> {
+        let (lc, data) = match (&self.land_cover, &self.elevation_data) {
+            (Some(lc), Some(data)) => (lc, data),
+            _ => return None,
+        };
+        let (mut gx0, mut gz0, mut gx1, mut gz1) = (usize::MAX, usize::MAX, 0usize, 0usize);
+        let mut any = false;
+        for (z, row) in lc.grid.iter().enumerate() {
+            for (x, &c) in row.iter().enumerate() {
+                if c == land_cover::LC_WATER {
+                    gx0 = gx0.min(x);
+                    gx1 = gx1.max(x);
+                    gz0 = gz0.min(z);
+                    gz1 = gz1.max(z);
+                    any = true;
+                }
+            }
+        }
+        if !any {
+            return None;
+        }
+        let (x0, x1) =
+            crate::water_depth::grid_span_to_block_span(gx0, gx1, data.world_width, lc.width);
+        let (z0, z1) =
+            crate::water_depth::grid_span_to_block_span(gz0, gz1, data.world_height, lc.height);
+        Some((x0, z0, x1, z1))
+    }
+
     /// Returns the ESA WorldCover land cover class at the given coordinates.
     /// Returns 0 if land cover data is not available.
     #[inline(always)]

src/ground_generation.rs

@@ -318,18 +318,10 @@ pub fn generate_ground_layer(
                         }
 
                         if place_esa_water {
-                            // Single block of water at snapped level
+                            // Pre-paint; carve_lc_water_pass later overwrites with depth.
                             editor.set_block_if_absent_absolute(WATER, x, water_y, z);
-
-                            // Floor: sand/gravel/clay + sandstone below
-                            let h = land_cover::coord_hash(x, z);
-                            let floor_block = match h % 5 {
-                                0 => GRAVEL,
-                                1 => CLAY,
-                                _ => SAND,
-                            };
                             if water_y - 1 > MIN_Y {
-                                editor.set_block_if_absent_absolute(floor_block, x, water_y - 1, z);
+                                editor.set_block_if_absent_absolute(SAND, x, water_y - 1, z);
                             }
                             if water_y - 2 > MIN_Y {
                                 editor.set_block_if_absent_absolute(SANDSTONE, x, water_y - 2, z);
@@ -1132,7 +1124,7 @@ pub fn generate_ground_layer(
 ///
 /// Cost: 4 hash calls + a few f64 ops per block — still well under 100 ns,
 /// negligible over the whole ground pass.
-fn value_noise_01(x: i32, z: i32, scale: i32) -> f64 {
+pub(crate) fn value_noise_01(x: i32, z: i32, scale: i32) -> f64 {
     let s = scale.max(1);
     // Integer lattice cell containing (x, z). div_euclid gives floor
     // division for negative coordinates too, so patches tile uniformly

src/main.rs

@@ -33,6 +33,7 @@ mod telemetry;
 #[cfg(test)]
 mod test_utilities;
 mod version_check;
+mod water_depth;
 mod world_editor;
 mod world_utils;