matrix.h

//##################################################################################################
//
// Copyright (c) 2024 Beijing Qiongqi Tech Co.,Ltd. All rights reserved. 
 
// This source code is confidential and proprietary to Beijing Qiongqi Tech Co.,Ltd(The Holder). 
// Any unauthorized use, copying, modification, or distribution of the code is strictly prohibited. 
// Any user shall obtain authorizaition from the Holder before modifying the source code. And the user shall not
// sublicense, sell, distribute, or transfer the source code, whether in original or modified form, to any third party
// without the prior written consent of the Holder.
 
// This copyright notice and permission grant shall be included in all copies or substantial portions of the source code.
 
// Author  Cumulia Illustrator
// Date    2024-10-31
// Version V1.1.0
//##################################################################################################
 
#pragma once
 
#include "tuple.h"
 
namespace cil
{
    class Vector2f;
    class Vector3f;
    class Vector4f;
    class Quaternion;
    class Matrix2f;
    class Matrix3f;
    class Matrix4f;
 
    template<typename S>
    class Matrix : public Tuple<float>
    {
    protected:
        int m_dim; 
 
    public:
        Matrix(int dim)
            : Tuple<float>(dim* dim)
        {
            this->m_dim = dim;
 
            for (int i = 0; i < this->m_dim; i++)
                this->m_data[i * this->m_dim + i] = 1;
        }
        const float* operator[](int index) const
        {
            return &this->m_data[index * this->m_dim];
        }
        float* operator[](int index)
        {
            return &this->m_data[index * this->m_dim];
        }
 
        Matrix& operator+=(const Matrix& other)
        {
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                this->m_data[i] += other.data()[i];
 
            return *this;
        }
 
        Matrix<S>& operator-=(const Matrix& other)
        {
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                this->m_data[i] -= other.data()[i];
 
            return *this;
        }
        Matrix<S>& operator*=(const Matrix& other)
        {
            auto a = this->m_data;
            auto b = other.data();
 
            int size = this->m_size;
            auto t = new float[size] {};
            int dim = this->m_dim;
            for (int i = 0; i < dim; i++)
                for (int j = 0; j < dim; j++)
                    for (int k = 0; k < dim; k++)
                        t[i * dim + j] += a[k * dim + j] * b[i * dim + k];
 
            for (int i = 0; i < size; i++)
                this->m_data[i] = t[i];
 
            delete[] t;
 
            return *this;
        }
        S operator+(const S& other) const
        {
            auto v = S();
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                v.data()[i] = this->m_data[i] + other.data()[i];
 
            return v;
        }
        S operator-(const S& other) const
        {
            auto v = S();
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                v.data()[i] = this->m_data[i] - other.data()[i];
 
            return v;
        }
        S operator*(const S& other) const
        {
            auto v = S();
            auto a = this->m_data;
            auto b = other.data();
            auto c = v.data();
 
            int size = v.size();
            for (int i = 0; i < size; i++)
                c[i] = 0;
 
            int dim = this->m_dim;
            for (int i = 0; i < dim; i++)
                for (int j = 0; j < dim; j++)
                    for (int k = 0; k < dim; k++)
                        c[i * dim + j] += a[k * dim + j] * b[i * dim + k];
 
            return v;
        }
        void setIdentity()
        {
            for (int i = 0; i < this->m_size; i++)
                this->m_data[i] = 0;
            for (int i = 0; i < this->m_dim; i++)
                this->m_data[i * this->m_dim + i] = 1;
        }
        void transpose()
        {
            auto data = this->m_data;
            int dim = this->m_dim;
            for (int i = 0; i < dim; i++)
                for (int j = 0; j < i; j++)
                {
                    float t = data[i * dim + j];
                    data[i * dim + j] = data[j * dim + i];
                    data[j * dim + i] = t;
                }
        }
    };
 
    class Matrix2f final : public Matrix<Matrix2f>
    {
    public:
        Matrix2f();
        Matrix2f(float e00, float e01,
            float e10, float e11);
        Matrix2f(const Vector2f& c0,
            const Vector2f& c1);
        Matrix2f(const Matrix2f& other);
        Matrix2f(const Matrix3f& other);
        Matrix2f(const Matrix4f& other);
        void set(float e00, float e01,
            float e10, float e11);
    };
    class Matrix3f final : public Matrix<Matrix3f>
    {
    public:
        Matrix3f();
        Matrix3f(float e00, float e01, float e02,
            float e10, float e11, float e12,
            float e20, float e21, float e22);
        Matrix3f(const Vector3f& c0,
            const Vector3f& c1,
            const Vector3f& c2);
 
        Matrix3f(const Matrix2f& other);
        Matrix3f(const Matrix3f& other);
        Matrix3f(const Matrix4f& other);
        void set(float e00, float e01, float e02,
            float e10, float e11, float e12,
            float e20, float e21, float e22);
        float determinant() const; 
        bool invert();
    };
    class Matrix4f final : public Matrix<Matrix4f>
    {
    public:
        Matrix4f();
        Matrix4f(float e00, float e01, float e02, float e03,
            float e10, float e11, float e12, float e13,
            float e20, float e21, float e22, float e23,
            float e30, float e31, float e32, float e33);
        Matrix4f(const Vector4f& c0,
            const Vector4f& c1,
            const Vector4f& c2,
            const Vector4f& c3);
        Matrix4f(const Matrix2f& other);
        Matrix4f(const Matrix3f& other);
        Matrix4f(const Matrix4f& other);
 
        Matrix4f operator*(const Matrix4f& other) const;
        Vector4f operator*(const Vector4f& other) const;
        void set(float e00, float e01, float e02, float e03,
            float e10, float e11, float e12, float e13,
            float e20, float e21, float e22, float e23,
            float e30, float e31, float e32, float e33);
 
        float determinant() const; 
        bool invert();
 
        Quaternion toRotation() const;
        Vector3f toScaling() const;
        Vector3f toTranslation() const;
        void rotate(const Quaternion& r);
        void scale(const Vector3f& s);
        void translate(const Vector3f& t);
 
        static Matrix4f fromRotation(const Quaternion& r);
        static Matrix4f fromScaling(const Vector3f& s);
        static Matrix4f fromTranslation(const Vector3f& t);
    };
 
    using mat2 = Matrix2f;
    using mat3 = Matrix3f;
    using mat4 = Matrix4f;
}