Film.h

//Copyright © 2014 SDXFramework
//[License]GNU Affero General Public License, version 3
//[Contact]http://sourceforge.jp/projects/dxframework/
#pragma once
#include <Multimedia/SDX.h>
#include <Multimedia/Image.h>
#include <Framework/ImagePack.h>

namespace SDX
{
    enum class NextFrame
    {
        Normal = -10000,
        ToFront,
        ToBack,
        End,
    };

    enum class FilmType
    {
        Normal,
        Reverse,
        End
    };

    class Film : public ImagePack
    {
        friend class Anime;
    private:
        std::vector<unsigned int> times;
        std::vector<int> nexts;
    public:
        Film() = default;

        Film(const char *ファイル名, int 総コマ数, int コマ割り横, int コマ割り縦, int １コマの再生時間 = 1) :
            ImagePack(ファイル名, 総コマ数, コマ割り横, コマ割り縦)
        {
            for (int a = 0; a < 総コマ数; ++a)
            {
                times.push_back(１コマの再生時間);
                nexts.push_back((int)NextFrame::Normal);
            }
        }

        Film(const char* ファイル名, const char *拡張子, int 総コマ数, int １コマの再生時間 = 1, const char* 書式 = "%03d.")
        {
            Load(ファイル名, 拡張子, 総コマ数, １コマの再生時間 ,書式);
        }

        bool Load(const char *ファイル名, int 総コマ数, int コマ割り横, int コマ割り縦, int １コマの再生時間 = 1)
        {
            if (Loading::IsLoading())
            {
                Loading::AddLoading([=]{ Load(ファイル名, 総コマ数, コマ割り横, コマ割り縦, １コマの再生時間); });
                return true;
            }

            if (!ImagePack::Load(ファイル名, 総コマ数, コマ割り横, コマ割り縦)) { return false; }

            for (int a = 0; a < 総コマ数; ++a)
            {
                times.push_back(１コマの再生時間);
                nexts.push_back((int)NextFrame::Normal);
            }

            return true;
        }

        bool Load(const char* ファイル名, const char *拡張子, int 総コマ数, int １コマの再生時間 = 1, const char* 書式 = "%03d.")
        {
            if (Loading::IsLoading())
            {
                Loading::AddLoading([=]{ Load(ファイル名, 拡張子, 総コマ数, １コマの再生時間 , 書式); });
                return true;
            }

            for (int a = 0; a < 総コマ数; ++a)
            {
                char fileBuf[8];
                sprintf_s(fileBuf, 8, 書式, a);
                std::string fileName = ファイル名;
                fileName += fileBuf;
                fileName += 拡張子;

                this->Add(new Image(fileName.c_str()), １コマの再生時間);
            }

            return true;
        }

        void Add(Image *追加イメージ, int 再生フレーム数 = 1)
        {
            if (Loading::IsLoading())
            {
                Loading::AddLoading([=]{ Add(追加イメージ, 再生フレーム数); });
                return;
            }

            ImagePack::Add(追加イメージ);
            times.push_back(再生フレーム数);
            nexts.push_back((int)NextFrame::Normal);
        }
        void Add(const char *ファイル名, int 再生フレーム数 = 1)
        {
            if (Loading::IsLoading())
            {
                Loading::AddLoading([=]{ Add(ファイル名, 再生フレーム数); });
                return;
            }

            Add(new Image(ファイル名), 再生フレーム数);
        }

        void Release() override
        {
            ImagePack::Release();
            times.clear();
            nexts.clear();
        }

        void SetFrameTime(const std::vector<int> &フレーム時間)
        {
            if (Loading::IsLoading())
            {
                Loading::AddLoading([=]{ SetFrameTime(フレーム時間); });
                return;
            }

            for (unsigned int a = 0; a < times.size(); ++a)
            {
                times[a] = フレーム時間[a];
            }
        }

        void SetType(FilmType 再生方法)
        {
            if (Loading::IsLoading())
            {
                Loading::AddLoading([=]{SetType(再生方法); });
                return;
            }

            switch (再生方法)
            {
            case FilmType::Normal:
                nexts[nexts.size() - 1] = (int)NextFrame::Normal;
                break;
            case FilmType::Reverse:
                nexts[0] = (int)NextFrame::ToFront;
                nexts[nexts.size() - 1] = (int)NextFrame::ToBack;
                break;
            case FilmType::End:
                nexts[nexts.size() - 1] = (int)NextFrame::End;
                break;
            }
        }

        void SetType(int コマ番号, int 次フレーム)
        {
            if (Loading::IsLoading())
            {
                Loading::AddLoading([=]{nexts[コマ番号] = 次フレーム; });
                return;
            }

            nexts[コマ番号] = 次フレーム;
        }

        void SetType(int コマ番号, NextFrame 次フレーム)
        {
            if (Loading::IsLoading())
            {
                Loading::AddLoading([=]{ nexts[コマ番号] = (int)次フレーム; });
                return;
            }

            nexts[コマ番号] = (int)次フレーム;
        }

        int GetAnimeTime() const
        {
            int totalTime = 0;

            for (auto it : times)
            {
                totalTime += it;
            }

            return totalTime;
        }
    };
}