first commit

include/math3d.hpp

@@ -0,0 +1,129 @@
+/**
+ * @file math3d.hpp
+ * @brief Minimal 3D math library for render pipeline visualization
+ */
+
+#pragma once
+
+#include <cmath>
+#include <algorithm>
+
+constexpr float PI = 3.14159265358979323846f;
+
+struct Vec3 {
+    float x = 0, y = 0, z = 0;
+    Vec3 operator+(Vec3 o) const { return {x+o.x, y+o.y, z+o.z}; }
+    Vec3 operator-(Vec3 o) const { return {x-o.x, y-o.y, z-o.z}; }
+    Vec3 operator*(float s) const { return {x*s, y*s, z*s}; }
+    float dot(Vec3 o) const { return x*o.x + y*o.y + z*o.z; }
+    Vec3 cross(Vec3 o) const { return {y*o.z - z*o.y, z*o.x - x*o.z, x*o.y - y*o.x}; }
+    float length() const { return std::sqrt(x*x + y*y + z*z); }
+    Vec3 normalized() const {
+        float l = length();
+        return l > 0 ? Vec3{x/l, y/l, z/l} : Vec3{0, 0, 0};
+    }
+};
+
+inline Vec3 lerp(Vec3 a, Vec3 b, float t) {
+    return {a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t};
+}
+
+inline float smoothstep(float t) {
+    return t * t * (3.0f - 2.0f * t);
+}
+
+struct Vec4 {
+    float x = 0, y = 0, z = 0, w = 1;
+    Vec3 xyz() const { return {x, y, z}; }
+    Vec3 perspDiv() const {
+        return w != 0 ? Vec3{x/w, y/w, z/w} : Vec3{x, y, z};
+    }
+};
+
+struct Mat4 {
+    float m[4][4] = {};
+
+    static Mat4 identity() {
+        Mat4 r;
+        r.m[0][0] = r.m[1][1] = r.m[2][2] = r.m[3][3] = 1;
+        return r;
+    }
+
+    Vec4 operator*(Vec4 v) const {
+        return {
+            m[0][0]*v.x + m[0][1]*v.y + m[0][2]*v.z + m[0][3]*v.w,
+            m[1][0]*v.x + m[1][1]*v.y + m[1][2]*v.z + m[1][3]*v.w,
+            m[2][0]*v.x + m[2][1]*v.y + m[2][2]*v.z + m[2][3]*v.w,
+            m[3][0]*v.x + m[3][1]*v.y + m[3][2]*v.z + m[3][3]*v.w,
+        };
+    }
+
+    Mat4 operator*(const Mat4& o) const {
+        Mat4 r;
+        for (int i = 0; i < 4; i++)
+            for (int j = 0; j < 4; j++)
+                for (int k = 0; k < 4; k++)
+                    r.m[i][j] += m[i][k] * o.m[k][j];
+        return r;
+    }
+
+    static Mat4 translate(float x, float y, float z) {
+        Mat4 r = identity();
+        r.m[0][3] = x; r.m[1][3] = y; r.m[2][3] = z;
+        return r;
+    }
+
+    static Mat4 scale(float sx, float sy, float sz) {
+        Mat4 r = identity();
+        r.m[0][0] = sx; r.m[1][1] = sy; r.m[2][2] = sz;
+        return r;
+    }
+
+    static Mat4 rotateX(float angle) {
+        float c = std::cos(angle), s = std::sin(angle);
+        Mat4 r = identity();
+        r.m[1][1] = c; r.m[1][2] = -s;
+        r.m[2][1] = s; r.m[2][2] = c;
+        return r;
+    }
+
+    static Mat4 rotateY(float angle) {
+        float c = std::cos(angle), s = std::sin(angle);
+        Mat4 r = identity();
+        r.m[0][0] = c;  r.m[0][2] = s;
+        r.m[2][0] = -s; r.m[2][2] = c;
+        return r;
+    }
+
+    static Mat4 rotateZ(float angle) {
+        float c = std::cos(angle), s = std::sin(angle);
+        Mat4 r = identity();
+        r.m[0][0] = c; r.m[0][1] = -s;
+        r.m[1][0] = s; r.m[1][1] = c;
+        return r;
+    }
+
+    // Standard OpenGL-style perspective (right-handed, -Z forward)
+    static Mat4 perspective(float fov, float aspect, float near, float far) {
+        float t = std::tan(fov * 0.5f);
+        Mat4 r;
+        r.m[0][0] = 1.0f / (aspect * t);
+        r.m[1][1] = 1.0f / t;
+        r.m[2][2] = -(far + near) / (far - near);
+        r.m[2][3] = -(2.0f * far * near) / (far - near);
+        r.m[3][2] = -1.0f;
+        return r;
+    }
+
+    // Standard lookAt (right-handed)
+    static Mat4 lookAt(Vec3 eye, Vec3 target, Vec3 up) {
+        Vec3 f = (target - eye).normalized();
+        Vec3 r = f.cross(up).normalized();
+        Vec3 u = r.cross(f);
+        Mat4 mat = identity();
+        mat.m[0][0] = r.x;  mat.m[0][1] = r.y;  mat.m[0][2] = r.z;  mat.m[0][3] = -r.dot(eye);
+        mat.m[1][0] = u.x;  mat.m[1][1] = u.y;  mat.m[1][2] = u.z;  mat.m[1][3] = -u.dot(eye);
+        mat.m[2][0] = -f.x; mat.m[2][1] = -f.y; mat.m[2][2] = -f.z; mat.m[2][3] = f.dot(eye);
+        return mat;
+    }
+};