1 files changed, 72 insertions, 9 deletions

diff --git a/src/libjin/Graphics/particles/je_particle_emitter.cpp b/src/libjin/Graphics/particles/je_particle_emitter.cpp
index edc4bee..d8fb78d 100644
--- a/src/libjin/Graphics/particles/je_particle_emitter.cpp
+++ b/src/libjin/Graphics/particles/je_particle_emitter.cpp
@@ -3,6 +3,7 @@
 #include "../../math/je_random.h"
 
 #include "je_particle_emitter.h"
+#include "je_particle_system.h"
 
 using namespace JinEngine::Math;
 
@@ -13,28 +14,90 @@ namespace JinEngine
         namespace Particles
         {
 
+            static const uint8 ACCURACY_4 = 4;
+            static const uint8 ACCURACY_5 = 5;
+            static const uint8 ACCURACY_6 = 6;
+
             // Particle emitter 
-            static RandomGenerator rnd(time(NULL));
+            static RandomGenerator rng(0xEA44944);
 
             ParticleEmitter::ParticleEmitter(ParticleSystem& ps)
-                : mParticleSystem(ps)
+                : mPS(ps)
+                , mDef(ps.mDef.emitterDef)
+                , mPDef(ps.mDef.particleDef)
+                , mTime(0)
             {
             }
 
             void ParticleEmitter::update(float dt)
             {
                 mTime += dt; 
-                if (mTime < 1)
-                    return;
-
-
-                mTime -= 1;
+                for (;mTime >= mInterval; mTime -= mInterval)
+                {
+                    emit();
+                    // Random rate.
+                    if (mDef.emitRateDef.enableRandom)
+                        mInterval = rng.randf(mDef.emitRateDef.rate.random.floor, mDef.emitRateDef.rate.random.ceil, ACCURACY_5);
+                    else
+                        mInterval = mDef.emitRateDef.rate.rate;
+                }
             }
 
             void ParticleEmitter::emit()
             {
-
-
+                Particle* p = mPS.claim();
+                if (p == nullptr)
+                    return;
+                p->reset();
+                // Init position.
+                if (mDef.positionDef.enableRandom)
+                {
+                    float x = rng.randf(mDef.positionDef.position.random.floor.x, mDef.positionDef.position.random.ceil.x, ACCURACY_4);
+                    float y = rng.randf(mDef.positionDef.position.random.floor.y, mDef.positionDef.position.random.ceil.y, ACCURACY_4);
+                    p->transform.setPosition(x, y);
+                }
+                else
+                {
+                    p->transform.setPosition(mDef.positionDef.position.position);
+                }
+                // Init speed.
+                float r = 0;
+                if (mDef.directionDef.enableRandom)
+                    r = rng.randf(mDef.directionDef.direction.random.floor, mDef.directionDef.direction.random.ceil, ACCURACY_4);
+                else
+                    r = mDef.directionDef.direction.direction;
+                float f = 0; 
+                if (mDef.forceDef.enableRandom)
+                    f = rng.randf(mDef.forceDef.force.random.floor, mDef.forceDef.force.random.ceil, ACCURACY_4);
+                else
+                    f = mDef.forceDef.force.force;
+                p->speed.set(f*cos(r), f*sin(r));
+                // Init life time
+                if (mPDef.lifeTimeDef.enableRandom)
+                    p->lifeTime = rng.randf(mPDef.lifeTimeDef.life.random.floor, mPDef.lifeTimeDef.life.random.floor, ACCURACY_4);
+                else
+                    p->lifeTime = mPDef.lifeTimeDef.life.life;
+                // Init linear accelaration
+                p->linearAcceleration = mPDef.linearAccelarationDef.linearAccelaration;
+                // Init angular accelaration
+                p->radialAcceleration = mPDef.radialAccelarationDef.radialAccelaration;
+                // Init Angular speed.
+                if (mPDef.angularSpeedDef.enableRandom)
+                    p->angularSpeed = rng.randf(mPDef.angularSpeedDef.angularSpeed.random.floor, mPDef.angularSpeedDef.angularSpeed.random.ceil, ACCURACY_4);
+                else
+                    p->angularSpeed = mPDef.angularSpeedDef.angularSpeed.angularSpeed;
+                // Scale over time
+                if (mPDef.sizeOverTimeDef.enable)
+                {
+                    p->scaleBegin = mPDef.sizeOverTimeDef.start;
+                    p->scaleEnd = mPDef.sizeOverTimeDef.end;
+                }
+                // Color over time 
+                if (mPDef.colorOverTimeDef.enable)
+                {
+                    p->colorStart = mPDef.colorOverTimeDef.colorStart;
+                    p->colorEnd = mPDef.colorOverTimeDef.colorEnd;
+                }
             }
 
         }