The limits of Processing are the limits of Java and eventually of OpenGL. Processing just ease the use of Java with a simplified syntax, tons of libraries and a great community of users and developers ; )
There are some libraries to span a sketch on multiple windows (Most Pixel Ever), to play with RSS (romefeeder), for particle systems (anar, Physics) and a lot more.
We have made a multitouch table from multiple LCD displays in under a week, building the table, programming a cheap video tracking from scratch and using a fluid simulation library (MSAFluids) with Supershapes flocking in it. The only limits I saw were time and programming skills ; )
If you use Processing as is, there is some limitations though.
- Processing only support Java 1.4. This is not a big deal unless you want to use some advance syntax or some libraries that need it.
You cannot currently use 1.5 syntax in the Processing Development Environment. This means no generics, templates, enum, varargs, foreach, and the rest. If you want to use Java 1.5 (or later), take core.jar and develop your project with another Java IDE [...]
- Processing also extends an applet and it limits the use of AWT and Swing. For example, it can be a bit tedious to do a layout without the AWT or Swing layout managers. You have to position all your graphic elements by hand.
You cannot use most of the AWT or Swing (which is built on the AWT), because it will interfere with the graphics model.
- The OpenGL support is not complete. You can use the OpenGL context directly, but:
This will give you JOGL's GL object that talks directly to OpenGL and will let you make OpenGL calls directly.
Again, this is not supported, in the sense that if you get weird problems with a GL-based sketch that uses this method, you're on your own.
- Processing is using a display loop more than an event-driven style of programming. It's not easy to bind events on-the-fly to any elements (like you can do in Javascript or ActionScript for example).
- The IDE is also very basic and unusable for big projects.
All those limitations are made to simplify the use of Java for very fast prototyping, easy deploying as a web applet, converting to Processing.js, etc. But when you want production code, you need to use it in a different way. For example, you can use it as a Java library in Eclipse (see
here) using the Java version you want, opening your applet fullscreen, etc. For OpenGL, you can use some libraries instead of the internal one (ex.:
GLGraphics,
anar), etc.
If you are a Java/OpenGL programmer that want to use all the great Processing libraries to simplify your work, I think you can manage this kind of project easily. But if you want a framework that can do very powerful production code out-of-the-box, but with a more steep learning curve, there is
OpenFrameworks (as cited by hapticdata) and
Cinder that are C++ based.
But depending on your needs (number of particles, display resolution, video resolution), this kind of project is not necesarily has computer-intensive as it sounds. For example, according to your description, I don't see any use for a 3D graphics framework. Maybe you could use
NodeBox for OpenGL,
Pyglet,
Summon or
SLUT that are Python based, a little less powerful but very easy to learn. And you can benefit from all the Python libraries. But if you want, for example, over 1 billion particles interacting in realtime, you have to do it on the GPU, no matter if it's from Java, Python or C++.
So the question is: what are your programming skills, the languages you already know and the level of involvement you are ready to put in learning a new language?