ImgComponent.hpp

[詳解]

#pragma once
#include <string>
#include <DxLib.h>
#include <map>
#include <vector>
#include <cassert>
#include <iterator>
#include <algorithm>
 
#include "Const.h"
#include "Kisaragi_Resource.h"
#include "utility/ID/IDAssignment.h"
#include "ComponentBase.hpp"
#include "GameObj.hpp"
#include "utility/Math/KisaragiMath.hpp"
#include "Accessor.hpp"
#include "Matrix2D.hpp"
 
#include "FontFacade/FontFacade.hpp"
#include "utility\Color.hpp"
 
//TODO AddComponentの時に使えると思うんですけど、
// https://cpprefjp.github.io/lang/cpp11/trailing_return_types.html
// </summary>auto Pop() -> decltype(queue.back()->GetThisData())
// <returns>ポップしたDrawBaseDataの派生クラスを返す</returns>
 
namespace
{
    using std::string;
    using std::map;
    using std::vector;
    using Kisaragi_Lib::ID::IDAssignment;
    using Kisaragi_Lib::ComponentBase;
}
 
 
namespace Kisaragi_Lib
{
    namespace ImgComponent
    {
        
        class LayerFacade;
        LayerFacade& GetLayerFacade();
 
        /// <summary>
        /// 描画コンポーネントの基底クラス.
        /// </summary>
        class ImgBase : public ComponentBase
        {
        protected:
            string layer;
        public:
 
            //TODO 消す
            virtual void Draw(Matrix2D _drawMat) {};
            virtual void Draw() {};
            string Layer() const
            {
                return layer;
            }
 
            void ChangeLayer(string _layerName, bool _layerCreate);
 
            void Start() override;
 
            virtual ~ImgBase();
        };
 
        /// <summary>
        /// 画像描画クラス
        /// </summary>
        class ImgGraph : public ImgBase
        {
        protected:
            int img;
            Vector2D<float>size;
            Vector2D<float>imgCentor;
            bool trans = true; //透過
 
        public:
            /// <summary>
            /// 要素に応じて画像の反転を行います
            /// </summary>
            Vector2D<bool>isTurn{0,0};
            /// <summary>
            /// 画像サイズ(読み取り専用)
            /// </summary>
            ReadOnly<Vector2D<float>>Size{ &size };
            /// <summary>
            /// 画像を透過するか否か
            /// </summary>
            Accessor<bool> Trans{ &trans };
 
            ImgGraph();
 
            void SetImg(string _imgKey);
 
            void SetImg(string _imgKey, string _imgPass);
 
            int GetImg();
 
            void Draw(Matrix2D _drawMat)override;
            void Draw()override;
 
            ImgGraph* GetThisComponent() override
            {
                return this;
            }
 
        };
 
        class ImgLine : public ImgBase
        {
        public:
            Point2D<double> p;
 
            void Draw(Matrix2D _drawMat)override
            {
                DrawLine(_drawMat.Position().x , _drawMat.Position().y, p.x + WINDOW_WIDTH/2, p.y+WINDOW_HEIGHT/2, GetColor(255, 255, 0));
            }
        };
 
        /// <summary>
        /// 縦書きか横書きか
        /// </summary>
        enum WritingType
        {
            HORIZONTAL,//横書き
            VERTICAL,//縦書き
        };
 
        class ImgText : public ImgBase
        {
        protected:
            string text;
            unsigned int col;
            unsigned int edgeCol;
            WritingType writingType = HORIZONTAL;
            std::shared_ptr<Font> font = FontFacade::Get("Default");
 
 
        public:
            Accessor<string>Text{ &text };
            Accessor<unsigned int>Col{ &col };
            Accessor<unsigned int>EdgeCol{ &edgeCol };
            Accessor<WritingType>Type{ &writingType };
            Accessor<std::shared_ptr<Font>>Font{ &font };
 
            void Draw(Matrix2D _drawMat)override
            {
 
                //縦書きフラグ
                bool v = (writingType == VERTICAL);
 
 
                int tmpX ;
                int tmpY ;
 
                GetDrawStringSizeToHandle(
                    &tmpX, &tmpY, 
                    nullptr, 
                    text.c_str(),text.size()+1, *font
                );
 
                tmpX /= 2;
                tmpY /= 2;
 
                DrawRotaStringToHandle(
                    _drawMat.Position().x, _drawMat.Position().y, //左上座標
                    _drawMat.Scale().x,_drawMat.Scale().y,                      //拡大率
                    tmpX, tmpY ,                                                //回転の中心(左上座標の相対座標)
                    _drawMat.Rotation(),                                        //回転角度
                    col,                                                     //文字色
                    *font,                                                      //フォント
                    edgeCol,                                                 //文字縁の色 
                    v,                                                          //縦書きか否か
                    text.c_str()                                                //テキスト
                );
            }
 
        };
 
        /// <summary>
        /// 円の描画クラス
        /// </summary>
        class ImgCircle : public ImgBase
        {
        public:
            // 半径
            double radius;
            // 円の色
            RGB255 rgb{ 255, 255, 0 };
            // 塗りつぶしを行うか
            bool isFill = false;
 
            void Draw(Matrix2D _drawMat)override
            {
                DrawOval(
                    _drawMat.Position().x, _drawMat.Position().y,
                    radius * _drawMat.Scale().x, radius * _drawMat.Scale().y,
                    rgb.ToDxLibColor(),
                    isFill
                    );
            }
        };
 
        class Layer
        {
        private:
            map<string,ImgBase*> queue;
 
        public:
            //Push()
            void Push(string _id,ImgBase* _drawComponent)
            {
                queue.emplace(_id, _drawComponent);
            }
 
            ~Layer()
            {
                Clear();
            }
 
            /// <summary>
            /// データをポップする.
            /// </summary>
            void Pop(string _id)
            {
                if (Empty())
                {
                    return;
                }
 
                queue.erase(_id);
            }
 
            /// <summary>
            /// キューをクリアする.
            /// </summary>
            void Clear()
            {
                queue.clear();
            }
 
            /// <summary>
            /// キューが空か調べる.
            /// </summary>
            /// <returns>空ならtrue</returns>
            bool Empty()
            {
                return queue.empty();
            }
 
            //TODO 描画処理はviewで行われるべき.
            /// <summary>
            /// 描画処理を行う.
            /// </summary>
            void Draw()
            {
                for (auto& q : queue)
                {
                    //ここでカメラを取得
                    //if ( camera.DrawLayer != q ) { continue; }
 
                    q.second->Draw();
                }
            }
 
            unsigned int Cnt()
            {
                return (unsigned int)queue.size();
            }
 
            map<string, ImgBase*> Queue()
            {
                return queue;
            }
        };
 
        class LayerFacade
        {
        private:
            map<string, Layer*>layers;
            vector<string>layerName;
 
        public:
            LayerFacade()
            {
                AddLayer("Default");
            }
 
            ~LayerFacade()
            {
                ClearLayer();
            }
 
            /// <summary>
            /// レイヤーを追加する.
            /// </summary>
            /// <param name="_key">レイヤー名</param>
            /// <returns>追加に成功したかどうか</returns>
            Result AddLayer(string _key);
 
            /// <summary>
            /// レイヤーを削除する
            /// </summary>
            /// <param name="_key">削除したいレイヤー名</param>
            void RemoveLayer(string _key);
 
            /// <summary>
            /// レイヤーを全て消去する.
            /// </summary>
            void ClearLayer();
 
            /// <summary>
            /// レイヤー名を取得する
            /// </summary>
            /// <returns></returns>
            vector<string> LayerName();
 
            map<string, Layer*> Layers()
            {
                return layers;
            }
 
            /// <summary>
            /// レイヤー順を交換する
            /// </summary>
            /// <param name="_key1">交換したいレイヤー名1</param>
            /// <param name="_key2">交換したいレイヤー名2</param>
            void SwapLayer(string _key1, string _key2);
 
            void Draw();
 
            //ImgComponent操作
#pragma region ImgComponent操作
            void ImgPush(string _layerName, ImgBase* _drawData, bool ifCreate = false);
 
            void ImgPop(string _layerName, string _id);
 
            void ImgClear(string _layerName);
 
            
#pragma endregion
 
        };
 
        LayerFacade& GetLayerFacade();
 
 
    }
}