From abf55d8d46fc7d5cfccc9f778da6fca10b33d0cd Mon Sep 17 00:00:00 2001
From: Arne Dußin
Date: Sat, 21 Nov 2020 20:55:47 +0100
Subject: Move containment of points/ lines into trait

---
 src/math/rect.rs | 112 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 57 insertions(+), 55 deletions(-)

(limited to 'src/math/rect.rs')

diff --git a/src/math/rect.rs b/src/math/rect.rs
index 6988b2c..876e728 100644
--- a/src/math/rect.rs
+++ b/src/math/rect.rs
@@ -1,6 +1,6 @@
-use super::Vec2;
+use super::{LineSegment, Surface, Vec2};
 //use alga::general::{Additive, Identity};
-use nalgebra::{RealField, Scalar};
+use nalgebra::{ClosedAdd, RealField, Scalar};
 use num_traits::identities::Zero;
 use serde::{Deserialize, Serialize};
 use std::ops::{Add, AddAssign, Sub};
@@ -18,48 +18,6 @@ pub struct Rect<T: Scalar + Copy> {
     pub h: T,
 }
 
-// This is sad, but also sadly necessary :/
-impl<T: Into<f32> + Scalar + Copy> Into<raylib::ffi::Rectangle> for Rect<T> {
-    fn into(self) -> raylib::ffi::Rectangle {
-        raylib::ffi::Rectangle {
-            x: self.x.into(),
-            y: self.y.into(),
-            width: self.w.into(),
-            height: self.h.into(),
-        }
-    }
-}
-impl<T: From<f32> + Scalar + Copy> From<raylib::ffi::Rectangle> for Rect<T> {
-    fn from(r: raylib::ffi::Rectangle) -> Self {
-        Self {
-            x: T::from(r.x),
-            y: T::from(r.y),
-            w: T::from(r.width),
-            h: T::from(r.height),
-        }
-    }
-}
-impl<T: Into<f32> + Scalar + Copy> Into<raylib::math::Rectangle> for Rect<T> {
-    fn into(self) -> raylib::math::Rectangle {
-        raylib::math::Rectangle {
-            x: self.x.into(),
-            y: self.y.into(),
-            width: self.w.into(),
-            height: self.h.into(),
-        }
-    }
-}
-impl<T: From<f32> + Scalar + Copy> From<raylib::math::Rectangle> for Rect<T> {
-    fn from(r: raylib::math::Rectangle) -> Self {
-        Self {
-            x: T::from(r.x),
-            y: T::from(r.y),
-            w: T::from(r.width),
-            h: T::from(r.height),
-        }
-    }
-}
-
 impl<T: Scalar + Copy> Rect<T> {
     pub fn new(x: T, y: T, w: T, h: T) -> Self {
         Self { x, y, w, h }
@@ -105,17 +63,6 @@ impl<T: Scalar + Copy> Rect<T> {
             || this.y + this.h < other.y)
     }
 
-    /// Check if the point is inside this Rect and return true if so.
-    pub fn contains(&self, point: Vec2<T>) -> bool
-    where
-        T: PartialOrd + Add<Output = T>,
-    {
-        point.x >= self.x
-            && point.x <= self.x + self.w
-            && point.y >= self.y
-            && point.y <= self.y + self.h
-    }
-
     /// Returns true if the entire rect is contained inside this rectangle.
     pub fn contains_rect(&self, rect: Rect<T>) -> bool
     where
@@ -181,6 +128,61 @@ impl<T: Scalar + Copy> Rect<T> {
     }
 }
 
+impl<T: Scalar + Copy + PartialOrd + ClosedAdd> Surface<T> for Rect<T> {
+    fn contains_point(&self, point: &Vec2<T>) -> bool {
+        point.x >= self.x
+            && point.x <= self.x + self.w
+            && point.y >= self.y
+            && point.y <= self.y + self.h
+    }
+
+    fn contains_line_segment(&self, line_segment: &LineSegment<T>) -> bool {
+        self.contains_point(&line_segment.start) && self.contains_point(&line_segment.end)
+    }
+}
+
+// This is sad, but also sadly necessary :/
+impl<T: Into<f32> + Scalar + Copy> Into<raylib::ffi::Rectangle> for Rect<T> {
+    fn into(self) -> raylib::ffi::Rectangle {
+        raylib::ffi::Rectangle {
+            x: self.x.into(),
+            y: self.y.into(),
+            width: self.w.into(),
+            height: self.h.into(),
+        }
+    }
+}
+impl<T: From<f32> + Scalar + Copy> From<raylib::ffi::Rectangle> for Rect<T> {
+    fn from(r: raylib::ffi::Rectangle) -> Self {
+        Self {
+            x: T::from(r.x),
+            y: T::from(r.y),
+            w: T::from(r.width),
+            h: T::from(r.height),
+        }
+    }
+}
+impl<T: Into<f32> + Scalar + Copy> Into<raylib::math::Rectangle> for Rect<T> {
+    fn into(self) -> raylib::math::Rectangle {
+        raylib::math::Rectangle {
+            x: self.x.into(),
+            y: self.y.into(),
+            width: self.w.into(),
+            height: self.h.into(),
+        }
+    }
+}
+impl<T: From<f32> + Scalar + Copy> From<raylib::math::Rectangle> for Rect<T> {
+    fn from(r: raylib::math::Rectangle) -> Self {
+        Self {
+            x: T::from(r.x),
+            y: T::from(r.y),
+            w: T::from(r.width),
+            h: T::from(r.height),
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
-- 
cgit v1.2.3-70-g09d2