Particles (Partiküller)

Bir partikül, bazı simülasyon kurallarına göre uzayda hareket eden bir noktadır. Bu noktalar genellikle her zaman kameraya dönük (billboarding) küçük 2D quad'lar olarak render edilir ve büyük kısımları şeffaf olan bir doku içerir. OpenGL oyunumuzda bir partikül, şimdiye kadar kullandığımız hareketli bir sprite'tan farksızdır. Ancak yüzlerce veya binlerce partiküllü bir araya getirdiğinizde inanılmaz efektler oluşturabilirsiniz.

Partiküller üzerinde çalışırken genellikle konumundan sürekli yeni partiküller doğuran (spawning) ve zamanla bozunan bir partikül yayıcı (particle emitter) veya partikül üreteci (particle generator) nesnesi bulunur. Böyle bir partikül yayıcı, duman benzeri dokuya sahip küçük partiküller doğurur, yayıcıdan uzaklaştıkça renklerini soluk hale getirip parlak bir görünüm verirse ateş benzeri bir efekt elde edersiniz:

Partikül ateş örneği

Tek bir partikülün çoğunlukla zamanla azalan bir yaşam (life) değişkeni vardır. Yaşamı belirli bir eşiğin (0) altına düştüğünde partiküllü öldürürüz. Partikül yayıcı, doğurduğu partikülleri yönetir ve özelliklerine göre davranışlarını değiştirir. Genel bir partikül yapısı:

struct Particle {
    glm::vec2 Position, Velocity;
    glm::vec4 Color;
    float     Life;
  
    Particle() 
      : Position(0.0f), Velocity(0.0f), Color(1.0f), Life(0.0f) { }
};

Breakout'ta, her şeyi biraz daha ilginç hale getirmek için topu takip eden basit bir partikül üreteci ekleyeceğiz:

Partikül demo

Partikül üreteci, her partiküllü topun konumunda doğurur; topun hızının bir bölümüne eşit hız verir ve partiküllerin rengini ne kadar süre yaşadığına göre değiştirir.

---

Shader'lar

Partikülleri render etmek için farklı shader'lar kullanırız:

Vertex Shader:

#version 330 core
layout (location = 0) in vec4 vertex; // <vec2 position, vec2 texCoords>

out vec2 TexCoords;
out vec4 ParticleColor;

uniform mat4 projection;
uniform vec2 offset;
uniform vec4 color;

void main()
{
    float scale = 10.0f;
    TexCoords = vertex.zw;
    ParticleColor = color;
    gl_Position = projection * vec4((vertex.xy * scale) + offset, 0.0, 1.0);
}

Fragment Shader:

#version 330 core
in vec2 TexCoords;
in vec4 ParticleColor;
out vec4 color;

uniform sampler2D sprite;

void main()
{
    color = (texture(sprite, TexCoords) * ParticleColor);
}

Her partikül için standart konum ve doku niteliklerini alıyoruz ve ayrıca her partikül için sonucu değiştirmek amacıyla offset ve color uniform'larını kabul ediyoruz. Vertex shader'da partikül quad'ını 10.0f ile ölçeklendirdiğimize dikkat edin.

---

Güncelleme Döngüsü

Önce varsayılan Particle struct'larıyla başlatılmış bir partikül listesine ihtiyacımız var:

unsigned int nr_particles = 500;
std::vector<Particle> particles;
  
for (unsigned int i = 0; i < nr_particles; ++i)
    particles.push_back(Particle());

Her karede başlangıç değerleriyle birkaç yeni partikül doğururuz. Hâlâ (hayatta olan her partikülin değerlerini güncelliyoruz:

unsigned int nr_new_particles = 2;
// yeni partiküller ekle
for (unsigned int i = 0; i < nr_new_particles; ++i)
{
    int unusedParticle = FirstUnusedParticle();
    RespawnParticle(particles[unusedParticle], object, offset);
}
// tüm partikülleri güncelle
for (unsigned int i = 0; i < nr_particles; ++i)
{
    Particle &p = particles[i];
    p.Life -= dt; // yaşamı azalt
    if (p.Life > 0.0f)
    {   // partikül hayatta, güncelle
        p.Position -= p.Velocity * dt;
        p.Color.a -= dt * 2.5f;
    }
}

Yeni partikülleri sürekli listeye eklersek hızla binlerce partikülle dolu bir listeyle karşılaşırız. İstediğimiz, ölen (yaşam < 0) ilk partiküllü bulup yeni bir partikül olarak güncellemek:

unsigned int lastUsedParticle = 0;
unsigned int FirstUnusedParticle()
{
    // son kullanılan partikülden ara, genellikle neredeyse anında döner
    for (unsigned int i = lastUsedParticle; i < nr_particles; ++i) {
        if (particles[i].Life <= 0.0f){
            lastUsedParticle = i;
            return i;
        }
    }
    // aksi takdirde doğrusal ara
    for (unsigned int i = 0; i < lastUsedParticle; ++i) {
        if (particles[i].Life <= 0.0f){
            lastUsedParticle = i;
            return i;
        }
    }
    // diğerleri hâlâ hayattaysa ilk partiküllü geçersiz kıl
    lastUsedParticle = 0;
    return 0;
}

Son öldürülen partiküllün indeksini saklıyoruz. Bir sonraki ölü partikül büyük olasılıkla bu indeksin hemen sonrasında olacağından önce bu saklanan indeksten aramaya başlıyoruz. Son duruma ulaşılırsa partiküllerin çok uzun yaşadığı anlamına gelir.

Liste üzerinde ilk ölü partikül bulunduktan sonra, partiküllü, bir GameObject ve bir offset vektörü alan RespawnParticle çağırarak değerlerini güncelliyoruz:

void RespawnParticle(Particle &particle, GameObject &object, glm::vec2 offset)
{
    float random = ((rand() % 100) - 50) / 10.0f;
    float rColor = 0.5f + ((rand() % 100) / 100.0f);
    particle.Position = object.Position + random + offset;
    particle.Color = glm::vec4(rColor, rColor, rColor, 1.0f);
    particle.Life = 1.0f;
    particle.Velocity = object.Velocity * 0.1f;
}

Bu fonksiyon partiküllün yaşamını 1.0f'a sıfırlar, rastgele bir parlaklık (0.5'ten başlayarak) verir ve oyun nesnesinin verisine göre (hafifçe rastgele) konum ve hız atar.

Güncelleme döngüsünün ikinci kısmı tüm partikülleri yineler ve her partiküllün yaşamını delta zaman değişkeniyle azaltır. Ardından partiküllün hayatta olup olmadığını kontrol eder; hayattaysa konum ve renk niteliklerini günceller. Her partiküllün alfa bileşenini yavaşça azaltarak zamanla kayboluyor izlenimi veriyoruz.

---

Render Etmek

glBlendFunc(GL_SRC_ALPHA, GL_ONE);
particleShader.Use();
for (Particle particle : particles)
{
    if (particle.Life > 0.0f)
    {
        particleShader.SetVector2f("offset", particle.Position);
        particleShader.SetVector4f("color", particle.Color);
        particleTexture.Bind();
        glBindVertexArray(particleVAO);
        glDrawArrays(GL_TRIANGLES, 0, 6);
        glBindVertexArray(0);
    } 
} 
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

Her partikül için offset ve renk uniform değerlerini ayarlıyoruz, dokuyu bağlıyoruz ve 2D quad render ediyoruz. glBlendFunc çağrılarına dikkat edin. Partikülleri render ederken varsayılan GL_ONE_MINUS_SRC_ALPHA yerine GL_ONE (katkılı/additive) blend modu kullanıyoruz; bu, partiküllerin üst üste yığıldığında çok güzel bir parlama efekti (glow effect) oluşturmasını sağlıyor.

---

Oyun İçinde Kullanım

Her şeyi düzenli tutmak için tüm bu işlevselliği barındıran bir ParticleGenerator sınıfı oluşturuyoruz. Kaynak kodu: başlık, kod.

Oyun kodunda bir partikül üreteci oluşturup bu dokuyla başlatıyoruz:

ParticleGenerator *Particles; 

void Game::Init()
{
    [...]
    ResourceManager::LoadShader("shaders/particle.vs", "shaders/particle.frag", nullptr, "particle");
    [...]
    ResourceManager::LoadTexture("textures/particle.png", true, "particle"); 
    [...]
    Particles = new ParticleGenerator(
        ResourceManager::GetShader("particle"), 
        ResourceManager::GetTexture("particle"), 
        500
    );
}

Update fonksiyonuna partikül üreteci için güncelleme ifadesi ekliyoruz:

void Game::Update(float dt)
{
    [...]
    // partikülleri güncelle
    Particles->Update(dt, *Ball, 2, glm::vec2(Ball->Radius / 2.0f));
    [...]
}

Her partikül, top nesnesinin özelliklerini kullanacak; her kare 2 partikül doğurulacak ve konumları topun merkezine doğru offset edilecek. Son olarak partikülleri render ediyoruz:

void Game::Render()
{
    if (this->State == GAME_ACTIVE)
    {
        [...]
        // oyuncuyu çiz
        Player->Draw(*Renderer);
        // partikülleri çiz	
        Particles->Draw();
        // topu çiz
        Ball->Draw(*Renderer);
    }
}

Partikülleri toptan önce render ettiğimize dikkat edin. Bu şekilde partiküller diğer tüm nesnelerin önünde ama topun arkasında render edilir.

Güncellenmiş oyun sınıfı kaynak kodunu buradan bulabilirsiniz.

Uygulamayı derleyip çalıştırdığınızda bölümün başındakine benzer şekilde topu takip eden bir partikül izi görmelisiniz; oyuna daha modern bir görünüm kazandırıyor. Sistem, daha gelişmiş efektleri barındıracak şekilde kolaylıkla genişletilebilir.