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!

In this tutorial I demonstrate a technique that allows you to create a sticky type effect with your dynamic simulations in Cinema4D.

By using the Force object in combination with Step Falloff you can create a setup where the objects stick together depending on the force applied.

Check out the tutorial below, or watch it on Vimeo.

You can download the scene file here.

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.

Hi everyone and welcome to helloluxx, the new home of my blog.

As a thank you for all the continued support, I’ve created a Light Dome scene that you can download for use in your own Cinema4D scenes. You will need MoGraph to use the setup and I created it using Cinema4D r11.5, but it should work fine in r11, and maybe even 10.5.

Light Dome - Basic Render Result

The Light Dome is fairly straight forward to use. Here’s a screenshot of the available parameters.

Light Dome Parameters

I’ve also created a short tutorial that gives you a quick overview of the controls. You can check this out on Vimeo.

Light Dome Introduction from Tim Clapham on Vimeo.

Download the Cinema4D Light Dome scene as a zip file here.