Did cloud, horizontal billboard, scaled billboard, extended particle system

Author: Cheng Xie

src/TornadoParticleSystem.cpp

@@ -73,7 +73,7 @@ void TornadoParticleSystem::update(float dt)
             // If we are past the threshold, it's time to bring a new pixel online,
             float threshold = m_tornado->getHeight() / (m_cycleSpeed * m_numParticles);
             if(m_lastActivation >= threshold){
-                std::cout<<"PING"<<endl;
+                //std::cout<<"PING"<<endl;
                 m_lastActivation -= threshold;
                 particle.active = true;
                 m_active_count++;

src/camera.cpp

@@ -10,7 +10,7 @@ Camera::Camera()
     heightAngle_ = 60;
 
     updateProjection();
-    lookAt({-100, 20, 100}, {0, 0, 0}, {0, 1, 0});
+    lookAt({0, 10, 10}, {0, 0, 0}, {0, 1, 0});
 }
 
 void Camera::apply(DrawContext &context)

src/cloud.cpp

@@ -0,0 +1,68 @@
+#include "cloud.h"
+#include "texture.h"
+#include "texturecache.h"
+#include "particlematerial.h"
+
+Cloud::Cloud(float radius)
+{
+    radius_ = radius;
+    
+    Texture* texture = TextureCache::getInstance()->acquire("cloud2", TextureType::Texture2D);
+    setParticleTexture(texture);
+    
+    setEmissionRate(10);
+    
+    setMaxParticleCount(1000);
+    
+    ParticleMaterial* material = static_cast<ParticleMaterial *>(material_);
+    material->setHorizontal(true);
+}
+
+void Cloud::spawnParticle(Particle *particle)
+{
+    float speed = randf(5, 15);
+    vec3 velocity = {0, 0, 1};
+    velocity *= speed;
+    
+    particle->velocity = velocity;
+    
+    float phi = randf(0, M_PI * 2);
+    float r = radius_ * randf();
+    
+//    float x = randf(-radius_, radius_);
+//    float z = randf(-radius_, radius_);
+    
+    float x = cosf(phi) * r;
+    float y = randf() * 10;
+    float z = sinf(phi) * r;
+    
+    particle->position = {x, y, z};
+    
+    particle->rotation = randf(180, 360);
+    
+    particle->maxLife = 20;
+    
+    particle->size = randf(50, 150);
+    
+    float scale = randf(0.6, 0.7f);
+    particle->color = {scale, scale, scale}; 
+    
+    particle->opacity = 0;
+}
+	
+void Cloud::updateParticle(Particle &particle, float dt)
+{
+    particle.position += particle.velocity * dt;
+    
+    float x = particle.life / particle.maxLife;
+    
+    if (x < 0.5) {
+        particle.opacity = x;
+    }
+    else {
+        particle.opacity = 1 - x;
+    }
+    
+    
+}
+

src/cloud.h

@@ -0,0 +1,19 @@
+#ifndef CLOUD_H
+#define CLOUD_H
+
+#include "particlesystem.h"
+
+class Cloud : public ParticleSystem
+{
+public:
+    Cloud(float radius);
+    
+    virtual void spawnParticle(Particle *particle) override;
+    
+    virtual void updateParticle(Particle &particle, float dt) override;
+    
+private:
+    float radius_;
+};
+
+#endif // CLOUD_H

src/common.h

@@ -43,8 +43,15 @@ class Texture;
 class MeshRenderer;
 class Mesh;
 
+
+// random number between 0 and 1
 inline float randf() {
-    return (float)rand() / RAND_MAX * 2 - 1;
+    return (float)rand() / RAND_MAX;
+}
+
+// random number between a and b
+inline float randf(float a, float b) {
+    return randf() * (b - a) + a; 
 }
 
 #endif // COMMON_H

src/final.pro

@@ -47,7 +47,8 @@ SOURCES += main.cpp \
     TornadoParticleSystem.cpp \
     DustcloudParticleSystem.cpp \
     terrainmaterial.cpp \
-    material.cpp
+    material.cpp \
+    cloud.cpp
 
 HEADERS += mainwindow.h \
     view.h \
@@ -83,6 +84,7 @@ HEADERS += mainwindow.h \
     Tornado.h \
     TornadoParticleSystem.h \
     DustcloudParticleSystem.h \
-    terrainmaterial.h
+    terrainmaterial.h \
+    cloud.h
 
 FORMS += mainwindow.ui

src/particlematerial.cpp

@@ -15,6 +15,14 @@ void ParticleMaterial::apply(DrawContext &context)
 
     Material::apply(context);
 
+    shader_->setUniformValue("lengthScale", lengthScale_);
+    shader_->setUniformValue("horizontal", horizontal_);
+    
+    mat4 slopeMatrix;
+    slopeMatrix.rotate(slope_, {1, 0, 0});
+    
+    shader_->setUniformValue("slope", slopeMatrix);
+    
     texture_->apply(context, "map", 0);
 
     //glDisable(GL_DEPTH_TEST);
@@ -32,3 +40,39 @@ void ParticleMaterial::setTexture(Texture *texture)
     texture_ = texture;
 }
 
+float ParticleMaterial::lengthScale() const
+{
+    return lengthScale_;
+}
+
+void ParticleMaterial::setLengthScale(float lengthScale)
+{
+    lengthScale_ = lengthScale;
+}
+
+float ParticleMaterial::slope() const
+{
+    return slope_;
+}
+
+void ParticleMaterial::setSlope(float slope)
+{
+    slope_ = slope;
+}
+bool ParticleMaterial::horizontal() const
+{
+    return horizontal_;
+}
+
+void ParticleMaterial::setHorizontal(bool horizontal)
+{
+    horizontal_ = horizontal;
+}
+
+
+
+
+
+
+
+

src/particlematerial.h

@@ -13,8 +13,21 @@ class ParticleMaterial : public Material
 
     void setTexture(Texture *texture);
 
+    float lengthScale() const;
+    void setLengthScale(float lengthScale);
+    
+    float slope() const;
+    void setSlope(float slope);
+    
+    bool horizontal() const;
+    void setHorizontal(bool horizontal);
+    
 protected:
     Texture* texture_;
+    
+    bool horizontal_ = false;
+    float lengthScale_ = 1;
+    float slope_ = 0;
 };
 
 #endif // PARTICLEMATERIAL_H

src/particlesystem.cpp

@@ -7,6 +7,8 @@
 
 ParticleSystem::ParticleSystem()
 {   
+    ParticleMaterial* material = new ParticleMaterial;
+    setMaterial(material);
     mesh_ = new Mesh;
 }
 
@@ -20,10 +22,14 @@ void ParticleSystem::renderGeometry(DrawContext &context)
 {   
     update(context.deltaTime);
 
+    if (particles_.size() < 1) {
+        return;
+    }
+    
     VertexBufferDesc desc;
     desc.bufferData = particles_.data();
     desc.bufferSize = particles_.size() * sizeof(Particle);
-    desc.vertexElementSizes = {3, 1, 1};
+    desc.vertexElementSizes = {3, 1, 1, 3, 1};
     desc.stride = sizeof(Particle);
 
     mesh_->setVertexBuffer(desc, PrimitiveType::Points);
@@ -33,16 +39,73 @@ void ParticleSystem::renderGeometry(DrawContext &context)
 
 void ParticleSystem::setParticleTexture(Texture *texture)
 {
-    ParticleMaterial* material = new ParticleMaterial;
+    ParticleMaterial* material = static_cast<ParticleMaterial *>(material_);
     material->setTexture(texture);
-    setMaterial(material);
 }
 
 void ParticleSystem::update(float dt)
 {   
-    for (Particle& particle : particles_) {
-        particle.position += {randf() * 10 * dt, randf() * 10 * dt, randf() * 10 * dt};
-        particle.size += 0.5 * dt;
-        particle.rotation += 90 * dt;
+    timeElapsed_ += dt;
+    
+    auto it = begin(particles_);
+    while (it != end(particles_)) {
+        Particle& particle = *it;
+        particle.life += dt;
+        if (particle.life >= particle.maxLife) {
+            particles_.erase(it);
+        }
+        else {
+            this->updateParticle(particle, dt);
+            it++;
+        }
+    }        
+    
+    float numParticles = emissionRate_ * dt;
+    numParticlesToSpawn_ += numParticles;
+    
+    uint32_t count = 0;
+    if (particles_.size() < maxParticleCount_) {
+        count = min((int)(maxParticleCount_ - particles_.size()), (int)numParticlesToSpawn_);
+    }
+    
+    numParticlesToSpawn_ -= count;
+    
+    for (uint32_t i = 0; i < count; i++) {
+        Particle particle;
+        this->spawnParticle(&particle);
+        particles_.push_back(particle);
     }
 }
+
+void ParticleSystem::spawnParticle(Particle *particle)
+{
+
+}
+
+void ParticleSystem::updateParticle(Particle &particle, float dt)
+{
+    
+}
+
+uint32_t ParticleSystem::emissionRate() const
+{
+    return emissionRate_;
+}
+
+void ParticleSystem::setEmissionRate(int emissionRate)
+{
+    emissionRate_ = emissionRate;
+}
+
+uint32_t ParticleSystem::maxParticleCount() const
+{
+    return maxParticleCount_;
+}
+
+void ParticleSystem::setMaxParticleCount(int maxParticleCount)
+{
+    maxParticleCount_ = maxParticleCount;
+}
+
+
+

src/particlesystem.h

@@ -6,15 +6,19 @@
 
 struct Particle
 {
-    // These three rendering related properties must be declared first in this order
+    // These rendering related properties must be declared first in this order
     vec3 position; 
     float rotation = 0; // in angle
     float size = 1;
-    bool active = true;
+    Color color = vec3(1.f, 1.f, 1.f);
+    float opacity = 1.f;
 
     // Other properties
+    float life = 0;
+    float maxLife = 0;
+    
+    bool active = true;
     vec3 velocity;
-    vec3 somethingelse;
 };
 
 typedef vector<Particle> Particles;
@@ -26,15 +30,37 @@ class ParticleSystem : public SceneObject
     virtual ~ParticleSystem();
 
     virtual void renderGeometry(DrawContext &context) override;
+   
+    virtual void update(float dt);
+    
+    // to be overrided
+    virtual void spawnParticle(Particle *particle);
+    
+    // to be overrided
+    virtual void updateParticle(Particle& particle, float dt);
 
     void setParticleTexture(Texture* texture);
-
-    virtual void update(float dt);
 
+    uint32_t emissionRate() const;
+    void setEmissionRate(int emissionRate);
+    
+    uint32_t maxParticleCount() const;
+    void setMaxParticleCount(int maxParticleCount);
+    
+protected:
     vector<Particle> particles_;
+
+private:
+    // time elapsed since the particle system was created
+    float timeElapsed_ = 0;
+    
+    // max number of particles allowed
+    uint32_t maxParticleCount_ = 0;
+    
+    // number of particles per second
+    uint32_t emissionRate_ = 0;
 
-    int numParticlesMax_;
-    int emissionRate_;
+    float numParticlesToSpawn_ = 0;
 };
 
 #endif // PARTICLESYSTEM_H