Fix some math

Signed-off-by: Slendi <slendi@socopon.com>

examples/tour.cpp

@@ -39,6 +39,9 @@ int main() {
   std::println("std::get<1>(v): {}", std::get<1>(v));
   auto [x, y, z] = v;
   std::println("Bindings: [{}, {}, {}]", x, y, z);
+  float x1{}, y1{}, z1{};
+  v.unpack(x1, y1, z1);
+  std::println("Unpacked: {}, {}, {}", x1, y1, z1);
 
   // Let's mix and match!
   Vec<6> v3(v, 7, swizzle<"zy">(v2));

include/smath.hpp

@@ -162,6 +162,16 @@ public:
   VEC_ACC(v, 2, 1)
 #undef VEC_ACC
 
+  template <class... Args, std::size_t... Is>
+  constexpr void unpack_impl(std::index_sequence<Is...>,
+                             Args &...args) noexcept {
+    ((args = (*this)[Is]), ...);
+  }
+
+  template <class... Args> constexpr void unpack(Args &...args) noexcept {
+    unpack_impl(std::index_sequence_for<Args...>{}, args...);
+  }
+
   // Unary
   constexpr auto operator-() noexcept -> Vec {
     Vec r{};
@@ -731,6 +741,14 @@ template <typename T>
   return res;
 }
 
+template <typename T>
+[[nodiscard]] inline auto translate(Vec<2, T> const &v) -> Mat<3, 3, T> {
+	Mat<3, 3, T> res{1};
+	res[2].x() = v.x();
+	res[2].y() = v.y();
+	return res;
+}
+
 template <typename T>
 [[nodiscard]] inline auto rotate(Mat<3, 3, T> const &m, T const angle)
     -> Mat<3, 3, T> {
@@ -783,6 +801,16 @@ template <typename T>
   return res;
 }
 
+
+template <typename T>
+[[nodiscard]] inline auto translate(Vec<3, T> const &v) -> Mat<4, 4, T> {
+	Mat<4, 4, T> res{1};
+	res[3].x() = v.x();
+	res[3].y() = v.y();
+	res[3].z() = v.z();
+	return res;
+}
+
 template <typename T>
 [[nodiscard]] inline auto rotate(Mat<4, 4, T> const &m, T const angle)
     -> Mat<4, 4, T> {
@@ -861,24 +889,26 @@ matrix_ortho3d(T const left, T const right, T const bottom, T const top,
 template <typename T>
 inline auto matrix_perspective(T fovy, T aspect, T znear, T zfar,
                                bool flip_z_axis = false) -> Mat<4, 4, T> {
-  Mat<4, 4, T> m{};
+	Mat<4, 4, T> m{};
 
-  T const f{1 / std::tan(fovy / T(2))};
+	T const f{T(1) / std::tan(fovy / T(2))};
 
-  m(0, 0) = f / aspect;
+	m[0, 0] = f / aspect;
-  m(1, 1) = f;
+	m[1, 1] = f;
 
-  if (!flip_z_axis) {
+	if (!flip_z_axis) {
-    m(2, 2) = -(zfar + znear) / (zfar - znear);
+		m[2, 2] = -(zfar + znear) / (zfar - znear);
-    m(2, 3) = -(T(2) * zfar * znear) / (zfar - znear);
+		m[2, 3] = -(T(2) * zfar * znear) / (zfar - znear);
-    m(3, 2) = -1;
+		m[3, 2] = -1;
-  } else {
+		m[3, 3] = 0;
-    m(2, 2) = (zfar + znear) / (zfar - znear);
+	} else {
-    m(2, 3) = (T(2) * zfar * znear) / (zfar - znear);
+		m[2, 2] = (zfar + znear) / (zfar - znear);
-    m(3, 2) = 1;
+		m[2, 3] = (T(2) * zfar * znear) / (zfar - znear);
-  }
+		m[3, 2] = 1;
+		m[3, 3] = 0;
+	}
 
-  return m;
+	return m;
 }
 
 template <typename T>
@@ -890,18 +920,18 @@ matrix_look_at(Vec<3, T> const eye, Vec<3, T> const center, Vec<3, T> const up,
   auto u = s.cross(f);
 
   if (!flip_z_axis) {
-    return {
+    return Mat<4, 4, T>{
-        {s.x(), u.x(), -f.x(), 0},
+        Vec<4, T>{s.x(), s.y(), s.z(), 0},
-        {s.y(), u.y(), -f.y(), 0},
+        Vec<4, T>{u.x(), u.y(), u.z(), 0},
-        {s.z(), u.z(), -f.z(), 0},
+        Vec<4, T>{-f.x(), -f.y(), -f.z(), 0},
-        {-s.dot(eye), -u.dot(eye), f.dot(eye), 1},
+        Vec<4, T>{-s.dot(eye), -u.dot(eye), f.dot(eye), 1},
     };
   } else {
-    return {
+    return Mat<4, 4, T>{
-        {s.x(), u.x(), f.x(), 0},
+        Vec<4, T>{s.x(), s.y(), s.z(), 0},
-        {s.y(), u.y(), f.y(), 0},
+        Vec<4, T>{u.x(), u.y(), u.z(), 0},
-        {s.z(), u.z(), f.z(), 0},
+        Vec<4, T>{f.x(), f.y(), f.z(), 0},
-        {-s.dot(eye), -u.dot(eye), -f.dot(eye), 1},
+        Vec<4, T>{-s.dot(eye), -u.dot(eye), -f.dot(eye), 1},
     };
   }
 }