First batch of matrix related functions

source/CMakeLists.txt

@@ -3,8 +3,8 @@
 # First most is build as a library
 add_library(rayonnement STATIC)
 
-set(RAY_HEADERS include/tuples.h include/math_helper.h include/colour.h include/canvas.h)
-set(RAY_SOURCES tuples.cpp math_helper.cpp colour.cpp canvas.cpp)
+set(RAY_HEADERS include/tuples.h include/math_helper.h include/colour.h include/canvas.h include/matrix.h)
+set(RAY_SOURCES tuples.cpp math_helper.cpp colour.cpp canvas.cpp matrix.cpp)
 
 target_include_directories(rayonnement PUBLIC include)
 target_sources(rayonnement PRIVATE ${RAY_HEADERS} ${RAY_SOURCES})

source/include/matrix.h

@@ -0,0 +1,100 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Matrix header
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#ifndef DORAYME_MATRIX_H
+#define DORAYME_MATRIX_H
+
+#include <tuples.h>
+
+class Matrix
+{
+private:
+    /* 4x4 is the default */
+    double data[4*4];
+    int width;
+
+public:
+    Matrix(int width) : width(width)
+    {
+        int i;
+        for(i = 0; i < width*width; i++)
+        {
+            this->data[i] = 0;
+        }
+    };
+    Matrix(double values[], int width)
+    {
+        int x, y;
+
+        this->width = width;
+
+        for(y = 0; y < this->width; y++)
+        {
+            for (x = 0 ; x < this->width ; x++)
+            {
+                this->data[this->width * x + y] = values[this->width * x + y];
+            }
+        }
+    };
+    double get(int x, int y) const { return this->data[this->width * x + y]; };
+    void set(int x, int y, double v) { this->data[this->width * x + y] = v; };
+
+    Matrix identity()
+    {
+        int i;
+        for(i = 0; i < this->width; i++)
+        {
+            this->set(i, i, 1);
+        }
+        return *this;
+    }
+
+    Matrix transpose()
+    {
+        int x, y;
+        Matrix ret = Matrix(this->width);
+        for(y = 0; y < this->width; y++)
+        {
+            for (x = 0 ; x < this->width ; x++)
+            {
+                ret.set(y, x, this->get(x, y));
+            }
+        }
+        return ret;
+    }
+
+    bool operator==(const Matrix &b) const;
+    bool operator!=(const Matrix &b) const;
+
+    Matrix operator*(const Matrix &b) const;
+    Tuple operator*(const Tuple &b) const;
+};
+
+class Matrix4: public Matrix
+{
+public:
+    Matrix4() : Matrix(4) { };
+    Matrix4(double values[]) : Matrix(values, 4) { };
+};
+
+
+class Matrix2 : public Matrix
+{
+public:
+    Matrix2() : Matrix(2) { };
+    Matrix2(double values[]) : Matrix(values, 2) { };
+};
+
+class Matrix3 : public Matrix
+{
+public:
+    Matrix3() : Matrix(3) { };
+    Matrix3(double values[]) : Matrix(values, 3) { };
+};
+
+#endif /* DORAYME_MATRIX_H */

source/matrix.cpp

@@ -0,0 +1,82 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Matrix implementation
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+
+#include <matrix.h>
+#include <tuples.h>
+#include <math_helper.h>
+
+bool Matrix::operator==(const Matrix &b) const
+{
+    int i;
+    if (this->width != b.width)
+    {
+        /* If they are not the same size don't even bother */
+        return false;
+    }
+
+    for(i = 0; i < this->width*this->width; i++)
+    {
+        if (!double_equal(this->data[i], b.data[i]))
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool Matrix::operator!=(const Matrix &b) const
+{
+    int i;
+    if (this->width != b.width)
+    {
+        /* If they are not the same size don't even bother */
+        return true;
+    }
+
+    for(i = 0; i < this->width*this->width; i++)
+    {
+        if (!double_equal(this->data[i], b.data[i]))
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+Matrix Matrix::operator*(const Matrix &b) const
+{
+    int x, y, k;
+    Matrix ret = Matrix(this->width);
+
+    if (this->width == b.width)
+    {
+        for (y = 0 ; y < this->width ; y++)
+        {
+            for (x = 0 ; x < this->width ; x++)
+            {
+                double v = 0;
+                for (k = 0 ; k < this->width ; k++)
+                {
+                    v += this->get(x, k) * b.get(k, y);
+                }
+                ret.set(x, y, v);
+            }
+        }
+    }
+    return ret;
+}
+
+Tuple Matrix::operator*(const Tuple &b) const
+{
+    return Tuple(b.x * this->get(0, 0) + b.y * this->get(0, 1) + b.z * this->get(0, 2) + b.w * this->get(0, 3),
+                 b.x * this->get(1, 0) + b.y * this->get(1, 1) + b.z * this->get(1, 2) + b.w * this->get(1, 3),
+                 b.x * this->get(2, 0) + b.y * this->get(2, 1) + b.z * this->get(2, 2) + b.w * this->get(2, 3),
+                 b.x * this->get(3, 0) + b.y * this->get(3, 1) + b.z * this->get(3, 2) + b.w * this->get(3, 3));
+}