LibGfx: Add Vector3 and Matrix4x4 classes

This adds two templated 3D math classes. They have already been typedf'd
as FloatVector3, DoubleVector3, FloatMatrix4x4 and DoubleMatrix4x4

2 files changed, 234 insertions, 0 deletions

diff --git a/Libraries/LibGfx/Matrix4x4.h b/Libraries/LibGfx/Matrix4x4.h
new file mode 100644
index 0000000000..54cf73db18
--- /dev/null
+++ b/Libraries/LibGfx/Matrix4x4.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2020, Stephan Unverwerth <s.unverwerth@gmx.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <LibGfx/Vector3.h>
+#include <math.h>
+
+namespace Gfx {
+
+template<typename T>
+class Matrix4x4 final {
+public:
+    Matrix4x4() = default;
+    Matrix4x4(T _11, T _12, T _13, T _14,
+        T _21, T _22, T _23, T _24,
+        T _31, T _32, T _33, T _34,
+        T _41, T _42, T _43, T _44)
+        : m_elements {
+            _11, _12, _13, _14,
+            _21, _22, _23, _24,
+            _31, _32, _33, _34,
+            _41, _42, _43, _44
+        }
+    {
+    }
+
+    Matrix4x4 operator*(const Matrix4x4& other) const
+    {
+        Matrix4x4 product;
+        for (int i = 0; i < 4; ++i) {
+            for (int j = 0; j < 4; ++j) {
+                product.m_elements[i][j] = m_elements[0][j] * other.m_elements[i][0]
+                    + m_elements[1][j] * other.m_elements[i][1]
+                    + m_elements[2][j] * other.m_elements[i][2]
+                    + m_elements[3][j] * other.m_elements[i][3];
+            }
+        }
+        return product;
+    }
+
+    Vector3<T> transform_point(const Vector3<T>& p) const
+    {
+        return Vector3<T>(
+            p.x() * m_elements[0][0] + p.y() * m_elements[1][0] + p.z() * m_elements[2][0] + m_elements[3][0],
+            p.x() * m_elements[0][1] + p.y() * m_elements[1][1] + p.z() * m_elements[2][1] + m_elements[3][1],
+            p.x() * m_elements[0][2] + p.y() * m_elements[1][2] + p.z() * m_elements[2][2] + m_elements[3][2]);
+    }
+
+    static Matrix4x4 translate(const Vector3<T>& p)
+    {
+        return Matrix4x4(
+            1, 0, 0, 0,
+            0, 1, 0, 0,
+            0, 0, 1, 0,
+            p.x(), p.y(), p.z(), 1);
+    }
+
+    static Matrix4x4 scale(const Vector3<T>& s)
+    {
+        return Matrix4x4(
+            s.x(), 0, 0, 0,
+            0, s.y(), 0, 0,
+            0, 0, s.z(), 0,
+            0, 0, 0, 1);
+    }
+
+    static Matrix4x4 rotate(const Vector3<T>& axis, T angle)
+    {
+        T c = cos(angle);
+        T s = sin(angle);
+        T t = 1 - c;
+        T x = axis.x();
+        T y = axis.y();
+        T z = axis.z();
+
+        return Matrix4x4(
+            t * x * x + c, t * x * y - z * s, t * x * z + y * s, 0,
+            t * x * y + z * s, t * y * y + c, t * y * z - x * s, 0,
+            t * x * z - y * s, t * y * z + x * s, t * z * z + c, 0,
+            0, 0, 0, 1);
+    }
+
+private:
+    T m_elements[4][4];
+};
+
+typedef Matrix4x4<float> FloatMatrix4x4;
+typedef Matrix4x4<double> DoubleMatrix4x4;
+
+}
+
+using Gfx::DoubleMatrix4x4;
+using Gfx::FloatMatrix4x4;
+using Gfx::Matrix4x4;
diff --git a/Libraries/LibGfx/Vector3.h b/Libraries/LibGfx/Vector3.h
new file mode 100644
index 0000000000..a0030ad99d
--- /dev/null
+++ b/Libraries/LibGfx/Vector3.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2020, Stephan Unverwerth <s.unverwerth@gmx.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <math.h>
+
+namespace Gfx {
+template<typename T>
+class Vector3 {
+public:
+    Vector3() = default;
+    Vector3(T x, T y, T z)
+        : m_x(x)
+        , m_y(y)
+        , m_z(z)
+    {
+    }
+
+    T x() const { return m_x; }
+    T y() const { return m_y; }
+    T z() const { return m_z; }
+
+    void set_x(T value) { m_x = value; }
+    void set_y(T value) { m_y = value; }
+    void set_z(T value) { m_z = value; }
+
+    Vector3 operator+(const Vector3& other) const
+    {
+        return Vector3(m_x + other.m_x, m_y + other.m_y, m_z + other.m_z);
+    }
+
+    Vector3 operator-(const Vector3& other) const
+    {
+        return Vector3(m_x - other.m_x, m_y - other.m_y, m_z - other.m_z);
+    }
+
+    Vector3 operator*(T f) const
+    {
+        return Vector3(m_x * f, m_y * f, m_z * f);
+    }
+
+    Vector3 operator/(T f) const
+    {
+        return Vector3(m_x / f, m_y / f, m_z / f);
+    }
+
+    T dot(const Vector3& other) const
+    {
+        return m_x * other.m_x + m_y * other.m_y + m_z * other.m_z;
+    }
+
+    Vector3 cross(const Vector3& other) const
+    {
+        return Vector3(
+            m_y * other.m_z - m_z * other.m_y,
+            m_z * other.m_x - m_x * other.m_z,
+            m_x * other.m_y - m_y * other.m_x);
+    }
+
+    Vector3 normalized() const
+    {
+        T inv_length = 1 / length();
+        return *this * inv_length;
+    }
+
+    void normalize()
+    {
+        T inv_length = 1 / length();
+        m_x *= inv_length;
+        m_y *= inv_length;
+        m_z *= inv_length;
+    }
+
+    T length() const
+    {
+        return sqrt(m_x * m_x + m_y * m_y + m_z * m_z);
+    }
+
+private:
+    T m_x;
+    T m_y;
+    T m_z;
+};
+
+typedef Vector3<float> FloatVector3;
+typedef Vector3<double> DoubleVector3;
+
+}
+
+using Gfx::DoubleVector3;
+using Gfx::FloatVector3;
+using Gfx::Vector3;