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

Two full-world grids were stored as `Vec<Vec<f64>>`, doubling their
resident size for no precision gain:

1. `ElevationData::heights` (computed by the elevation pipeline, used by
   `Ground::level` → `get_ground_level` on every block-placement hot
   path). Values are rounded to integer Minecraft Ys at final placement,
   so the full 15-digit f64 precision was wasted storage.

2. `LandCoverData::water_blend_grid` (Gaussian-blurred water mask used
   by `ground.water_blend`). Values are bounded to `[0, 1]` and only
   ever compared against a 0.5 threshold in the renderer — f32's ~7
   decimal digits are overkill.

Both grids can hit 10+ million cells on a city-sized bbox, so dropping
each from 8 to 4 bytes/cell saves ~92 MB combined on a Munich-sized
area.

Postprocess, rotation, and Gaussian blur stay in f64 internally — the
downcast to f32 happens once at storage assignment
(`ElevationData` construction + `Ground::set_elevation_data` +
`compute_water_blend_smooth` output). Read sites in `Ground` widen back
to f64 for bilinear interpolation so rounding behaviour matches the
previous implementation bit-for-bit on integer-valued elevations.

Local measurement on CI bbox `48.125768,11.552296,48.148565,11.593838`
with `--terrain` (integer seconds, 5 runs):

  main baseline:   ~24 s
  post-fix:        ~20-21 s  (−3-4 s)

Most of the speed gain comes from reduced memory bandwidth on the
`Ground::level` hot path — the elevation grid now fits tighter in L2/L3
cache during the per-block lookup loop. Peak memory saving lands
wherever in the pipeline the grids are resident (mainly during element
processing + ground generation + save), independent of the gen-time
win.

Tests (65/65), clippy `-D warnings`, fmt clean.

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,13 @@ 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 here so the bilinear interpolation
+            // (and the downstream 0.5-threshold comparison) doesn't lose any
+            // precision vs the previous all-f64 implementation.
+            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 +300,15 @@ 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, same as we always did
+        // before f32 storage — the arithmetic stays in f64 so rounding to the
+        // nearest block Y matches the old behaviour bit-for-bit on anything
+        // the previous f64 storage could represent exactly (integer-valued
+        // elevations do).
+        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 +326,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 +402,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

@@ -68,7 +68,13 @@ pub struct LandCoverData {
     /// 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>>,
+    ///
+    /// 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 +100,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 +116,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.