Particle.hpp

Go to the documentation of this file.

#pragma once

#include <ThirdParty/glm/glm/glm.hpp>

#include "Engine/Mesh/Mesh.hpp"
#include "Engine/Material/Material.hpp"
#include "Engine/Texture/Texture.hpp"

#include <ThirdParty/EASTL-master/include/EASTL/map.h>
#include <ThirdParty/EASTL-master/include/EASTL/shared_ptr.h>

namespace Engine {

    class Particle
    {
    public:
        Particle();
        ~Particle();

        enum class ParticleType {
            LINE = 0,
            BILLBOARD,
            MESH
        };

        enum class InterpolateType {
            START = 0,
            END,
            LINEAR,
            QUADRATIC
        };

        enum class BlendMode {
            ALPHA = 0,
            ADDATIVE,
            SOLID
        };

        enum class LineEndAction {
            STOP = 0,
            REMOVE_FIRST,
            REMOVE_SECOND,
            REMOVE_LAST,
            DESTROY
        };

        void SetParticleType(ParticleType type);

        ParticleType GetParticleType() const;

        void SetBlendMode(BlendMode mode);

        BlendMode GetParticleBlendMode() const;

        void SetStartColor(glm::vec4 colorMin, glm::vec4 colorMax);
        
        eastl::pair<glm::vec4, glm::vec4> GetStartColor();

        void SetEndColor(glm::vec4 colorMin, glm::vec4 colorMax);

        eastl::pair<glm::vec4, glm::vec4> GetEndColor();

        void SetColorInterpolateType(InterpolateType type);

        InterpolateType GetColorInterpolateType() const;

        void SetForce(glm::vec3 forceMin, glm::vec3 forceMax);

        eastl::pair<glm::vec3, glm::vec3> GetForce();

        void SetLifetime(float lifetimeMin, float lifetimeMax);

        eastl::pair<float, float> GetLifetime();

        void SetSpeed(float speedMin, float speedMax);

        eastl::pair<float, float> GetSpeed();

        void SetMass(float massMin, float massMax);

        eastl::pair<float, float> GetMass();

        void SetGravityEnabled(bool gravity);

        bool IsGravityEnabled() const;

        void SetTexture(eastl::weak_ptr<Texture> texture);

        eastl::weak_ptr<Texture> GetTexture() const;

        bool HasTexture() const;

        void SetLineMaxSegments(int segments);

        int GetLineMaxSegments() const;

        void SetNewSegmentsPerFrame(int segments);

        int GetNewSegmentsPerFrame() const;

        void SetLineEndAction(LineEndAction action);

        LineEndAction GetLineEndAction() const;

        void SetLineStartThickness(float thicknessMin, float thicknessMax);

        eastl::pair<float, float> GetLineStartThickness();

        void SetLineEndthickness(float thicknessMin, float thicknessMax);
        
        eastl::pair<float, float> GetLineEndThickness();

        void SetLineThicknessInterpolateType(InterpolateType type);

        InterpolateType GetLineThicknessInterpolateType() const;

        void SetBillboardSizeStart(glm::vec2 sizeMin, glm::vec2 sizeMax);

        eastl::pair<glm::vec2, glm::vec2> GetBillboardSizeStart();

        void SetBillboardSizeEnd(glm::vec2 sizeMin, glm::vec2 sizeMax);

        eastl::pair<glm::vec2, glm::vec2> GetBillboardSizeEnd();

        void SetBillboardSizeInterpolateType(InterpolateType type);

        InterpolateType GetBillboardSizeInterpolateType() const;

        void SetBillboardRollSpeedStart(float speedMin, float speedMax);

        eastl::pair<float, float> GetBillboardRollSpeedStart();

        void SetBillboardRollSpeedEnd(float speedMin, float speedMax);

        eastl::pair<float, float> GetBillboardRollSpeedEnd();

        void SetBillboardRoll(float rollMin, float rollMax);

        eastl::pair<float, float> GetBillboardRoll();

        void SetBillboardRollSpeedInterpolateType(InterpolateType type);

        InterpolateType GetBillboardRollSpeedInterpolateType() const;

        void SetMesh(eastl::weak_ptr<Mesh> mesh);

        eastl::weak_ptr<Mesh> GetMesh() const;

        void SetMaterial(eastl::weak_ptr<Material> material);

        eastl::weak_ptr<Material> GetMaterial() const;

        void SetMeshScaleStart(glm::vec3 scaleMin, glm::vec3 scaleMax);

        eastl::pair<glm::vec3, glm::vec3> GetMeshScaleStart();

        void SetMeshScaleEnd(glm::vec3 scaleMin, glm::vec3 scaleMax);

        eastl::pair<glm::vec3, glm::vec3> GetMeshScaleEnd();

        void SetMeshScaleInterpolateType(InterpolateType type);

        InterpolateType GetMeshScaleInterpolateType() const;

        void SetMeshRotationSpeedStart(glm::vec3 speedMin, glm::vec3 speedMax);

        eastl::pair<glm::vec3, glm::vec3> GetMeshRotationSpeedStart();

        void SetMeshRotationSpeedEnd(glm::vec3 speedMin, glm::vec3 speedMax);

        eastl::pair<glm::vec3, glm::vec3> GetMeshRotationSpeedEnd();

        void SetMeshRotation(glm::vec3 rotationMin, glm::vec3 rotationMax);

        eastl::pair<glm::vec3, glm::vec3> GetMeshRotation();

        void SetMeshRotationSpeedInterpolateType(InterpolateType type);

        InterpolateType GetMeshRotationSpeedInterpolateType() const;

        void SetMeshLit(bool lit);

        bool IsMeshLit() const;

        void SetCastsShadows(bool castShadows);

        bool CanCastShadows() const;

    protected:

        friend class Emitter;

        struct ParticleData {
            glm::vec4 position;
            glm::vec4 direction;
            glm::vec4 force;
            glm::vec4 startColor;
            glm::vec4 endColor;
            glm::vec4 currentColor;
            float lifetime;
            float currentLifetime;
            float speed;
            float mass;
        };

        struct LineData {
            int segmentCount;
            float startThickness;
            float endThickness;
            float currentThickness;
        };

        struct BillboardData {
            glm::vec2 startSize;
            glm::vec2 endSize;
            glm::vec2 currentSize;
            glm::vec2 padding;
            float startRotationSpeed;
            float endRotationSpeed;
            float currentRotationSpeed;
            float currentRotation;
        };

        struct MeshData {
            glm::vec4 startScale;
            glm::vec4 endScale;
            glm::vec4 currentScale;
            glm::vec4 startRotationSpeed;
            glm::vec4 endRotationSpeed;
            glm::vec4 currentRotationSpeed;
            glm::vec4 currentRotation;
        };

        ParticleData CreateParticle(glm::vec4 position, glm::vec4 direction) const;

        LineData CreateParticleLineData() const;

        BillboardData CreateParticleBillboardData() const;

        MeshData CreateParticleMeshData() const;

        float RandomFloatLinear(float min, float max) const;

        ParticleType particleType;
        BlendMode particleBlendMode;

        glm::vec4 startColorMin, startColorMax;
        glm::vec4 endColorMin, endColorMax;
        InterpolateType colorInterpolateType;

        glm::vec4 forceMin, forceMax;

        float lifetimeMin, lifetimeMax;
        float speedMin, speedMax;
        float massMin, massMax;

        bool gravity = false;

        eastl::weak_ptr<Texture> texture;

        bool textured = false;

        int maxSegments;
        int newSegmentsPerFrame;

        LineEndAction lineEndAction;

        float startLineThicknessMin, startLineThicknessMax;
        float endLineThicknessMin, endLineThicknessMax;
        InterpolateType lineThicknessInterpolateType;

        glm::vec2 startSizeMin, startSizeMax;
        glm::vec2 endSizeMin, endSizeMax;
        InterpolateType sizeInterpolateType;

        float startRollSpeedMin, startRollSpeedMax;
        float endRollSpeedMin, endRollSpeedMax;
        InterpolateType rollSpeedInterpolateType;

        float rollMin, rollMax;

        eastl::weak_ptr<Mesh> mesh;
        eastl::weak_ptr<Material> material;

        glm::vec4 startScaleMin, startScaleMax;
        glm::vec4 endScaleMin, endScaleMax;
        InterpolateType scaleInterpolateType;

        glm::vec4 startRotationSpeedMin, startRotationSpeedMax;
        glm::vec4 endRotationSpeedMin, endRotationSpeedMax;
        InterpolateType rotationSpeedInterpolateType;

        glm::vec4 rotationMin, rotationMax;

        bool meshLit;
        bool castShadows;
    };

}