These are some particle systems created by me and an SCG artist, using the particle system engine and editor I created (Based on MiniOrk, of course..).
The engine includes modules such as:
Particle Pool (pool)
Ring Emitter (source, spawns particles on a point that traverses a ring with variable radius)
Nozzle Emitter (source, spawns particles from a nozzle with variable dispersion)
Re-Emitter (source, spawns new particles where old ones die)
Globals (source, time, random generator, etc..)
Dataflow Connector (source, input connection to data outside of the dataflow graph, for example entity data)
Sprite-Renderer (sink, renders a configurable orientation square quad for each particle)
Streak-Renderer (sink, renders a billboarded streaked quad for each particle)
Model-Renderer (sink, renders a model for each particle)
As a modular dataflow system, most parameters can be manually tweaked, or ‘plugged’ into output ports on other modules. All floating point inputs also have input transformation via modulo,scale,bias and piecewise curve lookups, when this curve is indexed with a time input, you have an animation curve. Currently all are updated on the CPU (at least it is multi-threaded;>) and of course rendered on the GPU. The underlying tech is a generic multi-threaded heterogeneous (CPU/GPU) dataflow graph system which is also used in my procedural-texturing-engine, modular-audio-synthesizer, and modular terrain generator. I have been interested in dataflow graph based systems since I was a teenager. My interest was sparked by modular analog audio synthesizers, followed by TurboSynth, and then later CSound and Generator/Reaktor. It made sense to me to try to and apply the paradigm to the visual realm (as others have also done). The dataflow graph system shown here has many parallels to a csound like system, an example would be that each plug type has a sampling frequency associated with it, such as “float-uniform”, “vect3-uniform”, or “vect3-per-particle” which are analogous to CSound’s e-rate, k-rate and a-rate or even GLSL/HLSL’s uniform, vertex-rate and fragment-rates. These days, I am considering layering in an LLVM based system, by translating the dataflow graph into LLVM IR, letting LLVM optimize, and then translating the resultant IR back to execute on the “dataflow machine”. I may even consider generating a parser to translate expressions directly into dataflow-graphs, although I do have to say the tool makes it easier to animate and explore particle systems, so I think a textual/visual hybrid system would work best.