ParticleEmitter

Author: sdavydouski

resources/shaders/particle/shader.vert

@@ -8,7 +8,7 @@ out vec2 uv;
 uniform mat4 projection;
 uniform vec2 offset;
 
-float scale = 10.0f;
+float scale = 15.0f;
 
 void main() {
     uv = vertex.zw;

resources/shaders/sprite/shader.frag

@@ -3,9 +3,9 @@
 in vec2 uv;
 out vec4 finalColor;
 
-uniform sampler2D image;
+uniform sampler2D sprite;
 uniform vec3 color;
 
 void main() {
-    finalColor = texture(image, uv) * vec4(color, 1.0f);
+    finalColor = texture(sprite, uv) * vec4(color, 1.0f);
 }

resources/textures/particle.png

@@ -64,6 +64,7 @@ void Game::input(GLfloat delta) {
 
 void Game::update(GLfloat delta) {
     ball_->update(delta);
+    particleEmitter_->update(delta, *ball_, 5, glm::vec2(ball_->radius() / 2));
     this->checkCollisions();
 }
 
@@ -75,6 +76,7 @@ void Game::render() {
 
         levels_[currentLevel_]->render(spriteRenderer_);
         player_->render(spriteRenderer_);
+        particleEmitter_->render();
         ball_->render(spriteRenderer_);
     }
 
@@ -105,19 +107,28 @@ void Game::initGL() {
 }
 
 void Game::initResources() {
-    auto shader = resourceManager_.createShaderProgram("sprite",
-                                                        Shader(ShaderType::VERTEX,
-                                                                "../resources/shaders/sprite/shader.vert"),
-                                                        Shader(ShaderType::FRAGMENT,
-                                                                "../resources/shaders/sprite/shader.frag"));
+    auto spriteShader = resourceManager_.createShaderProgram("sprite",
+                                                             Shader(ShaderType::VERTEX,
+                                                                     "../resources/shaders/sprite/shader.vert"),
+                                                             Shader(ShaderType::FRAGMENT,
+                                                                     "../resources/shaders/sprite/shader.frag"));
     glm::mat4 projection = glm::ortho(0.0f, static_cast<GLfloat>(window_->width()),
                                       static_cast<GLfloat>(window_->height()), 0.0f,
                                       -1.0f, 1.0f);
-    shader->use();
-    shader->setUniform("projection", projection);
-    shader->setUniform("image", 0);
+    spriteShader->use();
+    spriteShader->setUniform("projection", projection);
+    spriteShader->setUniform("sprite", 0);
 
-    spriteRenderer_.init(shader);
+    spriteRenderer_.init(spriteShader);
+
+    auto particleShader = resourceManager_.createShaderProgram("particle",
+                                                               Shader(ShaderType::VERTEX,
+                                                                      "../resources/shaders/particle/shader.vert"),
+                                                               Shader(ShaderType::FRAGMENT,
+                                                                      "../resources/shaders/particle/shader.frag"));
+    particleShader->use();
+    particleShader->setUniform("projection", projection);
+    particleShader->setUniform("sprite", 0);
 
     resourceManager_.createTexture("background",
                                    "../resources/textures/background.jpg",
@@ -134,6 +145,13 @@ void Game::initResources() {
     resourceManager_.createTexture("paddle",
                                    "../resources/textures/paddle.png",
                                    512, 128, 4, GL_RGBA);
+    resourceManager_.createTexture("particle",
+                                   "../resources/textures/particle.png",
+                                   500, 500, 4, GL_RGBA);
+
+    particleEmitter_ = std::make_unique<ParticleEmitter>(resourceManager_.shaderProgram("particle"),
+                                                         resourceManager_.texture("particle"),
+                                                         500);
 
     levels_.push_back(std::make_unique<GameLevel>(
         "../resources/levels/1.txt", window_->width(), window_->height() / 2));

src/Game.cpp

@@ -10,6 +10,7 @@
 #include "game/GameLevel.h"
 #include "game/Player.h"
 #include "game/Ball.h"
+#include "graphics/ParticleEmitter.h"
 #include <memory>
 #include <vector>
 
@@ -37,6 +38,7 @@ class Game {
     ResourceManager& resourceManager_ = ResourceManager::Instance();
 
     SpriteRenderer& spriteRenderer_ = SpriteRenderer::Instance();
+    std::unique_ptr<ParticleEmitter> particleEmitter_;
 
     void initWindow(int width, int height, bool isFullScreen);
     void initGL();

src/Game.h

@@ -1,36 +1,115 @@
 #include "ParticleEmitter.h"
+#include <cstdlib>
 #include <iostream>
 
 ParticleEmitter::ParticleEmitter(ShaderProgram *shaderProgram,
                                  Texture *texture,
                                  GLuint amount)
-    : shaderProgram_(shaderProgram), texture_(texture), amount_(amount) {
+    : shaderProgram_(shaderProgram), texture_(texture), amount_(amount), lastUsedParticle_(0) {
     std::cout << "ParticleEmitter constructor" << std::endl;
 
+    GLfloat quad[] = {
+        0.0f, 1.0f, 0.0f, 1.0f,
+        1.0f, 0.0f, 1.0f, 0.0f,
+        0.0f, 0.0f, 0.0f, 0.0f,
 
+        0.0f, 1.0f, 0.0f, 1.0f,
+        1.0f, 1.0f, 1.0f, 1.0f,
+        1.0f, 0.0f, 1.0f, 0.0f
+    };
+
+    glGenVertexArrays(1, &VAO_);
+    glGenBuffers(1, &VBO_);
+    glBindVertexArray(VAO_);
+
+    glBindBuffer(GL_ARRAY_BUFFER, VBO_);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STATIC_DRAW);
+
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid *) 0);
+    glEnableVertexAttribArray(0);
+
+    glBindVertexArray(0);
+
+    for (GLuint i = 0; i < amount_; i++) {
+        particles_.push_back(Particle());
+    }
 }
 
 ParticleEmitter::~ParticleEmitter() {
     std::cout << "ParticleEmitter destructor" << std::endl;
+
+    glDeleteVertexArrays(1, &VAO_);
+    glDeleteBuffers(1, &VBO_);
 }
 
 void ParticleEmitter::update(float delta,
-                             const GameObject& object,
+                             const Ball& object,
                              int newParticles,
                              const glm::vec2 offset) {
+    // Add new particles
+    for (GLuint i = 0; i < newParticles; i++) {
+        int unusedParticle = this->getFirstUnusedParticle();
+        this->respawnParticle(particles_[unusedParticle], object, offset);
+    }
 
+    // Update all particles
+    for (auto& particle: particles_) {
+        particle.lifespan -= delta;
+        if (particle.lifespan > 0.0f) {
+            particle.position -= particle.velocity * delta;
+            particle.color.a -= delta * 2.5;
+        }
+    }
 }
 
 void ParticleEmitter::render() {
-
+    // Use additive blending to give it a 'glow' effect
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+    shaderProgram_->use();
+    for (auto& particle: particles_) {
+        if (particle.lifespan > 0.0f) {
+            shaderProgram_->setUniform("offset", particle.position);
+            shaderProgram_->setUniform("particleColor", particle.color);
+            texture_->bind();
+            glBindVertexArray(VAO_);
+            glDrawArrays(GL_TRIANGLES, 0, 6);
+            glBindVertexArray(0);
+        }
+    }
+    // Reset to default blending mode
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
 
 GLuint ParticleEmitter::getFirstUnusedParticle() {
-    return 0;
+    // First search from last used particle, this will usually return almost instantly
+    for (GLuint i = lastUsedParticle_; i < amount_; i++) {
+        if (particles_[i].lifespan <= 0.0f) {
+            lastUsedParticle_ = i;
+            return i;
+        }
+    }
+
+    // Otherwise, do a linear search
+    for (GLuint i = 0; i < lastUsedParticle_; i++) {
+        if (particles_[i].lifespan <= 0.0f) {
+            lastUsedParticle_ = i;
+            return i;
+        }
+    }
+
+    // All particles are taken, override the first one
+    // (note that if it repeatedly hits this case, more particles should be reserved)
+    lastUsedParticle_ = 0;
+    return lastUsedParticle_;
 }
 
-void ParticleEmitter::respawnParticle(const Particle& particle,
-                                      const GameObject& object,
+void ParticleEmitter::respawnParticle(Particle& particle,
+                                      const Ball& object,
                                       const glm::vec2& offset) {
-
+    GLfloat random = ((rand() % 100) - 50) / 10.0f;
+    GLfloat color = (GLfloat) 0.5 + ((rand() % 100) / 100.0f);
+    particle.position = object.position() + random + offset;
+    particle.color = glm::vec4(color, color, color, 1.0f);
+    particle.lifespan = 1.0f;
+    particle.velocity = object.velocity() * 0.1f;
 }

src/graphics/ParticleEmitter.cpp

@@ -2,8 +2,8 @@
 
 #include "Texture.h"
 #include "ShaderProgram.h"
-#include "../game/GameObject.h"
 #include "Particle.h"
+#include "../game/Ball.h"
 #include <GL/glew.h>
 #include <vector>
 
@@ -13,7 +13,7 @@ class ParticleEmitter {
     ~ParticleEmitter();
 
     void update(float delta,
-                const GameObject& object,
+                const Ball& object,
                 int newParticles,
                 const glm::vec2 offset = glm::vec2(0.0f));
     void render();
@@ -26,8 +26,10 @@ class ParticleEmitter {
     GLuint VAO_;
     GLuint VBO_;
 
+    GLuint lastUsedParticle_;
+
     GLuint getFirstUnusedParticle();
-    void respawnParticle(const Particle& particle,
-                         const GameObject& object,
+    void respawnParticle(Particle& particle,
+                         const Ball& object,
                          const glm::vec2& offset = glm::vec2(0.0f));
 };