From 221f632d6600ce03e09c2a44074ae100a507dd92 Mon Sep 17 00:00:00 2001
From: Mel <einebeere@gmail.com>
Date: Sat, 1 Jul 2023 22:03:51 +0200
Subject: Replace bespoke Generator maps with tensors and matrices

---
 src/Math/Matrix.hpp | 24 +++++++++++-------------
 src/Math/Tensor.hpp | 43 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+), 13 deletions(-)
 create mode 100644 src/Math/Tensor.hpp

(limited to 'src/Math')

diff --git a/src/Math/Matrix.hpp b/src/Math/Matrix.hpp
index 276dc4a..69241d3 100644
--- a/src/Math/Matrix.hpp
+++ b/src/Math/Matrix.hpp
@@ -2,23 +2,21 @@
 
 #include <sstream>
 #include <cstddef>
-#include <iostream>
 #include "Rotation.hpp"
 #include "Trig.hpp"
 
 template <size_t R, size_t C, typename T = float>
 struct Matrix {
-public:
-    Matrix<R, C, T>() : elements{} {};
+    Matrix() : elements{} {};
 
-    Matrix<R, C, T>(T scalar) {
+    explicit Matrix(T scalar) {
         std::fill(elements, elements + R * C, scalar);
     };
 
-    template<typename ...Args, typename std::enable_if<sizeof...(Args) == R * C, int>::type = 0>
-    Matrix<R, C, T>(Args... args): elements{ args... } {};
+    template<typename ...Args, typename std::enable_if_t<sizeof...(Args) == R * C, int> = 0>
+    Matrix(Args... args): elements{ args... } {};
 
-    Matrix<R, C, T>(T values[R * C]) {
+    explicit Matrix(T values[R * C]) {
         std::copy(values, values + R * C, elements);
     };
 
@@ -81,8 +79,8 @@ public:
         return result;
     }
 
-    Matrix<R, C, T> transpose() {
-        Matrix<R, C, T> result{};
+    Matrix transpose() {
+        Matrix result{};
         for (int y = 0; y < R; y++) {
             for (int x = 0; x < C; x++) {
                 result(x, y) = this->operator()(y, x);
@@ -91,16 +89,16 @@ public:
         return result;
     }
 
-    Matrix<R, C, T> operator+(Matrix<R, C, T> other) {
-        Matrix<R, C, T> result{};
+    Matrix operator+(Matrix other) {
+        Matrix result{};
         for (int i = 0; i < R * C; i++) {
             result.elements[i] = elements[i] + other.elements[i];
         }
         return result;
     }
 
-    Matrix<R, C, T> operator*(float scalar) {
-        Matrix<R, C, T> result{};
+    Matrix operator*(float scalar) {
+        Matrix result{};
         for (int i = 0; i < R * C; i++) {
             result.elements[i] = elements[i] * scalar;
         }
diff --git a/src/Math/Tensor.hpp b/src/Math/Tensor.hpp
new file mode 100644
index 0000000..e373c1f
--- /dev/null
+++ b/src/Math/Tensor.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+template<size_t O, typename T, size_t ...S>
+struct Tensor {
+    static constexpr size_t element_size = (S*...);
+
+    template<typename ...Args>
+    using EnableArgs = std::enable_if_t<sizeof...(Args) == O, bool>;
+    template<typename ...Args>
+    using EnableArgsPerElement = std::enable_if_t<sizeof...(Args) == element_size, bool>;
+    using Enable = std::enable_if_t<sizeof...(S) == O, bool>;
+
+    template<Enable = true>
+    Tensor() : elements{} {}
+
+    template<Enable = true>
+    explicit Tensor(T scalar) {
+        std::fill(elements, elements + element_size, scalar);
+    }
+
+    template<Enable = true, typename ...Args, EnableArgsPerElement<Args...> = true>
+    Tensor(Args... args) : elements{ args... } {}
+
+    template<typename ...Args, EnableArgs<Args...> = true>
+    auto& operator()(Args... args) {
+        return elements[pos(args...)];
+    }
+
+    template<typename ...Args, EnableArgs<Args...> = true>
+    static constexpr size_t pos(Args... args) {
+        size_t positions[O] = {static_cast<size_t>(args)...};
+        size_t dimensions[O] = {S...};
+
+        size_t p = 0;
+        for (int i = 0; i < O; i++) {
+            p *= dimensions[i];
+            p += positions[i];
+        }
+        return p;
+    }
+
+    T elements[element_size];
+};
-- 
cgit 1.4.1