Add GridAab::shrink(); make GridAab::expand() non-panicking.

Author: kpreid

CHANGELOG.md

@@ -19,6 +19,8 @@
     - `block::EvalBlockError` is now a `struct` with an inner `ErrorKind` enum, instead of an enum, and contains more information.
     - `block::Move`’s means of construction have been changed to be more systematic and orthogonal. In particular, paired moves are constructed from unpaired ones.
 
+    - `math::GridAab::expand()` now takes unsigned values; use `GridAab::shrink()` instead of negative ones. This allows both versions to never panic.
+
 - `all-is-cubes-gpu` library:
     - `in_wgpu::SurfaceRenderer::new()` requires `wgpu::Adapter` instead of `&wgpu::Adapter`.
 

all-is-cubes-base/src/math/grid_aab.rs

@@ -772,10 +772,9 @@ impl GridAab {
         Self::from_lower_upper(self.lower_bounds * scale, self.upper_bounds * scale)
     }
 
-    /// Moves all bounds outward or inward by the specified distances.
+    /// Moves all bounds outward by the specified distances.
     ///
-    /// TODO: Currently this will panic if the result is empty. Make it return Option
-    /// instead.
+    /// If the result’s coordinates would overflow, they are as large as possible instead.
     ///
     /// ```
     /// # extern crate all_is_cubes_base as all_is_cubes;
@@ -791,16 +790,59 @@ impl GridAab {
     /// );
     /// ```
     #[inline]
-    #[track_caller] // TODO: better error reporting
     #[must_use]
-    pub fn expand(self, deltas: FaceMap<GridCoordinate>) -> Self {
-        use Face6::*;
+    pub fn expand(self, deltas: FaceMap<GridSizeCoord>) -> Self {
         let l = self.lower_bounds();
         let u = self.upper_bounds();
         Self::from_lower_upper(
-            [l.x - deltas[NX], l.y - deltas[NY], l.z - deltas[NZ]],
-            [u.x + deltas[PX], u.y + deltas[PY], u.z + deltas[PZ]],
+            [
+                l.x.saturating_sub_unsigned(deltas.nx),
+                l.y.saturating_sub_unsigned(deltas.ny),
+                l.z.saturating_sub_unsigned(deltas.nz),
+            ],
+            [
+                u.x.saturating_add_unsigned(deltas.px),
+                u.y.saturating_add_unsigned(deltas.py),
+                u.z.saturating_add_unsigned(deltas.pz),
+            ],
+        )
+    }
+
+    /// Moves all bounds inward by the specified distances.
+    ///
+    /// Returns `None` if the result would have less than zero size.
+    ///
+    /// ```
+    /// # extern crate all_is_cubes_base as all_is_cubes;
+    /// use all_is_cubes::math::{GridAab, FaceMap};
+    ///
+    /// assert_eq!(
+    ///     GridAab::from_lower_upper([10, 10, 10], [20, 20, 20])
+    ///         .shrink(FaceMap {
+    ///             nx: 1, ny: 2, nz: 3,
+    ///             px: 4, py: 5, pz: 6,
+    ///         }),
+    ///     Some(GridAab::from_lower_upper([11, 12, 13], [16, 15, 14])),
+    /// );
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn shrink(self, deltas: FaceMap<GridSizeCoord>) -> Option<Self> {
+        let l = self.lower_bounds();
+        let u = self.upper_bounds();
+        Self::checked_from_lower_upper(
+            [
+                l.x.checked_add_unsigned(deltas.nx)?,
+                l.y.checked_add_unsigned(deltas.ny)?,
+                l.z.checked_add_unsigned(deltas.nz)?,
+            ],
+            [
+                u.x.checked_sub_unsigned(deltas.px)?,
+                u.y.checked_sub_unsigned(deltas.py)?,
+                u.z.checked_sub_unsigned(deltas.pz)?,
+            ],
         )
+        .ok()
     }
 
     /// Returns a [`GridAab`] which includes the volume between the given `face` rectangle

all-is-cubes-content/src/alg.rs

@@ -11,7 +11,7 @@ use all_is_cubes::block::{Atom, Block, Primitive, Resolution, AIR};
 use all_is_cubes::euclid::vec3;
 use all_is_cubes::math::{
     Cube, CubeFace, Face6, FaceMap, FreeCoordinate, FreePoint, GridAab, GridCoordinate, GridPoint,
-    GridVector, Gridgid, NotNan, Vol,
+    GridSizeCoord, GridVector, Gridgid, NotNan, Vol,
 };
 use all_is_cubes::space::{CubeTransaction, SetCubeError, Space, SpaceTransaction};
 
@@ -102,12 +102,12 @@ pub(crate) fn voronoi_pattern<'a>(
 /// TODO: Change the callback value to a struct
 pub(crate) fn four_walls<F, E>(bounding_box: GridAab, mut f: F) -> Result<(), E>
 where
-    F: FnMut(GridPoint, Face6, GridCoordinate, GridAab) -> Result<(), E>,
+    F: FnMut(GridPoint, Face6, GridSizeCoord, GridAab) -> Result<(), E>,
 {
-    let interior = bounding_box.expand(FaceMap::symmetric([-1, 0, -1]));
+    let interior = bounding_box.shrink(FaceMap::symmetric([1, 0, 1])).unwrap();
     let low = bounding_box.lower_bounds();
     let high = bounding_box.upper_bounds() - GridVector::new(1, 1, 1);
-    let size = bounding_box.size().to_i32();
+    let size = bounding_box.size();
     f(
         low,
         Face6::PZ,

all-is-cubes-content/src/atrium.rs

@@ -15,7 +15,7 @@ use all_is_cubes::euclid::Point3D;
 use all_is_cubes::linking::{BlockModule, BlockProvider, InGenError};
 use all_is_cubes::math::{
     rgb_const, Axis, Cube, Face6, FaceMap, FreeCoordinate, GridAab, GridCoordinate, GridPoint,
-    GridRotation, GridVector, Gridgid, Rgb, Rgba, Vol,
+    GridRotation, GridSizeCoord, GridVector, Gridgid, Rgb, Rgba, Vol,
 };
 use all_is_cubes::space::{SetCubeError, Space, SpacePhysics, SpaceTransaction};
 use all_is_cubes::transaction::{self, Transaction as _};
@@ -26,7 +26,8 @@ use crate::alg::{array_of_noise, four_walls, scale_color};
 use crate::Fire;
 
 /// A special name for "the thickness of a 1-block-thick wall/floor/pillar", for readability.
-const WALL: GridCoordinate = 1;
+const IWALL: GridCoordinate = 1;
+const UWALL: GridSizeCoord = 1;
 
 pub(crate) async fn atrium(
     universe: &mut Universe,
@@ -40,31 +41,31 @@ pub(crate) async fn atrium(
         blocks
     };
 
-    let ceiling_height = 6;
-    let between_small_arches = 3;
+    let ceiling_height = 6u32;
+    let between_small_arches = 3u32;
     let between_large_arches = between_small_arches * 2 + 1;
     let balcony_radius = 4;
     let large_arch_count_x = 1;
     let large_arch_count_z = 5;
     let floor_count = 4;
     let sun_height = 10;
 
-    let origin = GridAab::from_lower_size([0, 0, 0], [1, 1, 1]);
+    let origin = GridAab::ORIGIN_CUBE;
     let atrium_footprint = origin.expand(FaceMap::symmetric([
-        ((between_large_arches + WALL) * large_arch_count_x) / 2 - WALL,
+        ((between_large_arches + UWALL) * large_arch_count_x) / 2 - UWALL,
         0,
-        ((between_large_arches + WALL) * large_arch_count_z) / 2 - WALL,
+        ((between_large_arches + UWALL) * large_arch_count_z) / 2 - UWALL,
     ]));
-    let arches_footprint = atrium_footprint.expand(FaceMap::symmetric([WALL, 0, WALL]));
+    let arches_footprint = atrium_footprint.expand(FaceMap::symmetric([UWALL, 0, UWALL]));
     let balconies_footprint =
         arches_footprint.expand(FaceMap::symmetric([balcony_radius, 0, balcony_radius]));
-    let outer_walls_footprint = balconies_footprint.expand(FaceMap::symmetric([WALL, 0, WALL]));
+    let outer_walls_footprint = balconies_footprint.expand(FaceMap::symmetric([UWALL, 0, UWALL]));
 
-    let balcony_floor_pos = GridVector::new(0, ceiling_height + WALL, 0);
-    let top_floor_pos = GridVector::new(0, (ceiling_height + WALL) * 2, 0);
+    let balcony_floor_pos = GridVector::new(0, (ceiling_height + UWALL) as i32, 0);
+    let top_floor_pos = GridVector::new(0, (ceiling_height + UWALL) as i32 * 2, 0);
 
     let space_bounds = outer_walls_footprint
-        .expand(FaceMap::default().with(Face6::PY, ceiling_height * floor_count + sun_height));
+        .expand(FaceMap::default().with(Face6::PY, sun_height + ceiling_height * floor_count));
 
     let floor_with_cutout = |mut cube: Cube| {
         cube.y = 0;
@@ -134,7 +135,7 @@ pub(crate) async fn atrium(
         outer_walls_footprint
             .translate(top_floor_pos)
             .expand(FaceMap::from_fn(|f| {
-                GridCoordinate::from(f == Face6::PY) * ceiling_height
+                GridSizeCoord::from(f == Face6::PY) * ceiling_height
             })),
         floor_with_cutout,
     )?;
@@ -206,14 +207,14 @@ pub(crate) async fn atrium(
         *br"        ",
     ]]);
     four_walls(
-        arches_footprint.translate([0, WALL, 0]),
+        arches_footprint.translate([0, IWALL, 0]),
         |origin, direction, length, _box| {
             arch_row(
                 &mut space,
                 &blocks,
                 origin,
-                between_large_arches + WALL,
-                length / (between_large_arches + WALL),
+                between_large_arches + UWALL,
+                length / (between_large_arches + UWALL),
                 direction,
                 arches_pattern.as_ref(),
             )
@@ -331,14 +332,14 @@ fn arch_row(
     space: &mut Space,
     blocks: &BlockProvider<AtriumBlocks>,
     first_column_base: GridPoint,
-    section_length: GridCoordinate,
-    section_count: GridCoordinate,
+    section_length: GridSizeCoord,
+    section_count: GridSizeCoord,
     parallel: Face6,
     pattern: Vol<&[u8]>,
 ) -> Result<(), InGenError> {
-    let offset = parallel.normal_vector() * section_length;
+    let offset = parallel.normal_vector() * section_length as GridCoordinate;
     let rotation = GridRotation::from_to(Face6::NX, parallel, Face6::PY).unwrap();
-    for i in 0..section_count {
+    for i in 0..(section_count as GridCoordinate) {
         let column_base = first_column_base + offset * (i + 1);
 
         let banner_color = if parallel.axis() == Axis::Z {

all-is-cubes-content/src/city.rs

@@ -15,8 +15,8 @@ use all_is_cubes::drawing::VoxelBrush;
 use all_is_cubes::inv::{Slot, Tool};
 use all_is_cubes::linking::{BlockProvider, InGenError};
 use all_is_cubes::math::{
-    rgba_const, Cube, Face6, FaceMap, GridAab, GridCoordinate, GridRotation, GridSize, GridVector,
-    Gridgid, VectorOps,
+    rgba_const, Cube, Face6, FaceMap, GridAab, GridCoordinate, GridRotation, GridSize,
+    GridSizeCoord, GridVector, Gridgid, VectorOps,
 };
 use all_is_cubes::op::Operation;
 use all_is_cubes::space::{LightPhysics, Space, SpaceBuilder, SpacePhysics};
@@ -491,18 +491,16 @@ fn place_one_exhibit<I: Instant>(
         let front_face = plot_transform.rotation.transform(Face6::PZ);
         // Compute the surface that needs to be clear for walking
         let entrance_plane = enclosure_lower
-            .expand(
-                FaceMap {
-                    // don't alter y
-                    ny: 0,
-                    py: 0,
-                    ..enclosure_thickness
-                }
-                .map(|_, thick| -thick),
-            )
+            .shrink(FaceMap {
+                // don't alter y
+                ny: 0,
+                py: 0,
+                ..enclosure_thickness
+            })
+            .unwrap()
             .abut(Face6::PY, 0)
             .unwrap()
-            .abut(front_face, enclosure_thickness.pz) // re-add enclosure bounds
+            .abut(front_face, enclosure_thickness.pz as GridCoordinate) // re-add enclosure bounds
             .unwrap()
             .abut(
                 front_face,
@@ -839,7 +837,7 @@ impl CityPlanner {
     /// Distance from the center cube to the line of the front of each placed exhibit.
     /// TODO: The units of this isn't being consistent, since it is actually + 1 from the lamps
     const PLOT_FRONT_RADIUS: GridCoordinate = Self::LAMP_POSITION_RADIUS;
-    const GAP_BETWEEN_PLOTS: GridCoordinate = 1;
+    const GAP_BETWEEN_PLOTS: GridSizeCoord = 1;
 
     const SURFACE_Y: GridCoordinate = 1;
     const UNDERGROUND_FLOOR_Y: GridCoordinate = -10;

all-is-cubes-content/src/city/exhibits.rs

@@ -1126,9 +1126,9 @@ fn COLOR_LIGHTS(_: Context<'_>) {
 fn COLORED_BOUNCE(_: Context<'_>) {
     let mut txn = ExhibitTransaction::default();
 
-    let interior_radius = 3;
-    let wall_thickness = 3;
-    let total_radius = interior_radius + wall_thickness;
+    let interior_radius = 3i32;
+    let wall_thickness = 3u32;
+    let total_radius = interior_radius.saturating_add_unsigned(wall_thickness);
     let brightness = 50.0;
 
     // --- Blocks ---
@@ -1505,7 +1505,7 @@ fn TREES(ctx: Context<'_>) {
                     ny: 0,
                     nz: 2,
                     px: 2,
-                    py: ix + iz * 2,
+                    py: u32::try_from(ix + iz * 2).unwrap(),
                     pz: 2,
                 }),
             )

all-is-cubes-content/src/dungeon/demo_dungeon.rs

@@ -16,8 +16,8 @@ use all_is_cubes::euclid::Size3D;
 use all_is_cubes::inv::Tool;
 use all_is_cubes::linking::{BlockModule, BlockProvider, GenError, InGenError};
 use all_is_cubes::math::{
-    Axis, Cube, Face6, FaceMap, GridAab, GridCoordinate, GridRotation, GridSize, GridVector, Rgb,
-    Rgba, Vol,
+    Axis, Cube, Face6, FaceMap, GridAab, GridCoordinate, GridRotation, GridSize, GridSizeCoord,
+    GridVector, Rgb, Rgba, Vol,
 };
 use all_is_cubes::space::{LightPhysics, Space};
 use all_is_cubes::time;
@@ -313,7 +313,7 @@ impl Theme<Option<DemoRoom>> for DemoTheme {
                     |origin, along_wall, length, wall_excluding_corners_box| {
                         let wall = GridRotation::CLOCKWISE.transform(along_wall); // TODO: make four_walls provide this in a nice name
                         if let WallFeature::Window = room_data.wall_features[wall] {
-                            let midpoint = length / 2;
+                            let midpoint = (length / 2) as GridCoordinate;
                             for step in WINDOW_PATTERN {
                                 let mut window_pos =
                                     origin + along_wall.normal_vector() * (midpoint + step);
@@ -414,11 +414,11 @@ pub(crate) async fn demo_dungeon(
         room_wall_thickness: FaceMap::repeat(1),
         gap_between_walls: Size3D::new(1, 1, 1),
     };
-    let perimeter_margin: GridCoordinate = 30;
+    let perimeter_margin: GridSizeCoord = 30;
 
     let mut requested_rooms = Size3D::from(
         (requested_size.unwrap_or(Size3D::new(135, 40, 135))
-            - Size3D::new(perimeter_margin, 0, perimeter_margin).to_u32())
+            - Size3D::new(perimeter_margin, 0, perimeter_margin))
         .to_vector()
         .component_div(dungeon_grid.room_spacing().to_vector()),
     );

all-is-cubes-content/src/dungeon/generic.rs

@@ -49,7 +49,7 @@ impl DungeonGrid {
 
     pub fn room_box_including_walls(&self) -> GridAab {
         self.room_box
-            .expand(self.room_wall_thickness.map(|_, c| GridCoordinate::from(c)))
+            .expand(self.room_wall_thickness.map(|_, c| c.into()))
     }
 
     pub fn room_box_at(&self, room_position: Cube) -> GridAab {

all-is-cubes-content/src/template.rs

@@ -369,7 +369,9 @@ async fn islands(
             && cell_bounds.size().height >= margin + 25
             && cell_bounds.size().depth >= margin * 2
         {
-            let occupied_bounds = cell_bounds.expand(FaceMap::repeat(-10).with(Face6::PY, -25));
+            let occupied_bounds = cell_bounds
+                .shrink(FaceMap::repeat(10).with(Face6::PY, 25))
+                .unwrap();
             wavy_landscape(occupied_bounds, &mut space, &landscape_blocks, 0.5)?;
         }
         p.progress(i as f32 / island_grid.volume_f64() as f32).await;

all-is-cubes-mesh/examples/visualize-block-mesh.rs

@@ -91,7 +91,9 @@ fn make_transparent_block(universe: &mut Universe) -> Block {
         .light_emission(Rgb::new(0.0, 1.0, 1.0))
         .build();
     let resolution = Resolution::R16;
-    let solid_box = GridAab::for_block(resolution).expand(FaceMap::repeat(-2));
+    let solid_box = GridAab::for_block(resolution)
+        .shrink(FaceMap::repeat(2))
+        .unwrap();
     let transparent_box = GridAab::for_block(resolution).abut(Face6::PX, -4).unwrap();
     let emissive_box = GridAab::for_block(resolution).abut(Face6::NX, -4).unwrap();
     Block::builder()