#[derive(Copy, Clone, Debug)]
pub struct Rect {
pub minx: f32,
pub miny: f32,
pub maxx: f32,
pub maxy: f32,
}
impl Rect {
pub fn new(minx: f32, miny: f32, maxx: f32, maxy: f32) -> Rect {
return Rect { minx, miny, maxx, maxy };
}
pub fn cut_left(&mut self, a: f32) -> Rect {
let minx: f32 = self.minx;
if self.maxx < self.minx + a {
self.minx = self.maxx;
} else {
self.minx = self.minx + a;
}
return Rect::new(minx, self.miny, self.minx, self.maxy);
}
pub fn cut_right(&mut self, a: f32) -> Rect {
let maxx: f32 = self.maxx;
if self.minx > self.maxx - a {
self.maxx = self.minx;
} else {
self.maxx = self.maxx - a;
}
return Rect::new(self.maxx, self.miny, maxx, self.maxy);
}
pub fn cut_top(&mut self, a: f32) -> Rect {
let miny: f32 = self.miny;
if self.maxy < self.miny + a {
self.miny = self.maxy;
} else {
self.miny = self.miny + a;
}
return Rect::new(self.minx, miny, self.maxx, self.miny);
}
pub fn cut_bottom(&mut self, a: f32) -> Rect {
let maxy: f32 = self.maxy;
if self.miny > self.maxy - a {
self.maxy = self.miny;
} else {
self.maxy = self.maxy - a;
}
return Rect::new(self.minx, self.maxy, self.maxx, maxy);
}
pub fn get_left(&self, a: f32) -> Rect {
let maxx;
if self.maxx < self.minx + a {
maxx = self.maxx;
} else {
maxx = self.minx + a;
}
return Rect::new(self.minx, self.miny, maxx, self.maxy);
}
pub fn get_right(&self, a: f32) -> Rect {
let minx;
if self.minx > self.maxx - a {
minx = self.minx;
} else {
minx = self.maxx - a;
}
return Rect::new(minx, self.miny, self.maxx, self.maxy);
}
pub fn get_top(&self, a: f32) -> Rect {
let maxy;
if self.maxy < self.miny + a {
maxy = self.maxy;
} else {
maxy = self.miny + a;
}
return Rect::new(self.minx, self.miny, self.maxx, maxy);
}
pub fn get_bottom(&self, a: f32) -> Rect {
let miny;
if self.miny > self.maxy - a {
miny = self.miny;
} else {
miny = self.maxy - a;
}
return Rect::new(self.minx, miny, self.maxx, self.maxy);
}
pub fn add_left(&self, a: f32) -> Rect {
return Rect::new(self.minx - a, self.miny, self.minx, self.maxy);
}
pub fn add_right(&self, a: f32) -> Rect {
return Rect::new(self.maxx, self.miny, self.maxx + a, self.maxy);
}
pub fn add_top(&self, a: f32) -> Rect {
return Rect::new(self.minx, self.miny - a, self.maxx, self.miny);
}
pub fn add_bottom(&self, a: f32) -> Rect {
return Rect::new(self.minx, self.maxy, self.maxx, self.maxy + a);
}
pub fn extend(&self, a: f32) -> Rect {
return Rect::new(self.minx - a, self.miny - a, self.maxx + a, self.maxy + a);
}
pub fn contract(&self, a: f32) -> Rect {
return Rect::new(self.minx + a, self.miny + a, self.maxx - a, self.maxy - a);
}
}
#[test]
pub fn test_cut_left() {
let mut rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let left = rect.cut_left(1.0);
assert_eq!(0.0, left.minx);
assert_eq!(1.0, left.maxx);
assert_eq!(rect.miny, left.miny);
assert_eq!(rect.maxy, left.maxy);
assert_eq!(1.0, rect.minx);
assert_eq!(10.0, rect.maxx);
assert_eq!(0.0, rect.miny);
assert_eq!(10.0, rect.maxy);
}
#[test]
pub fn test_cut_right() {
let mut rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let right = rect.cut_right(1.0);
assert_eq!(9.0, right.minx);
assert_eq!(10.0, right.maxy);
assert_eq!(rect.miny, right.miny);
assert_eq!(rect.maxy, right.maxy);
assert_eq!(0.0, rect.minx);
assert_eq!(9.0, rect.maxx);
assert_eq!(0.0, rect.miny);
assert_eq!(10.0, rect.maxy);
}
#[test]
pub fn test_cut_top() {
let mut rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let top = rect.cut_top(1.0);
assert_eq!(0.0, top.minx);
assert_eq!(10.0, top.maxx);
assert_eq!(0.0, top.miny);
assert_eq!(1.0, top.maxy);
assert_eq!(0.0, rect.minx);
assert_eq!(10.0, rect.maxx);
assert_eq!(1.0, rect.miny);
assert_eq!(10.0, rect.maxy);
}
#[test]
pub fn test_cut_bottom() {
let mut rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let bottom = rect.cut_bottom(1.0);
assert_eq!(0.0, bottom.minx);
assert_eq!(10.0, bottom.maxx);
assert_eq!(9.0, bottom.miny);
assert_eq!(10.0, bottom.maxy);
assert_eq!(0.0, rect.minx);
assert_eq!(10.0, rect.maxx);
assert_eq!(0.0, rect.miny);
assert_eq!(9.0, rect.maxy);
}
#[test]
pub fn test_get_left() {
let rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let left = rect.get_left(1.0);
assert_eq!(0.0, left.minx);
assert_eq!(1.0, left.maxx);
assert_eq!(0.0, left.miny);
assert_eq!(10.0, left.maxy);
}
#[test]
pub fn test_get_right() {
let rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let right = rect.get_right(1.0);
assert_eq!(9.0, right.minx);
assert_eq!(10.0, right.maxx);
assert_eq!(0.0, right.miny);
assert_eq!(10.0, right.maxy);
}
#[test]
pub fn test_get_top() {
let rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let top = rect.get_top(1.0);
assert_eq!(0.0, top.minx);
assert_eq!(10.0, top.maxx);
assert_eq!(0.0, top.miny);
assert_eq!(1.0, top.maxy);
}
#[test]
pub fn test_get_bottom() {
let rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let bottom = rect.get_bottom(1.0);
assert_eq!(0.0, bottom.minx);
assert_eq!(10.0, bottom.maxx);
assert_eq!(9.0, bottom.miny);
assert_eq!(10.0, bottom.maxy);
}
#[test]
pub fn test_add_left() {
let rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let left = rect.add_left(1.0);
assert_eq!(-1.0, left.minx);
assert_eq!(0.0, left.maxx);
assert_eq!(0.0, left.miny);
assert_eq!(10.0, left.maxy);
}
#[test]
pub fn test_add_right() {
let rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let right = rect.add_right(1.0);
assert_eq!(10.0, right.minx);
assert_eq!(11.0, right.maxx);
assert_eq!(0.0, right.miny);
assert_eq!(10.0, right.maxy);
}
#[test]
pub fn test_add_top() {
let rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let top = rect.add_top(1.0);
assert_eq!(0.0, top.minx);
assert_eq!(10.0, top.maxx);
assert_eq!(-1.0, top.miny);
assert_eq!(0.0, top.maxy);
}
#[test]
pub fn test_add_bottom() {
let rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let bottom = rect.add_bottom(1.0);
assert_eq!(0.0, bottom.minx);
assert_eq!(10.0, bottom.maxx);
assert_eq!(10.0, bottom.miny);
assert_eq!(11.0, bottom.maxy);
}
#[test]
pub fn test_extend() {
let rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let extended = rect.extend(1.0);
assert_eq!(-1.0, extended.minx);
assert_eq!(11.0, extended.maxx);
assert_eq!(-1.0, extended.miny);
assert_eq!(11.0, extended.maxy);
}
#[test]
pub fn test_contract() {
let rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let contract = rect.contract(1.0);
assert_eq!(1.0, contract.minx);
assert_eq!(9.0, contract.maxx);
assert_eq!(1.0, contract.miny);
assert_eq!(9.0, contract.maxy);
}
#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
pub enum RectCutSide {
Left,
Right,
Top,
Bottom,
}
#[derive(Copy, Clone, Debug)]
struct RectCut {
pub rect: Rect,
pub side: RectCutSide,
}
impl RectCut {
pub fn new(rect: Rect, side: RectCutSide) -> RectCut {
return RectCut { rect, side };
}
pub fn cut(&mut self, a: f32) -> Rect {
match self.side {
RectCutSide::Left => return self.rect.cut_left(a),
RectCutSide::Right => return self.rect.cut_right(a),
RectCutSide::Top => return self.rect.cut_top(a),
RectCutSide::Bottom => return self.rect.cut_bottom(a),
}
}
}
#[test]
fn test_rectcut() {
let rect = Rect::new(0.0, 0.0, 10.0, 10.0);
let mut rectcut = RectCut::new(rect, RectCutSide::Left);
let left = rectcut.cut(1.0);
assert_eq!(0.0, left.minx);
assert_eq!(0.0, left.miny);
assert_eq!(1.0, left.maxx);
assert_eq!(10.0, left.maxy);
assert_eq!(1.0, rectcut.rect.minx);
assert_eq!(0.0, rectcut.rect.miny);
assert_eq!(10.0, rectcut.rect.maxx);
assert_eq!(10.0, rectcut.rect.maxy);
}