home about gallery publications education links contact

..::crash landing::..

For this example, we will use simple geometry and basic deflectors, but in your scene, depending on the shape of your objects, you might need to use UDeflectors which will increase particle calculation times, so please bear that in mind when setting particle generation amounts. The system’s construction is quite basic, but the main trick is the values that we drop into the Spawn tests and in the (pre-set) Space Warps in the scene; as the collision is very explosive, we need a lot of variation, particle / object interaction and friction to get the desired result.

The main problem that we have got is how to key off the impact debris when our hero object smashes into the ground. Obviously, we’re going to be using Particle Flow to handle the debris, but we’re also going to be using it to handle the object - ground interaction. This is quite a simple procedure which involves scattering “null” particles over the surface, normally using a Position Object operator (on a dummy version of the object to confine the particle distribution to the relevant areas), but as we are using a simple plane object for this example, we will just use the system’s icon to position them. This icon is raised a little off the “ground” so that the crashing object will “dig in” underneath, displacing more particles. We don’t want these particles to be rendered until the object collides with them, so we can add a simple Collision test to handle that which checks to see if the deflector linked to the falling object has hit them.

If so, the Collision test passes these individual particles across to the next event which makes them renderable because of the introduction of the Shape operator and also generates a lot more particles thanks to particle spawning. Here we have two Spawn tests – one to create a cloud of small debris at the point of impact which are automatically deleted once they have hit the ground a set number of times (to keep the polygon count down) and another which ejects fast trails of particles due to the high amount emitted and varying sizes. These fast trails are piped to another event which makes them fall back down to earth and collide with the surface; when this occurs they are piped to another event to spawn a few more particles to simulate the debris breaking up. And that’s about your lot. The combination of Spawn tests and Space Warps allows us to handle this effectively without having to resort to a massive dynamics simulation. Even though we are dealing with thousands upon thousands of particles, due to the way we are managing them, particle calculation times won’t be all that high as we are only generating particles when and where we need them.

Apart from instanced spinning geometry being kicked up from the ground, landing, and digging in the ground, the only other thing (not covered in the steps opposite) that would be desirable is a system to generate some impact dust and trails emitted from the ejected particles. This is a relatively simple procedure and could be implemented by adding a couple of Spawn tests to generate facing particles with a material assigned with a low opacity (animated with a Particle Age map) to simulate the dust. The impact cloud spawning should only be performed on the event which handles the initial spawning (and should be dropped in before this test to ensure multiple particles aren’t accidentally spawned!) and, to keep render times down, should only be performed on a small percentage of particles. The same can be said for the trails spawning; we don’t want every ejected particle to emit a trail as this particular test would be placed in the meat of the system, so set the Spawnable % value quite low. Both systems wouldn’t need to be affected by gravity or collisions, nor would they cast any shadows. The end result will be a very effective system that is completely automated, and keeps render times relatively low as we are only spawning particles where we need to!

Enlarge Screenshot
Open the crash_landing_start.max file on the cover cd; this contains a baked animation, Space Warps and basic lighting. Select the PF Source 01 system in the scene and set the Viewport Quantity Multiplier to 10. Open Particle View, add a new Birth event, set Emit Stop to 0 and Amount to 10000. Delete the added Display operator. Wire the input of this event to the output of the source event.
Enlarge Screenshot
Add a Position Icon operator and a Collision test. Add the SDeflector in the scene to its Deflectors list. Create a new Shape event, set its Shape to Sphere and wire its input to the output of the Collision test. Add a Scale operator and set its Scale Variation to 100 for all axes. Add a Spawn test, set the Offspring value to 150 with 100 Variation, Inherited Speed to 75 with 25 Variation and a Scale Factor of 10 with 20 Variation. Label this test Spawn – Dust Debris.
Enlarge Screenshot
Add another Spawn test and set the Spawnable % to 75, Offspring and Variation to 100, Speed Variation to 25 and Scale Factor and Variation to 50. Label it Spawn – Breakup. Add a Send out test to the event and create a new Force event. Wire this event to the output of the Send Out test. Add the Gravity Space Warp to this operator and set its Influence to 100. Add a Material Static operator and add the Debris material (in the Material Editor) to it. Add a Collision test and add the SDeflector and Deflector Space Warps to it.
Enlarge Screenshot
Instance this event to create a new one and wire the output of the original’s Collision test to the input of the instance. Copy the Spawn – Breakup to the top of this event, label it Spawn – Secondary Breakup, enable Delete Parent and set the Offspring to 10. Instance the event and remove the Spawn test in the new event. Wire the input of this new event to the output of the Spawn – Dust Debris test.
Enlarge Screenshot
In this new event, make the Collision test unique and chance its Test True If Particle from Collides to Collided Multiple Times, and leave the Times setting as 5. Add a new Delete event to the system and wire its input to the output of the amended Collision test.
Enlarge Screenshot
Set all of the Display operators in the system to Geometry to see them in action in the Viewport after the SDeflector (linked to the Teapot) has collided with the (invisible) particles on the “ground”. Finally, right-click the PF Source 01 event, select Properties and enable Image Motion Blur. Render off the animation. If you’re feeling adventurous, try using a UDeflector instead of the SDeflector (with the same properties), but expect longer calculation times!
Enlarge Screenshot
Even with just basic particle geometry and Space Warps, the crash landing particle dynamics are effective and give a convincing result.
Download the max file!
Zip file to accompany.


The particle system we have generated generates an absolute shedload of particles, so if you are running a machine without much memory, I would seriously suggest that you reduce either the amount of particles initially born, and/or reduce the amount of spawned particles. If you are unsure, start off at a lower amount, perform a few low res test renders and then gradually up the amount (performing test renders with each value change) to see how your system handles it.

The particles in the system we have created do not react to one another. If you threw a large rock into a body of gravel you would notice that the individual stones collide with one-another, and therefore so should our system. To simulate this, try adding a Keep Apart operator, with no Falloff so they bounce off one-another, to affect just the spawned particles. Be warned though that this will result in high particle calculation times, so try to limit it so it just affects the larger particles.

As the teapot / spaceship / airplane is crashing onto the surface, it will dig into the ground, fragmenting and displacing the surface. We are only simulating the debris kicked up from the impact, so to generate this fragmentation, use the teapot object to make a selection on the ground. You can then spawn additional fragment particles to be lifted up as the teapot “digs” under the surface. Alternatively, try using reactor’s fragment feature. Cut out parts of the ground mesh and have them in place so that when the object collides with them they are displaced accordingly. You could also fire off another particle system to check to see if the object is moving; if so, then particle trails could be emitted from the fragment geometry. A good example of the technology behind this effect can be found on discreet’s support site (a colliding ice cube) which you should be able to modify for this scene.

Initially published: 3D World magazine, Issue 54, August 2004.

Copyright Pete Draper, August 2004. Reproduction without permission prohibited.