Merge pull request #966 from louis-e/perf/shrink-grid-precision

Halve peak grid storage: f32 for elevation heights + water blend

Author: louis-e

src/elevation/mod.rs

@@ -19,8 +19,14 @@ use selector::select_provider;
 /// Holds processed elevation data and metadata
 #[derive(Clone)]
 pub struct ElevationData {
-    /// Height values in Minecraft Y coordinates (as f64, rounded to i32 at final block placement)
-    pub(crate) heights: Vec<Vec<f64>>,
+    /// Height values in Minecraft Y coordinates.
+    ///
+    /// Stored as `f32` on purpose: heights are already rounded to integer
+    /// block Ys at placement time, so the full f64 precision was wasted on a
+    /// grid that can easily hit 10+ million cells on a city-sized bbox
+    /// (≈80 MB at f64, halved at f32). Postprocess still runs in f64 for
+    /// numerical stability; the downcast happens once at construction.
+    pub(crate) heights: Vec<Vec<f32>>,
     /// Width of the elevation grid (may be smaller than world width due to capping)
     pub(crate) width: usize,
     /// Height of the elevation grid (may be smaller than world height due to capping)
@@ -223,8 +229,17 @@ pub fn fetch_elevation_data(
         }
     }
 
+    // Downcast the f64 postprocess output to the f32 storage format. One-time
+    // cost paid here so the large grid sits at half the memory for the rest
+    // of the generation run. NaN/infinity preservation is a requirement —
+    // downstream `is_finite` checks rely on non-finite sentinels surviving.
+    let mc_heights_f32: Vec<Vec<f32>> = mc_heights
+        .into_iter()
+        .map(|row| row.into_iter().map(|v| v as f32).collect())
+        .collect();
+
     Ok(ElevationData {
-        heights: mc_heights,
+        heights: mc_heights_f32,
         width: grid_width,
         height: grid_height,
         world_width,

src/ground.rs

@@ -175,10 +175,14 @@ impl Ground {
             // continuous — the renderer's hard `> 0.5` threshold then traces
             // a clean curved shoreline contour instead of the raw ESA 10 m
             // rectangular grid edge.
-            let w00 = lc.water_blend_grid[z0][x0];
-            let w10 = lc.water_blend_grid[z0][x1];
-            let w01 = lc.water_blend_grid[z1][x0];
-            let w11 = lc.water_blend_grid[z1][x1];
+            // Widen f32 storage to f64 for the bilinear arithmetic. This
+            // doesn't recover the ~10⁻⁷ precision lost at storage, but it
+            // prevents extra rounding from accumulating in the four
+            // multiply-adds + the threshold comparison downstream.
+            let w00 = lc.water_blend_grid[z0][x0] as f64;
+            let w10 = lc.water_blend_grid[z0][x1] as f64;
+            let w01 = lc.water_blend_grid[z1][x0] as f64;
+            let w11 = lc.water_blend_grid[z1][x1] as f64;
 
             // Bilinear interpolation
             let top = w00 * (1.0 - tx) + w10 * tx;
@@ -297,10 +301,17 @@ impl Ground {
         let z1 = (z0 + 1).min(data.height - 1);
         let dx = fx - x0 as f64;
         let dz = fz - z0 as f64;
-        let v00 = data.heights[z0][x0];
-        let v10 = data.heights[z0][x1];
-        let v01 = data.heights[z1][x0];
-        let v11 = data.heights[z1][x1];
+        // Widen f32 storage to f64 for the bilinear arithmetic. The real
+        // property we rely on: across the Minecraft Y range (roughly −64 up
+        // through a few thousand even with --disable-height-limit), f32's
+        // mantissa gives ~10⁻⁷ precision per stored cell, which is far
+        // smaller than the 0.5-block half-width used by `round()` below.
+        // So for any value that isn't pathologically close to a half-integer
+        // boundary, the final `result.round() as i32` matches the f64 path.
+        let v00 = data.heights[z0][x0] as f64;
+        let v10 = data.heights[z0][x1] as f64;
+        let v01 = data.heights[z1][x0] as f64;
+        let v11 = data.heights[z1][x1] as f64;
         let lerp_top = v00 + (v10 - v00) * dx;
         let lerp_bot = v01 + (v11 - v01) * dx;
         let result = lerp_top + (lerp_bot - lerp_top) * dz;
@@ -318,7 +329,12 @@ impl Ground {
         world_height: usize,
     ) {
         if let Some(ref mut data) = self.elevation_data {
-            data.heights = heights;
+            // Rotation operators build a fresh f64 work grid; downcast here to
+            // match `ElevationData::heights`'s f32 storage layout.
+            data.heights = heights
+                .into_iter()
+                .map(|row| row.into_iter().map(|v| v as f32).collect())
+                .collect();
             data.width = grid_width;
             data.height = grid_height;
             data.world_width = world_width;
@@ -389,8 +405,8 @@ impl Ground {
         let mut img: image::ImageBuffer<Rgb<u8>, Vec<u8>> =
             RgbImage::new(width as u32, height as u32);
 
-        let mut min_height: f64 = f64::MAX;
-        let mut max_height: f64 = f64::MIN;
+        let mut min_height: f32 = f32::MAX;
+        let mut max_height: f32 = f32::MIN;
 
         for row in heights {
             for &h in row {

src/land_cover.rs

@@ -64,11 +64,18 @@ pub struct LandCoverData {
     /// 0 = non-water, 1 = shore water, 2+ = progressively deeper water.
     pub water_distance: Vec<Vec<u8>>,
     /// Pre-smoothed water-ness field in [0, 1] — a Gaussian-blurred version
-    /// of the binary `grid == LC_WATER` mask. Used by `ground.water_blend()`
-    /// and compared against a hard 0.5 threshold in the renderer so the
-    /// shoreline follows the smoothed contour's 0.5 isoline instead of the
-    /// raw ESA 10 m rectangular grid edge.
-    pub water_blend_grid: Vec<Vec<f64>>,
+    /// of the binary `grid == LC_WATER` mask. Sampled via `ground.water_blend()`
+    /// and compared against a hard 0.5 threshold inside `ground_generation`
+    /// (water classification path) so the shoreline follows the smoothed
+    /// contour's 0.5 isoline instead of the raw ESA 10 m rectangular grid
+    /// edge.
+    ///
+    /// Stored as `f32` on purpose — the grid can be tens of millions of cells
+    /// on large bboxes, and the values are bounded to `[0, 1]` and only ever
+    /// compared against a 0.5 threshold, so f32's ~7 decimal digits are
+    /// overkill. Halving the storage saves ~46 MB peak on a Munich-sized
+    /// area.
+    pub water_blend_grid: Vec<Vec<f32>>,
     /// Grid width (matches elevation grid width)
     pub width: usize,
     /// Grid height (matches elevation grid height)
@@ -94,7 +101,7 @@ impl LandCoverData {
 /// - Coarser grid-to-world (large bbox, capped at 4096): each cell already
 ///   represents many blocks, so a 3-cell blur represents many blocks of
 ///   softening — appropriate for the coarser effective resolution.
-fn compute_water_blend_smooth(grid: &[Vec<u8>], width: usize, height: usize) -> Vec<Vec<f64>> {
+fn compute_water_blend_smooth(grid: &[Vec<u8>], width: usize, height: usize) -> Vec<Vec<f32>> {
     const SIGMA_CELLS: f64 = 3.0;
 
     if width == 0 || height == 0 {
@@ -110,7 +117,13 @@ fn compute_water_blend_smooth(grid: &[Vec<u8>], width: usize, height: usize) ->
                 .collect()
         })
         .collect();
+    // Gaussian blur runs in f64 for numerical stability, then we drop down to
+    // f32 for storage — values land in [0, 1] and are only ever compared to a
+    // 0.5 threshold, so precision beyond f32 is wasted.
     crate::elevation::postprocess::gaussian_blur_grid(&binary, SIGMA_CELLS)
+        .into_iter()
+        .map(|row| row.into_iter().map(|v| v as f32).collect())
+        .collect()
 }
 
 /// Metadata parsed from a COG (Cloud-Optimized GeoTIFF) IFD.