Hi there,

i want to create a 2D GPU/GLSL based particle system with some requirements in mind (up to 512k realtime simulated particles, opengl 3.3 features, dynamic grid search for neighbors, two-way collisions - no cuda/opencl if possible).

I am familiar with GLSL, but have not made anything beyond rendering on the GPU, but i have created several particle and physics systems on the CPU - so i have a pretty good understanding how such systems works, but dont know how these would work on the GPU. Please give me some light in the darkness i am in right now....

Thanks in advance,

Regards,

Finalspace

So transform feedback seems the way i need to go and has some advantages:

- No need to encode/decode positions from textures so its much easier to access particle position/velocity etc.

- No need to upload the modified positions into the VBO from the CPU - everything except initialization is done on the GPU

but also i found some drawbacks:

- Use of random seems like a real pain

- Hard to create multiple emitters, cause it works on the vertex level which processes every particle - even its active or inactive - require a completely different thinking, are there some "discard" function to skip certain vertices?

- Collisions seems to be limited maybe? (Passing array pointers via Uniforms, there are some limitation in the max length of array in GLSL right?, so i need to make a multi-pass system so that collision contacts are being splitted to passes based on the limitations)

- Is there some "Null" fragment shader i can create to ignore any rendering at all? - For multipass systems i want to render at the very end, but process a few times some sort of GLSL shaders which operates on the particles only.

But most importantly i have no idea how to detect neighbor particles. On the CPU i had used a dynamic two-dimensional hashmap to store the particle in a dynamic grid with a bucket index-list to particle in the cell, also every particle has stored its current x/y on the dynamic grid - may change once per frame.

How the hell do i integrate something like that with GLSL? I heart about radix sort and some hash based algorythmn to access neighbors, but seesm to be very complex...

What about compute shader? I heard this is now part of opengl 4.x? Are this some sort of cuda like thing, but based on GLSL only???

I checked out some examples and tutorials regarding compute shader and transform feedback.

Transform feedback is nice, cause it requires just opengl 3.3 but compute shader is much more suitable for my scenario i am targeting for.

For the start i will just use compute shader only and render the final particle positions with spherical point sprites.

Thanks for the anwers.

I implemented a basic compute shader particle system with simple attraction force physics. Works great and i can simulate up to 2 mio particles running at 60 fps from my crappy GTX580M. What i have so far are two shader storage buffer objects - one for position and one for velocity, both initialized to max-particles (1 mio) and filled using glMapBufferRange.

Now i want to add emitter to that system, so that i can emit and destroy particles when i needed to, but i have no idea how to do that with this technique.

There are three questions i have for that:

- How can i integrate some sort of particle index buffer, to differentiate between active/dead particles with compute shaders and SSBO?

- How to limit the dispatch compute to a certain amount? I dont want to process the entire buffer count always, i want to different between active/dead particles and i do this using a technique to move dead particles to the end and process only the active particles.

- How can i integrate the concept of particle emitters, using compute shaders or is there a good way to mix CPU/GPU which is fast enough for ~512k particles?