sparse_strips/vello_common/src/geometry.rs - external/github.com/linebender/vello - Git at Google

 // Copyright 2025 the Vello Authors
 // SPDX-License-Identifier: Apache-2.0 OR MIT

 //! Geometry utilities.

 use crate::kurbo::Rect;
 use bytemuck::{Pod, Zeroable};
 use core::num::TryFromIntError;
 use core::ops::Add;

 /// A size represented by two 16-bit unsigned integers.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Pod, Zeroable, PartialEq, Eq)]
 pub struct SizeU16(pub [u16; 2]);

 impl SizeU16 {
     /// A zero size.
     pub const ZERO: Self = Self::new(0);

     /// Create a new square size.
     pub const fn new(size: u16) -> Self {
         Self([size; 2])
     }

     /// Create a new size from its width and height.
     pub const fn from_wh(width: u16, height: u16) -> Self {
         Self([width, height])
     }

     /// The width of this size.
     pub const fn width(self) -> u16 {
         self.0[0]
     }

     /// The height of this size.
     pub const fn height(self) -> u16 {
         self.0[1]
     }

     /// Return the maximum of the two sizes.
     pub fn max(self, other: Self) -> Self {
         Self::from_wh(
             self.width().max(other.width()),
             self.height().max(other.height()),
         )
     }

     /// Return the minimum of the two sizes.
     pub fn min(self, other: Self) -> Self {
         Self::from_wh(
             self.width().min(other.width()),
             self.height().min(other.height()),
         )
     }

     /// Clamp both dimensions to the given range.
     pub fn clamp(self, min: u16, max: u16) -> Self {
         Self::from_wh(self.width().clamp(min, max), self.height().clamp(min, max))
     }
 }

 impl From<[u16; 2]> for SizeU16 {
     fn from(value: [u16; 2]) -> Self {
         Self(value)
     }
 }

 impl Add for SizeU16 {
     type Output = Self;

     fn add(self, rhs: Self) -> Self::Output {
         // Shouldn't overflow for our use cases.
         Self::from_wh(
             self.width().checked_add(rhs.width()).unwrap(),
             self.height().checked_add(rhs.height()).unwrap(),
         )
     }
 }

 impl Add<u16> for SizeU16 {
     type Output = Self;

     fn add(self, rhs: u16) -> Self::Output {
         self + Self::new(rhs)
     }
 }

 /// Padding for the four sides of a region.
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
 pub struct PaddingU16 {
     /// The left padding.
     pub left: u16,
     /// The top padding.
     pub top: u16,
     /// The right padding.
     pub right: u16,
     /// The bottom padding.
     pub bottom: u16,
 }

 impl PaddingU16 {
     /// Padding with all sides set to zero.
     pub const ZERO: Self = Self::new(0, 0, 0, 0);

     /// Create padding from its left, top, right, and bottom amounts.
     pub const fn new(left: u16, top: u16, right: u16, bottom: u16) -> Self {
         Self {
             left,
             top,
             right,
             bottom,
         }
     }
 }

 /// An axis-aligned rectangle with `u16` coordinates, stored as two corners `(x0, y0)` and
 /// `(x1, y1)`.
 ///
 /// `(x0, y0)` is the top-left (minimum) corner and `(x1, y1)` is the bottom-right (maximum) corner.
 /// The rectangle is considered to be empty when `x0 >= x1` or `y0 >= y1`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct RectU16 {
     /// The minimum x coordinate (left edge).
     pub x0: u16,
     /// The minimum y coordinate (top edge).
     pub y0: u16,
     /// The maximum x coordinate (right edge, exclusive).
     pub x1: u16,
     /// The maximum y coordinate (bottom edge, exclusive).
     pub y1: u16,
 }

 impl RectU16 {
     /// A rectangle with all coordinates set to zero.
     pub const ZERO: Self = Self {
         x0: 0,
         y0: 0,
         x1: 0,
         y1: 0,
     };

     /// An empty, maximally inverted rectangle, useful as a starting value for incremental union
     /// operations.
     ///
     /// Has `(x0, y0) = (u16::MAX, u16::MAX)` and `(x1, y1) = (0, 0)`.
     pub const INVERTED: Self = Self {
         x0: u16::MAX,
         y0: u16::MAX,
         x1: 0,
         y1: 0,
     };

     /// Create a new rectangle from its corner coordinates.
     #[inline(always)]
     pub const fn new(x0: u16, y0: u16, x1: u16, y1: u16) -> Self {
         Self { x0, y0, x1, y1 }
     }

     /// The width of the rectangle (`x1 - x0`), saturating at zero.
     #[inline(always)]
     pub const fn width(self) -> u16 {
         self.x1.saturating_sub(self.x0)
     }

     /// The height of the rectangle (`y1 - y0`), saturating at zero.
     #[inline(always)]
     pub const fn height(self) -> u16 {
         self.y1.saturating_sub(self.y0)
     }

     /// Returns `true` if the rectangle has zero area (`x0 >= x1` or `y0 >= y1`).
     #[inline(always)]
     pub const fn is_empty(self) -> bool {
         self.x0 >= self.x1 || self.y0 >= self.y1
     }

     /// Check if a point `(x, y)` is contained within this rectangle.
     ///
     /// Returns `true` if `x0 <= x < x1` and `y0 <= y < y1`.
     #[inline(always)]
     pub const fn contains(self, x: u16, y: u16) -> bool {
         (x >= self.x0) & (x < self.x1) & (y >= self.y0) & (y < self.y1)
     }

     /// Compute the intersection of two rectangles.
     ///
     /// The result may have zero area if the rectangles do not overlap, but is never inverted.
     #[inline(always)]
     pub const fn intersect(self, other: Self) -> Self {
         let x0 = const_max(self.x0, other.x0);
         let y0 = const_max(self.y0, other.y0);
         let x1 = const_min(self.x1, other.x1);
         let y1 = const_min(self.y1, other.y1);

         Self::new(x0, y0, const_max(x1, x0), const_max(y1, y0))
     }

     /// Expand this rectangle by the given left, top, right, and bottom padding.
     #[inline(always)]
     pub const fn expand(self, padding: PaddingU16) -> Self {
         Self {
             x0: self.x0.saturating_sub(padding.left),
             y0: self.y0.saturating_sub(padding.top),
             x1: self.x1.saturating_add(padding.right),
             y1: self.y1.saturating_add(padding.bottom),
         }
     }

     /// Return this rectangle relative to `origin`, clamping negative coordinates to zero.
     #[inline(always)]
     pub fn relative_to_origin(self, origin: (u16, u16)) -> Self {
         self.shift((-(origin.0 as i32), -(origin.1 as i32)))
     }

     /// Return a shifted version of the rectangle, clamping negative coordinates to zero.
     #[inline]
     pub fn shift(self, shift: (i32, i32)) -> Self {
         Self {
             x0: (self.x0 as i32)
                 .saturating_add(shift.0)
                 .clamp(0, u16::MAX as i32) as u16,
             y0: (self.y0 as i32)
                 .saturating_add(shift.1)
                 .clamp(0, u16::MAX as i32) as u16,
             x1: (self.x1 as i32)
                 .saturating_add(shift.0)
                 .clamp(0, u16::MAX as i32) as u16,
             y1: (self.y1 as i32)
                 .saturating_add(shift.1)
                 .clamp(0, u16::MAX as i32) as u16,
         }
     }

     /// Expand this rectangle to also cover `other` (union in place).
     ///
     /// The union of `self` with a [`Self::INVERTED`] returns `self`.
     #[inline(always)]
     pub const fn union(&mut self, other: Self) {
         self.x0 = const_min(self.x0, other.x0);
         self.y0 = const_min(self.y0, other.y0);
         self.x1 = const_max(self.x1, other.x1);
         self.y1 = const_max(self.y1, other.y1);
     }

     /// Return the rect as a [`Rect`].
     pub fn as_rect(self) -> Rect {
         Rect::new(
             self.x0 as f64,
             self.y0 as f64,
             self.x1 as f64,
             self.y1 as f64,
         )
     }
 }

 impl From<RectU16> for SizeU16 {
     fn from(rect: RectU16) -> Self {
         Self::from_wh(rect.width(), rect.height())
     }
 }

 // TODO: Remove these types once we've completely moved to u16 everywhere in Vello Hybrid.

 /// An offset represented by two 32-bit unsigned integers.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Pod, Zeroable, PartialEq, Eq)]
 pub struct OffsetU32(pub [u32; 2]);

 impl OffsetU32 {
     /// A zero offset.
     pub const ZERO: Self = Self::new(0);

     /// Create a new offset with equal x and y coordinates.
     pub const fn new(offset: u32) -> Self {
         Self([offset; 2])
     }

     /// Create a new offset from its x and y coordinates.
     pub const fn from_xy(x: u32, y: u32) -> Self {
         Self([x, y])
     }

     /// The x coordinate of this offset.
     pub const fn x(self) -> u32 {
         self.0[0]
     }

     /// The y coordinate of this offset.
     pub const fn y(self) -> u32 {
         self.0[1]
     }
 }

 impl From<[u32; 2]> for OffsetU32 {
     fn from(value: [u32; 2]) -> Self {
         Self(value)
     }
 }

 /// A size represented by two 32-bit unsigned integers.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Pod, Zeroable, PartialEq, Eq)]
 pub struct SizeU32(pub [u32; 2]);

 impl SizeU32 {
     /// A zero size.
     pub const ZERO: Self = Self::new(0);

     /// Create a new square size.
     pub const fn new(size: u32) -> Self {
         Self([size; 2])
     }

     /// Create a new size from its width and height.
     pub const fn from_wh(width: u32, height: u32) -> Self {
         Self([width, height])
     }

     /// The width of this size.
     pub const fn width(self) -> u32 {
         self.0[0]
     }

     /// The height of this size.
     pub const fn height(self) -> u32 {
         self.0[1]
     }

     /// Return the maximum of the two sizes.
     pub fn max(self, other: Self) -> Self {
         Self::from_wh(
             self.width().max(other.width()),
             self.height().max(other.height()),
         )
     }

     /// Return the minimum of the two sizes.
     pub fn min(self, other: Self) -> Self {
         Self::from_wh(
             self.width().min(other.width()),
             self.height().min(other.height()),
         )
     }

     /// Clamp both dimensions to the given range.
     pub fn clamp(self, min: u32, max: u32) -> Self {
         Self::from_wh(self.width().clamp(min, max), self.height().clamp(min, max))
     }
 }

 impl From<[u32; 2]> for SizeU32 {
     fn from(value: [u32; 2]) -> Self {
         Self(value)
     }
 }

 impl From<(u32, u32)> for SizeU32 {
     fn from((width, height): (u32, u32)) -> Self {
         Self::from_wh(width, height)
     }
 }

 impl From<SizeU32> for (u32, u32) {
     fn from(size: SizeU32) -> Self {
         (size.width(), size.height())
     }
 }

 impl From<SizeU16> for SizeU32 {
     fn from(size: SizeU16) -> Self {
         Self::from_wh(u32::from(size.width()), u32::from(size.height()))
     }
 }

 impl TryFrom<SizeU32> for SizeU16 {
     type Error = TryFromIntError;

     fn try_from(size: SizeU32) -> Result<Self, Self::Error> {
         Ok(Self::from_wh(
             u16::try_from(size.width())?,
             u16::try_from(size.height())?,
         ))
     }
 }

 impl Add for SizeU32 {
     type Output = Self;

     fn add(self, rhs: Self) -> Self::Output {
         Self::from_wh(self.width() + rhs.width(), self.height() + rhs.height())
     }
 }

 impl Add<u32> for SizeU32 {
     type Output = Self;

     fn add(self, rhs: u32) -> Self::Output {
         self + Self::new(rhs)
     }
 }

 /// An axis-aligned rectangle with `u32` coordinates.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Pod, Zeroable, PartialEq, Eq)]
 pub struct RectU32 {
     /// The minimum x coordinate.
     pub x0: u32,
     /// The minimum y coordinate.
     pub y0: u32,
     /// The exclusive maximum x coordinate.
     pub x1: u32,
     /// The exclusive maximum y coordinate.
     pub y1: u32,
 }

 impl RectU32 {
     /// Create a new rectangle from its corner coordinates.
     pub const fn new(x0: u32, y0: u32, x1: u32, y1: u32) -> Self {
         Self { x0, y0, x1, y1 }
     }

     /// The width of this rectangle.
     pub const fn width(self) -> u32 {
         self.x1.saturating_sub(self.x0)
     }

     /// The height of this rectangle.
     pub const fn height(self) -> u32 {
         self.y1.saturating_sub(self.y0)
     }
 }

 #[inline(always)]
 const fn const_max(a: u16, b: u16) -> u16 {
     if a > b { a } else { b }
 }

 #[inline(always)]
 const fn const_min(a: u16, b: u16) -> u16 {
     if a < b { a } else { b }
 }

 #[cfg(test)]
 mod tests {
     use super::RectU16;

     #[test]
     fn rect_u16_relative_to_origin() {
         let rect = RectU16::new(10, 20, 30, 40);

         assert_eq!(rect.relative_to_origin((5, 12)), RectU16::new(5, 8, 25, 28));
     }

     #[test]
     fn rect_u16_relative_to_origin_clamps_to_zero() {
         let rect = RectU16::new(10, 20, 30, 40);

         assert_eq!(rect.relative_to_origin((20, 35)), RectU16::new(0, 0, 10, 5));
     }

     #[test]
     fn disjoint_intersection_is_empty_but_not_inverted() {
         let intersection = RectU16::new(0, 0, 4, 4).intersect(RectU16::new(8, 1, 12, 3));

         assert_eq!(intersection, RectU16::new(8, 1, 8, 3));
         assert!(intersection.is_empty());
         assert!(intersection.x0 <= intersection.x1);
         assert!(intersection.y0 <= intersection.y1);
     }
 }
	// Copyright 2025 the Vello Authors
	// SPDX-License-Identifier: Apache-2.0 OR MIT

	//! Geometry utilities.

	use crate::kurbo::Rect;
	use bytemuck::{Pod, Zeroable};
	use core::num::TryFromIntError;
	use core::ops::Add;

	/// A size represented by two 16-bit unsigned integers.
	#[repr(C)]
	#[derive(Copy, Clone, Debug, Pod, Zeroable, PartialEq, Eq)]
	pub struct SizeU16(pub [u16; 2]);

	impl SizeU16 {
	/// A zero size.
	pub const ZERO: Self = Self::new(0);

	/// Create a new square size.
	pub const fn new(size: u16) -> Self {
	Self([size; 2])
	}

	/// Create a new size from its width and height.
	pub const fn from_wh(width: u16, height: u16) -> Self {
	Self([width, height])
	}

	/// The width of this size.
	pub const fn width(self) -> u16 {
	self.0[0]
	}

	/// The height of this size.
	pub const fn height(self) -> u16 {
	self.0[1]
	}

	/// Return the maximum of the two sizes.
	pub fn max(self, other: Self) -> Self {
	Self::from_wh(
	self.width().max(other.width()),
	self.height().max(other.height()),
	)
	}

	/// Return the minimum of the two sizes.
	pub fn min(self, other: Self) -> Self {
	Self::from_wh(
	self.width().min(other.width()),
	self.height().min(other.height()),
	)
	}

	/// Clamp both dimensions to the given range.
	pub fn clamp(self, min: u16, max: u16) -> Self {
	Self::from_wh(self.width().clamp(min, max), self.height().clamp(min, max))
	}
	}

	impl From<[u16; 2]> for SizeU16 {
	fn from(value: [u16; 2]) -> Self {
	Self(value)
	}
	}

	impl Add for SizeU16 {
	type Output = Self;

	fn add(self, rhs: Self) -> Self::Output {
	// Shouldn't overflow for our use cases.
	Self::from_wh(
	self.width().checked_add(rhs.width()).unwrap(),
	self.height().checked_add(rhs.height()).unwrap(),
	)
	}
	}

	impl Add<u16> for SizeU16 {
	type Output = Self;

	fn add(self, rhs: u16) -> Self::Output {
	self + Self::new(rhs)
	}
	}

	/// Padding for the four sides of a region.
	#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
	pub struct PaddingU16 {
	/// The left padding.
	pub left: u16,
	/// The top padding.
	pub top: u16,
	/// The right padding.
	pub right: u16,
	/// The bottom padding.
	pub bottom: u16,
	}

	impl PaddingU16 {
	/// Padding with all sides set to zero.
	pub const ZERO: Self = Self::new(0, 0, 0, 0);

	/// Create padding from its left, top, right, and bottom amounts.
	pub const fn new(left: u16, top: u16, right: u16, bottom: u16) -> Self {
	Self {
	left,
	top,
	right,
	bottom,
	}
	}
	}

	/// An axis-aligned rectangle with `u16` coordinates, stored as two corners `(x0, y0)` and
	/// `(x1, y1)`.
	///
	/// `(x0, y0)` is the top-left (minimum) corner and `(x1, y1)` is the bottom-right (maximum) corner.
	/// The rectangle is considered to be empty when `x0 >= x1` or `y0 >= y1`.
	#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
	pub struct RectU16 {
	/// The minimum x coordinate (left edge).
	pub x0: u16,
	/// The minimum y coordinate (top edge).
	pub y0: u16,
	/// The maximum x coordinate (right edge, exclusive).
	pub x1: u16,
	/// The maximum y coordinate (bottom edge, exclusive).
	pub y1: u16,
	}

	impl RectU16 {
	/// A rectangle with all coordinates set to zero.
	pub const ZERO: Self = Self {
	x0: 0,
	y0: 0,
	x1: 0,
	y1: 0,
	};

	/// An empty, maximally inverted rectangle, useful as a starting value for incremental union
	/// operations.
	///
	/// Has `(x0, y0) = (u16::MAX, u16::MAX)` and `(x1, y1) = (0, 0)`.
	pub const INVERTED: Self = Self {
	x0: u16::MAX,
	y0: u16::MAX,
	x1: 0,
	y1: 0,
	};

	/// Create a new rectangle from its corner coordinates.
	#[inline(always)]
	pub const fn new(x0: u16, y0: u16, x1: u16, y1: u16) -> Self {
	Self { x0, y0, x1, y1 }
	}

	/// The width of the rectangle (`x1 - x0`), saturating at zero.
	#[inline(always)]
	pub const fn width(self) -> u16 {
	self.x1.saturating_sub(self.x0)
	}

	/// The height of the rectangle (`y1 - y0`), saturating at zero.
	#[inline(always)]
	pub const fn height(self) -> u16 {
	self.y1.saturating_sub(self.y0)
	}

	/// Returns `true` if the rectangle has zero area (`x0 >= x1` or `y0 >= y1`).
	#[inline(always)]
	pub const fn is_empty(self) -> bool {
	self.x0 >= self.x1 \|\| self.y0 >= self.y1
	}

	/// Check if a point `(x, y)` is contained within this rectangle.
	///
	/// Returns `true` if `x0 <= x < x1` and `y0 <= y < y1`.
	#[inline(always)]
	pub const fn contains(self, x: u16, y: u16) -> bool {
	(x >= self.x0) & (x < self.x1) & (y >= self.y0) & (y < self.y1)
	}

	/// Compute the intersection of two rectangles.
	///
	/// The result may have zero area if the rectangles do not overlap, but is never inverted.
	#[inline(always)]
	pub const fn intersect(self, other: Self) -> Self {
	let x0 = const_max(self.x0, other.x0);
	let y0 = const_max(self.y0, other.y0);
	let x1 = const_min(self.x1, other.x1);
	let y1 = const_min(self.y1, other.y1);

	Self::new(x0, y0, const_max(x1, x0), const_max(y1, y0))
	}

	/// Expand this rectangle by the given left, top, right, and bottom padding.
	#[inline(always)]
	pub const fn expand(self, padding: PaddingU16) -> Self {
	Self {
	x0: self.x0.saturating_sub(padding.left),
	y0: self.y0.saturating_sub(padding.top),
	x1: self.x1.saturating_add(padding.right),
	y1: self.y1.saturating_add(padding.bottom),
	}
	}

	/// Return this rectangle relative to `origin`, clamping negative coordinates to zero.
	#[inline(always)]
	pub fn relative_to_origin(self, origin: (u16, u16)) -> Self {
	self.shift((-(origin.0 as i32), -(origin.1 as i32)))
	}

	/// Return a shifted version of the rectangle, clamping negative coordinates to zero.
	#[inline]
	pub fn shift(self, shift: (i32, i32)) -> Self {
	Self {
	x0: (self.x0 as i32)
	.saturating_add(shift.0)
	.clamp(0, u16::MAX as i32) as u16,
	y0: (self.y0 as i32)
	.saturating_add(shift.1)
	.clamp(0, u16::MAX as i32) as u16,
	x1: (self.x1 as i32)
	.saturating_add(shift.0)
	.clamp(0, u16::MAX as i32) as u16,
	y1: (self.y1 as i32)
	.saturating_add(shift.1)
	.clamp(0, u16::MAX as i32) as u16,
	}
	}

	/// Expand this rectangle to also cover `other` (union in place).
	///
	/// The union of `self` with a [`Self::INVERTED`] returns `self`.
	#[inline(always)]
	pub const fn union(&mut self, other: Self) {
	self.x0 = const_min(self.x0, other.x0);
	self.y0 = const_min(self.y0, other.y0);
	self.x1 = const_max(self.x1, other.x1);
	self.y1 = const_max(self.y1, other.y1);
	}

	/// Return the rect as a [`Rect`].
	pub fn as_rect(self) -> Rect {
	Rect::new(
	self.x0 as f64,
	self.y0 as f64,
	self.x1 as f64,
	self.y1 as f64,
	)
	}
	}

	impl From<RectU16> for SizeU16 {
	fn from(rect: RectU16) -> Self {
	Self::from_wh(rect.width(), rect.height())
	}
	}

	// TODO: Remove these types once we've completely moved to u16 everywhere in Vello Hybrid.

	/// An offset represented by two 32-bit unsigned integers.
	#[repr(C)]
	#[derive(Copy, Clone, Debug, Pod, Zeroable, PartialEq, Eq)]
	pub struct OffsetU32(pub [u32; 2]);

	impl OffsetU32 {
	/// A zero offset.
	pub const ZERO: Self = Self::new(0);

	/// Create a new offset with equal x and y coordinates.
	pub const fn new(offset: u32) -> Self {
	Self([offset; 2])
	}

	/// Create a new offset from its x and y coordinates.
	pub const fn from_xy(x: u32, y: u32) -> Self {
	Self([x, y])
	}

	/// The x coordinate of this offset.
	pub const fn x(self) -> u32 {
	self.0[0]
	}

	/// The y coordinate of this offset.
	pub const fn y(self) -> u32 {
	self.0[1]
	}
	}

	impl From<[u32; 2]> for OffsetU32 {
	fn from(value: [u32; 2]) -> Self {
	Self(value)
	}
	}

	/// A size represented by two 32-bit unsigned integers.
	#[repr(C)]
	#[derive(Copy, Clone, Debug, Pod, Zeroable, PartialEq, Eq)]
	pub struct SizeU32(pub [u32; 2]);

	impl SizeU32 {
	/// A zero size.
	pub const ZERO: Self = Self::new(0);

	/// Create a new square size.
	pub const fn new(size: u32) -> Self {
	Self([size; 2])
	}

	/// Create a new size from its width and height.
	pub const fn from_wh(width: u32, height: u32) -> Self {
	Self([width, height])
	}

	/// The width of this size.
	pub const fn width(self) -> u32 {
	self.0[0]
	}

	/// The height of this size.
	pub const fn height(self) -> u32 {
	self.0[1]
	}

	/// Return the maximum of the two sizes.
	pub fn max(self, other: Self) -> Self {
	Self::from_wh(
	self.width().max(other.width()),
	self.height().max(other.height()),
	)
	}

	/// Return the minimum of the two sizes.
	pub fn min(self, other: Self) -> Self {
	Self::from_wh(
	self.width().min(other.width()),
	self.height().min(other.height()),
	)
	}

	/// Clamp both dimensions to the given range.
	pub fn clamp(self, min: u32, max: u32) -> Self {
	Self::from_wh(self.width().clamp(min, max), self.height().clamp(min, max))
	}
	}

	impl From<[u32; 2]> for SizeU32 {
	fn from(value: [u32; 2]) -> Self {
	Self(value)
	}
	}

	impl From<(u32, u32)> for SizeU32 {
	fn from((width, height): (u32, u32)) -> Self {
	Self::from_wh(width, height)
	}
	}

	impl From<SizeU32> for (u32, u32) {
	fn from(size: SizeU32) -> Self {
	(size.width(), size.height())
	}
	}

	impl From<SizeU16> for SizeU32 {
	fn from(size: SizeU16) -> Self {
	Self::from_wh(u32::from(size.width()), u32::from(size.height()))
	}
	}

	impl TryFrom<SizeU32> for SizeU16 {
	type Error = TryFromIntError;

	fn try_from(size: SizeU32) -> Result<Self, Self::Error> {
	Ok(Self::from_wh(
	u16::try_from(size.width())?,
	u16::try_from(size.height())?,
	))
	}
	}

	impl Add for SizeU32 {
	type Output = Self;

	fn add(self, rhs: Self) -> Self::Output {
	Self::from_wh(self.width() + rhs.width(), self.height() + rhs.height())
	}
	}

	impl Add<u32> for SizeU32 {
	type Output = Self;

	fn add(self, rhs: u32) -> Self::Output {
	self + Self::new(rhs)
	}
	}

	/// An axis-aligned rectangle with `u32` coordinates.
	#[repr(C)]
	#[derive(Copy, Clone, Debug, Pod, Zeroable, PartialEq, Eq)]
	pub struct RectU32 {
	/// The minimum x coordinate.
	pub x0: u32,
	/// The minimum y coordinate.
	pub y0: u32,
	/// The exclusive maximum x coordinate.
	pub x1: u32,
	/// The exclusive maximum y coordinate.
	pub y1: u32,
	}

	impl RectU32 {
	/// Create a new rectangle from its corner coordinates.
	pub const fn new(x0: u32, y0: u32, x1: u32, y1: u32) -> Self {
	Self { x0, y0, x1, y1 }
	}

	/// The width of this rectangle.
	pub const fn width(self) -> u32 {
	self.x1.saturating_sub(self.x0)
	}

	/// The height of this rectangle.
	pub const fn height(self) -> u32 {
	self.y1.saturating_sub(self.y0)
	}
	}

	#[inline(always)]
	const fn const_max(a: u16, b: u16) -> u16 {
	if a > b { a } else { b }
	}

	#[inline(always)]
	const fn const_min(a: u16, b: u16) -> u16 {
	if a < b { a } else { b }
	}

	#[cfg(test)]
	mod tests {
	use super::RectU16;

	#[test]
	fn rect_u16_relative_to_origin() {
	let rect = RectU16::new(10, 20, 30, 40);

	assert_eq!(rect.relative_to_origin((5, 12)), RectU16::new(5, 8, 25, 28));
	}

	#[test]
	fn rect_u16_relative_to_origin_clamps_to_zero() {
	let rect = RectU16::new(10, 20, 30, 40);

	assert_eq!(rect.relative_to_origin((20, 35)), RectU16::new(0, 0, 10, 5));
	}

	#[test]
	fn disjoint_intersection_is_empty_but_not_inverted() {
	let intersection = RectU16::new(0, 0, 4, 4).intersect(RectU16::new(8, 1, 12, 3));

	assert_eq!(intersection, RectU16::new(8, 1, 8, 3));
	assert!(intersection.is_empty());
	assert!(intersection.x0 <= intersection.x1);
	assert!(intersection.y0 <= intersection.y1);
	}
	}