Matrix2D.hpp

[詳解]

#pragma once
 
#include <array>
#include "Const.h"
#include "utility/Math/KisaragiMath.hpp"
#include <cmath>
#include "utility/Primitive.hpp"
 
 
using std::array;
using Kisaragi_Lib::Math;
 
namespace Kisaragi_Lib
{
 
    enum Matrix2DType
    {
        ZERO_CLEAR,
        IDENTITY_MATRIX,
    };
 
    //matrix2x2は平行移動ができない
    class Matrix2D
    {
    private:
        array<array<double, 3>, 3>matrix;
        /*
              | [_][0]    |[_][1]       |[_][2]
        [0][_]|sx⋅cos(θ) | −sy⋅sin(θ) | tx
        [1][_]|sx⋅sin(θ) |  sy⋅cos(θ) | ty
        [2][_]|   0       |    0        | 1
 
        sxとsyはそれぞれx方向とy方向のスケール係数、
        θは回転角度（ラジアン）、
        txとtyは平行移動の成分です。
 
        */
 
    public:
        Matrix2D()
        {
            ZeroClear();
        }
 
        Matrix2D(Matrix2DType _type)
        {
            switch (_type)
            {
            case Kisaragi_Lib::ZERO_CLEAR:
                ZeroClear();
                break;
 
            case Kisaragi_Lib::IDENTITY_MATRIX:
                ObjectInit();
                break;
            default:
                break;
            }
 
        }
 
        void ZeroClear()
        {
            //0で初期化する
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    matrix[i][j] = 0;
                }
            }
        }
 
        void ObjectInit()
        {
            ZeroClear();
 
            //サイズとzを1にする
            for (int i = 0; i < 3; i++)
            {
                matrix[i][i] = 1;
            }
        }
 
#pragma region ゲッタ
        //確認済み
        Point2D<double>Position()
        {
            return Point2D<double>(matrix[0][2], matrix[1][2]);
        }
 
        /// <summary>
        /// 回転をラジアン値で返す
        /// </summary>
        /// <returns>ラジアン値を返す</returns>
        double Rotation()
        {
            // atan2を使用して回転角度を取得
            return atan2(matrix[1][0], matrix[0][0]);
        }
 
        //TODO debug
        Point2D<double> Scale()
        {
            double tmpX, tmpY;
 
            tmpX = std::sqrt(Math::Pow(matrix[0][0],2) + Math::Pow(matrix[1][0], 2));
 
            tmpY = std::sqrt(Math::Pow(matrix[0][1], 2) + Math::Pow(matrix[1][1], 2));
 
            return Point2D<double>(tmpX, tmpY);
        }
 
#pragma endregion
 
        //確認済み(平行移動行列)
        void operator*=(Matrix2D _mat)
        {
            Matrix2D tmp(ZERO_CLEAR);
 
            for (int i = 0; i < 3; i++) 
            {
                for (int j = 0; j < 3; j++) 
                {
                    for (int k = 0; k < 3; k++) 
                    {
                        tmp.matrix[i][j] += matrix[i][k] * _mat.matrix[k][j];
                    }
                }
            }
 
            matrix = tmp.matrix;
        }
 
        //確認済み(平行移動行列)
        Matrix2D operator*(Matrix2D _mat)
        {
            Matrix2D tmp(ZERO_CLEAR);
 
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    for (int k = 0; k < 3; k++)
                    {
                        tmp.matrix[i][j] += matrix[i][k] * _mat.matrix[k][j];
                    }
                }
            }
 
            return tmp;
        }
 
 
        Matrix2D operator*(double scalar)
        {
            Matrix2D result(*this); // 現在の行列をコピー
 
            // 行列の各要素にスカラーを掛ける
            for (int i = 0; i < 3; ++i)
            {
                for (int j = 0; j < 3; ++j)
                {
                    result.matrix[i][j] *= scalar;
                }
            }
 
            return result;
        }
 
        const Matrix2D& operator*=(double scalar)
        {
            // 行列の各要素にスカラーを掛ける
            for (int i = 0; i < 3; ++i)
            {
                for (int j = 0; j < 3; ++j)
                {
                    matrix[i][j] *= scalar;
                }
            }
 
            return *this;
        }
 
#pragma region  移動行列作成関数
        //確認済み
        static Matrix2D CreateMoveMatrix(double _x,double _y)
        {
            Matrix2D tmp(IDENTITY_MATRIX);
 
            tmp.matrix[0][2] = _x;
            tmp.matrix[1][2] = _y;
 
            return tmp;
        }
 
        Matrix2D CreateMoveMatrix()
        {
            Matrix2D tmp(IDENTITY_MATRIX);
 
            tmp.matrix[0][2] = Position().x;
            tmp.matrix[1][2] = Position().y;
 
            return tmp;
        }
 
        //radianだよ
        static Matrix2D CreateRotaMatrix(double _angle)
        {
            Matrix2D tmp(ZERO_CLEAR);
 
            double cos = std::cos(_angle);
            double sin = std::sin(_angle);
 
            tmp.matrix[0][0] = cos;
            tmp.matrix[1][1] = cos;
 
            tmp.matrix[0][1] = -sin;
            tmp.matrix[1][0] = sin;
 
            tmp.matrix[2][2] = 1;
 
            return tmp;
        }
 
        Matrix2D CreateRotaMatrix()
        {
            Matrix2D tmp(ZERO_CLEAR);
 
            double cos = std::cos(Rotation());
            double sin = std::sin(Rotation());
 
            tmp.matrix[0][0] = cos;
            tmp.matrix[1][1] = cos;
 
            tmp.matrix[0][1] = -sin;
            tmp.matrix[1][0] = sin;
 
            tmp.matrix[2][2] = 1;
 
            return tmp;
        }
 
        static Matrix2D CreateScaleMatrix(double _x,double _y)
        {
            //0以下にはなりません
            assert(_x > 0);
            assert(_y > 0);
 
            Matrix2D tmp(ZERO_CLEAR);
 
            tmp.matrix[0][0] = _x;
            tmp.matrix[1][1] = _y;
            tmp.matrix[2][2] = 1;
 
            return tmp;
        }
 
        static Matrix2D CreateScaleMatrix(Scale2D<double> _scale)
        {
            //0以下にはなりません
            assert(_scale.x > 0);
            assert(_scale.y > 0);
 
            Matrix2D tmp(ZERO_CLEAR);
 
            tmp.matrix[0][0] = _scale.x;
            tmp.matrix[1][1] = _scale.y;
            tmp.matrix[2][2] = 1;
 
            return tmp;
        }
 
        Matrix2D CreateScaleMatrix()
        {
            //0以下にはなりません
            assert(Scale().x > 0);
            assert(Scale().y > 0);
 
            Matrix2D tmp(ZERO_CLEAR);
 
            tmp.matrix[0][0] = Scale().x;
            tmp.matrix[1][1] = Scale().y;
            tmp.matrix[2][2] = 1;
 
            return tmp;
        }
#pragma endregion
 
#pragma region  逆行列作成関数
        Matrix2D  CreateInverseMoveMatrix()  
        {
            Matrix2D tmp(IDENTITY_MATRIX);
            tmp *= Matrix2D::CreateMoveMatrix(Position().x * -1, Position().y * -1);
 
            return tmp;
        }
 
        static Matrix2D  CreateInverseMoveMatrix(Point2D<double> _pos)
        {
            Matrix2D tmp(IDENTITY_MATRIX);
            tmp *= Matrix2D::CreateMoveMatrix(_pos.x * -1, _pos.y * -1);
 
            return tmp;
        }
 
        Matrix2D  CreateInverseRotaMatrix()
        {
            Matrix2D tmp(IDENTITY_MATRIX);
            tmp *= Matrix2D::CreateRotaMatrix(Rotation() * -1);
 
            return tmp;
        }
 
        template <class T>
        static Matrix2D  CreateInverseRotaMatrix(T _rotation)
        {
            Matrix2D tmp(IDENTITY_MATRIX);
            tmp *= Matrix2D::CreateRotaMatrix(_rotation * -1);
 
            return tmp;
        }
 
        Matrix2D  CreateInverseScaleMatrix()
        {
            Matrix2D tmp(IDENTITY_MATRIX);
            tmp *= Matrix2D::CreateScaleMatrix(1 / Scale().x, 1 / Scale().y);
 
            return tmp;
        }
 
        template <class T>
        static Matrix2D  CreateInverseScaleMatrix(Scale2D<T> _scale)
        {
            Matrix2D tmp(IDENTITY_MATRIX);
            tmp *= Matrix2D::CreateScaleMatrix(1 / _scale.x, 1 / _scale.y);
 
            return tmp;
        }
 
        //TODO Debug
        Matrix2D CreateInverseTransformationMatrix()
        {
            Matrix2D tmp(IDENTITY_MATRIX);
 
            // 移動の逆行列
            tmp *= CreateInverseMoveMatrix();
 
            // 回転の逆行列
            tmp *= CreateInverseRotaMatrix();
 
            // スケーリングの逆行列
            tmp *= CreateInverseScaleMatrix();
 
            return tmp;
        }
 
#pragma endregion
 
        /// <summary>
        /// X軸、Y軸に平行移動する
        /// 回転の影響を受けない.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="_x"></param>
        /// <param name="_y"></param>
        template<class T>
        void AxisAlignedTranslation(T _x, T _y)
        {
            matrix[0][2] += _x;
            matrix[1][2] += _y;
        }
 
        /// <summary>
        /// X軸、Y軸に平行な座標をセットする
        /// 回転、拡大の影響を受けない
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="_x"></param>
        /// <param name="_y"></param>
        template<class T>
        void SetAxisAlignedTranslation(T _x, T _y)
        {
            matrix[0][2] = _x;
            matrix[1][2] = _y;
        }
 
    };
}