JanneKarhu.code.particles

Introduction

top

Particles can be emitted from meshes, surfaces/curves and text objects. Each object can have up to 10 separate particle systems and particle settings can be shared among systems, just like materials or textures can be applied to many objects etc.

To add a new particle system to an object go to the Object Physics buttons and click "Add New" in the Particle System tab or select existing particle settings from the dropdown menu.

To add more particle systems to an object advance the active particle system (1 Part 1) selector to an empty slot by clicking it near it's right edge.

System settings

top

Emitters:

"Normal" particles which are emitted from the selected emitter elements from sta-frame untill end-frame.

Datablock selector: here you can select particle settings, name them or delete particle systems
1 Part 1: active particle system selector
Enabled: on/off switch for the particle system
Baking: toggle for baking settings
Type: in terms of when particles are born there are two types of particles systems: emitters and reactors.

Basic:

Amount: the total amount of particles used in the simulation, in grid distribution this changes to show the grid resolution
Sta: the start frame of particle emission
End: the end frame of particle emission
Life: the lifetime of particles
RLife: random variation of the particles' lifetime
Mass & RMass: mass is used in particle physics
RSize: amount of randomness in the particles' sizes

Emit From:

Random: the emitter element indices are gone through in a random order
Emitter element: vertices, edges, faces, volume, particles (with reactor particles)
Even: particle distribution is made even based on surface area of the elements
Distribution:
- Jittered: particles are placed at jittered intervals on the emitter elements, "Amount" sets the amount of jitter
- Random: particles are placed randomly in the emitter elements
- Grid: Particles are set in a 3d grid and particles near/in the elements are kept, "Invert" inverts what is considered to be the emitter

Reactors:

Reactor particles are born when other particle system's particles do things. Usually (not with emit from particles) the target particle's size determines it's area of influence. The target system must be before the reactor system (in the same object) so that the targets are allways updated first. Targeting systems cyclically (system in object 1 targets a system in object 2 and vice versa) may cause trouble since one target system will allways be not yet updated.

React on: what event of the target particles triggers emission
Target: the target particle system that creates the events that are reacted on, if the ob field is left blank the current object is used. In the image the "Psys:" field is red because the current particle system is the first particlesystem of the current object (Ob-field empty) so there is no valid target.
Sta/End: particles are only emitted when the chosen event happens, with this you can force remaining particles to be emitted at some point

React on - Death

Particles are emitted when the target particles die. Two example usages:

Fireworks: Target particles are emitted upwards with normal gravity. Reactor particles are set to emit from particles with random initial velocity and similar gravity.
Minefield: Reactor particles emitted from a large volume with reactor initial velocity. Target particles that die inside the volume cause "explosions" when they die.

React on - Collision

Particles are emitted when target particles collide with something. Example usage:

Raindrops: Reactor particles are on the ground plane with normal and reactor velocity. Target particles fall from above and collide with the ground plane.

React on - Near

Particles are emitted when target particles are near them. Example usage:

Trails: Reactor particles set to emit from particles with random initial velocity. Now the reactor particles are allways "near" the target particles so they emit constantly leaving a trail for the target particles.

Baking:

By default the particle system is dynamically calculated so that the next state is calculated from the current state (This is why particles are reset with a frame step backwards). To be able to use many particle features the whole path of the particles has to be known. Baking calculates and stores the whole path information during the particles' lives.

Before baking

Before baking there are two things to consider:

Bake space: in what coordinates the particles are stored in the baked keys
- World: particles are stored independently of the emitter object
- Object: particles are stored relative to the objects location/rotation/scaling
- Geometry: particles are stored relative to the emitter elements so that they can for example stick to the emitter under deformations by armatures
Bake step: how many frames there are between key frames for the particles. If you set this to 1 you get most accurate results because every frame is stored individually, but this way the particles will also take up a lot of memory since there's so much to store. If the step is not 1 the particle paths are interpolated between the key points.

The baking itself is done with the "BAKE" button. Autobaking is discussed later.

After baking

The first thing you should notice after baking is that the particle physics tab has disappeared. This is because the physics is exactly what we have baked, so we can't change them anymore. Also the "Baking" toggle has disappeared since we can't change the amount or starting variables of the particles as they are now baked.

This is where the real power of the particle system starts to show. One of the main ideas is that at one point you create the data - the baked particle keys - but you can then later decide how you want to interpret the data.

Interpolation: how the particle locations are interpolated along their paths. Only cubic interpolation takes the calculated particle velocities into account. This is probably wanted when particles are used as particles, but for example in creating hair it's best to switch to cardinal or b-spline interpolation for smoother results.
Rotation from: how the particle rotations are created
- Keys: the actual rotations stored in the keys are interpolated along the path
- Z Direction: the first rotation of the path is aligned to the z-axis and rotated to match the direction of the path at each point
- Z Incremental: same as the former, but the rotation are calculated incrementally along the path, acchieves better results, but is slower
- I Direction & I Incremental: same as above, but the first rotation is taken from the first key
Keys: creates "instances" of particles along each particles path
Steps: subdivision of drawn paths (the value is a power of 2)
Ren: subdivision of rendered paths (the value is a power of 2)
Adaptive render: tries to remove unnescessary geometry from the paths before rendering particle strands
Abs Length & Max Length: Use an absolute maximum length (in blender units) for particle path visualization.
RLength: randomize path lengths
Guide: apply guide curves to baked paths
Lattice: apply lattices to baked paths
Deaths: create death events from baked particles, this is usefull if you use a baked system as the target system of reactor particles.

Autobaking

Autobaking bakes the particles but keeps physics and initial settings modifyable. All changes made to these settings re-bake the particles. In the future also changing the emitter object or effector objects will re-bake the particles. To finalize the bake (for example to enable particle mode) you have to click the "BAKE" button to end autobaking.