Add polygon that can check if a point is inside

..except for one super super edgy edge case, but I wanted to get this
algorithm out into a commit before I ruin it completely (probably)

1 files changed, 29 insertions, 2 deletions

diff --git a/src/math/mod.rs b/src/math/mod.rs
index 07d518e..bfc2ab4 100644
--- a/src/math/mod.rs
+++ b/src/math/mod.rs
@@ -1,9 +1,15 @@
+pub mod line_segment;
+pub mod polygon;
 pub mod rect;
-pub use self::rect::*;
-
 pub mod vec2;
+
+pub use self::line_segment::*;
+pub use self::polygon::*;
+pub use self::rect::*;
 pub use self::vec2::*;
 
+use std::cmp::Ordering;
+
 /// Round a floating point number to the nearest step given by the step argument. For instance, if
 /// the step is 0.5, then all numbers from 0.0 to 0.24999... will be 0., while all numbers from
 /// 0.25 to 0.74999... will be 0.5 and so on.
@@ -21,3 +27,24 @@ pub fn round(num: f32, step: f32) -> f32 {
         upper_bound
     }
 }
+
+/// Works like `std::cmp::max`, however also allows partial comparisons. It is specifically
+/// designed so functions that should be able to use f32 and f64 work, eventhough these do not
+/// implement Ord. The downside of this function however is, that its behaviour is undefined when
+/// `f32::NaN` for instance were to be passed.
+fn partial_max<T>(a: T, b: T) -> T
+where
+    T: PartialOrd,
+{
+    match a.partial_cmp(&b) {
+        Some(Ordering::Greater) => a,
+        _ => b,
+    }
+}
+/// Like `partial_max`, but for minimum values. Comes with the same downside, too.
+fn partial_min<T>(a: T, b: T) -> T
+where
+    T: PartialOrd,
+{
+    partial_max(b, a)
+}