tbx_cutscene_entity.hpp

#ifndef TurtleBrainsExpress_CutsceneEntity_hpp
#define TurtleBrainsExpress_CutsceneEntity_hpp

#include <turtle_brains/core/tb_string.hpp>
#include <turtle_brains/core/tb_dynamic_structure.hpp>
#include <turtle_brains/math/tb_interpolation.hpp>
#include <turtle_brains/game/tb_entity.hpp>
#include <turtle_brains/game/tb_game_timer.hpp>

#include <unordered_map>

namespace TurtleBrainsExpress
{
    namespace Entities
    {
        namespace Unstable
        {

            class CutsceneEntity : public tbGame::Entity
            {
            public:
                explicit CutsceneEntity(void);

                explicit CutsceneEntity(const tbCore::tbString& scriptFile, const std::vector<tbCore::tbString>& parameters = { });

                virtual ~CutsceneEntity(void);

                bool IsPlaying(void) const;

                void Play(bool isLooping);

                void Pause(void);

                void Stop(void);

                static void CheckAndReloadCutsceneScripts(void);

            protected:
                enum TweenChannel
                {
                    Position,
                    Rotation,
                    Scale,
                    Count
                };

                struct KeyFrame
                {
                    tbGame::GameTimer mStartTime;
                    tbMath::Vector2 mPosition;
                    tbMath::Vector2 mScale;
                    tbMath::Angle mRotation;
                    tbGraphics::Color mColor;
                    tbMath::Interpolation::InterpolationMode mTweenMode[TweenChannel::Count];
                };

                virtual void OnAdd(void) override;
                virtual void OnRemove(void) override;
                virtual void OnSimulate(void) override;
                virtual void OnUpdate(const float deltaTime) override;
                virtual void OnRender(void) const override;
                virtual void OnCollide(const tbGame::Entity& otherEntity) override;

                void AddSceneProp(const tbCore::tbString& name, tbGraphics::Graphic& graphic, bool setInitialFrame);
                void AddSceneProp(const tbCore::tbString& name, tbGraphics::Graphic* graphic, bool setInitialFrame);

                void AddKeyFrame(const tbCore::tbString& name, const KeyFrame& keyFrame, bool additive);
                void AddKeyFrame(const tbCore::tbString& name, const tbGraphics::Graphic& graphic,
                    const tbGame::GameTimer& startTime, bool additive);
                bool GetLastKeyFrame(const tbCore::tbString& name, KeyFrame& keyFrame) const;

            private:
                struct SceneProp
                {
                    tbGraphics::Graphic* mGraphic;
                    std::vector<KeyFrame> mKeyFrames;
                    size_t mCurrentFrameIndex;
                };

                void AddKeyFrame(SceneProp& sceneProp, const KeyFrame& keyFrame, bool additive);

                static KeyFrame BetweenKeyFrames(float percentage, const KeyFrame& start, const KeyFrame& final);
                static KeyFrame KeyFrameFromGraphic(const tbGraphics::Graphic& graphic, const tbGame::GameTimer& startTime = 0);
                static void SetGraphicToKeyFrame(tbGraphics::Graphic& graphic, const KeyFrame& keyFrame);

                void ClearScript(void);
                void LoadScript(void);
                tbGraphics::Graphic* LoadGraphic(const tbCore::DynamicStructure& graphicData) const;
                void LoadSceneProp(const tbCore::DynamicStructure& propData, SceneProp& sceneProp) const;
                bool LoadKeyFrame(const tbCore::DynamicStructure& keyFrameData, KeyFrame& keyFrame, const SceneProp& sceneProp) const;

                bool ReallyAddSceneProp(const tbCore::tbString& name, tbGraphics::Graphic& graphic, bool setInitialFrame);
                bool ReallyAddSceneProp(const tbCore::tbString& name, const SceneProp& sceneProp);

                typedef std::unordered_map<tbCore::tbString, SceneProp> ScenePropTable;
                ScenePropTable mSceneProps;
                tbGame::GameTimer mCurrentTime;
                const tbCore::tbString mScriptFile;
                const std::vector<tbCore::tbString> mScriptParameters;
                bool mIsPlaying;
                bool mIsLooping;
            };

        }; /* namespace Unstable */

    }; /* namespace Entities */
}; /* namespace TurtleBrainsExpress */

namespace tbxEntities = TurtleBrainsExpress::Entities;

#endif /* TurtleBrainsExpress_CutsceneEntity_hpp */