ICE Particles: An Introductory Walkthough

The following is a simple example of how you can create a basic fire using ICE particles.

UNDER RECONSRUCTION for Softimage 2011 Subscription Advantage Pack ... please stand by!

  • Part I shows you how to create a simple particle emission and simulation. Using this exercise, you can see where things are in the ICE tree and get comfortable with connecting nodes together and editing properties. For more information on each of the compounds you’ve used in creating this fire, see A Closer Look at the ICE Tree.
  • Part II shows you how you can create a compound of your own containing the ICE tree you just created.
  • Part III shows you how you can render your fire using ICE particle shaders.

For general information about ICE particles, see ICE Particles (


Table of contents

Making Fire with ICE: Part I - Creating the ICE Tree to Emit Particles

This exercise is designed to help you get used to working in the ICE tree and seeing how a few basic compounds work together to create an effect.

Let's start off by emitting some particles from a simple disc. There are different ways in which you can emit particles, but this is the simplest.

1. Create a polygon mesh disc and make its inner radius smaller so that it’s almost closed. This is the particle emitter.

2. Emit particles from the disc by choosing Particles > Create > Basic Emission from the ICE toolbar.

When you do this, the following things happen:

  • A point cloud is created. You can give this a new name, if you like.
  • An ICE tree for that point cloud is created in the ICE Tree view. The necessary nodes that are used to emit particles from the selected emitter object are already connected in the ICE tree — see below.
  • The Emit from Geometry property editor opens in which you can set the particle attributes.

3. Click the play button in the playback controls below the timeline to see the particles being emitted.

Particles are emitted starting at the second frame of the simulation frame range. For example, if the start frame of the simulation is set to 1, the simulation starts then, but particles are not actually emitted until frame 2. This is because the initial state of the particle emission is set on the first frame of the simulation range.

By default, the particles are small yellow points. You’ll also notice a bounding box around the particles to indicate that the point cloud is selected.


4. With the point cloud selected, open the ICE tree view by pressing Alt+9.

The ICE tree view has a large work area in the center where you drag in compounds and nodes and connect them together.

As you can see, there are five nodes already connected for you:

  • The emitter’s Get Data node
  • The Emit from Geometry compound
  • The Simulate Particles node
  • The Simulation Root node
  • The ICETree node

These are all explained later in A Closer Look at the ICE Tree.

xxx update image xxx


  • Nodes are represented as boxes with rounded edges, containing ports which are displayed as small, colored circles. Base nodes are operators working on the lowest level of object data, while compounds are collectives of nodes and possibly other compounds. Compounds are often referred to generically as nodes when they’re in the ICE tree because they look the same as base nodes except that they have a double line around them.
  • Ports on the left side of the boxes are input ports, while the ones on the right side are output ports. As you can see, each node can have one or more input and output ports.
  • On the left side of the ICE Tree is the preset manager, which houses all the compounds and nodes.

For more information on the ICE tree and all its parts, see The ICE Tree View (

5. In the ICE Tree, double-click the Emit from Geometry compound to open its property editor. In it, set these parameters to these values to define how the particles will look and act when they are emitted:

Rate 1000 (particles per second)
Size 0.2 - 0.5, depending on the Shape you choose.
Shape Set it to any shape you like for display, such as Sphere or Cone.
Select Emit Direction Use Initial Direction Vector
Direction -1 in Y (this seems unintuitive right now, but it works when forces and turbulence are added later)
Speed 0 (the particles stay on the emitter for now, but they will be moved by forces later)

Tip: For an explanation of any parameter, click the ? icon in the property editor to open up the online help for that topic.

By default, particles live for the whole duration of the simulation - however, you can change all that with one command.

6. With the point cloud selected, choose Particles > After Emission > Kill Particles from the ICE toolbar. This does two things in one command: it sets the particle limit and then deletes the particles when they reach this limit.

Note that you can also do each of these tasks separately by using the Particles > On Emission > Set Particle Limit and Delete Particles commands from the ICE toolbar.

Normally, you would now set the Age Limit in the Kill Particles property editor to set the particles life span value (in seconds) there. However, you’re going to drive the age limit with another compound called Turbulize Around Value.

7. In the ICE tree view, there is a preset manager on the left side that displays all ICE nodes and compounds. Click the Task tab at the top, then select Particles from the drop-down list. This opens the Particles tab which contains all the compounds directly related to creating particle effects.

xx update image xx


8. In the Modifiers group in the preset manager, select the Turbulize Around Value compound and drag it into the tree area. This compound randomizes the particle’s age limit using a turbulence field so that the particle lifetimes are not too uniform as they’re emitted.

9. Click on this compound’s circle (output port) called Value and drag toward the gray circle (input port) called Age Limit on the Kill Particles compound.

Release the mouse when the Age Limit label looks highlighted — this means that the ports are connected.

You can connect ports together only if their data matches in type and context. For details on what this means, see Connecting ICE Nodes (

10. Open the Turbulence Around Value compound’s property editor and set these values (you can leave the others as is):

Base Value 0.5 (this makes half a second the average age limit)
Variance 1 (the amount of variation on either side of the Base Value)
Turbulence Scale 3.5
Animated option On
Animation Speed 0.3
Complexity 1

When you plug compounds into the ICETree node, their output gets evaluated at every frame. When you plug compounds into any of the Emit compounds, their output is evaluated only once, upon particle emission.

Now to add some force to make those particles move!

13. In the Forces group in the preset manager, select Add Forces and drag it into the tree area. This compound is a hub for other forces, whose values it blends together and then outputs into the ICETree node.

14. You need to make some more ports on the ICETree node, so right-click on Port3 and choose Insert Port Before.

15. Plug the Add Forces compound’s Execute output into Port3 on the ICETree node.

16. In the Modifiers group in the preset manager, select the Turbulize Around Value compound again and drag it into the tree area. This time, you’re going to drive the force value with a turbulence field so that it has a nice random movement.

17. Plug this compound’s Value output into the Force1 port on the Add Forces compound. If there was another force plugged into the Add Forces compound, it would blend that with the Turbulence value and create one output.

18. Double-click this Turbulence Around Value compound to open its property editor and set these values (you can leave the others as is):

Base Value 1.5 in Y (this is the force moving the flames upward)
Variance 2.5 in Y; 1 in both X and Z
Turbulence Scale 3
Animated option On
Animation Speed 1
Complexity 1

The particles are moving upward in a random way when you play the simulation.

And finally, add some color:

19. In the Modifiers group, select the Modify Particle Color compound and drag it into the tree area. This lets you change the color of the particle at every frame.

20. Make a new port above Port4 on the ICETree node, then plug the Modify Particle Color compound’s Execute output into Port4.

21. Double-click the Modify Particle Color compound to open its property editor, and change the Source Parameter to be Age Percentage. This uses the color gradient for the duration of the particle’s life.

Set these values on the color gradient:


The colors you set for the particles in the ICE tree are only for display in the viewport. When you render the particles, you can set it up so that the shaders use this color for rendering, but you can also set up the colors separately in the shaders.

This is what your final result should look like, depending on how many variations you made to the parameters.


You can continue tweaking the parameters here and experiment by adding more compounds to the tree as you like.

A Closer Look at the ICE Tree

Now let’s look more closely at this masterpiece you’ve just created in order to understand the different pieces of the ICE tree.

Data flows from each node and compound from left to right in an ICE tree, all ending up being processed the ICETree node.

For more information, you can check out Understanding the ICE Framework ( later.

xxx update image xxx


Here’s a description of each of the ICE particle system elements:

1 The ICETree node is the main node in any ICE tree. Because this is a particle simulation, the ICETree node is simulated. At each frame, the ICETree node processes all nodes and compounds that are connected to its ports, from top to bottom.

See The Simulation Regions and Nodes ( for more information.

2 The Simulation Root node is "central station" for ICE simulation nodes. It needs to be plugged into the ICETree node.

This node gives you easy access to many ports in which you can plug in nodes that are often used in simulations. In this case, the Emit from Geometry and Simulate Particles nodes are plugged into it.

To use the commands on the ICE toolbar, you need to have this node plugged into the point cloud’s ICE tree.

3 The Emit from Geometry compound is responsible for creating and emitting the particles. At every frame, it adds points and sets their attributes such as size, color, velocity, mass, shape, etc. You can open the Emit compound’s property editor and change all these attributes as you like.

Emit compounds are usually plugged into the top of the Simulation Root node in a particle simulation because you need to emit the particles before anything else can happen to them.

See Setting Up Any Type of ICE Particle Emission ( for more information.

4 The disc is the particle emitter object: nothing more than that. The Get Data node that is created for it simply does that: gets the disc’s object data from the scene so that it can be used in the ICE tree. In this case, the node is called Get grid because that’s the name of the emitter object.
5 The Simulate Particles node updates the position and velocity of each particle at each frame based on its mass, position, and velocity (based on the forces affecting them) of the previous frame. Updating each frame based on the previous frame is what makes the particles simulated.

The Simulate Particles node takes all information from the compounds that are plugged in above it and then uses that information to update each particle at each frame.

See The Simulation Regions and Nodes ( for more information.

6 The Turbulize Around Value compound adds noise as a turbulence field to the age limit of the particles, driving the age limit value. If you had another value entered for the Age Limit, it’s overwritten by this compound’s value.

Turbulence is great to use with many types of physical effects because it creates a noise pattern that helps particles look more natural. In this case, it makes it look as if the flames are flickering.

See Turbulizing Particle Values ( for more information.

7 The Kill Particles compound does two things: it lets you set the particle age limit, then it deletes the particles when they reach their age limit.

The age limit determines how long the particle will live, in number of seconds or frames.

This node is plugged into the PostSimulation node, below the Simulate Particles node, because you want it to be evaluated at every frame.

The age limit is set at birth based on a turbulence field values so the particles appear to be deleted in "waves", creating long and short flames.

See ICE Particle Lifespan ( for more information.

8 The Add Forces compound is a hub for other forces to be connected into it. It adds up the values of all those forces and then outputs a single vector value to the ICETree node. In this example, only the Turbulence value described in 9 is setting the force, but you could easily add other forces, such as a wind.

The Simulate Particles node moves the particles by getting the force vector on each particle via Add Forces and then updating the particle’s position and velocity at every frame.

See ICE Forces ( for more information.

9 And another Turbulize Around Value compound! This time, it’s using a turbulence field to drive the particles in an upward direction, creating a nice random movement to the fire.

You’ll notice in ICE that you can the same node or compound in different ways, depending on where it’s plugged in. For forces, any port that returns a 3D vector can be used to define a force: just plug it into the Add Forces compound.

Note that you can also use the standard force objects (available from the Get > Forces menu on the Simulate toolbar) in the ICE tree.

10 The Modify Particle Color compound sets the color of the particle based on its age percentage (what percentage of its life it has already lived) and a color gradient.

See ICE Particle Color ( for more information.

Making Fire with ICE: Part II - Creating Your Own ICE Particle Compound

Because you’ve made such a beautiful fire effect, you want to share it with the world! You can do this by creating a compound containing all the compounds and nodes you’ve used in this ICE tree.

These steps quickly show how you can create a compound. These steps are brief, but for more information on creating compounds, make sure to see Building ICE Compounds ( later.

1. Make sure that the ICE tree is open for the point cloud you created in Part I.

2. You can’t store the ICETree node in a compound, so insert an Execute node to merge all the root connections into a single output: right-click the ICETree node and choose Insert Execute Node.

This creates an Execute node that receives all the inputs that were previously plugged into the ICETree node, and in turn, it is plugged into the ICETree node.

How easy was that!

xx update image xx


3. Select all the nodes and compounds you want to save in your new compound, including the Execute node. You can rectangle-select or press Ctrl or Shift as you add compounds.

To keep the compound generic, you should leave out the emitter object node (Get Disc) so that you can apply this fire effect to any particle emitter.

4. From the ICE Tree toolbar, choose Compounds > Create Compound.

And poof! All the compounds and nodes disappear from view, and you’re left with a generic compound named CompoundNode. But don't worry: it contains all the compounds and nodes that have just disappeared.


Congratulations, you have just created your first compound (and it didn’t even hurt that much).

5. Move the cursor over your new compound and click the little e in the upper-left corner. This opens up the compound for editing so that you can start exposing ports for it.

For more information on editing compounds, you can check out Editing Compounds ( later.


You now want to expose the different ports from the compounds inside to make only those parameters visible and editable.

The gray bar on the left shows all exposed ports for your compound. The only port that is currently exposed is the Emitter port coming from the Emit from Surface compound.

Before you start exposing other ports, you need to decide on what you really want to be able to change in your compound. In this exercise, just will try exposing a few ports to get the hang of it.


You can click the arrow at the top of the exposed ports bar to expand or collapse the list of exposed input ports. When the list is collapsed, you can display the name of a port by hovering the mouse pointer over its connection.


6. To include a port in the bar, click the black circle (Expose Input) at the top of the exposed port bar and drag it to a port that you want to expose in your compound. The port is then included on the bar.


7. You can rename this exposed port by either double-clicking on the name, or right-clicking on it and choosing Rename, then entering a new name. This is what the name of the parameter will be in your compound in the ICE tree and in its property editor.


8. In the bar at the top, double-click where CompoundNode is written and give your compound a descriptive name, such as Campfire.

You can add a group name for the Category, which will make your compound show up in that group on the Tool tab in the preset manager.

Or you can include a Task name for your compound to put it on the Task tab in the preset manager. You can also include a subtask name to create a group for it on that tab. For example, to create a group called Fires on the Task > Particles tab, enter this as the Tasks name: Particles/Fires.


If you like, you can add comments to your compound to document how everything inside it works. For more information on this, see Documenting Trees: Groups and Comments (

9. Click the little x in the upper-left corner to close the compound and return to the regular ICE tree. You’ll see your new compound with the ports you exposed and the name you gave it.


As final step, you can export your compound to make it available to others, and in the preset manager.

10. Select your compound node and choose Compounds > Export Compound from the ICE Tree toolbar to export your compound.

For more information on this, see Exporting Compounds (

And you’re done!

Making Fire with ICE: Part III - Rendering the Flames

There are several ICE particle shaders and shader compounds that you can use for rendering ICE particles. Once you start to understand the effects of the shaders, you can add more shaders and tweak the parameter values to get just the right look as you like it. The following example is just a simple render tree to get you started.

For general information about particle shaders, see ICE Particle Shading ( for more information.

Tip: The colors that you set for the particles in its ICE tree are used for display in the viewport. However, you can use an Attribute Color shader to bring these colors into the render tree if you like. See Using the ICE Particle Color in the Render Tree ( for how to do this.


If you’re using the fire scene you created in the first part of the example, you need to first make a few changes to the particles:

1. Select the point cloud, open the ICE tree, and then open the Emit from Surface compound’s property editor and make these changes:

  • Change the Size of the particles to something quite large like a value of 2. This is because you’re going to render the particles as a volume into whose density you’re going to "cut" and shape.
  • Make sure the Shape is something volumetric and slightly elongated, like a cone or Capsule.

Now you’re ready to apply the shaders:

2. With the point cloud still selected, open a render tree (press 7).

By default, you’ll see a Phong shader attached to the point cloud’s Material node.

You’re going to render the particle’s volume, not the surface, so for that you need a Volume shader. In this case, you’re going to use the Particle Renderer shader compound, which contains several shaders that help you achieve the volumic look.

Tip: When you're using instanced objects as particles, you need to use surface shaders to render the objects.

3. From the preset manager on the left of the render tree, select the Particle group and drag the Particle Renderer shader compound into the render tree workspace.


4. Plug its output into the Volume port of the Material node.

You can also delete the default Phong shader, or at least disconnect its outputs that are plugged into the Material node.


5. Now you'll make the following connections so that you end up with a render tree that looks like this:


  • From the Particle group in the preset manager, drag in the Particle Gradient Fcurve compound and plug it into the Global/Gradient Density port of the Particle Renderer compound. This contains a curve that allows you to shape the volume density.
  • From the Particle group, drag in the Particle Gradient shader and plug it into the Global/Gradient Color port of the Particle Renderer compound. This contains a color gradient that lets you color the flame.
  • From the Texture group, drag in the Fractal Scalar shader and plug it into the Density Shape port of the Particle Renderer compound. This shader lets you create fractal noise on the flame’s shape so that it’s more random looking.

Tip: For the sake of learning, you just went through the process of hooking up shaders from scratch. For the sake of speed, however, you can choose Get > Material > ICE Particle Volume from the Render toolbar to do most of this work for you. This command applies the Particle Renderer shader compound to the Volume port on the point cloud’s Material node. As well, it plugs the Particle Shaper shader compound into the Shape Density port on the Particle Renderer shader compound.

Once you’ve got the shaders hooked up together, it’s time to set up some basic parameters. Change only the parameters described here for now and leave all other settings in the default values.

Later on, you can go back and tweak these parameters and others with the render region drawn over the flame. The settings described here are just to get you started ...

For more information on any of these parameters, click the ? icon in each of the shader’s property editor to open the online help for that shader.

6. Set these parameters in these shader property editors:

Particle Renderer shader compound:

Particle > Density Limit (Density tab) 8.6
Particle > Elliptical Shape (Density tab) 0.65
Volume Density > Global Density (Density tab) 125
Marching > Detail (Volume Rendering tab) Default for previewing; High for final render.
Shadow Table > Interpolation (Volume Rendering tab) Linear for previewing; Cubic or Full Light Trace for final render
Shadow Table > Cell Size (Volume Rendering tab) 2 for previewing; 0.5 or less for final render
Shadow Table > Enable Fast Preview for Region (Volume Rendering tab) On for previewing; off for final render

Particle Gradient shader:

On the Gradient Position tab, set these parameter values:

Per Cloud: Density - Gradient Starts At 0
Per Cloud: Density - Gradient Ends At 5
Per Particle: Age % - Gradient Starts At 0
Per Particle: Age % - Gradient Ends At 1
Per Particle: Age % - Intensity/Influence 1

On the RBGA Gradient tab, make the color gradient look something like this:


Fractal Scalar shader:

Color1 (Color tab) 0.5
Recursion > Scale down (Noise tab) 1.7
Recursion > Gain/Smooth (Noise tab) 2.6
Coordinate Scale > Scale (Texture Support tab) 6

Particle Gradient Fcurve shader compound:

Make the curve look something like this:


7. Continue tweaking the shader parameters to get the results that you want.

This is just the beginning!

When you're done, you can even create your own shader compound for this rendertree - see Shader Compounds ( for more information.


This page was last modified 20:34, 14 Dec 2010.
This page has been accessed 38535 times.

© Copyright 2009 Autodesk Inc. All Rights Reserved. Privacy Policy | Legal Notices and Trademarks | Report Piracy