Sound.hpp

[詳解]

#pragma once
#include <DxLib.h>
#include <unordered_map>
#include <unordered_set>
#include <string>
#include <memory>
#include "../ConsoleDebug/Debug.hpp"
#include "../utility/RangeNum.hpp"
#include "../ComponentBase.hpp"
#include "../utility/utility.hpp"
#include <mutex>
#include "../Accessor.hpp"
 
 
namespace Kisaragi_Lib
{
    class SoundHandle
    {
        int handle;
 
    public:
        SoundHandle(int _handle) : handle{_handle}
        {
 
        }
 
 
        ~SoundHandle()
        {
            DeleteSoundMem(handle);
        }
 
        operator const int&() const
        {
            return handle;
        }
    };
 
    class SoundClip;
 
    class SoundResourceFacade
    {
    public:
        static void Load(std::string _key, std::string _pass);
        static void UnLoad(std::string _key);
        static std::unique_ptr<SoundClip> CreateClip(std::string _key);
 
    private:
        static void Init();
 
        static std::once_flag once;
 
        class SoundResourceFacade_Impl;
        static std::weak_ptr<SoundResourceFacade_Impl> ptr;
    };
 
    enum SoundPlayType
    {
        ASYNC  = DX_PLAYTYPE_BACK  ,   //: 非同期再生
        LOOP    = DX_PLAYTYPE_LOOP  ,   //: ループ再生
        SYNC    = DX_PLAYTYPE_NORMAL,   //: 同期再生
    };
 
    class SoundClip
    {
        SoundHandle handle;
        bool isPlayTop = 1;
 
        RangeNum<int, ClampOnOutOfRange> vol{ 0,255 };
 
    public:
 
        SoundClip(int _handle) : handle{ _handle }
        {
            Vol(128);
        }
 
 
        SoundPlayType playType = ASYNC;
 
        template<typename Num>
        const int& Vol(Num _in)
        {
            vol = _in;
            ChangeVolumeSoundMem(vol,handle);
            return vol;
        }
 
 
        void Play()
        {
            if (IsPlay())
            {
                Debug::PrintWarningStatic("既に再生中です");
                return;
            }
 
            PlaySoundMem(handle, playType, isPlayTop);
 
        }
 
        void Pause()
        {
            if (IsPlay())
            {
                isPlayTop = 0;
                StopSoundMem(handle);
                return;
            }
 
            Debug::PrintWarningStatic("再生されていない音声を停止しようとしました");
        }
 
 
        void Stop()
        {
            if (IsPlay())
            {
                isPlayTop = 1;
                StopSoundMem(handle);
                return;
            }
 
            Debug::PrintWarningStatic("再生されていない音声を停止しようとしました");
        }
 
 
        bool IsPlay()
        {
            return CheckSoundMem(handle) == 1;
        }
    };
 
    class DeleteWaitSoundClips;
 
    class DeleteWaitSoundClipsController
    {
        static std::once_flag once;
 
        static std::weak_ptr<DeleteWaitSoundClips> deleteWaitClips;
 
    public:
 
        static void Init();
 
        static void Push(std::unique_ptr<SoundClip> _clip);
 
        static void Delete();
 
        static void Clear();
 
    };
 
 
 
    /// <summary>
    /// Facadeクラスのcontainerに対するインターフェースとなるクラス
    /// </summary>
    class SoundPlayerComponent : public ComponentBase
    {
        std::unordered_map<std::string,std::unique_ptr<SoundClip>> vec;
 
    public:
 
        SoundPlayerComponent();
 
        SoundClip& operator[](std::string _key)
        {
            if (!vec.count(_key))
            {
                Debug::PrintAssertStatic("keyの要素が存在しません");
            }
            return *vec[_key];
        }
 
        void Add(std::string _key, std::string _soundFile, std::string _clipName);
 
        void Add(std::string _key, std::string _clipName);
 
        void Pop(std::string _clipName);
 
 
        ~SoundPlayerComponent()
        {
            while (vec.size()!=0)
            {
                Pop(vec.begin()->first);
            }
        }
    };
}