Transform.hpp

[詳解]

#pragma once
 
#include "Const.h"
#include "Accessor.hpp"
#include "utility/Math/KisaragiMath.hpp"
#include <cmath>
#include "utility/Primitive.hpp"
#include "Matrix2D.hpp"
 
namespace Kisaragi_Lib
{
    /// <summary>
    /// matrix3x3座標系のラッパークラス
    /// </summary>
    class Transform2D
    {
    protected:
        
        //座標の実体
        Matrix2D mat{ IDENTITY_MATRIX };
 
        /// <summary>
        /// matrixのポジションを扱うラッパークラス
        /// </summary>
        class Position2D
        {
        private:
            Matrix2D* pMat;
 
            class PosX
                {
                private:
                    Matrix2D* pMat;
                public:
                    PosX(Matrix2D* _p) :pMat(_p) {}
 
                    operator double() const
                    {
                        return pMat->Position().x;
                    }
                };
 
            class PosY
                {
                private:
                    Matrix2D* pMat;
                public:
                    PosY(Matrix2D* _p) :pMat(_p) {}
 
                    operator double() const
                    {
                        return pMat->Position().y;
                    }
                };
 
 
        public:
            Position2D(Matrix2D* _p):pMat(_p){}
 
            operator Point2D<double>() const
            {
                    return pMat->Position();
            }
 
            Point2D<double> operator + (Point2D<double> _p)
            {
                return pMat->Position() + _p;
            }
 
            Point2D<double> operator += (Point2D<double> _p)
            {
                //回転の影響を受けた移動をする.
                //*pMat *= Matrix2D::CreateMoveMatrix(_p.x, _p.y);
 
                //軸に平行な移動をする.
                pMat->AxisAlignedTranslation(_p.x, _p.y);
 
                return *this;   //operator呼び出し-
            }
 
            Point2D<double> operator - (Point2D<double> _p)
            {
                return pMat->Position() - _p;
            }
 
            Point2D<double> operator -= (Point2D<double> _p)
            {
                //回転の影響を受けた移動をする.
                //*pMat *= Matrix2D::CreateMoveMatrix(_p.x, _p.y);
 
                //軸に平行な移動をする.
                pMat->AxisAlignedTranslation(-_p.x, -_p.y);
 
                return *this;   //operator呼び出し
            }
 
            Point2D<double> operator = (Point2D<double> _p)
            {
 
                pMat->SetAxisAlignedTranslation(_p.x, _p.y);
                return *this;   //operator呼び出し
            }
 
            operator Point2D<double>()
            {
                return Point2D<double>(x,y);
            }
 
            PosX x{ pMat };
            PosY y{ pMat };
        };
 
        /// <summary>
        /// matrixのRotaを扱うラッパークラス.
        /// </summary>
        class Rotation2D
            {
            private:
                Matrix2D* pMat;
 
                class Radian
                {
                private:
                    Matrix2D* pMat;
                public:
                    Radian(Matrix2D* _p) :pMat(_p) {}
 
                    operator double() const
                    {
                        return pMat->Rotation();
                    }
                };
 
            public:
                Rotation2D(Matrix2D* _p) :pMat(_p) {}
 
                //0~360で返す.
                operator double() const
                {
                    return Math::RadianToDegree(pMat->Rotation());
                }
 
                double operator =(double _degree)
                {
                    *pMat *= pMat->CreateInverseRotaMatrix();
 
                    if (_degree > 360)
                    {
                        _degree = std::fmod(_degree, 360);
                    }
 
                    if (_degree < 0)
                    {
                        _degree = std::fmod(_degree, 360);
                    }
 
                    *pMat *= Matrix2D::CreateRotaMatrix(Math::DegreeToRadian(_degree));
                    
                    return *this;
                }
 
                double operator +=(double _degree)
                {
                    if (_degree > 360)
                    {
                        _degree = std::fmod(_degree, 360);
                    }
 
                    if (_degree < 0)
                    {
                        _degree = std::fmod(_degree, 360);
                    }
 
                    *pMat *= Matrix2D::CreateRotaMatrix(Math::DegreeToRadian(_degree));
 
                    return *this;
                }
 
                double operator -=(double _degree)
                {
                    if (_degree > 360)
                    {
                        _degree = std::fmod(_degree, 360);
                    }
 
                    if (_degree < 0)
                    {
                        _degree = std::fmod(_degree, 360);
                    }
 
                    *pMat *= Matrix2D::CreateRotaMatrix(Math::DegreeToRadian(-_degree));
 
                    return *this;
                }
                
                Radian radian{ pMat };
 
                
            };
 
        /// <summary>
        /// matrixの拡大率を扱うラッパークラス.
        /// </summary>
        class Scale2D
            {
            private:
                Matrix2D* pMat;
 
                class ScaleX
                {
                private:
                    Matrix2D* pMat;
                public:
                    ScaleX(Matrix2D* _p) :pMat(_p) {}
 
                    operator double() const
                    {
                        return pMat->Scale().x;
                    }
                };
 
                class ScaleY
                {
                private:
                    Matrix2D* pMat;
                public:
                    ScaleY(Matrix2D* _p) :pMat(_p) {}
 
                    operator double() const
                    {
                        return pMat->Scale().y;
                    }
                };
 
            public:
                Scale2D(Matrix2D* _p) :pMat(_p) {}
 
                operator Point2D<double>() const
                {
                    return pMat->Scale();
                }
 
                Point2D<double> operator += (Point2D<double> _p)
                {
                    *pMat *= Matrix2D::CreateScaleMatrix(_p.x, _p.y);
                    return *this;   //operator呼び出し
                }
 
                Point2D<double> operator -= (Point2D<double> _p)
                {
                    *pMat *= Matrix2D::CreateScaleMatrix(-_p.x, -_p.y);
                    return *this;   //operator呼び出し
                }
 
                Point2D<double> operator = (Point2D<double> _p)
                {
                    //移動打消し.
                    *pMat *= pMat->CreateInverseScaleMatrix();
                    //移動
                    *pMat *= Matrix2D::CreateScaleMatrix(_p.x, _p.y);
                    return *this;   //operator呼び出し
                }
 
                ScaleX x{ pMat };
                ScaleY y{ pMat };
            };
 
        //親座標
        Transform2D* pearent;
        
        //デフォルトの親座標
        static Transform2D world;   //世界座標
 
    public:
        Position2D    position{ &mat };
        Rotation2D    rotation{ &mat };
        Scale2D      scale  { &mat };
 
        bool isWorld = false;
 
        Transform2D()
        {
            pearent = &world;
        }
 
        Transform2D(bool _isWorld) : isWorld(_isWorld)
        {
 
        }
 
        void SetPearent(Transform2D* _pearent)
        {
            pearent = _pearent;
        }
 
        //matirxとして扱うときの変換
        operator Matrix2D()
        {
            if (isWorld)
            {
                return mat;
            }
 
            return ((Matrix2D)*pearent * mat);
        }
 
        const Matrix2D& operator*=(Matrix2D _mat)
        {
            mat *= _mat;
            return mat;
        }
 
#pragma region 要素アクセス子
        const Matrix2D& operator -> ()
        {
            return mat;
        }
#pragma endregion
    };
}