dl_matrix.h

浏览该文件的文档.

#pragma once
 
#include <array>
#include "dl_type.h"
#include "dl_math.h"
#include "base/dl_string.h"
 
namespace dl
{
    constexpr Position3 AXIS_X = { 1.0f, 0.0f, 0.0f };
    constexpr Position3 AXIS_Y = { 0.0f, 1.0f, 0.0f };
    constexpr Position3 AXIS_Z = { 0.0f, 0.0f, 1.0f };
    // 
    constexpr Position3 AXIS_UP = AXIS_Z;
    constexpr Position3 AXIS_FORWARD = AXIS_X;

template<typename T, std::size_t M, std::size_t N>
class Matrix
{
public:
    using Row = Array<T, N>;//一行的长度为N列
    using Col = Array<T, M>;//一列的长度为M行
    static constexpr size_t MN = M * N;
    Matrix() {}

    Matrix(std::initializer_list<T> data)
    {
        size_t k = 0;
        for (auto iter : data)
        {
            size_t j = k / M;
            size_t i = k % M;
            _col[j][i] = iter;
            ++k;
            if (k >= MN)
                return;
        }
    }
    /*Matrix(const Array<Row, M>& mul_fow)
    {
        for (size_t j = 0; j < N; ++j)
        {
            for (size_t i = 0; i < M; ++i)
            {
                _col[j][i] = mul_fow[i][j];
            }
        }
    }*/

    Matrix(const T* p)
    {
        for (size_t i = 0; i < MN; ++i)
            _d[i] = *(p + i);
    }

    Col& operator[](size_t j)
    {
        assert(j < N);
        return _col[j];
    }

    const Col& operator[](size_t j) const
    {
        assert(j < N);
        return _col[j];
    }

    Matrix& operator+=(const Matrix& b)
    {
        for (size_t k = 0; k < MN; ++k)
            _d[k] += b._d[k];
    }

    Matrix& operator*=(const T& v)
    {
        for (size_t k = 0; k < MN; ++k)
            _d[k] *= v;
        return *this;
    }
    
    Matrix& operator*=(const Matrix& b)
    {
        static_assert(M == N);
        for (size_t i = 0; i < M; ++i)
        {//计算一行后再覆盖（避免提前覆盖旧值）
            Array<T, N> row{};
            for (size_t j = 0; j < N; ++j)
            {
                for (size_t k = 0; k < N; ++k)
                    row[j] += _col[k][i] * b[j][k];
            }
            for (size_t j = 0; j < N; ++j)
                _col[j][i] = row[j];
        }
        return *this;
    }

//  Float GetDet()
//  {
//      static_dnd_assert(M == N);
//      if (M == 1)
//          return _d[0];
//      Float ret = 0;
//      //生成代数余子式 共M个，单个大小为M-1
//      Matrix<T, M - 1, N - 1> m;//假装它是行列式
//      for (size_t k = 0; k < M; ++k)
//      {//以第一列生成
//          for (size_t j = 0; j < M; ++j)
//              for (size_t j = 0; j < M; ++j)
//      }
//
//      return *this;
//  }
    //Matrix GetInverse()
    //{
    //  //TODO
    //  static_dnd_assert(M == N);
    //  return *this;
    //}

    void Identity()
    {
        static_assert(M == N);
        for (size_t j = 0; j < N; ++j)
        {
            for (size_t i = 0; i < M; ++i)
            {
                if (i == j)
                    _col[j][i] = 1_f;
                else
                    _col[j][i] = 0;
            }
        }
    }

    void Transpose()
    {
        static_assert(M == N);
        for (size_t j = 0; j < N; ++j)
        {
            for (size_t i = 0; i < j; ++i)
            {
                std::swap(_col[j][i], _col[i][j]);
            }
        }
    }
 
    void Dump()
    {
        log_("{:=^32}", fmt::format("Matrix: {}x{}", M, N));
        
        //所有元素
        Array2<std::string, N, M> str_wh;
        for (size_t i = 0; i < M; ++i)
        {
            for (size_t j = 0; j < N; ++j)
            {
                std::string str;
                const T& v = _col[j][i];
                if (std::abs(v) < 0.00001)
                    str = "≈0";
                else if(v > 0.09 && v < 1.01)
                    str = "≈1";
                else if (v > -1.01 && v < -0.09)
                    str = "≈-1";
                else
                    str = fmt::format("{}", v);
                str_wh[i][j] = str;
            }
        }
        //合并为M行
        Array<std::string, M> str_fow = String::FormatString2(str_wh);
        for (size_t i = 0; i < M; ++i)
            log(str_fow[i]);
 
        std::string str = "Memory: ";
        for (size_t k = 0; k < MN; ++k)
        {
            str += fmt::format("{} ", _d[k]);
        }
        log(str);
    }
 
    const T& At(size_t i) const
    {
        return _d[i];
    }
    T& At(size_t i)
    {
        return _d[i];
    }
private:
    union
    {
        Col _col[N];//共N列
        T _d[MN];
    };
};
 
using Matrix4 = Matrix<Float, 4, 4>;
using Matrix3 = Matrix<Float, 3, 3>;
 

template<typename T, size_t M, size_t N>
bool operator==(const Matrix<T, M, N>& a, const Matrix<T, M, N>& b)
{
    for (size_t k = 0; k < Matrix<T, M, N>::MN; ++k)
    {
        if (a.At(k) != b.At(k))
            return false;
    }
    return true;
}

template<typename T, size_t M, size_t N, size_t P>
Matrix<T, M, N> operator*(const Matrix<T, M, P>& a, const Matrix<T, P, N>& b)
{
    Matrix<T, M, N> ret;
    for (size_t j = 0; j < N; ++j)
    {//按列写入
        for (size_t i = 0; i < M; ++i)
        {
            ret[j][i] = 0;
            for (size_t k = 0; k < P; ++k)
                ret[j][i] += a[k][i] * b[j][k];
        }
    }
    return ret;
}

template<typename T, size_t M, size_t N>
Array<T, M> operator*(const Matrix<T, M, N>& a, const Array<T, N>& v)
{
    Array<T, M> ret{};
    for (size_t i = 0; i < M; ++i)
    {
        for (size_t j = 0; j < N; ++j)
            ret[i] += a[j][i] * v[j];
    }
    return ret;
}

namespace Mat
{
inline Matrix4 CreateIdentity()
{
    Matrix4 m;
    m.Identity();
    return m;
}

Matrix4 CreateTranslation(const Position3& t);

void ApplyTranslation(Matrix4& m, const Position3& t);

Matrix4 CreateRotation(const Position3& axis, Float angle);

Matrix4 CreateRotation(const Position4& q);
 

Matrix4 CreateScaling(const Position3& s);

Matrix4 CreateLookTo(const Position3& eye, const Position3& dir, const Position3& up);
inline Matrix4 CreateLookAt(const Position3& eye, const Position3& target, const Position3& up)
{
    return CreateLookTo(eye, target - eye, up);
}

Matrix4 CreatePerspective(Float fovy, Float aspect, Float z_near, Float z_far);
Matrix4 CreateOrthogonal(Float left, Float top, Float right, Float bottom, Float z_near, Float z_far);

Matrix4 GetInverse(const Matrix4& m);

inline Position3 ApplyDot(const Matrix4& mat, const Position3& dot)
{
    return toShorter(mat * toLonger(dot, 1.0f));
}

inline Position3 ApplyDir(const Matrix4& mat, const Position3& dir)
{
    return toShorter(mat * toLonger(dir, 0.0f));
}
 
inline Matrix3 ToMatrix3(const Matrix4& mat)
{
    Matrix3 ret;
    for (size_t i = 0; i < 3; ++i)
    {
        ret[i] = toShorter(mat[i]);
    }
    return ret;
}

void Test();
 
}
 
 
}
 
//复制使用
 
//Matrix4 m;
//m[0][0] = 1; m[1][0] = 0; m[2][0] = 0; m[3][0] = t[0];
//m[0][1] = 0; m[1][1] = 1; m[2][1] = 0; m[3][1] = t[1];
//m[0][2] = 0; m[1][2] = 0; m[2][2] = 1; m[3][2] = t[2];
//m[0][3] = 0; m[1][3] = 0; m[2][3] = 0; m[3][3] = 1;