Value types in the Emitter Guide

Almost every number in the Emitter Guide — a starting size, a speed, a colour — is a value, and every value has a type that decides where its number comes from. The type button at the left of each value opens the menu of types that make sense in that particular slot.

This page is a reference to those types. How a value becomes several rows combined by an expression is a separate topic — see Multi-values in the Emitter Guide.

Why the menu differs from slot to slot

The menu never shows every type that exists. A type appears only when it can actually produce a number in that slot:

• Dimension. A type that yields one number (like Random) is offered for a 1D slot; a spatial type such as Sphere only for a 3D one.
• Stage. Camera direction exists only while the particle is being drawn, so it is offered on construction-stage values and nowhere else.
• What the emitter is made of. Types that read another part of the emitter are offered only when that part exists: Particle velocity needs a moving particle, and the generator-backed types below need a generator that has the thing they read.

If a value is set to a type and the emitter later loses what that type needs — you switch to a generator without it, for example — the value quietly falls back to its default type rather than becoming invalid.

The everyday types

• Fixed — one constant number, the same for every particle.
• Random — a number drawn from a range, once per particle.
• Graph — a curve; the value follows it over the graph's own X axis.
• Over particle life / time / speed — a graph driven by how far the particle is through its life, how long it has lived, or how fast it moves. Each of these is the same thing as an Over value whose X is set to the matching source below (Particle life, Particle time, Particle speed) — the menu entry just fills X in for you.
• Over emitter time / system time — a graph driven by the emitter's or the whole effect's clock, so all particles change together.
• Emitter property — a number your game sets at runtime. On an R value it is a rotation, edited as an axis and an angle in degrees, and the game sets it as a quaternion.

Spatial types

Offered for 3D slots — most usefully for a starting position:

• Sphere, Circle, Area — a random point on or inside a shape.
• Point from path, Point between paths — a point taken from a path you draw.
• Grid — a node of a rectangular grid, so particles snap to regular positions.
• Points — exactly one of the points you place by hand, picked in their order by a nested distribution. Feed the distribution from Emitter time to light the points one after another (the time is in seconds, so for a longer or looping cycle make it a multi-value with an expression such as a / 4 - floor(a / 4)), or leave it Random to scatter particles over them. See the Points block.
• Particle position, Emitter position — the current position of the particle or of the emitter itself.

Reading the particle and the camera

• Particle velocity — how fast and in which direction the particle moves.
• Particle speed — how fast the particle moves, as a single number: the length of its velocity. Use it wherever the direction does not matter — a trail that grows longer the faster the particle flies, a colour that shifts with speed. It is offered only while the Changing Position mode produces a speed it can actually measure; under Manual driven by a single path the movement is described by a direction alone, so there is no speed to read and the type is not offered.
• Particle direction — the direction of movement as a unit vector. Unlike velocity it stays meaningful when the particle stands still, which is why it is the better choice for orienting geometry.
• Camera direction — the direction from the camera to the particle; available on construction-stage values, typically to face geometry at the viewer.
• Curl Noise — a smooth, divergence-free 3D field sampled at a point you choose (by default the particle's own position, where the slot can read it).
• Noise (legacy) — the older smooth 3D noise, sampled the same way; prefer Curl Noise for new effects.

Reading the generator

These types read the generator that spawns the particles, so they are offered only when the current generator kind actually provides them. Both are frozen at the moment the particle is born: they describe the shot the particle came from, not the generator's state later on.

• Gen burst position — where the particle sits inside its own burst: 0 for the first particle of the shot, 1 for the last one. Available for the Periodic, Distance and Even Ring generators. Use it to spread a burst along a gradient, a circle or a line.

• Number of shots — how many shots the generator had already completed when the particle was born: 0 for the particles of the very first shot, 1 for the second one, and so on. Available for the Periodic and Even Ring generators. Use it to make each shot differ from the ones before it — every volley a different colour, each wave slightly larger than the last.

  On GPU33 this count is not stored anywhere but computed from the emitter's time. That gives the same numbers as the other backends as long as the generator's timing (rate, burst, delay, start phase) stays constant. If any of those is driven by a changing value, exporting reports a warning, because the count may then drift.

Reading the emitter

• Number of particles — how many particles this emitter instance currently has alive. Useful to make an effect react to its own density: thin out the colour as the count grows, or drive a value from how crowded the emitter is.

  Not supported by GPU33. On the GPU there is no way for a shader to read how many particles are alive, so exporting an effect that uses this value to GPU33 reports a validation error. If what you need is a counter that grows over time, use Number of shots instead.

Reading another section

A value can take its number from what another section of the same emitter currently computes for the particle. These types are listed in the menu with an EG: prefix and the icon of the section they read:

• EG: Size — the particle's current size: the starting size multiplied by its change over life. 1D for a Square size, 2D for a Rectangle one.
• EG: Rotation — the particle's current rotation: the angle (1D) while the rotation is Faced; the full rotation (R, a quaternion) in Free, By velocity free and From axes. Self has no rotation of its own to read, and By velocity faced is composed with the camera at render time, so nothing computed before it can read it.
• EG: Color — the particle's current color (3D).
• EG: Transparency — the particle's current transparency (1D).
• EG: Texture frame — the frame index the particle currently shows, when the texture is cut into a Grid or uses Frames.

With Stripes geometry the same entries read the strip's own Size, Color, Transparency and Rotation sections; the strip's rotation is R in Free, By velocity free and From axes, and has no output in Facing and Self.

A quaternion output only fits an R value. In practice that is a quaternion parameter of an attached emitter. The child consumes it through its own Self Rotation: set the Self Rotation (Controlled) to an Emitter property with the parameter's name and the child's Rotation to Self, and its particles start turned exactly like the parent particle was. When the rotation stops being a quaternion, for example Free → Faced, the parameter goes back to AxisRotation, the default of an R value.

The main use is passing the state of a dying particle to an emitter that takes over from it. In Attached Emitters, attach a child emitter with On terminate and give it a parameter (an Emitter property in the child) for its size or color. Set that parameter to EG: Size or EG: Color: the child starts exactly where its parent ended, so an explosion, a splash or a trail picks up seamlessly instead of jumping to a size or color of its own.

When an entry is offered:

• The section exists in the current geometry: the Quads sections under Quads, the strip sections under Stripes, and Texture frame only with a Grid or Frames texture.
• The section's output fits the slot's dimension: a 1D slot cannot read a Rectangle size or a color.
• The section is computed before the slot. A section never reads itself, and two sections cannot read each other. A random color or transparency counts: it is drawn once, when the particle is born. A color that depends on the camera direction is computed only while the particle is drawn, so a parameter cannot read it.
• The emitter is not a mirror. On a mirrored emitter you do not pick these entries yourself: the mirror follows the choice made on its original and reads the same section of its own, including anything you overrode there.

If the section later stops providing the output — you switch the size to Rectangle under a 1D reader, or leave Quads — the value falls back to its default type, the same way as the other types on this page.

OnInit decides which moment the value comes from:

• Off (the default): the value follows the section every frame. A child attached with On terminate gets the parent's value at the moment it dies.
• On: the value is taken once, when the parent particle is born. The child then gets the parent's starting size or color, not the one it had at the end.

On GPU33 the value without OnInit comes from the last frame in which the parent particle was still alive, which can be up to one frame before it dies. JavaScript and C# export give the value at the moment of death exactly. The difference is at most what the section changes over one frame, so it can show only where the section changes quickly right before the particle dies.

Custom values

• Custom value — a reference to a named value you defined once in the emitter's Custom values section and reuse in several places.
• Over this value — a graph whose X axis is one of those custom values, so one number can shape many others.

See Multi-values in the Emitter Guide for how these combine with rows and expressions.