Kisaragi_Resource.h

[詳解]

#pragma once
 
#include "Const.h"
#include <string>
#include <map>
#include "DesignPattern/Singleton/Singleton.hpp"
#include <DxLib.h>
 
using std::string;
using std::map;
 
namespace Kisaragi_Lib
{
    namespace Resource
    {
 
        /// <summary>
        /// 4���̓����������J�b�g�������摜��ۑ�����.
        /// </summary>
        /// <param name="_pass">�摜�̃p�X</param>
        /// <returns>�摜�n���h��</returns>
        int LoadAlphCutImg(string _pass);
 
        class ResourceFacade
        {
 
        };
 
 
        /// <summary>
        /// �t�@�C���p�X��Key���L�������\�[�X�����݂��邩��T��.
        /// </summary>
        class ResourceFind
        {
        private:
            //map<key,pass>
            std::map<string, string>keyToPass;
            //map<pass,key>
            std::map<string, string>passToKey;
 
        public:
            /// <summary>
            /// _key�����݂��邩�m�F����.
            /// </summary>
            /// <param name="_key">��������key</param>
            /// <returns>true = ���݂��Ȃ�. false = ���݂���
            bool IsEmptyKey(string _key)
            {
                bool empty = true;
                if (keyToPass.end() != keyToPass.find(_key))
                {
                    empty = false;
                }
                return empty;
            }
 
            /// <summary>
            /// _pass�����݂��邩��������.
            /// </summary>
            /// <param name="_pass">��������p�X</param>
            /// <returns>true = ���݂��Ȃ�. false = ���݂���
            bool IsEmptyPass(string _pass)
            {
                bool empty = true;
                if (passToKey.end() != passToKey.find(_pass))
                {
                    empty = false;
                }
                return empty;
            }
 
            /// <summary>
            /// �v�f�̒lj����s��.�d���s��.
            /// </summary>
            /// <param name="_key">�lj�������Key</param>
            /// <param name="_pass">�lj�������Pass</param>
            /// <returns>�lj��������������ǂ���</returns>
            Result Add(string _key, string _pass)
            {
                //_key�����݂���Ȃ�A��
                if (!IsEmptyKey(_key))
                {
                    return FAIL;
                }
 
                //_pass���d������Ȃ�A��
                if (!IsEmptyPass(_pass))
                {
                    return FAIL;
                }
 
                //map�ɒlj�.
                keyToPass.emplace(_key, _pass);
                passToKey.emplace(_pass, _key);
 
                return SUCCESS;
            }
 
            /// <summary>
            /// �v�f�̍폜���s��.
            /// </summary>
            /// <param name="_key">�폜�������v�f��Key</param>
            /// <returns>�폜�̉”�
            Result Remove(string _key)
            {
                //key�����݂��Ȃ��Ȃ�
                if (!IsEmptyKey(_key))
                {
                    return FAIL;
                }
 
                passToKey.erase(KeyToPass(_key));
                keyToPass.erase(_key);
                return SUCCESS;
            }
 
            /// <summary>
            /// Key���p�X�ɕϊ�����.
            /// </summary>
            /// <param name="_key">�ϊ�������key</param>
            /// <returns>_key�ɑΉ�����p�X</returns>
            string KeyToPass(const string _key)
            {
                return keyToPass[_key];
            }
 
            /// <summary>
            /// �p�X��Key�ɕϊ�����.
            /// </summary>
            /// <param name="_pass">�ϊ��������p�X</param>
            /// <returns>_pass�ɑΉ�����key</returns>
            string PassToKey(const string _pass)
            {
                return passToKey[_pass];
            }
 
            void Reset()
            {
                keyToPass.clear();
                passToKey.clear();
            }
        };
 
        class ResourceBase
        {
        protected:
            ResourceFind resourceFind;
 
        public:
            ResourceFind ResourceFind()
            {
                return resourceFind;
            }
 
            virtual Result Add(const string _key, const string _pass) = 0;
 
            virtual Result Remove(const string _key) = 0;
 
            virtual void Reset() = 0;
 
        };
 
        //�����ǂݍ��ݐ�p�̉摜���\�[�X�N���X
        class ImgResource : ResourceBase
        {
        private:
            map<string, int> imgData;
 
        public:
 
            Result Add(const string _key, const string _pass) override
            {
                int* tmp = new int();
                *tmp = DxLib::LoadGraph(_pass.c_str());
 
                if (*tmp == -1)
                {
                    delete tmp;
                    return FAIL;
                }
 
 
                //key�̒lj��Ɏ��s
                if (resourceFind.Add(_key, _pass) == FAIL)
                {
                    delete tmp;
                    return FAIL;
                }
 
                imgData.emplace(_key, *tmp);
 
                delete tmp;
                return SUCCESS;
            }
 
            /// <summary>
            /// 4���̓����ӏ���؂������摜��lj����܂�.
            /// </summary>
            /// <param name="_key">�摜�f�[�^�̃L�[</param>
            /// <param name="_pass">�摜�̃p�X</param>
            /// <returns>�֐��̐���
            Result Add_AlphaCut(const string _key, const string _pass)
            {
                int* tmp = new int();
                *tmp = LoadAlphCutImg(_pass);
 
                if (*tmp == -1)
                {
                    delete tmp;
                    return FAIL;
                }
 
 
                //key�̒lj��Ɏ��s
                if (resourceFind.Add(_key, _pass) == FAIL)
                {
                    delete tmp;
                    return FAIL;
                }
 
                imgData.emplace(_key, *tmp);
 
                delete tmp;
                return SUCCESS;
            }
 
            int GetImg(const string _key)
            {
                if (imgData.count(_key) == 0)
                {
                    return -1;
                }
 
                return imgData[_key];
            }
 
            Result Remove(const string _key) override
            {
                if (resourceFind.IsEmptyKey(_key) == false)
                {
                    return FAIL;
                }
 
                resourceFind.Remove(_key);
                DeleteGraph(imgData[_key]);
 
                imgData.erase(_key);
 
                return SUCCESS;
            }
 
            void Reset() override
            {
                imgData.clear();
                resourceFind.Reset();
                InitGraph();
            }
 
        };
 
        
        ImgResource& GetImgResource();
    }
}