The same task stands before software developers, right now almost every year we receive new, innovative and inteligent tools helping in our everyday work. To keep this introduction short, when saying about VFX simulations, we may roughly sort them into groups like: rigid body simulations, soft body simulations, hair, liquids, materials and flame (or such) simulations. We can't forget about the correlations between objects like: friction, springiness, viscosity or fragmentation. If we also add to this atmospheric simulations, we get quite nice list of features, that CG artists are made to work with, in order to content a casual (but probably not only casual), spectator. One of the applications that can boast of the biggest VFX plugins and tools library, is well known 3D Studio Max from Autodesk, but at the field of dynamics and fragmentation of the objects, a new player has appeared. It's name is "Pulldownit" and comes from Thinkinetic studio.
FIRST TESTS
While writing this review I decided not to focus at all the available options, features etc. but rather test the software in typical simulations. This would help us to really see, what was this aplication made for. The review is divided into 3 parts. The first one would be about static body simulations and collisions of many objects of high poly count. The second part would cover the objects fragmentation issue and in third I would present capabilities of using "Pulldownit" together with "RayFire". Hope you enjoy.
PART 1-1 Dynamics (Big objects count, animated objects.)
After a few hours of playing with the software itself, it's time for the first test. Does anyone remember game "The Incredible machine"? I decided to test how "Pulldownit" would cope with thousands of objects (ten tousands of spheres) coming into collision with animated, high poly and complicated one. It was not enough for me so I've also issued two other players into this test: already mentioned RayFire 1.46 using PhysX technology, and build in Max application - Reactor. Here are the results:
- Pulldownit - 17 minutes
- RayFire - 20 minutes
- Reactor - 59 minutes
...and here are the tests itselves:
We can surely admit that "Pulldownit" has a great stiff body simulating algorithms. 17 minutes is a very good result keeping in mind, that there was only single CPU core used. On the bottom screens it can be a little "interpenetration" noticed between the spheres and the shaker's faces. Rising up the subsamples value from 5 to 10, the "interpenetration" was practically eliminated. Perfect collisions between the spheres and the sieve are also admirable.
RayFire basing on the PhysX engine was uncompetitive if it comes to propriety of collisions.
Build in 3DS Max, Reactor was tragic. Not only the simulation took almost an hour, but also the "interpenetrations" were unacceptable, even between the spheres itself. During the collisions with sieve, they also behaved very chaotically.
To sum this up, I've also included an interesting comparisment about the scene itself. The diskspace needed for the simulations was:
- Pulldownit - 83 MB
- RayFire - 101 MB
- reactor - 104 MB
PART 1-2 Dynamics (High poly objects.)
Seeing that "Pulldownit" does really good when it comes to precision and accuracy of simulations, I wanted to see how would it work with objects of dense mesh structure. In this test we're having twelve, falling down, 50k poly models.
The accuracy of collisions and the lightning speed of simulations is surely what the "Pulldownit" can be boast of. Simple wathing how this software calculates the simulations may become real pleasure for the viewer!
Ending this part, I decided to include two more videos. They shortly show the basic features and how to make your scene ready for the simulation.
PART 2-1 (Fragmentation, description.)
Object's fragmentation available in "Pulldownit" is not as advanced as RayFire's, but still it gives the user very big capabilities. The results I would achieve in this part would be compared with those from RayFire. Object's fragmentation (used in most of the descruction simulations) is based on the Voronoi diagram. You can find more about Voronoi's cells
here. The main difference noticable in "Pulldownit" is that your object wouldn't divide into pieces automatically after collision (like it takes place in RayFire). Fragmentation (which in fact is dividing an object into smaller parts) must be done before we get into any simulations, so it's called "pre-fragmentation". "Pulldownit" offers us a few options for this:
- uniform fragmentation
- fragmentation based on the object's center
- radial fragmentation
- fragmentation on path
Here are some examples:
Uniform fragmentation
The most simple form of this kind of simulations. Here, "Pulldownit" seems to be rather poorly equipped in comparison to competition. There could be more different variations in this type of fragmentation. For instance, RayFire gives user all sort of fragmentation types together with different setup options. But there's still a small advantage - "shell" type simulation goes almost without any troubles, which cannot be said about RayFire or Volume Breaker (in these apps you need to work out how to join inner and outer object's faces).
Path fragmentation
Path fragmentation has been solved perfectly in "Pulldownit". After creating a path, or multiple paths and matching the object, the fragmentation simulation starts automatically. In the end, there's special cracking object generated (so called "cracker"), which moves according to created paths and brakes the "pre-fragmentated" mesh. Here's an example:
Radial fragmentation
That's another advantage of "Pulldownit". Very user friendly and fast fragmentation even up to 1500 pieces. The effect is very spectacular. Dynamics of simulation also causes no problems at all, even after simulating breaking wood.
During this kind of tests, I've encountered a some kind of drawback. There can be only one cracking "center" set for each object. Also the number of crack rings is set maximally up to 20 which seems too few for me.
PART 2-2 (Fragmentation, tests and comparisment.)
Fragmentation of "torus knot" into 512 pieces (voronoi uniform)
- Pulldownit - 1m 11 sec
- RayFire - 1m 19 sec
Fragmentation of "torus knot" into 1024 pieces (voronoi uniform)
- Pulldownit - 2m 03 sec
- RayFire - 2m 40 sec
Another test was about to cover 4092 pieces, but "Pulldownit" has a limit of maximum 2000 pieces.
Fragmentation of high poly object (28k polygons) into 32 pieces
- Pulldownit - 25m 49 sec
- RayFire - 18 sec
- F.R.A.C.T.U.R.E - 42 sec (free script, visit - www.scriptspot.com)
Fragmentation of high poly objects is really tragic... just look at the timings. It's for sure the weakest point of "Pulldownit" so I decided to skip the other Hi-poly simulations. Yet, fragmentation of colliding objects looks really nice and I would even say that it's better than in RayFire, but in order to achieve such results, there should be some time spend on better knowing all the available "Pulldownit" features. We can fragmentate objects multiple times. Each time we need to choose which piece would be spreaded into exact amount of other pieces (the amount which we can control). Pieces impact on each other by "stress" factors which can be controlled for all the pieces or separate groups of them.
It's also worth of mention that developers gave us possibility to use "space warps" in our collisions:
By using predefined "velocity" values we can easily apply motion to the object (nie wiem czy o to ci chodzilo) without animating it. It's very handy and usable, there's similar feature in application called "Thinking Particles".
PART 3 ("Pullitdown" + "RayFire" = Yes, please Sir!)
We already know that the biggest flaw of "Pulldownit" is poor, high poly objects fragmentation. However RayFire handles this issue perfectly, so I decided to choose what's the best from both of the applications.
Example 1
Making a natural looking, cracking and breaking wood is really difficult. One of the most advanced tools for this task - DMM form Pixelus studio, handles it perfectly. In our example we would use RayFire for pre-fragmentation of "wood-splinter" type and then we'll move them to "Pulldownit" where the final collision simulation would take place. Here's the result:
Example 2
RayFire seems to be not a perfect choice for "wood-splinter" like simulations. It's caused by complicated geometry which results in "exploding" of the object (PhysX, Reactor). However "Pulldownit" handles almost all the objects really nicely, so I've tried to apply "wood-splinter" fragmentation in RayFire and then export it to "Pulldownit" which would handle the simulation. Result looks like this:
CONCLUSION
Summing everything up, I can easily say that "Pulldownit" is a really solid piece of software. It's very good with objects dynamics. the speed of calculations and their accuracy sets it just behind the PhysX. Collisions and objects desctructions are also computed really nicely, the results look very realistically but unfortunatelly, there are also some drawbacks. For me these are mostly: fragmentation of complex objects, lack of automatic fragmentation during the collision. There could also be a bigger diversity of options for object's fragmentations. But still, there should be mentioned the ease of the applications workflow. It's really simple and just after a few clicks one can play and see his destructing dreams coming to pass. It should be also a good news for Maya users, as "Pulldownit" is also available for that application. now it could be a real challenge to "NSharter Ruins". My personal wishlist:
- faster hi-poly obietcts fragmentations!
- automatic fragmentations on impact (as a option with user pre-fragmentation)
- more uniform fragmentation options (as a perturbation of uniform method)
- more "origins" for radial fragmentation for one obiect
- bigger limits (max.fragments,radials etc.)
- animatable gravity values
- fully supported 'use all CPU-cores'
- collision map generator (as a animated mate texture) for obiect collisions
- version for Autodesk XSI
Happy destroing !
COMMENTS