Multithreaded world generation with Perlin

1 files changed, 17 insertions, 1 deletions

diff --git a/src/Math/Vector.hpp b/src/Math/Vector.hpp
index cb5eb24..9cc2d75 100644
--- a/src/Math/Vector.hpp
+++ b/src/Math/Vector.hpp
@@ -12,13 +12,17 @@ struct Vector {
 public:
     Vector(): elements{} {};
 
-    template<typename ...Args>
+    template<typename ...Args, typename std::enable_if<sizeof...(Args) == S, int>::type = 0>
     Vector<S, T>(Args... args) : elements{ args... } {};
 
     Vector<S, T>(T values[S]) {
         std::copy(values, values + S, elements);
     };
 
+    Vector<S, T>(T scalar) {
+        std::fill(elements, elements + S, scalar);
+    };
+
     Vector<S, T>(Vector<S - 1, T> vector, T scalar) {
         std::copy(vector.elements, vector.elements + S - 1, elements);
         elements[S - 1] = scalar;
@@ -61,6 +65,10 @@ public:
         return map([=](auto x) { return x / m; });
     }
 
+    Vector<S, T> abs() const {
+        return map([=](auto x) { return std::abs(x); });
+    }
+
     Vector<3, T> cross(Vector<3, T> other) const {
         return {
             y() * other.z() - z() * other.y(),
@@ -81,6 +89,10 @@ public:
         return map([&](auto i, auto x) { return x + other[i]; });
     }
 
+    Vector<S, T> operator+(T scalar) const {
+        return map([=](auto x) { return x + scalar; });
+    }
+
     Vector<S, T> operator*(T scalar) const {
         return map([=](auto x) { return x * scalar; });
     }
@@ -97,6 +109,10 @@ public:
         return map([](T x) -> T { return -x; });
     }
 
+    Vector<S, T> operator/(T scalar) const {
+        return map([=](auto x) { return x / scalar; });
+    }
+
     T x() const {
         static_assert(S > 0);
         return elements[0];