Change particle struct

ParticleGenerator/assets/shaders/Instanced.frag

@@ -10,7 +10,7 @@ uniform vec4 uGlobalColor;
 
 void main() {
     vec4 color =  texture(uSlots[uTextureId[zInstanceId]], zTex);
-    if(color.a < 0.1) {
+    if(color.a == 0.0) {
         discard;
     }
 

ParticleGenerator/src/Particle/Particle.cpp

+#include "Particle.hpp"
+
+#include <chrono>
+
+namespace pg {
+    Particle::Particle(const ct::Point& position) 
+    : Particle(0, position) {}
+
+    Particle::Particle(size_t birth, const ct::Point& position) 
+    : m_position(position), m_birth(birth) {}
+}
\ No newline at end of file

ParticleGenerator/src/Particle/Particle.hpp

 #pragma once
 
+#include <chrono>
 #include <CurveTools/CPU/CurveGenerator.hpp>
 
-namespace pg
-{
-	template <class ... Args>
-	class Particle
-	{
+namespace pg {	
+	class Particle {
 		private:
-		double m_birth;
+			size_t m_birth;
+
+		protected:
 			ct::Point m_position;
 
 		public:
-		inline Particle(const ct::Point& position = ct::Point(0.0), double birth = 0)
-		: m_birth(birth), m_position(position) {}
-
+			Particle(const ct::Point& position = ct::Point(0.0));
+			Particle(size_t birth, const ct::Point& position);
    virtual ~Particle() = default;
 
 			inline ct::Point getPosition() const {return this->m_position;}
-		inline double getBirth() const {return this->m_birth;}
+			inline size_t getBirth() const {return this->m_birth;}
 
 			inline void setPosition(const ct::Point& position) {this->m_position = position;}
-		inline void setBirth(double time) {this->m_birth = time;}
+			inline void setBirth(size_t time) {this->m_birth = time;}
 
-		virtual void update(Args ... args) = 0;
+			virtual void update(double) = 0;
 	};
 }
\ No newline at end of file

ParticleGenerator/src/Particle/PathParticle.cpp

 #include "PathParticle.hpp"
 
-namespace pg
-{
-	PathParticle::PathParticle(const ct::Curve& path, double birth) :
-		Particle({0, 0, 0}, birth),
-		m_path(path),
-		m_positionVariation()
-	{
-
+namespace pg {
+	PathParticle::PathParticle(ct::CurveGenerator* generator, const ct::Curve& path, double u) 
+	: Particle(), m_generator(generator), m_contrlPoints(path), m_positionVariation(), m_u(u) {
+		if(!path.empty()) {
+			this->setPosition(this->m_contrlPoints.at(0));
 		}
-
-	glm::dvec3 PathParticle::getPositionVariation() const
-	{
-		return m_positionVariation;
 	}
 
-	void PathParticle::setPositionVariation(const glm::dvec3& positionVariation)
-	{
-		m_positionVariation = positionVariation;
+	PathParticle::PathParticle(size_t birth, ct::CurveGenerator* generator, const ct::Curve& controlPoints, double u) 
+	: PathParticle(generator, controlPoints, u) {
+		this->setBirth(birth);
 	}
 
-	void PathParticle::update(ct::CurveGenerator* generator, double u)
-	{
-		setPosition((*generator)(m_path, u));
+	void PathParticle::update(double u) {
+		this->m_position = this->m_generator->operator()(this->m_contrlPoints, u);
 	}
 }

ParticleGenerator/src/Particle/PathParticle.hpp

@@ -3,20 +3,25 @@
 #include "Particle.hpp"
 #include <CurveTools/CPU/CurveGenerator.hpp>
 
-namespace pg
-{
-	class PathParticle : public Particle<ct::CurveGenerator*, double>
-	{
+namespace pg {
+	class PathParticle : public Particle {
 		private:
-		ct::Curve m_path;
+			ct::CurveGenerator* m_generator;
+			ct::Curve m_contrlPoints;
 			glm::dvec3 m_positionVariation;
+			double m_u;
 
 		public:
-		PathParticle(const ct::Curve& path, double birth = 0);
+			PathParticle(size_t birth, ct::CurveGenerator* generator, const ct::Curve& controlPoints, double u = 0.0);
+			PathParticle(ct::CurveGenerator* generator, const ct::Curve& path, double u = 0.0);
 
-		glm::dvec3 getPositionVariation() const;
-		void setPositionVariation(const glm::dvec3& positionVariation);
+			inline const ct::Curve & getControlPoints() const {return this->m_contrlPoints;}
+			inline glm::dvec3 getPositionVariation() const {return m_positionVariation;}
+			inline double getParameterValue() const {return this->m_u;}
 
-		void update(ct::CurveGenerator* generator, double u);
+			inline void setPositionVariation(const glm::dvec3& positionVariation) {this->m_positionVariation = positionVariation;}
+			inline void setParameterValue(double u) {this->m_u = u;}
+
+			virtual void update(double delta = 0.0) override;
 	};
 }

ParticleGenerator/src/Particle/PhysicsParticle.cpp

 #include "PhysicsParticle.hpp"
 
-namespace pg
-{
-	PhysicsParticle::PhysicsParticle(const ct::Point& position, double birth, const glm::dvec3& velocity, const glm::dvec3& acceleration, double friction) :
-		Particle(position, birth),
-		m_velocity(velocity),
-		m_acceleration(acceleration),
-		m_friction(friction)
-	{
+namespace pg {
+	PhysicsParticle::PhysicsParticle(size_t birth, const ct::Point& position, const glm::dvec3& velocity) 
+	: Particle(birth, position), m_velocity(velocity), m_acceleration(ct::Point()), m_friction(ct::Point()) {}
 
-	}
-
-	glm::dvec3 PhysicsParticle::getVelocity() const
-	{
-		return m_velocity;
-	}
-
-	glm::dvec3 PhysicsParticle::getAcceleration() const
-	{
-		return m_acceleration;
-	}
-
-	double PhysicsParticle::getFriction() const
-	{
-		return m_friction;
-	}
-
-	void PhysicsParticle::setVelocity(const glm::dvec3& velocity)
-	{
-		m_velocity = velocity;
-	}
-
-	void PhysicsParticle::setAcceleration(const glm::dvec3& acceleration)
-	{
-		m_acceleration = acceleration;
-	}
-
-	void PhysicsParticle::setFriction(double friction)
-	{
-		m_friction = friction;
-	}
+	PhysicsParticle::PhysicsParticle(const ct::Point& position, const glm::dvec3& velocity)
+	: PhysicsParticle(0, position, velocity) {}
 
-	void PhysicsParticle::update(const glm::dvec3& gravity)
-	{
+	void PhysicsParticle::update(double t) {
 		m_acceleration -= glm::dvec3(m_friction) * m_velocity;
-		m_velocity += m_acceleration + gravity;
+		m_velocity += m_acceleration;
 
-		setPosition(getPosition() + m_velocity);
+		this->m_position += this->m_velocity;
 	}
 }
\ No newline at end of file

ParticleGenerator/src/Particle/PhysicsParticle.hpp

@@ -2,26 +2,25 @@
 
 #include "Particle.hpp"
 
-namespace pg
-{
-	class PhysicsParticle : public Particle<const glm::dvec3&>
-	{
+namespace pg {
+	class PhysicsParticle : public Particle {
 		private:
 			glm::dvec3 m_velocity;
 			glm::dvec3 m_acceleration;
-		double m_friction;
+			glm::dvec3 m_friction;
 
 		public:
-		PhysicsParticle(const ct::Point& position = ct::Point(0.0), double birth = 0, const glm::dvec3& velocity = ct::Point(0.0), const glm::dvec3& acceleration = ct::Point(0.0), double friction = 0.1);
+			PhysicsParticle(size_t birth, const ct::Point& position = ct::Point(), const glm::dvec3& velocity = ct::Point());
+			PhysicsParticle(const ct::Point& position = ct::Point(), const glm::dvec3& velocity = ct::Point());
 			
-		glm::dvec3 getVelocity() const;
-		glm::dvec3 getAcceleration() const;
-		double getFriction() const;
+			inline glm::dvec3 getVelocity() const {return this->m_velocity;}
+			inline glm::dvec3 getAcceleration() const {return this->m_acceleration;}
+			inline glm::dvec3 getFriction() const {return this->m_friction;}
 
-		void setVelocity(const glm::dvec3& velocity);
-		void setAcceleration(const glm::dvec3& acceleration);
-		void setFriction(double friction);
+			void setVelocity(const glm::dvec3& velocity) {this->m_velocity = velocity;}
+			void setAcceleration(const glm::dvec3& acceleration) {this->m_acceleration = acceleration;}
+			void setFriction(const glm::dvec3& friction) {this->m_friction = friction;}
 
-		void update(const glm::dvec3& gravity = glm::dvec3(0.0, -9.81, 0.0));
+			virtual void update(double delta = 0.0) override;
 	};
 }
\ No newline at end of file

ParticleGenerator/src/Particle/generator/ParticleGenerator.hpp

@@ -2,55 +2,52 @@
 
 #include <CurveTools/CPU/CurveGenerator.hpp>
 
-namespace pg
-{
+namespace pg {
 	template<typename T>
-	class ParticleGenerator
-	{
+	class ParticleGenerator {
+		private:
+			double m_positionVariation;
+
 		protected:
 			ct::Point m_position;
-		double m_positionVariation;
 			
 		public:
-		ParticleGenerator(const ct::Point& position, double positionVariation);
-
-		virtual std::vector<T> operator()(size_t count, double birth = 0) const = 0;
+			ParticleGenerator(const ct::Point& position = ct::Point(), double positionVariation = 0.0);
 
 			ct::Point getPosition() const;
 			double getPositionVariation() const;
+
 			void setPosition(const ct::Point& position);
 			void setPositionVariation(double positionVariation);
+
+			virtual std::vector<T> generate(size_t count, size_t birth = 0) const = 0;
+ 
+			inline std::vector<T> operator()(size_t count, size_t birth = 0) const {return this->generate(count, birth);}
 	};
 
 	template<typename T>
-	ParticleGenerator<T>::ParticleGenerator(const ct::Point& position, double positionVariation) :
-		m_position(position),
-		m_positionVariation(positionVariation)
-	{
+	ParticleGenerator<T>::ParticleGenerator(const ct::Point& position, double positionVariation) 
+	: m_position(position), m_positionVariation(positionVariation) {
 
 	}
 
 	template<typename T>
-	ct::Point ParticleGenerator<T>::getPosition() const
-	{
+	ct::Point ParticleGenerator<T>::getPosition() const {
 		return m_position;
 	}
 
 	template<typename T>
-	double ParticleGenerator<T>::getPositionVariation() const
-	{
+	double ParticleGenerator<T>::getPositionVariation() const {
 		return m_positionVariation;
 	}
 
 	template<typename T>
-	void ParticleGenerator<T>::setPosition(const ct::Point& position)
-	{
+	void ParticleGenerator<T>::setPosition(const ct::Point& position) {
 		m_position = position;
 	}
 
 	template<typename T>
-	void ParticleGenerator<T>::setPositionVariation(double positionVariation)
-	{
+	void ParticleGenerator<T>::setPositionVariation(double positionVariation) {
 		m_positionVariation = positionVariation;
 	}
 }
\ No newline at end of file

ParticleGenerator/src/Particle/generator/PathParticleGenerator.cpp

@@ -2,31 +2,16 @@
 
 #include <random>
 
-namespace pg
-{
-	PathParticleGenerator::PathParticleGenerator(const ct::Point& position, double positionVariation, const ct::Curve& path) :
-		ParticleGenerator(position, positionVariation),
-		m_path(path)
-	{
-
-	}
+namespace pg {
+	PathParticleGenerator::PathParticleGenerator(ct::CurveGenerator * generator, const ct::Curve& controlPoints, const ct::Point& position,  double positionVariation) 
+	: ParticleGenerator(position, positionVariation), m_generator(generator), m_controlPoints(controlPoints) {}
 
-	const ct::Curve& PathParticleGenerator::getPath() const
-	{
-		return m_path;
-	}
-
-	void PathParticleGenerator::setPath(const ct::Curve& path)
-	{
-		m_path = path;
-	}
-
-	std::vector<PathParticle> PathParticleGenerator::operator()(size_t count, double birth) const
-	{
+	std::vector<PathParticle> PathParticleGenerator::generate(size_t count, size_t birth) const {
 		std::random_device device;
 		std::mt19937 randomEngine(device());
 
-		std::uniform_real_distribution<double> positionGenerator(-m_positionVariation, m_positionVariation);
+		using ureal_dist = std::uniform_real_distribution<double>;
+		ureal_dist positionGenerator(-this->getPositionVariation(), this->getPositionVariation());
 
 		std::vector<PathParticle> particles;
 		particles.reserve(count);
@@ -39,7 +24,7 @@ namespace pg
 			positionVariation.y = positionGenerator(randomEngine);
 			positionVariation.z = positionGenerator(randomEngine);
 
-			PathParticle particle(m_path, birth);
+			PathParticle particle(birth, m_generator, m_controlPoints);
 			particle.setPositionVariation(positionVariation);
 
 			particles.push_back(particle);

ParticleGenerator/src/Particle/generator/PathParticleGenerator.hpp

@@ -3,19 +3,18 @@
 #include "ParticleGenerator.hpp"
 #include "../PathParticle.hpp"
 
-namespace pg
-{
-	class PathParticleGenerator : public ParticleGenerator<PathParticle>
-	{
+namespace pg {
+	class PathParticleGenerator : public ParticleGenerator<PathParticle> {
 		private:
-		ct::Curve m_path;
+			ct::Curve m_controlPoints;
+			ct::CurveGenerator * m_generator;
 
 		public:
-		PathParticleGenerator(const ct::Point& position, double positionVariation, const ct::Curve& path);
+			PathParticleGenerator(ct::CurveGenerator * generator, const ct::Curve& controlPoints, const ct::Point& position,  double positionVariation);
 
-		const ct::Curve& getPath() const;
-		void setPath(const ct::Curve& path);
+			inline const ct::Curve& getControlPoint() const {return this->m_controlPoints;}
+			inline void setControlPoint(const ct::Curve& points) {this->m_controlPoints = points;}
 
-		std::vector<PathParticle> operator()(size_t count, double birth = 0) const override;
+			std::vector<PathParticle> generate(size_t count, size_t birth = 0) const override;
 	};
 }
\ No newline at end of file

ParticleGenerator/src/Particle/generator/PhysicsParticleGenerator.cpp

@@ -4,113 +4,64 @@
 
 namespace pg
 {
-	PhysicsParticleGenerator::PhysicsParticleGenerator(const ct::Point& position, double positionVariation, const glm::dvec3& velocity, const glm::dvec3& acceleration, double friction, double velocityVariation, double accelerationVariation, double frictionVariation) :
-		ParticleGenerator(position, positionVariation),
+	PhysicsParticleGenerator::PhysicsParticleGenerator(const ct::Point& position, double positionVariation, const glm::dvec3& velocity) 
+	: 	ParticleGenerator(position, positionVariation),
 		m_velocity(velocity),
-		m_acceleration(acceleration),
-		m_friction(friction),
-		m_velocityVariation(velocityVariation),
-		m_accelerationVariation(accelerationVariation),
-		m_frictionVariation(frictionVariation)
-	{
-
-	}
-
-	glm::dvec3 PhysicsParticleGenerator::getVelocity() const
-	{
-		return m_velocity;
-	}
-
-	glm::dvec3 PhysicsParticleGenerator::getAcceleration() const
-	{
-		return m_acceleration;
-	}
-
-	double PhysicsParticleGenerator::getFriction() const
-	{
-		return m_friction;
-	}
-
-	double PhysicsParticleGenerator::getVelocityVariation() const
-	{
-		return m_velocityVariation;
-	}
-
-	double PhysicsParticleGenerator::getAccelerationVariation() const
-	{
-		return m_accelerationVariation;
-	}
-
-	double PhysicsParticleGenerator::getFrictionVariation() const
-	{
-		return m_frictionVariation;
-	}
+		m_acceleration(),
+		m_friction(),
+		m_velocityVariation(),
+		m_accelerationVariation(),
+		m_frictionVariation() {
 
-	void PhysicsParticleGenerator::setVelocity(const glm::dvec3 velocity)
-	{
-		m_velocity = velocity;
 	}
 
-	void PhysicsParticleGenerator::setAcceleration(const glm::dvec3 acceleration)
-	{
-		m_acceleration = acceleration;
-	}
+	std::vector<PhysicsParticle> PhysicsParticleGenerator::generate(size_t count, size_t birth) const {
+		std::random_device device;
+		std::mt19937 randomEngine(device());
 
-	void PhysicsParticleGenerator::setFriction(double friction)
-	{
-		m_friction = friction;
-	}
+		using ureal_dist = std::uniform_real_distribution<double>;
 
-	void PhysicsParticleGenerator::setVelocityVariation(double velocityVariation)
-	{
-		m_velocityVariation = velocityVariation;
-	}
+		double positionVariation = this->getPositionVariation();
 
-	void PhysicsParticleGenerator::setAccelerationVariation(double acceleratiionVariation)
-	{
-		m_accelerationVariation = acceleratiionVariation;
-	}
+		ureal_dist p(-positionVariation, positionVariation);
 	
-	void PhysicsParticleGenerator::setFrictionVariation(double frictionVariation)
-	{
-		m_frictionVariation = frictionVariation;
-	}
+		ureal_dist vx(-this->m_velocityVariation.x, this->m_velocityVariation.x);
+		ureal_dist vy(-this->m_velocityVariation.y, this->m_velocityVariation.y);
+		ureal_dist vz(-this->m_velocityVariation.z, this->m_velocityVariation.z);
 
-	std::vector<PhysicsParticle> PhysicsParticleGenerator::operator()(size_t count, double birth) const
-	{
-		std::random_device device;
-		std::mt19937 randomEngine(device());
+		ureal_dist ax(-this->m_accelerationVariation.x, this->m_accelerationVariation.x);
+		ureal_dist ay(-this->m_accelerationVariation.y, this->m_accelerationVariation.y);
+		ureal_dist az(-this->m_accelerationVariation.z, this->m_accelerationVariation.z);
 
-		std::uniform_real_distribution<double> positionGenerator(-m_positionVariation, m_positionVariation);
-		std::uniform_real_distribution<double> velocityGenerator(-m_velocityVariation, m_velocityVariation);
-		std::uniform_real_distribution<double> accelerationGenerator(-m_accelerationVariation, m_accelerationVariation);
-		std::uniform_real_distribution<double> frictionGenerator(0.0, m_frictionVariation);
+		ureal_dist fx(0.0, this->m_frictionVariation.x);
+		ureal_dist fy(0.0, this->m_frictionVariation.y);
+		ureal_dist fz(0.0, this->m_frictionVariation.z);
 
-		std::vector<PhysicsParticle> particles;
-		particles.reserve(count);
+		std::vector<PhysicsParticle> particles(count);
 
-		for (unsigned int i = 0; i < count; ++i)
-		{
-			PhysicsParticle particle({0, 0, 0}, birth);
+		for (size_t i = 0; i < count; ++i) {
+			PhysicsParticle particle(birth);
 
-			ct::Point position = m_position;
-			glm::dvec3 velocity = m_velocity;
-			glm::dvec3 acceleration = m_acceleration;
-			double friction = m_friction;
+			ct::Point position = this->m_position;
+			glm::dvec3 velocity = this->m_velocity;
+			glm::dvec3 acceleration = this->m_acceleration;
+			glm::dvec3 friction = this->m_friction;
 
-			position.x += positionGenerator(randomEngine);
-			position.y += positionGenerator(randomEngine);
-			position.z += positionGenerator(randomEngine);
+			position.x += p(randomEngine);
+			position.y += p(randomEngine);
+			position.z += p(randomEngine);
 
-			velocity.x += velocityGenerator(randomEngine);
-			velocity.y += velocityGenerator(randomEngine);
-			velocity.z += velocityGenerator(randomEngine);
+			velocity.x += vx(randomEngine);
+			velocity.y += vy(randomEngine);
+			velocity.z += vz(randomEngine);
 
-			acceleration.x += accelerationGenerator(randomEngine);
-			acceleration.y += accelerationGenerator(randomEngine);
-			acceleration.z += accelerationGenerator(randomEngine);
+			acceleration.x += ax(randomEngine);
+			acceleration.y += ay(randomEngine);
+			acceleration.z += az(randomEngine);
 
-			friction += frictionGenerator(randomEngine);
+			friction.x += fx(randomEngine);
+			friction.y += fy(randomEngine);
+			friction.z += fz(randomEngine);
 
 			particle.setPosition(position);
 			particle.setVelocity(velocity);

ParticleGenerator/src/Particle/generator/PhysicsParticleGenerator.hpp

@@ -3,36 +3,33 @@
 #include "ParticleGenerator.hpp"
 #include "../PhysicsParticle.hpp"
 
-namespace pg
-{
-	class PhysicsParticleGenerator : public ParticleGenerator<PhysicsParticle>
-	{
+namespace pg {
+	class PhysicsParticleGenerator : public ParticleGenerator<PhysicsParticle> {
 		private:
 			glm::dvec3 m_velocity;
 			glm::dvec3 m_acceleration;
-		double m_friction;
-
-		double m_velocityVariation;
-		double m_accelerationVariation;
-		double m_frictionVariation;
+			glm::dvec3 m_friction;
+			glm::dvec3 m_velocityVariation;
+			glm::dvec3 m_accelerationVariation;
+			glm::dvec3 m_frictionVariation;
 
 		public:
-		PhysicsParticleGenerator(const ct::Point& position, double positionVariation, const glm::dvec3& velocity = glm::dvec3(0.0, 0.0, 0.0), const glm::dvec3& acceleration = glm::dvec3(0.0), double friction = 0.01, double velocityVariation = 0.0, double accelerationVariation = 0.0, double frictionVariation = 0.0);
+			PhysicsParticleGenerator(const ct::Point& position = ct::Point(), double positionVariation = 0.0, const glm::dvec3& velocity = glm::dvec3(0.0, 0.0, 0.0));
 
-		glm::dvec3 getVelocity() const;
-		glm::dvec3 getAcceleration() const;
-		double getFriction() const;
-		double getVelocityVariation() const;
-		double getAccelerationVariation() const;
-		double getFrictionVariation() const;
+			inline const glm::dvec3 & getVelocity() const {return this->m_velocity;}
+			inline const glm::dvec3 & getAcceleration() const {return this->m_acceleration;}
+			inline const glm::dvec3 & getFriction() const {return this->m_friction;}
+			inline const glm::dvec3 & getVelocityVariation() const {return this->m_velocityVariation;}
+			inline const glm::dvec3 & getAccelerationVariation() const {return this->m_accelerationVariation;}
+			inline const glm::dvec3 & getFrictionVariation() const {return this->m_frictionVariation;}
 
-		void setVelocity(const glm::dvec3 velocity);
-		void setAcceleration(const glm::dvec3 acceleration);
-		void setFriction(double friction);
-		void setVelocityVariation(double velocityVariation);
-		void setAccelerationVariation(double acceleratiionVariation);
-		void setFrictionVariation(double frictionVariation);
+			inline void setVelocity(const glm::dvec3 & velocity) {this->m_velocity = velocity;}
+			inline void setAcceleration(const glm::dvec3 & acceleration) {this->m_acceleration = acceleration;}
+			inline void setFriction(const glm::dvec3  & friction) {this->m_friction = friction;}
+			inline void setVelocityVariation(const glm::dvec3 & velocityVariation) {this->m_velocityVariation = velocityVariation;}
+			inline void setAccelerationVariation(const glm::dvec3 & accelerationVariation) {this->m_accelerationVariation = accelerationVariation;}
+			inline void setFrictionVariation(const glm::dvec3 & frictionVariation) {this->m_frictionVariation = frictionVariation;}
 
-		std::vector<PhysicsParticle> operator()(size_t count, double birth = 0) const override;
+			std::vector<PhysicsParticle> generate(size_t count, size_t birth = 0) const override;
 	};
 }
\ No newline at end of file

ParticleGenerator/src/main.cpp

@@ -72,8 +72,8 @@ int main()
         std::cout << "GLEW Inited" << std::endl;
 
         //? Shaders
-        pg::Source vertices("assets/shaders/Instanced.vert", pg::Source::Categorie::VERTEX);
-        pg::Source fragment("assets/shaders/Instanced.frag", pg::Source::Categorie::FRAGMENT);
+        pg::Source vertices("../../assets/shaders/Instanced.vert", pg::Source::Categorie::VERTEX);
+        pg::Source fragment("../../assets/shaders/Instanced.frag", pg::Source::Categorie::FRAGMENT);
 
         pg::Program program;
 
@@ -109,11 +109,11 @@ int main()
         std::cout << "Buffer Inited" << std::endl;
 
         //? Texture
-        pg::Material A("assets/textures/smoke1.png", true);
-        pg::Material B("assets/textures/smoke2.png", true);
-        pg::Material C("assets/textures/smoke3.png", true);
-        pg::Material D("assets/textures/smoke4.png", true);
-        pg::Material E("assets/textures/smoke5.png", true);
+        pg::Material A("../../assets/textures/smoke1.png", true);
+        pg::Material B("../../assets/textures/smoke2.png", true);
+        pg::Material C("../../assets/textures/smoke3.png", true);
+        pg::Material D("../../assets/textures/smoke4.png", true);
+        pg::Material E("../../assets/textures/smoke5.png", true);
         
         {
             A.bind(0);
@@ -144,28 +144,28 @@ int main()
         std::cout << "Camera Inited" << std::endl;
 
         //? Particle
-        pg::PhysicsParticleGenerator generator({0.0, 0.0, 0.0}, 0.1, {0, 0.0000001, 0}, {0, 0.0000001, 0}, 0.0, 0.0, 0.0, 0.0);
+        pg::PhysicsParticleGenerator generator({0.0, 0.0, 0.0}, 0.5, {0, 0.0000001, 0});
+        generator.setAcceleration({0.0, 0.0000001, 0.0});
+
         std::vector<pg::PhysicsParticle> particles = generator(5);
 
         //? Render Loop
-        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         glEnable(GL_BLEND);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-        glClearColor(0.15f, 0.0f, 0.15f, 1.0f);
+        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
 
         pg::error::opengl_error::check();
         std::cout << "Render Loop Start" << std::endl;
 
         glm::vec4 global_color = {1.0, 1.0, 1.0, 1.0};
 
-        auto start = std::chrono::high_resolution_clock::now();
+        auto start = std::chrono::system_clock::now();
 
         while(window.isOpen()) {
             window.pollEvents();
             glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
-            
- 
             const glm::mat4 VIEW_MATRIX = camera.getViewMatrix();
             const glm::mat4 PROJECTION_MATRIX = camera.getViewFrustum().getProjectionMatrix();
 
@@ -183,7 +183,7 @@ int main()
                 models.push_back(model);
 
                 slots.push_back(i%5);
-                textures.push_back(i%5);
+                textures.push_back(0);
 
                 ++i;
             }
@@ -211,17 +211,17 @@ int main()
             window.swapBuffer();
             pg::error::opengl_error::check();
             
-            auto end = std::chrono::high_resolution_clock::now();
+            auto end = std::chrono::system_clock::now();
             if(duration_cast<std::chrono::milliseconds>(end - start).count() >= 500) {
-                start = std::chrono::high_resolution_clock::now();
+                start = std::chrono::system_clock::now();
                 kill_old_particle(particles, glfwGetTime(), 5);
                 std::vector<pg::PhysicsParticle> newParticles = generator(5, glfwGetTime());
-                particles.insert(particles.begin(), newParticles.begin(), newParticles.end());
+                particles.insert(particles.end(), newParticles.begin(), newParticles.end());
             }
 
             if(duration_cast<std::chrono::milliseconds>(end - start).count() >= 10) {
                 for(auto & particle : particles) {
-                    particle.update({0.0, 0.0, 0.0});
+                    particle.update();
                 }
             }
         }