I found this Pyrocluster preset kicking about in my 3D library today and I cannot remember where I got it from. If you sent this to me, then please let me know and I’ll credit you in this post.

Pyrocluster with Thinking Particles

I’ve used pyrocluster many times and although I feel that there is much room for improvement, it is still a unique tool within the Cinema4D feature set. If you haven’t ever used this volumetric shader system then this short tutorial should get you started.

Pyrocluster Volume Tracer

In this tutorial take you through the steps to create a simple cloud fly through. Pyrocluster has got a bit of bad rap over the years for being painfully slow. This tutorial demonstrates some simple tricks to speed up workflow and ensure you are not waiting around for renders when setting up these type of complex volumetric effects.

Pyrocluster Preview

The setup is fairly basic but there is a lot of scope to take this type of technique much further and create some cool effects. I’d definitely encourage you to play around with the lighting, use falloff, add shadows. Check the lights ‘Project’ tab where you can choose to use specific lights for Pyrocluster Illumination and Shadow Casting. Of course there are so many things you can do with MoGraph and generating Thinking Particles, shading those particles with Pyrocluster opens up a whole new world of rendering.

No Particles

I recently had a question of how to create TP from dynamic collisions when using a Cloner Object.  In other words how do you create an emitter at the collision point of each clone.  If you haven’t seen the original tutorial on this then please check this post.

It isn’t actually that tricky once you understand the basic principle.  What you need to do is to iterate through each of the clones in the cloner and then by using the Dynamic Body State node you can output the dynamic position of each object (clone).

Xpresso Setup

In your Xpresso setup, output the Object from the Cloner Node, then link this into a Dynamics Body Node, you can then output the Count.  This number corresponds to the number of clones in the cloner.  Use this as the Iteration End value in an Iteration Node.  Now you have an iterator which will iterate through all the clones.  You also need to link the Cloner Object Output into another Dynamics Body Node.  In this second Dynamics Body Node you can link your Iterator Output into the Object Index, this will then link the iteration value to the index of the clone.  In other words it will count through each clone and check the dynamics state.

Particles From Clones

Once you’ve done that you can link the object output into one of the Object A / B inputs of the Dynamics Collision Node, just as I did in the original tutorial.  You should find that all your clones will emit particles when they collide with the other specified collision object.

Particles Galore!

Here’s another little tip for working with Cinema4D, specifically Thinking Particles. I offer up a solution to what appears to be quite a common problem with TP and hopefully this small tutorial will stop a lot of head scratching.

This time around, I show you a simple technique you can use to stop the pulsing you sometimes see with Thinking Particles when your emitter is moving too fast and you get those big lumps of particles emitted on every frame rather than a nice smooth emission..  Yes – you guessed it, this is sub-frame particle emission.

Of course this tutorial doesn’t cover many of the different ways that you can emit particles using TP but hopefully it gives you some idea of a solution that you can adapt to your own TP scenes.

Check out the quick tip over on the helloluxx vimeo channel.

Emit into multiple objects

Here is a setup that you can use when working with Thinking Particles and emitting into objects. This setup allows you to emit particles from multiple objects but only using one emitter. The principle is as follows…

You basically iterate through a list of objects. Then pass these objects into the volume position node, the result being that the particles are then placed into each object from the list. There is also included a simple method of enabling or disabling the objects from being included. Therefore you can control which objects have particles inside or not on a per object basis.

The great thing about a setup like this is that it is fairly simple to use and expand. It is easy to adjust the particle emitter as you are only using one emitter, yet it is quite powerful because it allows you to emit particles into an infinite number of objects. Well ok, perhaps not infinite, but you can certainly emit into hundreds if not thousands of objects with relative ease.

If you look at the screenshot above it may look like the particles are all in the same mesh, but each letter of the logo is an independent object. This means each letter can be transformed, textured and animated individually. Yet all the particles are generated with one emitter.

Anyway enough of this banter, how does it actually work?

Xpresso Setup

Here is a screenshot of the Xpresso setup. The first node is the Object List node. You can find this by right clicking in the Xpresso window and choosing
New Node > Xpresso > Iterator > ObjectList

Object List Node

This node is really handy as it allows you to drag any objects from your scene into the Iteration List field and it will then iterate through the list. In other words it will output the object for every object in the list. It doesn’t matter where in the object manager hierarchy these objects are, so they don’t all need to exist in the same hierarchy. If you do want to add multiple objects by shift or control clicking to select your objects, remember to lock the attribute manager with the ObjectList parameters visible before you start clicking in the object manager to select your objects. If you don’t, you’ll lose the Iteration List field and will have to go back and select the ObjectList node in your Xpresso window again.

Iteration List

The next node along is a simple object node. Link the Instance output into the object node Object input port. If you drag one of your objects into the Xpresso window it will automatically add the Object node for you. You can see I dragged the ‘L’ object into my setup.

To emit particles we will use the most basic of all the TP generators. We would like to create particles and we are not really bothered about speed, position etc at this point in the setup. ThePBorn node is found under…
New Node > Thinking Particles > TP Generators > PBorn

Add the PBorn node

Next we need to place our particles into each of the objects. To do this we can use the PVolumePosition node.
New Node > Thinking Particles > TP Helper > PVolumePosition

Add the PVolumePosition node

The PVolumePosition node allows us to specify an object volume that we would like to use with our particles. So you could link an object node output port into the PVolumePosition Object input port. However we want to iterate through our list, so we will link the ObjectList Instance output into this port instead. This in itself will not place the particles into the objects. We need to explicitly define the particles we would like to affect and what we would like to do to them. We use the PSetData node for this, which can be found under
New Node > Thinking Particles > TP Standard > PSetData

Add the PSetData node

First of all you drag the Particle Birth from the PBorn node into the PSetData Particle input port. This tells the node that these are the particles we would like to affect. We then drag the PVolumePosition Position output and link it into the PSetData Position input port. Basically saying that we would like to place our particles into the positions that are defined by the PVolumePosition node.

So in a setup where you use one object, this would all work fine now. If you have been building the setup as you read through this, then press play and you will probably see all your particles being created in the first object that you placed into the ObjectList. It seems that it isn’t iterating through the list. So at this point we can employ a new trick which offers another benefit as well. We need to force the PBorn node to refresh on each frame. By default the PBorn node is on. If we link our iteration through the On port of the node it will check this port for every frame as the ObjectList iterates through each object. The trick I chose to use for this was to link the Xray checkbox into the PBorn On port. By doing this we have the added benefit of including or excluding objects from the setup depending on the state of the Xray checkbox. Of course you don’t need to use the Xray checkbox, you could add some userdata and link that to the On port.

The Xray checkbox

In my setup the Object from the ObjectList is passed through the Xpresso, the Xray checkbox is evaluated, the particles are created and the same object is passed into the PVolumePosition and the particles are placed there. The objects are of course iterated through, so this happens for all the objects in the list. This is then repeated.

Xpresso Setup

So as you can see a nice simple setup with a great workflow and lots of potential. Certainly saves creating an emitter for every object you’d like to place particle into. Now what you do with those particles is entirely up to you.

If you’d like to download the sample scene I created which demonstrates this then click here. It was made in 11.5, but should be fine in r11 and r12 too. Have fun!

This tutorial from demonstrates a method to create Thinking Particles from Dynamic Collisions using Cinema4D and some simple Xpresso.

Although the technique described is fairly basic, this will lay the foundation for much more complex effects that are possible by developing the principle further.

Download the scene file for this project here.

Here’s a simple setup that I thought I’d share with you all. It is a way of emitting Thinking Particles as one object collides with another. The particles are actually emitted from the centre of the polygon of the colliding object, so not 100% accurate with the collision point, but hopefully you’ll still find it useful.

Xpresso Setup

The Xpresso isn’t too complex. Basically the Collision node checks if there is a collision occurring between the two objects, if there is it switches the PStorm node on.

To decide where the PStorm node should emit from the Polygon Selection is used and all the polygons from the object are iterated through. The polygon centre is then passed to the PStorm node and used for position.

Emit On Collision

Should be a nice preset to add to your arsenal of TP tools. Enjoy.

Download the scene file here (should work in r11+)

So as promised, here is another preset for Thinking Particles. This is from the old HYPA archive that I am slowly resurrecting.  I told you I’d get them online eventually, my apologies that it is taking some time!  I’ve been pretty busy lately with projects and some new training, but more about that later.  On with the particle goodness!

Thinking Particles Fire?

This preset uses the P_MotionInheritance node. It also covers a few other TP / Xpresso tricks.

The Start Group Xpresso

The particles are emitted and they take on a cone shape.  The cone shape is forced to point in the direction of travel using the PAlignment node. PGravity and PScale are used to… well give the particles gravity (upwards via some spherical gravity) and affect their scale.  The PBubble node gives the particles a little deviation from their paths as they move along.

The top few nodes use PData to obtain the particle position, this is then compared with the Y position of a null object.  Once the particles are above this null, they are moved from the Start group into the End group.

Check the Height of the Null

Once the particles are moved from the Start group into the End group the second set of Xpresso takes over.

The End group Xpresso

This is fairly simple, firstly the particles change shape to become cubes.  They also scale down using the PScale node.  The PMotionInheritance node is used here.  Basically there is a null object in the scene that is rotating around.  This is then referenced by the PMotionInheritance node and the motion is applied to the particles.  This makes the cubes swirl around as they rise up.

Here’s a quicktime movie that shows a render of the result.  I used GI for the render and you can see that the ‘fire’ is the main source for illumination.  Of course there are a lot more creative uses for this technique, but hopefully this simple example is enough to spark your creative juices and encourage you to play more with those lovely Thinking Particles!

You can download the scene file here.  It is saved with r11.5, but I’m sure it will be ok with r11 and r12 too.

Here we go with another Thinking Particles example…

This scene also makes use of the Proximal shader. As you may have guessed from the name, the Proximal shader works based on the proximity of objects. In other words you can use it to control a material when it is near another object, edge, vertex, etc.

Thinking Particles and Proximal

Take for instance a hot iron branding some skin. You could use proximal in the skin luminance channel, place it in a layer shader as a layer mask to reveal a glowing red colour. Point Proximal at the Branding Iron object and set the Start / End Distance and the Intensity. As the branding iron object moves towards the skin object, the proximal shader will get whiter. As it is used as a mask, it will reveal red coloured shader.

The Proximal Shader

As for the TP side of things, I’ve created a simple Surface Emitter and then dropped all the particles down using PGravity. The particles bounce off the surface using the PDeflector node. The surface that they bounce off has the proximal shader. I’ve used it in the displacement channel and also in a layer shader in the colour channel. So as the particles get close to the surface, they make dents and they also change the colour.

TP Xpresso Setup

Of course there are a lot more creative uses for this technique, but hopefully this simple example will whet your appetite and you will put it to a more suitable usage! How about emitting particles from the rear of a boat to stir up some wake. I remember JeremyW had a superb example of just that a few years back.

For those of you who don’t have Thinking Particles or just like to experiment. This type of technique is certainly possible using MoGraph too. You can use TP particles as the source for falloff on the Shader Effector and the Displace Deformer. If you don’t have TP then why not use MoDynamics to drop the clones down onto the surface?

I hope you find this useful and you are inspired to use the Proximal shader in your own projects.

You can download the Cinema4D scene file here.

A question was raised on fxphd about the different ways to generate geometry for Thinking Particles if you have created them using the MoGraph Matrix object.

You can do it several ways. You can create a Particle Geometry Object then create the particle geometry using Xpresso and the PShape node.

Alternatively you can use the Cloner Object and clone onto the Matrix Object.

I’ve created a couple of simple scenes that illustrate this. I’ve used two particle groups and then a simple Xpresso setup for each. The first scales one group of particles down and and the other aligns the second group to a null object.

The final scene is an example of doing this using only MoGraph, so no Thinking Particles or Xpresso is used.

Here’s a link to the files.

I hope you find them useful.