remade matrix classes to reduce dependencies and enable constexpr

Author: Raelr

engine/utils/math/Projection.h

@@ -0,0 +1,108 @@
+//
+//  Copyright (c) 2022 Jonathan Moallem (@J-Mo63) & Aryeh Zinn (@Raelr)
+//
+//  This code is released under an unmodified zlib license.
+//  For conditions of distribution and use, please see:
+//      https://opensource.org/licenses/Zlib
+//
+
+#ifndef SIEGE_ENGINE_UTILS_MATH_PROJECTION_H
+#define SIEGE_ENGINE_UTILS_MATH_PROJECTION_H
+
+#include "../Logging.h"
+#include "mat/Mat4.h"
+#include "vec/Vec2.h"
+#include "vec/Vec3.h"
+
+namespace Siege
+{
+/**
+ * Creates a right-handed perspective matrix
+ * @param fovy the vertical field of view of the perspective projection
+ * @param aspect the aspect ratio of the perspective view
+ * @param near the near plane
+ * @param far the far plane
+ * @return a new matrix with the provided perspective values
+ */
+inline constexpr Mat4 Perspective(float fovy, float aspect, float near, float far)
+{
+    float const tanHalfFovy = tan(fovy / 2);
+
+    Mat4 result(0);
+    result[0][0] = 1 / (aspect * tanHalfFovy);
+    result[1][1] = -1 / tanHalfFovy;
+    result[2][2] = far / (near - far);
+    result[2][3] = -1;
+    result[3][2] = -(far * near) / (far - near);
+    return result;
+}
+
+/**
+ * Creates a right-handed orthographic projection
+ * @param left the left side of the screen
+ * @param right the right side (the far edge of the screen)
+ * @param bottom the bottom of the screen
+ * @param top the top of the screen
+ * @param zNear the near clipping plane
+ * @param zFar the far clipping plane
+ * @return a new matrix with the orthographic projection
+ */
+inline constexpr Mat4 Orthographic(float left,
+                                   float right,
+                                   float bottom,
+                                   float top,
+                                   float zNear,
+                                   float zFar)
+{
+    Mat4 result(1);
+    result[0][0] = 2.f / (right - left);
+    result[1][1] = -2.f / (bottom - top);
+    result[2][2] = -1.f / (zFar - zNear);
+    result[3][0] = -(right + left) / (right - left);
+    result[3][1] = -(bottom + top) / (bottom - top);
+    result[3][2] = -zNear / (zFar - zNear);
+    return result;
+}
+
+/**
+ * Un-projects a point from 2D view space to 3D world space
+ * @param viewMatrix the view matrix to un-project from
+ * @param projection the projection matrix used by the scene
+ * @param ndc the normalised device coordinates (-1 to 1 on the x and y coordinates and 0 to 1 on
+ * the z coordinates)
+ * @return a 3D vector specifying the position in 3D space
+ */
+inline constexpr Vec3 UnProjectPoint3D(const Mat4& viewMatrix,
+                                       const Mat4 projection,
+                                       const Vec4& ndc)
+{
+    Mat4 inv = Mat4::Inverse(projection * viewMatrix);
+
+    Vec4 unProjected = inv* Vec4 {ndc.XYZ(), 1.f};
+    return unProjected.XYZ() / unProjected.w;
+}
+
+/**
+ * Converts a 3D coordinate to screen space
+ * @param worldCoords the position in 3D space
+ * @param viewProjection the combined view + projection matrix
+ * @param width the width of the viewport
+ * @param height the height of the viewport
+ * @return a 2D vector specifying the position in screen space
+ */
+inline constexpr Vec2 WorldToScreen(const Vec3& worldCoords,
+                                    const Mat4& viewProjection,
+                                    float width,
+                                    float height)
+{
+    Siege::Vec4 clipCoords = viewProjection * Siege::Vec4 {worldCoords.XYZ(), 1.f};
+    Siege::Vec3 coords = clipCoords.XYZ() / clipCoords.w;
+
+    float x = ((coords.x + 1.f) * 0.5f) * width;
+    float y = ((coords.y + 1.f) * 0.5f) * height;
+
+    return {x, y};
+}
+} // namespace Siege
+
+#endif // SIEGE_ENGINE_PROJECTION_H

engine/utils/math/Transform.h

@@ -0,0 +1,177 @@
+//
+//  Copyright (c) 2022 Jonathan Moallem (@J-Mo63) & Aryeh Zinn (@Raelr)
+//
+//  This code is released under an unmodified zlib license.
+//  For conditions of distribution and use, please see:
+//      https://opensource.org/licenses/Zlib
+//
+
+#ifndef SIEGE_ENGINE_UTILS_MATH_TRANSFORM_H
+#define SIEGE_ENGINE_UTILS_MATH_TRANSFORM_H
+
+#include <cmath>
+
+#include "mat/Mat4.h"
+#include "vec/Vec2.h"
+#include "vec/Vec3.h"
+
+namespace Siege
+{
+/**
+ * Creates a view matrix which is pointing at a specific location in 3D space
+ * @param eye the position of the camera
+ * @param center the location the camera is pointing at
+ * @param up the global up direction in world space (defaults to -1 on the y axis)
+ * @return a new 4x4 matrix with the view matrix values
+ */
+inline constexpr Mat4 LookAt(const Vec3& eye, const Vec3& center, const Vec3& up = Vec3::Up())
+{
+    Vec3 const f(Vec3::Normalise(center - eye));
+    Vec3 const s(Vec3::Normalise(Vec3::Cross(f, up)));
+    Vec3 const u(Vec3::Cross(s, f));
+
+    Mat4 result {1};
+    result[0][0] = s.x;
+    result[1][0] = s.y;
+    result[2][0] = s.z;
+    result[0][1] = u.x;
+    result[1][1] = u.y;
+    result[2][1] = u.z;
+    result[0][2] = -f.x;
+    result[1][2] = -f.y;
+    result[2][2] = -f.z;
+    result[3][0] = -Vec3::Dot(s, eye);
+    result[3][1] = -Vec3::Dot(u, eye);
+    result[3][2] = Vec3::Dot(f, eye);
+    return result;
+}
+
+/**
+ * Creates a translation matrix. A translation matrix specifies a movement in space
+ * @param matrix the 4x4 matrix to translate
+ * @param position the position to move the matrix to
+ * @return a new matrix with the provided translation
+ */
+inline constexpr Mat4 Translate(const Mat4& matrix, const Vec3& position)
+{
+    Mat4 result = matrix;
+    result[3] =
+        matrix[0] * position[0] + matrix[1] * position[1] + matrix[2] * position[2] + matrix[3];
+    return result;
+}
+
+/**
+ * Creates a rotation matrix
+ * @param matrix the matrix to rotate
+ * @param angle the angle of rotation
+ * @param rotation the axis to rotate the matrix on (specified by using 1 for the axis)
+ * @return a new matrix specifying the rotation
+ */
+inline constexpr Mat4 Rotate(const Mat4& matrix, float angle, const Vec3& rotation)
+{
+    float const a = angle;
+    float const c = cos(a);
+    float const s = sin(a);
+
+    Vec3 axis(Vec3::Normalise(rotation));
+    Vec3 temp((1 - c) * axis);
+
+    Mat4 rotate;
+    rotate[0][0] = c + temp[0] * axis[0];
+    rotate[0][1] = temp[0] * axis[1] + s * axis[2];
+    rotate[0][2] = temp[0] * axis[2] - s * axis[1];
+
+    rotate[1][0] = temp[1] * axis[0] - s * axis[2];
+    rotate[1][1] = c + temp[1] * axis[1];
+    rotate[1][2] = temp[1] * axis[2] + s * axis[0];
+
+    rotate[2][0] = temp[2] * axis[0] + s * axis[1];
+    rotate[2][1] = temp[2] * axis[1] - s * axis[0];
+    rotate[2][2] = c + temp[2] * axis[2];
+
+    Mat4 result;
+    result[0] = matrix[0] * rotate[0][0] + matrix[1] * rotate[0][1] + matrix[2] * rotate[0][2];
+    result[1] = matrix[0] * rotate[1][0] + matrix[1] * rotate[1][1] + matrix[2] * rotate[1][2];
+    result[2] = matrix[0] * rotate[2][0] + matrix[1] * rotate[2][1] + matrix[2] * rotate[2][2];
+    result[3] = matrix[3];
+    return result;
+}
+
+/**
+ * Creates a scale matrix
+ * @param matrix the matrix to scale
+ * @param scale the dimensions to scale the matrix by
+ * @return a matrix with the new scaling factors
+ */
+inline constexpr Mat4 Scale(const Mat4& matrix, const Vec3 scale)
+{
+    Mat4 result;
+    result[0] = matrix[0] * scale.x;
+    result[1] = matrix[1] * scale.y;
+    result[2] = matrix[2] * scale.z;
+    result[3] = matrix[3];
+    return result;
+}
+
+/**
+ * Creates a transform matrix in 3D space
+ * @param position the position in 3D space
+ * @param rotation the rotation in 3D space
+ * @param scale the scale in 3D space
+ * @return a new 4x4 matrix specifying the 3D transform
+ */
+inline constexpr Mat4 Transform3D(const Vec3& position, const Vec3& rotation, const Vec3& scale)
+{
+    const float cosR = Float::Cos(rotation.z);
+    const float sinR = Float::Sin(rotation.z);
+    const float cosP = Float::Cos(rotation.x);
+    const float sinP = Float::Sin(rotation.x);
+    const float cosY = Float::Cos(rotation.y);
+    const float sinY = Float::Sin(rotation.y);
+
+    return {{scale.x * (cosY * cosR + sinY * sinP * sinR),
+             scale.x * (cosP * sinR),
+             scale.x * (cosY * sinP * sinR - cosR * sinY)},
+            {scale.y * (cosR * sinY * sinP - cosY * sinR),
+             scale.y * (cosP * cosR),
+             scale.y * (cosY * cosR * sinP + sinY * sinR)},
+            {scale.z * (cosP * sinY), scale.z * (-sinP), scale.z * (cosY * cosP)},
+            {position.XYZ(), 1.0f}};
+}
+
+/**
+ * Calculates the normal matrix for a 3D object
+ * @param rotation the rotation of the object
+ * @param scale the scale of the object
+ * @return a 4x4 matrix specifying the object normals
+ */
+inline constexpr Mat4 Normal(const Vec3& rotation, const Vec3& scale)
+{
+    const float cosR = Float::Cos(rotation.z);
+    const float sinR = Float::Sin(rotation.z);
+    const float cosP = Float::Cos(rotation.x);
+    const float sinP = Float::Sin(rotation.x);
+    const float cosY = Float::Cos(rotation.y);
+    const float SinY = Float::Sin(rotation.y);
+
+    Siege::Vec3 inverseScale = 1.0f / scale;
+
+    return {{
+                inverseScale.x * (cosY * cosR + SinY * sinP * sinR),
+                inverseScale.x * (cosP * sinR),
+                inverseScale.x * (cosY * sinP * sinR - cosR * SinY),
+            },
+            {
+                inverseScale.y * (cosR * SinY * sinP - cosY * sinR),
+                inverseScale.y * (cosP * cosR),
+                inverseScale.y * (cosY * cosR * sinP + SinY * sinR),
+            },
+            {
+                inverseScale.z * (cosP * SinY),
+                inverseScale.z * (-sinP),
+                inverseScale.z * (cosY * cosP),
+            }};
+}
+} // namespace Siege
+
+#endif // SIEGE_ENGINE_UTILS_MATH_TRANSFORM_H

engine/utils/math/mat/Equality.h

@@ -0,0 +1,77 @@
+//
+//  Copyright (c) 2022 Jonathan Moallem (@J-Mo63) & Aryeh Zinn (@Raelr)
+//
+//  This code is released under an unmodified zlib license.
+//  For conditions of distribution and use, please see:
+//      https://opensource.org/licenses/Zlib
+//
+
+#ifndef SIEGE_ENGINE_UTILS_MATH_MAT_EQUALITY_H
+#define SIEGE_ENGINE_UTILS_MATH_MAT_EQUALITY_H
+
+#include "Mat.h"
+#include <cmath>
+
+namespace Siege
+{
+/**
+ * A fuzzy equals comparison function. Checks if two 4x4 matrices are equal within a given tolerance
+ * level
+ * @tparam T the type of numerical value stored by the matrix
+ * @param lhs the matrix on the left hand side of the operation
+ * @param rhs the matrix on the right hand side of the operation
+ * @return a boolean specifying if they are equal within the given tolerance
+ */
+template<typename T>
+inline constexpr bool FEquals(const Mat<T, 4, 4>& lhs, const Mat<T, 4, 4>& rhs)
+{
+    T epsilon = std::numeric_limits<T>::epsilon();
+
+    return (lhs[0][0] - rhs[0][0] <= epsilon) && (lhs[0][1] - rhs[0][1] <= epsilon) &&
+           (lhs[0][2] - rhs[0][2] <= epsilon) && (lhs[0][3] - rhs[0][3] <= epsilon) &&
+           (lhs[1][0] - rhs[1][0] <= epsilon) && (lhs[1][1] - rhs[1][1] <= epsilon) &&
+           (lhs[1][2] - rhs[1][2] <= epsilon) && (lhs[1][3] - rhs[1][3] <= epsilon) &&
+           (lhs[2][0] - rhs[2][0] <= epsilon) && (lhs[2][1] - rhs[2][1] <= epsilon) &&
+           (lhs[2][2] - rhs[2][2] <= epsilon) && (lhs[2][3] - rhs[2][3] <= epsilon) &&
+           (lhs[3][0] - rhs[3][0] <= epsilon) && (lhs[3][1] - rhs[3][1] <= epsilon) &&
+           (lhs[3][2] - rhs[3][2] <= epsilon) && (lhs[3][3] - rhs[3][3] <= epsilon);
+}
+
+/**
+ * A fuzzy equals comparison function. Checks if two 3x3 matrices are equal within a given tolerance
+ * level
+ * @tparam T the type of numerical value stored by the matrix
+ * @param lhs the matrix on the left hand side of the operation
+ * @param rhs the matrix on the right hand side of the operation
+ * @return a boolean specifying if they are equal within the given tolerance
+ */
+template<typename T>
+inline constexpr bool FEquals(const Mat<T, 3, 3>& lhs, const Mat<T, 3, 3>& rhs)
+{
+    T epsilon = std::numeric_limits<T>::epsilon();
+
+    return (lhs[0][0] - rhs[0][0] <= epsilon) && (lhs[0][1] - rhs[0][1] <= epsilon) &&
+           (lhs[0][2] - rhs[0][2] <= epsilon) && (lhs[1][0] - rhs[1][0] <= epsilon) &&
+           (lhs[1][1] - rhs[1][1] <= epsilon) && (lhs[1][2] - rhs[1][2] <= epsilon) &&
+           (lhs[2][0] - rhs[2][0] <= epsilon) && (lhs[2][1] - rhs[2][1] <= epsilon) &&
+           (lhs[2][2] - rhs[2][2] <= epsilon);
+}
+
+/**
+ * A fuzzy equals comparison function. Checks if two 2x2 matrices are equal within a given tolerance
+ * level
+ * @tparam T the type of numerical value stored by the matrix
+ * @param lhs the matrix on the left hand side of the operation
+ * @param rhs the matrix on the right hand side of the operation
+ * @return a boolean specifying if they are equal within the given tolerance
+ */
+template<typename T>
+inline constexpr bool FEquals(const Mat<T, 2, 2>& lhs, const Mat<T, 2, 2>& rhs)
+{
+    T epsilon = std::numeric_limits<T>::epsilon();
+    return (lhs[0][0] - rhs[0][0] <= epsilon) && (lhs[0][1] - rhs[0][1] <= epsilon) &&
+           (lhs[1][0] - rhs[1][0] <= epsilon) && (lhs[1][1] - rhs[1][1] <= epsilon);
+}
+} // namespace Siege
+
+#endif // SIEGE_ENGINE_UTILS_MATH_MAT_EQUALITY_H