Laboratorul 05

Sisteme de particule

Introducere

Sistemele de particule au fost introduse in grafica cu principalul scop de a reprezenta diferite obiecte ce nu pot fi reprezentate eficient prin geometrie opaca. Obiectele de tip fuzzy, obiectele in care lumina sufera procese de difuzie si diferite fenomene naturale sunt toate implementabile cu mare usurinta prin utilizarea sistemelor de particule.

Totusi, datorita lipsei de capacitate de reprezentare a unei singure particule, pentru a reprezenta aceste obiecte este nevoie de un numar foarte mare de particule, de multe ori de ordinul zecilor si chiar sutelor de mii. De aceea este vital ca particulele sa fie implementate cat mai eficient.

Shader Storage Buffer Objects

Pentru a implementa eficient particulele vom folosi un nou tip de buffer. Shader storage buffer objects (SSBO) sunt niste tipuri de buffere specifice Shader Model 5 (OpenGL 4.3) ce ofera flexbilitate foarte mare algoritmilor prin faptul ca permit IO direct in shadere (desi exista restrictii).

Acestea sunt construite ca orice alt buffer cu:

glGenBuffers(1, &buf);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, buf);
glBufferData(GL_SHADER_STORAGE_BUFFER, data.size()*sizeof(Data), &data[0], GL_STATIC_DRAW );

Diferenta cheie fata de celelalte buffere este ca SSBO-urile (Shader Storage Buffer Objects) sunt legabile la puncte de legatura indexate, astfel:

glBindBufferBase(GL_SHADER_STORAGE_BUFFER,0, buf);

Astfel, pe fiecare punct de legatura (GL_SHADER_STORAGE_BUFFER), pot exista mai multe obiecte legate. In shader legatura se face in modul urmator:

struct particle{
	vec4 position;
	vec4 speed;
	vec4 iposition;
	vec4 ispeed;
};

layout(std140,binding=0) buffer particles{
	particle data[];
};

Intai este definit tipul de structura tinut in SSBO iar apoi se definiste legatura prin layout. Pentru a accesa acest buffer se poate folosi:

vec3 pos = data[gl_VertexID].position.xyz;
vec3 spd = data[gl_VertexID].speed.xyz;

Pentru sincronizare, pe partea de CPU se foloseste:

glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);

Constructie

Un sistem de particule este construit din doua componente: un set de date ce reprezinta o stare initiala sau ciclica si un set de reguli urmate de toate particulele. Din punct de vedere al redarii vizuale particulele urmeaza urmatorul proces:

Sunt trimise initial doar ca puncte catre banda grafica, fiecare din particule continand informatii de tipul pozitie curenta, viteza curenta, samd
In vertex shader sunt calculate noile pozitii si viteze, pentru fiecare particula. Rezultatele sunt scrise inapoi in buffer, direct din shader.
Apoi in geometry shader se efectueaza o expansiune, transformand punctul intrat in geometrie cu coordonate de texturare. Acest lucru se face exact ca imaginea urmatoare, de obiecei dupa aplicarea transformarii de vizualizare.
In fragment shader se textureaza/coloreaza.

particulele sunt in general limitate de bandwidth, cu cat sunt mai multe cu atat sunt mai multe fragmente ce fac citiri din texturi.
In poza cu laboratorul rezolvat fiecare particula urmareste o ecuatie de aruncare
Daca nu aveti un procesor grafic cu Shader Model 5 puteti utiliza transform feedback, un tutorial ok gasiti aici: http://ogldev.atspace.co.uk/www/tutorial28/tutorial28.html . Fata de varianta cu SSBO exista o serie de dezavantaje notabile.
Daca doriti sa comunicati intre invocari de shader trebuie sa aveti un mecanism de sincronizare sau un algoritm in care nu exista race-uri.
Exista mai multe layouturi ca std140, packed sau std430. Mai multe puteti citi in specificatia OpenGL sau pe scurt in reference: https://www.opengl.org/sdk/docs/man/