This tutorial will cover the basics of particle generation using Thinking Particles. This tutorial assumes familiarity with Cinema 4D.

Note that it takes some time to learn Thinking Particles. Please read through this tutorial carefully and make sure you understand each part before moving on. The aim of this tutorial is to explain not just what to do, but why you are doing it. The "why" is the critical part of learning this system.

We will explore four nodes for particle generation:

1. PStorm
2. PBorn
3. PMatterWaves
4. PFragment

So, right off the bat, let's get going and make some particles.

1. Start with a brand new scene in C4D.
2. Add a null object to the scene. You may choose to call this object "TP" or "Particles" or something similar.
3. Add an Xpresso tag to the null object.

4. Double-Click on the Xpresso tag to open the Xpresso Editor window.

5. Right-click inside the Xpresso editor window and choose New Node->Thinking Particles-> TP Generator->PStorm


6. Bring the play-head to zero and play the scene. You should see a circle with particles emitting from it.


Before we move on, let's talk about what we did and why we did it.

Why did we add a null object?
Thinking Particles is an entirely node-based sytem. It can only be accessed through the Xpresso Editor, which requires an Xpresso tag to be placed on some object in the scene. Null objects are excellent tools for organizing scenes and make perfect candidates for Xpresso Nodes. They contain no geometry, and very few object parameters, and thus require little system resources. Also, Thinking Particle nodes generally affect large sytems of objects, and placing them on a "neutral" object (an object with no scene dependencies) makes quite a bit of sense, as it can be copied from scene to scene and (hopefully) still work. This will become more apparent as you grow more and more comfortable with the Thinking Particles system.

Why did we add an Xpresso tag?
As mentioned above, Thinking Particles is an entirely node-based system. The Xpresso Editor was designed as a node-based expression system to be used in Cinema 4D. It can be used in many, many ways. Thinking Particles is only one part of this complicated and powerful tool. As you get more comfortable with Thinking Particles, it will greatly help you to learn about the Xpresso Editior and Xpresso nodes. It will open up many possibilities in Cinema 4D - not just for Thinking Particles, but for rigging, animation, effects, etc. The list goes on-and-on.

Why did we double-click on the Xpresso tag?
That opens the Xpresso Editor and loads the current Xpresso tag into the editor. You can have many Xpresso tags in your scene, but only one tag will open at a time in the editor.

What is a PStorm node? What are all these nodes? Do I really need to know all of them? This is already intimidating!
Ok, that's a lot of questions! First, most of the right-click options can be ignored for now. In fact, a lot of them you will never need to know about at all. In time, you may want to investigate them further but for now, let's stick with the basics. The way to generate Thinking Particles is by adding a Thinking Particles generator node to the scene. There are no such things as Thinking Particle objects, and the whole idea of particle objects (like the standard Particle System in C4D) needs to be let go of. Don't believe me? Try grabbing that null and moving it around. It makes no difference. The particles still appear in the exact same place they were before, no matter what you do. You cannot directly grab those particles and move them around like the standard particle system. (Don't worry, I'll show you how to, later, as well as explain why this is a GOOD thing). Now, with the nodes... The way to add nodes to the Xpresso Editor is with the right-click menu. Simply right-click in the editor window and you will see a context menu pop up. Since no nodes existed in our editor, we needed to add a new node. Going into the New Node directory brings us to the Thining Particles directory, which brings us to the TP Generator directory. Selecting PStorm creates a PStorm node, which generates particles. All of the nodes in the TP Generator directory will generate particles in one way or another, but PStorm is probably the one you will use the most. It is a very versatile node and has many options already built-in. The other nodes I will talk about later...

So, I have some particles... Now what?
Let's take a look at our basic options. Select the PStorm node and look at the Attribute Manager (I will call it the AM from now on). You may need to open the AM first or make it active before you select the PStorm node. The AM is where you will control all of your particle settings. There will be three tabs in the AM: Basic, Node, and Parameter...

Select the Basic tab. Here you can enable or disable the node, change its name, change its display color and add notes (which can be very helpful). Try out all of these options to see what they do. Make sure you remember to leave the Enabled check on before you continue!

Now go to the Node tab. There is only one property here, Random Seed. Every time you create a PStorm node, it will emit particles in the exact same place, speed, rotation, etc. This must happen so that you get consistent results no matter how may times you load the scene or render it. So, if you have two PStorm nodes in your scene with the exact same settings, they will both do exactly the same thing. Altering the Random Seed for the generator will make sure each system has unique values and appears different in the scene.

Go to the Parameter tab. This is where the majority of the setting you will alter will be. Play around with these settings to see what they do. Here is a brief explanation of the options:
Type: Controls the shape of the Emitter (Shape that emits the particles)
Birth Type: You can choose between Count, Rate, and Shot. Count will cap the number of particles from this emitter at the number specified in Count. Rate will steadily emit particles per second at the specified rate. Shot will emit the specified particles per frame.
Life: A particle is "born" at the first frame it is emitted from the emitter. From that point on, the particle will exist in the scene until it is killed in one way or another. Specifying a "life" value will kill the particle after it has been in your scene for the amount of frames specified by Life.
Speed: Sets the speed at which particles move. Note that speed only affects particles at the moment they are born! Keyframing speed will not speed up or slow down particles after they have been born - only on birth. Think of it like setting an autopilot, and once you have set a particle's speed, it cannot recieve any more instructions from you through this node. Later, I will show you ways to influence particles after birth.
Size: Controls the size of the particles. This will not be apparent until you associate some geometry with the particles.
FOV: The spread of the particles.
X and Y Size: The size of the emitter.
Distance: The distance from the emitter that particle birth takes place.
Spin: The spin of the particles. This will not be apparent until you associate some geometry with the particles.

Ok. Let's render our particles! Reset the play bar to zero, then play the scene. Stop on a frame with some particles and render.

It's all black! Nothing's there!

That's right. To make a particle render, we need to associate a shape or a geometry object with it. Right now, all we have are little points (or ticks) that represent the position of our particles, but nothing that will actually render. Let's create an object to place on each particle.

1. Create a cube, and make it 20 for each dimension. Make it 1 segment in each dimension. While I'm on this step, let me take a brief detour to talk about scene optimization. What you need to know is that you will be placing a copy of this object on each particle in your scene. It is a good idea to use objects at the lowest possible level of detail necessary for your shot in order to make sure you have the memory and processor power required to calculate the particles and render the scene. Think about what will happen if you have 1000s of copies of your object in the scene. Will you be able to render it? Will you run out of memory? Will you crash? Sometimes it is necessary to create special low resolution geometry to be used in particles. You will often have a system that is made of thousands of low resolution objects, and another system that is made of only a few higher resolution "hero" objects the will be closer to the camera.

2. In the Xpresso Editor, create a PShape node. (New Node->Thinking Particles->TP Standard->PShape). This is a special node that allows you to assign geometry to your particles.

3. Select the PShape node, and in the AM, drag your Cube object into the Object link area. Whatever object you put in here will get assigned to the particles.

4. Add a Particle Geometry object to your scene. Object->Thinking Particles->Particle Geometry. Make sure this object is at the top of the hierarchy in the AM or place the Cube object as a child of it. It is necessary that any object to be used as a particle must be placed below a Particle Geometry object in the AM. I don't know why, but that's just how it is... The Particle Geometry object is a special object that enables particles to be calculated and rendered in your scene. You can use Particle Geometry objects to manage the rendering of different particle systems by assigning groups to the Particle Group parameter (To be discussed later). For now, leave that field blank.


5. Click the Red rectangle on the top right part of the PStorm node and select Particle Birth. You will see that text saying "Particle Birth" has been added to the PStorm node.
6. Grab the PShape node and place it directly to the right of the PStorm node.
7. Click on the red circle next to Particle Birth, hold down the mouse button, and drag to the blue button next to "Cube" on the PShape node to connect the two nodes. If you are successful, you will see a black line connecting the two nodes.

8. Select the PStorm node and change size to 100.

9. Bring the Play Bar to zero and press play. You should now see cubes on top of your particles.

10. Stop on a frame you want to render, and try out a test render. Cubes will now render in the viewport.
11. If you want, you can also make the cube invisible in the editor and renderer, so that only the particles will render, and not the source object.

Let's break down steps 5-10.

What is this Particle Birth port?
First, while the boxes in the Xpresso Editor are called "nodes", the text inside them are called "ports." Each node will have its own set of available ports that have options unique to its node. The ports typically represent properties you will see in the AM when you select the node. Ports can be wired from one node to another to send information from one node to another. Nodes flow from left to right (or red to blue), meaning the ports on the right send out data and information and the ports on the left recieve data and information. This can be confusing when ports on the left and the right have the same names, but try to keep in mind that nodes flow from left to right. The Particle Birth port sends out information about particles at their exact moment of birth. This can be used in many ways. Typically, you use Particle birth to organize particles into different groups. In this case, we want to assign a shape to the particle right at the moment of birth.

Why move the ports next to each other?
Simple. Organization. Also, since Xpresso typically flows from left to right, you may way to organize your flows that way to keep your setups easy to navigate and understand.

How to connect ports?
The click and drag method is the way to connect ports. If ports are compatible, the line between them will turn green. If not, the line will be grey, and you will not be allowed to connect ports. Just because two ports can be connected does not mean that connection is necessarilly logical. It simply means they are compatible, for example, two integer values wired together... (I'll explain integers later)

Why change the PStorm size to 100?
The PShape node has a bounding radius setting set at 100. From the manual: "(Size/Bounding Radius)*size of the object = size of the particle object)" For the particle object to appear the same size as the base object in your viewport, these two values must be the same. You can use either one to scale up or down your particles, or you can scale the base object.

Ok, now that you know how to generate particles and assign geometry to them, let's look at some of the other ways to generate particles:

PBorn

In a new scene, create a null with an Xpresso tag, open up the Xpresso tag and create a PBorn node (New Node->Thinking Particles-> TP Generator->PBorn). If you play the scene, you will now see particles forming at the origin (0,0,0) and doing nothing. This is the nature of PBorn. It is the base particle system that has options only for number of particles and particle life. Having a generator with so few options can be useful if you're using other methods to control your particle settings (such as using an object for an emitter) and you only need a simple generator for your setup.

PMatterWaves

PMatterWaves is designed to emit particles from objects, using textures to control particle settings. This is a very useful node with a variety of applications. Just to name a couple reasons you might want to use textures to control particles:
1. You need an object to dissolve, so you have an an animated map in the alpha channel of your object making it disappear. To enhance the effect, you want particles to emit from the edges of the object as it dissolves. You can use this alpha texture as a basis for particle emission from your object.
2. You want an object to appear as if it is coated in mud. You use a texture map to decide where the mud should be placed, and create the mud out of particles that can be manipulated with forces, such as being shaken off of you object.

To create a PMatterWaves object, do the following:

1. Like before start a new scene, create a null object, and place an Xpresso tag on the null. Open the Xpresso editor for that tag.
2. Create a PMatterWaves node. (New Node->Thinking Particles-> TP Generator->PMatterWaves)

3. Create a Plane object that is orientated +Y, width 400, Height 400.

4. Create a new texture and assign it to the Plane. Make sure the texture is set to UVW coordinates.
5. Select the Plane and make it editable. You should now have a UVW tag on the object. Do not delete this!

6. In the texture that is assigned to the plane, disable all options except for luminance.

7. Put a noise texture in the luminance channel.

8. Open up the noise texture and set the Contrast to 100%

9. Step up one in the material hierarchy and click on the arrow next to the Texture button. Select "Copy Channel" to copy the noise channel.

10. Select the PMatterWaves node, and drag the Plane into the Object link area in the AM.
11. Drag the UVW tag from the Plane into the UVW link area in the AM.
12. Set Birth Type to Rate and Rate to 5000
13. Set Birth Type to Texture and paste the noise texture into the Birth Texture Channel.

14. Play the scene and you will see particles emitting from the plane only where the noise texture is white.

Time to talk about what we just did...

PMatterWaves uses an object as an emitter, so we needed to create an object to emit from. This can be any object, but it should be one that has been made editable and has a good set of UVW coordinates, since UVW coordinates are used as the basis for texture mapping of the PMatterWaves node. The actual texture that is on the object has no correlation at all to what happens in the PMatterWaves node. This is purely optional, but can be very helpful for previewing where particle generation will take place. Here, we are using the material to preview where particles will be emitting from the object, but you could delete that material from the object and still get the same results, as long as the UVW tag remains on the object. The contrast of the texture was set very high to exagerate the distribution of particle birth on the surface of our object. Since multiple UVW coordinates can be used on an object, it is necessary to tell PMatterWaves which one to use, which is why you dragged it into the link in the AM. We set birth rate very high to more easily display the distribution of particles. Changing the Birth Type to Texture ensures that we will be using a texture to control birth. If you explore the PMatterWaves node, you will find other options, as well. You can even use lights to control particle emission based on the illumination of an object. This is a very useful node and one you should take the time to get to know.

PFragment

This node is designed with one purpose: To shatter or fragment particles. This tool is very useful for explosions, dissolving objects, and other special effects.

Let's try a basic fragmentation.

1. In a new scene, create a null object and place an Xpresso tag on the object.
2. Create a Sphere with radius 100 and 16 segments.

3. Make the Sphere editable.

4. Double-click on the Xpresso tag to open the Xpresso Editor.
5. Create a new PBorn node ((New Node->Thinking Particles-> TP Generator->PBorn).

6. Select the PBorn node, and change Birth Type to Shot, and Shot to 1.

7. Create a Time node (New Node->Xpresso->General->Time).
8. Select the Time node, click on the Red Rectangle, and add a Frame port.
9. Right click on the Time port to delete it.
10. Add a Compare node (New Node->Xpresso->Logic->Compare).
11. Click the blue rectangle on the PBorn node, and add an On port.
12. Wire the Time Node to the Compare node, and then the Compare node to the On Port of the PBorn node.

13. Select the Compare node, and change the Data Type to Integer. Function should be ==, and Input 2 should be 0.

14. Add a PShape node (New Node->Thinking Particles->TP Standard->PShape, and connect this to the Particle Birth port of the PShape node.

15. Drag the Sphere into the Object link box of the PShape node, and set the Bounding Radius to 10.

16. Add a Particle Geometry Object to the scene, and make sure it is at the top of the hierarchy in the AM.

17. Disable the Sphere to Editor and Renderer (Both circles should be red). Now, if you play the scene, you will see one sphere at 0,0,0.
18. Create a PFragment node (New Node->Thinking Particles->TP Generator->PFragment) and wire it to the Particle Birth Port of the PBorn node.


19. Select the PFragment node and change the Threshold to 0, and Thickness to 10%.

20. Rewind the Playhead, and play the scene. You will see the Sphere break into pieces.

The Breakdown:
One thing to know about PFragment is that, while it is a generator, it does not work like a traditional TP generator object. It will only work on particle objects. So, any object that you want to fragment must first be converted into a particle. Steps 1-17 are spent converting the Sphere into a single particle. In steps 1-3, we create and prepare our object for fragmenting. PFragment will only work on editable objects. As a general rule, many nodes and options of Thinking Particles only work with editable objects, so it is good practice to always make editable any object you want to work in the system. If you are worried about needing to go back to the parametric object for any reason, you can keep a version history of the object hidden in your project, or in a separate file. On step 5, we've decided to use PBorn for the simplicity of the node. Since we only need to create 1 particle that is stationary, this simple node is the best choice. All the bells and whistles of PStorm and PMatterWaves would go unused in this setup. On step 6, we've changed the Birth Type to Shot and Shot to 1. This means that exactly 1, and 1 only particle will be emitted per frame. Now, we just need to make sure the emitter is only on for the first frame, and then is turned off for the rest of the animation. To accomplish this, I'm introducing two new nodes to you - the Time node and the Compare node.

Like the name implies, the Time node handles time parameters. The default port, Time, uses seconds as its base, but, depending on preference, you may want to use frames, instead. I find frames easier to work with (as long as the frame-rate is guaranteed not to change) so I've chosen to use frames, instead. If you right-click on Frame and select Port Information, you can see that the value type is integer, which means our Compare node should be looking for a matching Integer value type. Integers are non-fractional numbers, such as 0, 1, 5, 437, 8537, etc. Numbers such as 1.345, 22.5, 987.5767 are known as Real Numbers. You should always try to match output and input types to avoid errors.

The Compare node is a commonly used node, and you should take the time to understand it completely. It can be thought of as the "if, then..." of the Xpresso language (well, not entirely... The "then" comes later). It outputs a Bool. A Bool value is either TRUE or FALSE. In numerical terms, TRUE = 1 and FALSE = 0. In terms of the compare node, if the values it is comparing meet the terms of the comparison, then the output is TRUE. If the terms are not met, then the output is FALSE. Sound confusing? Let's break that down even further...

We have a time node that is set to Frame. This node will output the current frame of the animation to the next node. As stated before, this is an Integer value (there is no such thing as frame 25.467). When we add the Compare node, we are setting up some conditions for enabling or disabling the generator object (the On port of the PBorn node). The On port is always on unless it recieves a FALSE or 0 value from a node. So, how can the Compare node send out FALSE to the PBorn node to turn it off after frame 0? Simple. It must fail some sort of a comparison. The Compare node is set up to take in two values and compare them to each other. The first value gets wired into Input 1, and the second value gets either wired into Input 2 or entered in the AM. In our case, we've decided that this comparison should only test true when the current frame == 0. (Two equals signs is a special sign for comparison equality, as opposed to variable assignment. This is a principle of basic programming, and if you are interested further, there are plenty of programming references available to check out. For our intents and purposes, you can think of = and == as the same thing, for now). If you change the input value, you will see that particle generation does not start until the value specified by Input 2.

In steps 14-17 we have finishing initializing our particle object, and now we can begin to fragment it. In step 18, we create a PFragment node, and wire it into the Particle Birth port of the PBorn node. By doing this, we are saying the the fragmentation should begins immediately when the particle is born. Later, I will show you how to use events to control the timing of forces that affect particles. In step 19, we adjust the PFragment node to make the entire object fragment at once, and increase the thickness of each piece. Check the manual for a description of Threshold to understand more why the value was changed to 0. It is important to note that a Threshold value of 1 produces no fragmentation at all. You should also explore all of the settings in this node to really get a feel for how it works.

PStrom Revisited:
So, one thing I mentioned above is that moving the null associated with a particle generator has no effect on the particles. As promised, I'll quickly show you a way to make this possible.

Let's go back to our PStorm example.

Create a new scene with a null named "TP" and add an Xpresso node. Open the Xpresso Editor and add a PStorm node. Drag the TP null into the Xpresso Editor Window, which will create an Object node with your Null already assigned to the Object link field. Add a Global Position output port (Coordinates->Global Position->GlobalPosition) and a Global Matrix output port to the TP object node. Add and Emitter Alignment port to the PStorm node. Connect the nodes as shown below. Now, the alignment and position of the PStorm emitter is linked to the null object!