some fun changes.
This commit is contained in:
Yggdrasil75
166
util/vecmat/mat2.hpp
Normal file
166
util/vecmat/mat2.hpp
Normal file
@@ -0,0 +1,166 @@
|
||||
#ifndef MAT2_HPP
|
||||
#define MAT2_HPP
|
||||
|
||||
#include "Vec2.hpp"
|
||||
#include <array>
|
||||
#include <cmath>
|
||||
|
||||
class Mat2 {
|
||||
public:
|
||||
union {
|
||||
struct { float m00, m01, m10, m11; };
|
||||
struct { float a, b, c, d; };
|
||||
float data[4];
|
||||
float m[2][2];
|
||||
};
|
||||
|
||||
// Constructors
|
||||
Mat2() : m00(1), m01(0), m10(0), m11(1) {}
|
||||
Mat2(float scalar) : m00(scalar), m01(scalar), m10(scalar), m11(scalar) {}
|
||||
Mat2(float m00, float m01, float m10, float m11) : m00(m00), m01(m01), m10(m10), m11(m11) {}
|
||||
|
||||
// Identity matrix
|
||||
static Mat2 identity() { return Mat2(1, 0, 0, 1); }
|
||||
|
||||
// Zero matrix
|
||||
static Mat2 zero() { return Mat2(0, 0, 0, 0); }
|
||||
|
||||
// Rotation matrix
|
||||
static Mat2 rotation(float angle) {
|
||||
float cosA = std::cos(angle);
|
||||
float sinA = std::sin(angle);
|
||||
return Mat2(cosA, -sinA, sinA, cosA);
|
||||
}
|
||||
|
||||
// Scaling matrix
|
||||
static Mat2 scaling(const Vec2& scale) {
|
||||
return Mat2(scale.x, 0, 0, scale.y);
|
||||
}
|
||||
|
||||
// Arithmetic operations
|
||||
Mat2 operator+(const Mat2& other) const {
|
||||
return Mat2(m00 + other.m00, m01 + other.m01,
|
||||
m10 + other.m10, m11 + other.m11);
|
||||
}
|
||||
|
||||
Mat2 operator-(const Mat2& other) const {
|
||||
return Mat2(m00 - other.m00, m01 - other.m01,
|
||||
m10 - other.m10, m11 - other.m11);
|
||||
}
|
||||
|
||||
Mat2 operator*(const Mat2& other) const {
|
||||
return Mat2(
|
||||
m00 * other.m00 + m01 * other.m10,
|
||||
m00 * other.m01 + m01 * other.m11,
|
||||
m10 * other.m00 + m11 * other.m10,
|
||||
m10 * other.m01 + m11 * other.m11
|
||||
);
|
||||
}
|
||||
|
||||
Mat2 operator*(float scalar) const {
|
||||
return Mat2(m00 * scalar, m01 * scalar,
|
||||
m10 * scalar, m11 * scalar);
|
||||
}
|
||||
|
||||
Mat2 operator/(float scalar) const {
|
||||
return Mat2(m00 / scalar, m01 / scalar,
|
||||
m10 / scalar, m11 / scalar);
|
||||
}
|
||||
|
||||
Vec2 operator*(const Vec2& vec) const {
|
||||
return Vec2(
|
||||
m00 * vec.x + m01 * vec.y,
|
||||
m10 * vec.x + m11 * vec.y
|
||||
);
|
||||
}
|
||||
|
||||
Mat2& operator+=(const Mat2& other) {
|
||||
m00 += other.m00; m01 += other.m01;
|
||||
m10 += other.m10; m11 += other.m11;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Mat2& operator-=(const Mat2& other) {
|
||||
m00 -= other.m00; m01 -= other.m01;
|
||||
m10 -= other.m10; m11 -= other.m11;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Mat2& operator*=(const Mat2& other) {
|
||||
*this = *this * other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Mat2& operator*=(float scalar) {
|
||||
m00 *= scalar; m01 *= scalar;
|
||||
m10 *= scalar; m11 *= scalar;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Mat2& operator/=(float scalar) {
|
||||
m00 /= scalar; m01 /= scalar;
|
||||
m10 /= scalar; m11 /= scalar;
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool operator==(const Mat2& other) const {
|
||||
return m00 == other.m00 && m01 == other.m01 &&
|
||||
m10 == other.m10 && m11 == other.m11;
|
||||
}
|
||||
|
||||
bool operator!=(const Mat2& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
// Matrix operations
|
||||
float determinant() const {
|
||||
return m00 * m11 - m01 * m10;
|
||||
}
|
||||
|
||||
Mat2 transposed() const {
|
||||
return Mat2(m00, m10, m01, m11);
|
||||
}
|
||||
|
||||
Mat2 inverse() const {
|
||||
float det = determinant();
|
||||
if (std::abs(det) < 1e-10f) {
|
||||
return Mat2(); // Return identity if not invertible
|
||||
}
|
||||
float invDet = 1.0f / det;
|
||||
return Mat2( m11 * invDet, -m01 * invDet,
|
||||
-m10 * invDet, m00 * invDet);
|
||||
}
|
||||
|
||||
// Access operators
|
||||
float& operator()(int row, int col) {
|
||||
return m[row][col];
|
||||
}
|
||||
|
||||
const float& operator()(int row, int col) const {
|
||||
return m[row][col];
|
||||
}
|
||||
|
||||
float& operator[](int index) {
|
||||
return data[index];
|
||||
}
|
||||
|
||||
const float& operator[](int index) const {
|
||||
return data[index];
|
||||
}
|
||||
|
||||
std::string toString() const {
|
||||
return "Mat2([" + std::to_string(m00) + ", " + std::to_string(m01) + "],\n" +
|
||||
" [" + std::to_string(m10) + ", " + std::to_string(m11) + "])";
|
||||
}
|
||||
};
|
||||
|
||||
inline std::ostream& operator<<(std::ostream& os, const Mat2& mat) {
|
||||
os << mat.toString();
|
||||
return os;
|
||||
}
|
||||
|
||||
inline Mat2 operator*(float scalar, const Mat2& mat) {
|
||||
return mat * scalar;
|
||||
}
|
||||
|
||||
#endif
|
||||
232
util/vecmat/mat3.hpp
Normal file
232
util/vecmat/mat3.hpp
Normal file
@@ -0,0 +1,232 @@
|
||||
#ifndef MAT3_HPP
|
||||
#define MAT3_HPP
|
||||
|
||||
#include "Vec3.hpp"
|
||||
#include <array>
|
||||
#include <cmath>
|
||||
|
||||
class Mat3 {
|
||||
public:
|
||||
union {
|
||||
struct {
|
||||
float m00, m01, m02,
|
||||
m10, m11, m12,
|
||||
m20, m21, m22;
|
||||
};
|
||||
float data[9];
|
||||
float m[3][3];
|
||||
};
|
||||
|
||||
// Constructors
|
||||
Mat3() : m00(1), m01(0), m02(0),
|
||||
m10(0), m11(1), m12(0),
|
||||
m20(0), m21(0), m22(1) {}
|
||||
|
||||
Mat3(float scalar) : m00(scalar), m01(scalar), m02(scalar),
|
||||
m10(scalar), m11(scalar), m12(scalar),
|
||||
m20(scalar), m21(scalar), m22(scalar) {}
|
||||
|
||||
Mat3(float m00, float m01, float m02,
|
||||
float m10, float m11, float m12,
|
||||
float m20, float m21, float m22) :
|
||||
m00(m00), m01(m01), m02(m02),
|
||||
m10(m10), m11(m11), m12(m12),
|
||||
m20(m20), m21(m21), m22(m22) {}
|
||||
|
||||
// Identity matrix
|
||||
static Mat3 identity() {
|
||||
return Mat3(1, 0, 0,
|
||||
0, 1, 0,
|
||||
0, 0, 1);
|
||||
}
|
||||
|
||||
// Zero matrix
|
||||
static Mat3 zero() { return Mat3(0); }
|
||||
|
||||
// Rotation matrices
|
||||
static Mat3 rotationX(float angle) {
|
||||
float cosA = std::cos(angle);
|
||||
float sinA = std::sin(angle);
|
||||
return Mat3(1, 0, 0,
|
||||
0, cosA, -sinA,
|
||||
0, sinA, cosA);
|
||||
}
|
||||
|
||||
static Mat3 rotationY(float angle) {
|
||||
float cosA = std::cos(angle);
|
||||
float sinA = std::sin(angle);
|
||||
return Mat3(cosA, 0, sinA,
|
||||
0, 1, 0,
|
||||
-sinA, 0, cosA);
|
||||
}
|
||||
|
||||
static Mat3 rotationZ(float angle) {
|
||||
float cosA = std::cos(angle);
|
||||
float sinA = std::sin(angle);
|
||||
return Mat3(cosA, -sinA, 0,
|
||||
sinA, cosA, 0,
|
||||
0, 0, 1);
|
||||
}
|
||||
|
||||
// Scaling matrix
|
||||
static Mat3 scaling(const Vec3& scale) {
|
||||
return Mat3(scale.x, 0, 0,
|
||||
0, scale.y, 0,
|
||||
0, 0, scale.z);
|
||||
}
|
||||
|
||||
// Arithmetic operations
|
||||
Mat3 operator+(const Mat3& other) const {
|
||||
return Mat3(m00 + other.m00, m01 + other.m01, m02 + other.m02,
|
||||
m10 + other.m10, m11 + other.m11, m12 + other.m12,
|
||||
m20 + other.m20, m21 + other.m21, m22 + other.m22);
|
||||
}
|
||||
|
||||
Mat3 operator-(const Mat3& other) const {
|
||||
return Mat3(m00 - other.m00, m01 - other.m01, m02 - other.m02,
|
||||
m10 - other.m10, m11 - other.m11, m12 - other.m12,
|
||||
m20 - other.m20, m21 - other.m21, m22 - other.m22);
|
||||
}
|
||||
|
||||
Mat3 operator*(const Mat3& other) const {
|
||||
return Mat3(
|
||||
m00 * other.m00 + m01 * other.m10 + m02 * other.m20,
|
||||
m00 * other.m01 + m01 * other.m11 + m02 * other.m21,
|
||||
m00 * other.m02 + m01 * other.m12 + m02 * other.m22,
|
||||
|
||||
m10 * other.m00 + m11 * other.m10 + m12 * other.m20,
|
||||
m10 * other.m01 + m11 * other.m11 + m12 * other.m21,
|
||||
m10 * other.m02 + m11 * other.m12 + m12 * other.m22,
|
||||
|
||||
m20 * other.m00 + m21 * other.m10 + m22 * other.m20,
|
||||
m20 * other.m01 + m21 * other.m11 + m22 * other.m21,
|
||||
m20 * other.m02 + m21 * other.m12 + m22 * other.m22
|
||||
);
|
||||
}
|
||||
|
||||
Mat3 operator*(float scalar) const {
|
||||
return Mat3(m00 * scalar, m01 * scalar, m02 * scalar,
|
||||
m10 * scalar, m11 * scalar, m12 * scalar,
|
||||
m20 * scalar, m21 * scalar, m22 * scalar);
|
||||
}
|
||||
|
||||
Mat3 operator/(float scalar) const {
|
||||
return Mat3(m00 / scalar, m01 / scalar, m02 / scalar,
|
||||
m10 / scalar, m11 / scalar, m12 / scalar,
|
||||
m20 / scalar, m21 / scalar, m22 / scalar);
|
||||
}
|
||||
|
||||
Vec3 operator*(const Vec3& vec) const {
|
||||
return Vec3(
|
||||
m00 * vec.x + m01 * vec.y + m02 * vec.z,
|
||||
m10 * vec.x + m11 * vec.y + m12 * vec.z,
|
||||
m20 * vec.x + m21 * vec.y + m22 * vec.z
|
||||
);
|
||||
}
|
||||
|
||||
Mat3& operator+=(const Mat3& other) {
|
||||
*this = *this + other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Mat3& operator-=(const Mat3& other) {
|
||||
*this = *this - other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Mat3& operator*=(const Mat3& other) {
|
||||
*this = *this * other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Mat3& operator*=(float scalar) {
|
||||
*this = *this * scalar;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Mat3& operator/=(float scalar) {
|
||||
*this = *this / scalar;
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool operator==(const Mat3& other) const {
|
||||
for (int i = 0; i < 9; ++i) {
|
||||
if (data[i] != other.data[i]) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool operator!=(const Mat3& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
// Matrix operations
|
||||
float determinant() const {
|
||||
return m00 * (m11 * m22 - m12 * m21)
|
||||
- m01 * (m10 * m22 - m12 * m20)
|
||||
+ m02 * (m10 * m21 - m11 * m20);
|
||||
}
|
||||
|
||||
Mat3 transposed() const {
|
||||
return Mat3(m00, m10, m20,
|
||||
m01, m11, m21,
|
||||
m02, m12, m22);
|
||||
}
|
||||
|
||||
Mat3 inverse() const {
|
||||
float det = determinant();
|
||||
if (std::abs(det) < 1e-10f) {
|
||||
return Mat3(); // Return identity if not invertible
|
||||
}
|
||||
|
||||
float invDet = 1.0f / det;
|
||||
|
||||
return Mat3(
|
||||
(m11 * m22 - m12 * m21) * invDet,
|
||||
(m02 * m21 - m01 * m22) * invDet,
|
||||
(m01 * m12 - m02 * m11) * invDet,
|
||||
|
||||
(m12 * m20 - m10 * m22) * invDet,
|
||||
(m00 * m22 - m02 * m20) * invDet,
|
||||
(m02 * m10 - m00 * m12) * invDet,
|
||||
|
||||
(m10 * m21 - m11 * m20) * invDet,
|
||||
(m01 * m20 - m00 * m21) * invDet,
|
||||
(m00 * m11 - m01 * m10) * invDet
|
||||
);
|
||||
}
|
||||
|
||||
// Access operators
|
||||
float& operator()(int row, int col) {
|
||||
return m[row][col];
|
||||
}
|
||||
|
||||
const float& operator()(int row, int col) const {
|
||||
return m[row][col];
|
||||
}
|
||||
|
||||
float& operator[](int index) {
|
||||
return data[index];
|
||||
}
|
||||
|
||||
const float& operator[](int index) const {
|
||||
return data[index];
|
||||
}
|
||||
|
||||
std::string toString() const {
|
||||
return "Mat3([" + std::to_string(m00) + ", " + std::to_string(m01) + ", " + std::to_string(m02) + "],\n" +
|
||||
" [" + std::to_string(m10) + ", " + std::to_string(m11) + ", " + std::to_string(m12) + "],\n" +
|
||||
" [" + std::to_string(m20) + ", " + std::to_string(m21) + ", " + std::to_string(m22) + "])";
|
||||
}
|
||||
};
|
||||
|
||||
inline std::ostream& operator<<(std::ostream& os, const Mat3& mat) {
|
||||
os << mat.toString();
|
||||
return os;
|
||||
}
|
||||
|
||||
inline Mat3 operator*(float scalar, const Mat3& mat) {
|
||||
return mat * scalar;
|
||||
}
|
||||
|
||||
#endif
|
||||
355
util/vecmat/mat4.hpp
Normal file
355
util/vecmat/mat4.hpp
Normal file
@@ -0,0 +1,355 @@
|
||||
#ifndef MAT4_HPP
|
||||
#define MAT4_HPP
|
||||
|
||||
#include "../vectorlogic/vec3.hpp"
|
||||
#include "../vectorlogic/vec4.hpp"
|
||||
#include "../ray3.hpp"
|
||||
#include <array>
|
||||
#include <cmath>
|
||||
|
||||
template<typename T>
|
||||
class Mat4 {
|
||||
public:
|
||||
union {
|
||||
struct {
|
||||
T m00, m01, m02, m03,
|
||||
m10, m11, m12, m13,
|
||||
m20, m21, m22, m23,
|
||||
m30, m31, m32, m33;
|
||||
};
|
||||
T data[16];
|
||||
T m[4][4];
|
||||
};
|
||||
|
||||
// Constructors
|
||||
Mat4() : m00(1), m01(0), m02(0), m03(0),
|
||||
m10(0), m11(1), m12(0), m13(0),
|
||||
m20(0), m21(0), m22(1), m23(0),
|
||||
m30(0), m31(0), m32(0), m33(1) {}
|
||||
|
||||
Mat4(T scalar) : m00(scalar), m01(scalar), m02(scalar), m03(scalar),
|
||||
m10(scalar), m11(scalar), m12(scalar), m13(scalar),
|
||||
m20(scalar), m21(scalar), m22(scalar), m23(scalar),
|
||||
m30(scalar), m31(scalar), m32(scalar), m33(scalar) {}
|
||||
|
||||
Mat4(T m00, T m01, T m02, T m03,
|
||||
T m10, T m11, T m12, T m13,
|
||||
T m20, T m21, T m22, T m23,
|
||||
T m30, T m31, T m32, T m33) :
|
||||
m00(m00), m01(m01), m02(m02), m03(m03),
|
||||
m10(m10), m11(m11), m12(m12), m13(m13),
|
||||
m20(m20), m21(m21), m22(m22), m23(m23),
|
||||
m30(m30), m31(m31), m32(m32), m33(m33) {}
|
||||
|
||||
// Identity matrix
|
||||
static Mat4<T> identity() {
|
||||
return Mat4<T>(1, 0, 0, 0,
|
||||
0, 1, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
0, 0, 0, 1);
|
||||
}
|
||||
|
||||
// Zero matrix
|
||||
static Mat4 zero() { return Mat4(0); }
|
||||
|
||||
// Translation matrix
|
||||
static Mat4 translation(const Vec3<T>& translation) {
|
||||
return Mat4(1, 0, 0, translation.x,
|
||||
0, 1, 0, translation.y,
|
||||
0, 0, 1, translation.z,
|
||||
0, 0, 0, 1);
|
||||
}
|
||||
|
||||
// Rotation matrices
|
||||
static Mat4 rotationX(T angle) {
|
||||
T cosA = std::cos(angle);
|
||||
T sinA = std::sin(angle);
|
||||
return Mat4(1, 0, 0, 0,
|
||||
0, cosA, -sinA, 0,
|
||||
0, sinA, cosA, 0,
|
||||
0, 0, 0, 1);
|
||||
}
|
||||
|
||||
static Mat4 rotationY(T angle) {
|
||||
T cosA = std::cos(angle);
|
||||
T sinA = std::sin(angle);
|
||||
return Mat4(cosA, 0, sinA, 0,
|
||||
0, 1, 0, 0,
|
||||
-sinA, 0, cosA, 0,
|
||||
0, 0, 0, 1);
|
||||
}
|
||||
|
||||
static Mat4 rotationZ(T angle) {
|
||||
T cosA = std::cos(angle);
|
||||
T sinA = std::sin(angle);
|
||||
return Mat4(cosA, -sinA, 0, 0,
|
||||
sinA, cosA, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
0, 0, 0, 1);
|
||||
}
|
||||
|
||||
// Scaling matrix
|
||||
static Mat4 scaling(const Vec3<T>& scale) {
|
||||
return Mat4(scale.x, 0, 0, 0,
|
||||
0, scale.y, 0, 0,
|
||||
0, 0, scale.z, 0,
|
||||
0, 0, 0, 1);
|
||||
}
|
||||
|
||||
// Perspective projection matrix
|
||||
static Mat4 perspective(T fov, T aspect, T near, T far) {
|
||||
T tanHalfFov = std::tan(fov / static_cast<T>(2));
|
||||
T range = near - far;
|
||||
|
||||
return Mat4(static_cast<T>(1) / (aspect * tanHalfFov), 0, 0, 0,
|
||||
0, static_cast<T>(1) / tanHalfFov, 0, 0,
|
||||
0, 0, (-near - far) / range, static_cast<T>(2) * far * near / range,
|
||||
0, 0, 1, 0);
|
||||
}
|
||||
|
||||
// Orthographic projection matrix
|
||||
static Mat4 orthographic(T left, T right, T bottom, T top, T near, T far) {
|
||||
return Mat4(static_cast<T>(2) / (right - left), 0, 0, -(right + left) / (right - left),
|
||||
0, static_cast<T>(2) / (top - bottom), 0, -(top + bottom) / (top - bottom),
|
||||
0, 0, -static_cast<T>(2) / (far - near), -(far + near) / (far - near),
|
||||
0, 0, 0, 1);
|
||||
}
|
||||
|
||||
// LookAt matrix (view matrix)
|
||||
static Mat4 lookAt(const Vec3<T>& eye, const Vec3<T>& target, const Vec3<T>& up) {
|
||||
Vec3<T> z = (eye - target).normalized();
|
||||
Vec3<T> x = up.cross(z).normalized();
|
||||
Vec3<T> y = z.cross(x);
|
||||
|
||||
return Mat4(x.x, x.y, x.z, -x.dot(eye),
|
||||
y.x, y.y, y.z, -y.dot(eye),
|
||||
z.x, z.y, z.z, -z.dot(eye),
|
||||
0, 0, 0, 1);
|
||||
}
|
||||
|
||||
// Arithmetic operations
|
||||
Mat4 operator+(const Mat4& other) const {
|
||||
Mat4 result;
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
result.data[i] = data[i] + other.data[i];
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
Mat4 operator-(const Mat4& other) const {
|
||||
Mat4 result;
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
result.data[i] = data[i] - other.data[i];
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
Mat4 operator*(const Mat4& other) const {
|
||||
Mat4 result;
|
||||
for (int i = 0; i < 4; ++i) {
|
||||
for (int j = 0; j < 4; ++j) {
|
||||
result.m[i][j] = 0;
|
||||
for (int k = 0; k < 4; ++k) {
|
||||
result.m[i][j] += m[i][k] * other.m[k][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
Mat4 operator*(T scalar) const {
|
||||
Mat4 result;
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
result.data[i] = data[i] * scalar;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
Mat4 operator/(T scalar) const {
|
||||
Mat4 result;
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
result.data[i] = data[i] / scalar;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
Vec4<T> operator*(const Vec4<T>& vec) const {
|
||||
return Vec4<T>(
|
||||
m00 * vec.x + m01 * vec.y + m02 * vec.z + m03 * vec.w,
|
||||
m10 * vec.x + m11 * vec.y + m12 * vec.z + m13 * vec.w,
|
||||
m20 * vec.x + m21 * vec.y + m22 * vec.z + m23 * vec.w,
|
||||
m30 * vec.x + m31 * vec.y + m32 * vec.z + m33 * vec.w
|
||||
);
|
||||
}
|
||||
|
||||
Vec3<T> transformPoint(const Vec3<T>& point) const {
|
||||
Vec4<T> result = *this * Vec4<T>(point, static_cast<T>(1));
|
||||
return result.xyz() / result.w;
|
||||
}
|
||||
|
||||
Vec3<T> transformDirection(const Vec3<T>& direction) const {
|
||||
Vec4<T> result = *this * Vec4<T>(direction, static_cast<T>(0));
|
||||
return result.xyz();
|
||||
}
|
||||
|
||||
Mat4& operator+=(const Mat4& other) {
|
||||
*this = *this + other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Mat4& operator-=(const Mat4& other) {
|
||||
*this = *this - other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Mat4& operator*=(const Mat4& other) {
|
||||
*this = *this * other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Mat4& operator*=(T scalar) {
|
||||
*this = *this * scalar;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Mat4& operator/=(T scalar) {
|
||||
*this = *this / scalar;
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool operator==(const Mat4& other) const {
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
if (data[i] != other.data[i]) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool operator!=(const Mat4& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
// Matrix operations
|
||||
T determinant() const {
|
||||
// Using Laplace expansion for 4x4 determinant
|
||||
T det = 0;
|
||||
det += m00 * (m11 * (m22 * m33 - m23 * m32) - m12 * (m21 * m33 - m23 * m31) + m13 * (m21 * m32 - m22 * m31));
|
||||
det -= m01 * (m10 * (m22 * m33 - m23 * m32) - m12 * (m20 * m33 - m23 * m30) + m13 * (m20 * m32 - m22 * m30));
|
||||
det += m02 * (m10 * (m21 * m33 - m23 * m31) - m11 * (m20 * m33 - m23 * m30) + m13 * (m20 * m31 - m21 * m30));
|
||||
det -= m03 * (m10 * (m21 * m32 - m22 * m31) - m11 * (m20 * m32 - m22 * m30) + m12 * (m20 * m31 - m21 * m30));
|
||||
return det;
|
||||
}
|
||||
|
||||
Mat4 transposed() const {
|
||||
return Mat4(m00, m10, m20, m30,
|
||||
m01, m11, m21, m31,
|
||||
m02, m12, m22, m32,
|
||||
m03, m13, m23, m33);
|
||||
}
|
||||
|
||||
Mat4 inverse() const {
|
||||
T det = determinant();
|
||||
if (std::abs(det) < static_cast<T>(1e-10)) {
|
||||
return Mat4(); // Return identity if not invertible
|
||||
}
|
||||
|
||||
Mat4 result;
|
||||
T invDet = static_cast<T>(1) / det;
|
||||
|
||||
// Calculate inverse using adjugate matrix
|
||||
result.m00 = (m11 * (m22 * m33 - m23 * m32) - m12 * (m21 * m33 - m23 * m31) + m13 * (m21 * m32 - m22 * m31)) * invDet;
|
||||
result.m01 = (m01 * (m22 * m33 - m23 * m32) - m02 * (m21 * m33 - m23 * m31) + m03 * (m21 * m32 - m22 * m31)) * -invDet;
|
||||
result.m02 = (m01 * (m12 * m33 - m13 * m32) - m02 * (m11 * m33 - m13 * m31) + m03 * (m11 * m32 - m12 * m31)) * invDet;
|
||||
result.m03 = (m01 * (m12 * m23 - m13 * m22) - m02 * (m11 * m23 - m13 * m21) + m03 * (m11 * m22 - m12 * m21)) * -invDet;
|
||||
|
||||
result.m10 = (m10 * (m22 * m33 - m23 * m32) - m12 * (m20 * m33 - m23 * m30) + m13 * (m20 * m32 - m22 * m30)) * -invDet;
|
||||
result.m11 = (m00 * (m22 * m33 - m23 * m32) - m02 * (m20 * m33 - m23 * m30) + m03 * (m20 * m32 - m22 * m30)) * invDet;
|
||||
result.m12 = (m00 * (m12 * m33 - m13 * m32) - m02 * (m10 * m33 - m13 * m30) + m03 * (m10 * m32 - m12 * m30)) * -invDet;
|
||||
result.m13 = (m00 * (m12 * m23 - m13 * m22) - m02 * (m10 * m23 - m13 * m20) + m03 * (m10 * m22 - m12 * m20)) * invDet;
|
||||
|
||||
result.m20 = (m10 * (m21 * m33 - m23 * m31) - m11 * (m20 * m33 - m23 * m30) + m13 * (m20 * m31 - m21 * m30)) * invDet;
|
||||
result.m21 = (m00 * (m21 * m33 - m23 * m31) - m01 * (m20 * m33 - m23 * m30) + m03 * (m20 * m31 - m21 * m30)) * -invDet;
|
||||
result.m22 = (m00 * (m11 * m33 - m13 * m31) - m01 * (m10 * m33 - m13 * m30) + m03 * (m10 * m31 - m11 * m30)) * invDet;
|
||||
result.m23 = (m00 * (m11 * m23 - m13 * m21) - m01 * (m10 * m23 - m13 * m20) + m03 * (m10 * m21 - m11 * m20)) * -invDet;
|
||||
|
||||
result.m30 = (m10 * (m21 * m32 - m22 * m31) - m11 * (m20 * m32 - m22 * m30) + m12 * (m20 * m31 - m21 * m30)) * -invDet;
|
||||
result.m31 = (m00 * (m21 * m32 - m22 * m31) - m01 * (m20 * m32 - m22 * m30) + m02 * (m20 * m31 - m21 * m30)) * invDet;
|
||||
result.m32 = (m00 * (m11 * m32 - m12 * m31) - m01 * (m10 * m32 - m12 * m30) + m02 * (m10 * m31 - m11 * m30)) * -invDet;
|
||||
result.m33 = (m00 * (m11 * m22 - m12 * m21) - m01 * (m10 * m22 - m12 * m20) + m02 * (m10 * m21 - m11 * m20)) * invDet;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Access operators
|
||||
T& operator()(int row, int col) {
|
||||
return m[row][col];
|
||||
}
|
||||
|
||||
const T& operator()(int row, int col) const {
|
||||
return m[row][col];
|
||||
}
|
||||
|
||||
T& operator[](int index) {
|
||||
return data[index];
|
||||
}
|
||||
|
||||
const T& operator[](int index) const {
|
||||
return data[index];
|
||||
}
|
||||
|
||||
std::string toString() const {
|
||||
return "Mat4([" + std::to_string(m00) + ", " + std::to_string(m01) + ", " + std::to_string(m02) + ", " + std::to_string(m03) + "],\n" +
|
||||
" [" + std::to_string(m10) + ", " + std::to_string(m11) + ", " + std::to_string(m12) + ", " + std::to_string(m13) + "],\n" +
|
||||
" [" + std::to_string(m20) + ", " + std::to_string(m21) + ", " + std::to_string(m22) + ", " + std::to_string(m23) + "],\n" +
|
||||
" [" + std::to_string(m30) + ", " + std::to_string(m31) + ", " + std::to_string(m32) + ", " + std::to_string(m33) + "])";
|
||||
}
|
||||
};
|
||||
|
||||
// Stream output operator
|
||||
template<typename T>
|
||||
inline std::ostream& operator<<(std::ostream& os, const Mat4<T>& mat) {
|
||||
os << mat.toString();
|
||||
return os;
|
||||
}
|
||||
|
||||
// Scalar multiplication from left
|
||||
template<typename T>
|
||||
inline Mat4<T> operator*(T scalar, const Mat4<T>& mat) {
|
||||
return mat * scalar;
|
||||
}
|
||||
|
||||
using Mat4f = Mat4<float>;
|
||||
using Mat4d = Mat4<double>;
|
||||
|
||||
Mat4f lookAt(Vec3f const& eye, Vec3f const& center, Vec3f const& up) {
|
||||
Vec3f const f = (center - eye).normalized();
|
||||
Vec3f const s = f.cross(up).normalized();
|
||||
Vec3f const u = s.cross(f);
|
||||
|
||||
Mat4f Result = Mat4f::identity();
|
||||
Result(0, 0) = s.x;
|
||||
Result(1, 0) = s.y;
|
||||
Result(2, 0) = s.z;
|
||||
Result(3, 0) = -s.dot(eye);
|
||||
Result(0, 1) = u.x;
|
||||
Result(1, 1) = u.y;
|
||||
Result(2, 1) = u.z;
|
||||
Result(3, 1) = -u.dot(eye);
|
||||
Result(0, 2) = -f.x;
|
||||
Result(1, 2) = -f.y;
|
||||
Result(2, 2) = -f.z;
|
||||
Result(3, 2) = f.dot(eye);
|
||||
return Result;
|
||||
}
|
||||
|
||||
Mat4f perspective(float fovy, float aspect, float zNear, float zfar) {
|
||||
float const tanhalfF = tan(fovy / 2);
|
||||
Mat4f Result = 0;
|
||||
Result(0,0) = 1 / (aspect * tanhalfF);
|
||||
Result(1,1) = 1 / tanhalfF;
|
||||
Result(2,2) = zfar / (zNear - zfar);
|
||||
Result(2,3) = -1;
|
||||
Result(3,2) = -(zfar * zNear) / (zfar - zNear);
|
||||
return Result;
|
||||
}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user