tb_particle_manager.hpp

#ifndef TurtleBrains_ParticleManager_hpp
#define TurtleBrains_ParticleManager_hpp

#include <turtle_brains/core/tb_string.hpp>
#include <turtle_brains/core/tb_noncopyable.hpp>
#include <turtle_brains/core/tb_types.hpp>
#include <turtle_brains/math/tb_vector.hpp>
#include <turtle_brains/graphics/tb_sprite.hpp>

#include <vector>
#include <list>
#include <map>

namespace tbImplementation
{

    class Particle
    {
    public:
        tbMath::Vector2 mPosition;
        tbMath::Vector2 mVelocity;
        tbMath::Vector2 mAcceleration;

        float mScale;
        float mDragCoefficient;
        tbCore::uint32 mFadeInTime;
        tbCore::uint32 mFadeOutTime;
        tbCore::uint32 mLifeTimer;
        bool mGlobalAcceleration;

        tbGraphics::SpriteFrame mSpriteFrame;
        tbGraphics::Color mColor;

        Particle(void);
        bool Update(const float deltaTime);
    };

};

namespace TurtleBrains
{
    namespace Graphics
    {
        namespace Unstable
        {

            template <typename Type> class RangedType
            {
            public:
                explicit RangedType(const Type& value) :
                    mMinimumValue(value),
                    mMaximumValue(value)
                {
                }

                explicit RangedType(const Type& minimumValue, const Type& maximumValue) :
                    mMinimumValue(minimumValue),
                    mMaximumValue(maximumValue)
                {
                    tb_error_if(maximumValue < minimumValue, "tbExternalError: Expected minimumValue to be less-than-or-equal-to maximumValue.");
                }

                ~RangedType(void)
                {
                }

                void SetRange(const Type& minimumValue, const Type& maximumValue)
                {
                    //tb_error_if(maximumValue < minimumValue, "tbExternalError: Expected minimumValue to be less-than-or-equal-to maximumValue.");
                    mMinimumValue = minimumValue;
                    mMaximumValue = maximumValue;
                }

                const Type& Minimum(void) const { return mMinimumValue; }
                const Type& Maximum(void) const { return mMaximumValue; }

            private:
                Type mMinimumValue;
                Type mMaximumValue;
            };

            struct ParticleDefinition
            {
                tbGraphics::SpriteFrame mSpriteFrame;
                RangedType<float> mSpawnDistanceRange;
                RangedType<float> mDragCoefficientRange;
                RangedType<float> mScaleRange;
                RangedType<float> mSpeedRange;
                RangedType<float> mLaunchAngleRange;
                RangedType<tbMath::Vector2> mAccelerationRange;

                RangedType<tbCore::uint32> mParticleLifeTimeRange;
                RangedType<tbCore::uint32> mParticleFadeInTimeRange;
                RangedType<tbCore::uint32> mParticleFadeOutTimeRange;

                bool mGlobalAcceleration; //Users Gravity/Wind accelerations.
                tbGraphics::Color mColor;

                explicit ParticleDefinition(const tbGraphics::SpriteFrame& spriteFrame);
            };

            struct EmitterDefinition
            {
                TextureHandle mTextureHandle;
                std::vector<ParticleDefinition> mParticleDefinitions;
                tbCore::uint32 mLifeTime;
                tbCore::uint32 mSpawnRate;
                tbCore::uint8 mSpawnCount;

                explicit EmitterDefinition(const TextureHandle& textureHandle);
            };

            class ParticleManager : tbCore::Noncopyable
            {
            public:
                ParticleManager(void);
                ~ParticleManager(void);

                bool LoadParticleSheetFromFile(const tbCore::tbString& particleSheetName, const tbCore::tbString& particleSheetFile);

                const EmitterDefinition& GetEmitterDefinition(const tbCore::tbString& particleSheet, const tbCore::tbString& emitterName) const;


                void ReloadModifiedSheets(void);


                void ClearAllParticles(void);
                void ManageParticle(const tbImplementation::Particle& particle);
                void UpdateParticles(const float deltaTime);
                void RenderParticles(void) const;

                void SetAcceleration(const tbMath::Vector2& accelerations);

                size_t GetParticleCount(void);

            private:
                typedef std::list<tbImplementation::Particle> ParticleList;
                typedef std::map<tbGraphics::TextureHandle, ParticleList> ParticleTable;

                ParticleTable mParticleTable;

                struct ParticleSheet
                {
                    typedef std::map<tbCore::tbString, ParticleDefinition> ParticleDefinitionTable;
                    typedef std::map<tbCore::tbString, EmitterDefinition> EmitterDefinitionTable;

                    ParticleDefinitionTable mParticles;
                    EmitterDefinitionTable mEmitters;
                };

                typedef std::map<tbCore::tbString, ParticleSheet> ParticleSheetTable;
                ParticleSheetTable mParticleSheets;

                typedef std::map<tbCore::tbString, tbCore::tbString> FileToSheetTable;
                FileToSheetTable mFileToSheets;
            };

            extern ParticleManager theParticleManager;

        } /* namespace Unstable */
    }; /* namespace Graphics */
}; /* namespace TurtleBrains */

namespace tbGraphics = TurtleBrains::Graphics;

#endif /* TurtleBrains_ParticleManager_hpp */