ParticleSystem refactor

Hey guys!
As some of you know, I've been working on refactoring the ParticleSystem.

Mostly I've been aiming at updating the ParticleSystem to a more modern design, generally I dislike the Polymorphic and simple design that T3D uses, in which inheritance seems to be the solution to everything!

One of my teacher at CS taught me to major lessons: Polymorphism is usually a bad solution in the long-term and you should always design your code such that you add by addition and not by modification!
Which is exactly what I've done with the ParticleSystem.

Originally, all the functionality was packed down into two classes: ParticleData and ParticleEmitters.
Which means that ParticleEmitters had the responsibility of: calculating particles initial position, manage the particle memory pool, render the particles, simulate the particles, update the particles and the list goes on and on.

Now I've split it up into more smaller classes:



It's pretty simple actually, you have the ParticleSystem class, which delegates the work into the other classes. Besides delegating the work out, it's also responsible for being the glue between the components of the ParticleSystem and the rest of the engine, so it handles all external requests (like emitParticles) and sends the appropriate commands to the components.

ParticleRenderers renders the particle, whatever this entails is up to the renderer. It could be Billboards, Pointlights or whatever. By changing how particles are rendered, you can easily accomplish stuff like glowing particles, ribbonParticles etc.
Or even utilize other objects as if they were particles! This is one of the newer IPS features which you can preview in the video below:



The ParticleEmitter changes the pattern which particles are emitted in, this is the good old roots of IPS. This is where you'll create your GraphEmitter, GroundEmitter, MaskEmitter or whatever you need.

Last but not least you have the IParticleBehaviours, which is small components you plug into the system to affect how particle behave (this is actually ripped right out of IPS).
This way you can have attracted particles, sticky particles or particles that can collide with objects without having to touch any of the existing code!

Here is a short video of the ParticleSystem refactor in action:

The discussion

So before we go ahead and mindlessly vote this into T3D here is a pro/con list of:

Pros

Adding features is as easy as creating a new class, and include it in your project.. No need to modify any of the existing code. The class is lightweight and easy to understand. SphereEmitter example.

The code is cleaner and easier to maintain.

I'll be extending the ParticleSystem with some of the features found in IPS, so this isn't entirely a "behind the scenes" change.

Cons

This will break ALL of your existing datablocks. All of the ParticleEmitterData and ParticleData scripts will be obsolete.

This will break the ParticleEditor, since even if we made a patch-solution it is simply not geared to handle this change. (Although the datablock editor still works fine as you can see in the video above, I don't know if the ParticleEditor is necessary in the first place).

More work needs to be done, I'm still working on it but to really polish this refactor, we will at some point need other people to look at the refactor and find bugs and tell me what features are missing.

Finally

The branch can be found here but the interesting changes can be found here.

Edit: btw some of the changes that I forgot to mention are:
Instead of specifying the time between particles, you now specify the particles per second. I liked this approach more, since the time between particles doesn't increase the amount of emitted particles linearly.

I also trimmed down the Particle struct a bit, which should save some memory, completely removed the "ParticleData" class and I added a "ParticlePool" class to manage the particle pool, instead of having that code directly in the ParticleSystem class.