Particle.h

#pragma once
#include"../res-management/texManager.h"
#include"../res-management/meshManager.h"
#include"../res-management/terrain.h"
#include"shaderProgram.h"
#include"camera.h"
 
#include <random>
 
namespace Aire {
 
    enum GeneratorType
    {
        NORMAL,
        RECTANGLE
    };
 
    enum RectangleType
    {
        XY_PLANE,
        XZ_PLANE,
        YZ_PLANE
    };
 
    struct Rectangle
    {
        glm::vec3 leftTop;
        glm::vec3 leftBottom;
        glm::vec3 rightBottom;
        glm::vec3 rightTop;
 
        glm::vec3 getNormal()
        {
            glm::vec3 v1 = leftTop - leftBottom;
            glm::vec3 v2 = leftTop - rightTop;
            return glm::cross(v1, v2);
        }
 
        Rectangle():leftTop(0.0f),leftBottom(0.0f),rightBottom(0.0f),rightTop(0.0f){}
 
        Rectangle(float width, float length, float height, RectangleType type, glm::vec2 initialPosition = glm::vec2(0.0f))
        {
            if (type == XY_PLANE)
            {
                leftBottom = glm::vec3(initialPosition.x - width / 2.0f, initialPosition.y - length / 2.0f,height);
                leftTop = glm::vec3(initialPosition.x - width / 2.0f, initialPosition.y + length / 2.0f, height);
                rightTop = glm::vec3(initialPosition.x + width / 2.0f, initialPosition.y + length / 2.0f, height);
                rightBottom = glm::vec3(initialPosition.x + width / 2.0f, initialPosition.y - length / 2.0f, height);
            }
            else if (type == XZ_PLANE)
            {
                leftBottom = glm::vec3(initialPosition.x - width / 2.0f, height, initialPosition.y - length / 2.0f);
                leftTop = glm::vec3(initialPosition.x - width / 2.0f, height, initialPosition.y + length / 2.0f);
                rightTop = glm::vec3(initialPosition.x + width / 2.0f, height, initialPosition.y + length / 2.0f);
                rightBottom = glm::vec3(initialPosition.x + width / 2.0f, height, initialPosition.y - length / 2.0f);
            }
            else if (type == YZ_PLANE)
            {
                leftBottom = glm::vec3(height, initialPosition.x - width / 2.0f, initialPosition.y - length / 2.0f);
                leftTop = glm::vec3(height, initialPosition.x - width / 2.0f, initialPosition.y + length / 2.0f);
                rightTop = glm::vec3(height, initialPosition.x + width / 2.0f, initialPosition.y + length / 2.0f);
                rightBottom = glm::vec3(height, initialPosition.x + width / 2.0f, initialPosition.y - length / 2.0f);
            }
        }
    };
 
    struct Particle {
        glm::vec3 Velocity;
        Model* model;
        glm::vec3 position;
        float   Life;
        bool isEmitted;
        Rigidbody* rigidbody = nullptr;
        Particle(Model* m) : Velocity(0.1f), model(m), position(glm::vec3()), Life(10.0f),isEmitted(false) { }
        Particle(Model* m, glm::vec3 position, glm::vec3 v, float l) : Velocity(v), model(m), position(position), Life(l), isEmitted(false) { }
 
        void setRigidbody(float radius) {
            RigidbodyHandler* rbHandler = RigidbodyHandler::getInstance();
            this->rigidbody = rbHandler->createRigidbodyBall(radius, position);
        }
    };
 
 
    class ParticleGenerator
    {
    public:
        ParticleGenerator(std::vector<Model*> models, Terrain* terrain, unsigned int amount, MeshManager& meshManager, const glm::vec3& position,
            const glm::vec3& direction, float interval);
 
        ParticleGenerator(std::vector<Model*> models, Terrain* terrain, unsigned int amount, MeshManager& meshManager, Rectangle range, float interval);
 
        void setSpeed(float speed);
 
        std::vector<Particle>& getParticles() { return particles; }
 
        Terrain* getTerrain() { return terrain; }
 
        std::vector<Model*> models;
 
        void Update(float dt);
 
        void renderParticles(ShaderProgram& shader, Camera& playCamera);
    private:
 
        std::vector<Particle> particles; 
        
        unsigned int amount; 
        
        Terrain* terrain;
       
        float interval;
 
        float countDown = 0.0f;
 
        MeshManager* meshManager;
 
        GeneratorType generatorType;
 
        glm::vec3 position; //< Position of the generator
 
        glm::vec3 direction;
 
        float speed = 1.0f;
 
        Rectangle range;
 
        std::default_random_engine generatorOne, generatorTwo;
 
        // Variable to create floats
        // Since now we only use two components in vec3, just create two variables
        std::uniform_real_distribution<float> distributionOne;
        std::uniform_real_distribution<float> distributionTwo;
 
        void respawnParticle(Particle& particle);
    };
}