PopcornFX v2.9

Generic selectors
Exact matches only
Search in title
Search in content
  1. Home
  2. Docs
  3. PopcornFX v2.9
  4. Node Reference
  5. Builtin nodes

Builtin nodes

Here you will find the reference for all builtin nodes. A builtin node is any node which is not a template.

Sections

 

Common to all nodes

All nodes have the following common properties:

 

PropertyTypeDescription
CustomNameLocalizedStringName of the node
DescriptionLocalizedStringDescription of the node
ActiveboolDetermines if the node is enabled or disabled (acts as a pass-through when disabled)
ExecStageenumDesired evolve behavior of the node

  • Auto: (default) Automatically determined by the graph compiler
  • Spawn: Node will be evaluated at spawn (once at birth)
  • Evolve: Node will be evaluated at evolve (every update tick)
ExecFrequencyenumDesired update rate of the node. Determines how frequently the node update will tick, based on the current LOD.

  • Auto: (default) Automatically determined by the graph compiler
  • Full: Updates every frame / simulation step
  • High: Updates less or as often as Full
  • Medium: Updates less or as often as High
  • Low: Updates less or as often as Medium.

With default settings and in low-detail LOD conditions, Low will update once every 32 frames.

 

Annotation

Annotation nodes allow to comment regions of the graph and visually tidy them up.
They are available in two flavors: Regular annotations, and post-its (since v2.8.0)

 

Arithmetic

Arithmetic nodes provide basic math operations such as addition, subtraction, multiplication, etc…

 

PropertyTypeDescription
OperationenumArithmetic operation to perform

  • Add: Addition. Works with types float-float4 and int-int4
  • Sub: Subtraction. Works with types float-float4 and int-int4
  • Mul: Multiplication. Works with types float-float4 and int-int4
  • Div: Division. Works with types float-float4 and int-int4
  • Mod: Modulus operator (Remainder of the integer division). Works with types float-float4 and int-int4
  • ShiftLeft: Bitwise shift left. Works with types int-int4
  • ShiftRight: Bitwise shift right. Works with types int-int4
  • And: Bitwise AND. Works with types int-int4
  • Or: Bitwise OR. Works with types int-int4
  • Xor: Bitwise XOR. Works with types int-int4
InputCountintSpecifies how many inputs the node has.
Min value: 2, Max value: 32
Does not apply to the following operations, where the input count will always be 2: Mod, ShiftLeft, ShiftRight
Input pins
Value
ValueB
...
ValueN
float-float4
int-int4
Input values.
Output pins
Valuefloat-float4
int-int4
Output value, contains the result of the operation.
+ all common properties

 

Assign

The assign node is mainly useful when used in conjunction with discretization paths, and the discretization point node.
It allows redirecting the load/store path, or rather, assigning a new value without changing the load-store path.

 

Input pinsTypeDescription
Valuefloat-float4
int-int4
bool-bool4
orientation
Original value / discretization path
NewValuefloat-float4
int-int4
bool-bool4
orientation
Value to inject into the discretization path in place of the Value input.
Output pins
Valuefloat-float4
int-int4
bool-bool4
orientation
New value, will always be equal to the NewValue pin
+ all common properties

 

Compare

The compare node compares two values and tells if they satisfy a compare operation (equal, not equal, greater or equal, lower or equal, strictly greater, or strictly lower)

 

PropertyTypeDescription
OperationenumCompare operation to perform

  • Equal: returns true if Value is equal to ValueB
  • NotEqual: returns true if Value is not equal to ValueB
  • Lower: returns true if Value is lower than ValueB
  • LowerOrEqual: returns true if Value is lower than or equal to ValueB
  • Greater: returns true if Value is greater than ValueB
  • GreaterOrEqual: returns true if Value is greater than or equal to ValueB
Input pins
Value
ValueB
float-float4
int-int4
bool-bool4
Input values to compare against each other
Output pins
Resultbool-bool4Result of the compare operation, either true or false
When comparing vectors, the result will be an identically-sized vector of bool values.
You can use the Any or All nodes to bring the result back to a single bool value.
+ all common properties

 

Constant

The constant node represents a static numeric constant in the graph, which can then be wired into the input pins of other nodes.
Note that you usually do not have to use the constant node, as you can specify numeric constants inline in the propertygrid of most nodes instead of wiring in a constant node.

 

PropertyTypeDescription
TypeenumType of the constant

  • float1
  • float2
  • float3
  • float4
  • int1
  • int2
  • int3
  • int4
  • bool1
  • bool2
  • bool3
  • bool4
  • orientation
SemanticenumSpecifies the semantic of the constant

  • None: No special semantic, just a “dry” numeric constant
  • 3D_Coordinate: Will be treated as a 3D-space coordinate, and be affected by axis-system conversions, including axis-flips. Works for float3 or int3 types
  • 3D_Scale: Will be treated as 3D-space scaling factors, and be affected by axis-system conversions, except axis-flips. Works for float3 or int3 types
  • Color: Will be treated as a color. Works for float3 or float4 types
  • Angle: Will be treated as an angle.

3D_Coordinate and 3D_Scale will be affected by axis-system conversions in the project settings or when the effect is baked for & loaded into an engine with a different axis-system. This is useful to make axis-system-independent effects.

Value*float-float4
int-int4
bool-bool4
orientation
Constant value
Output pins
Valuefloat-float4
int-int4
bool-bool4
orientation
Outputs the constant value
+ all common properties

 

Constructor

The constructor node allows you to assemble a vector from its separate components. For example, construct a 3D vector from separate X, Y, and Z values each coming from different nodes.
See also the Splitter node.

 

PropertyTypeDescription
DimensionenumDimensions of the output vector

  • 2D: Construct a 2-dimensional vector. Will expose input pins X and Y
  • 3D: Construct a 3-dimensional vector. Will expose input pins X, Y and Z
  • 4D: Construct a 4-dimensional vector. Will expose input pins X, Y, Z and W
ModeenumSemantic of the value to assemble, use this to make the effect axis-system independent. The S, U, F nomenclature refer to Side, Up, Forward.
Only applicable to 3D vectors.

  • XYZ: (default) The vector components will be treated as raw X, Y, Z values without any specific transform
  • SUF_RightHanded: X will be treated as the Side axis, Y as the Up axis, and Z as the Forward axis of a right-handed coordinate system.
  • SFU_RightHanded: X will be treated as the Side axis, Y as the Forward axis, and Z as the Up axis of a right-handed coordinate system.
  • SUF_LeftHanded: X will be treated as the Side axis, Y as the Up axis, and Z as the Forward axis of a left-handed coordinate system.
  • SFU_LeftHanded: X will be treated as the Side axis, Y as the Forward axis, and Z as the Up axis of a left-handed coordinate system.
Input pins
X
Y
Z
W
float
int
bool
Value of each separate X, Y, Z, W components. The number of pins available will depend on the Dimension property.
Output pins
Valuefloat2-float4
int2-int4
bool2-bool4
Final assembled vector
+ all common properties

 

DebugCheck

Allows to perform a runtime check and either break the simulation in-editor when a condition isn’t met, or show a runtime warning in the editor viewport.
When the condition can be evaluated at compile-time, will emit a compile-time diagnostic instead of a runtime one.

 

PropertyTypeDescription
TypeenumType of action to perform based on the value of the input condition.

  • Info : if the condition is a compile-time constant, and true, will emit a build info
  • Warning : if the condition is a compile-time constant, and true, will emit a build warning
  • Error : if the condition is a compile-time constant, and true, will emit a build error, and build will fail.
  • Assert : if the condition is a compile-time constant, and NOT true, will emit an error and build will fail.

If not a compile-time constant, and set to ‘Error’ or ‘Assert’, will pause the simulation in the editor and select the incriminated particles.

MessageStringMessage to display in the build report
Input pins
ConditionboolCondition that should be evaluated
+ all common properties

 

DiscretizationPoint

The discretization node allows to specify “discretization” paths, forcing the graph to do a load & store from one frame to the next, effectively discretizing that value.
The editor displays discretization (load/store) paths with a yellow outline so they are easy to spot and troubleshoot.
You can see the discretization point node as a generalized “store” node.

 

When a discretization point is placed in the graph, the graph compiler will walk back its input wire until it encounters a node which is not evaluated at evolve. It will create a per-particle storage for this value, store the value at spawn, and insert a load from that storage at the beginning of the frame. The discretization point node will then store to that same storage, causing the next frame to load that value. When multiple discretization nodes are encountered on the same path, the store is only done on the last one. This allows to create accumulators, timers, and things like the physics node. Basically any behavior that needs to accumulate a value from one frame to the next.

 

See also the Assign node, which is extremely useful to replace a value along a discretization path.
Because the graph compiler will always walk back the first functional input pin of each node it encounters when building the discretization path, and because not all nodes are commutative (such as a subtract or divide node), it means it can sometimes be tedious to make the discretization path walk back the branch you want it to follow. Using the Assign node makes this considerably easier and less error-prone.

 

Input pinsTypeDescription
Valuefloat-float4
int-int4
bool-bool4
orientation
Value to discretize (store)
Output pins
Valuefloat-float4
int-int4
bool-bool4
orientation
Same value as the input value
+ all common properties

 

EvaluateAtSpawn

This node evaluates the graph wired into its input pin at spawn.
Wiring any “evolve” nodes in the input pin will output the value they had at the time of the initial spawn.
This is the only node that can convert an “evolve” value back into a “spawn” value.

 

Input pinsTypeDescription
Valuefloat-float4
int-int4
bool-bool4
orientation
Input ‘Evolve’ value
Output pins
Valuefloat-float4
int-int4
bool-bool4
orientation
Output ‘Spawn’ value
+ all common properties

 

If

This node selects between two input values based on a condition.
It always evaluates both inputs, and is not a dynamic-branching if statement, it is identical to a select operation. Therefore it cannot be used to avoid doing some expensive operations based on a dynamic condition.
The graph optimizer will properly simplify it when the input condition is a compile-time constant though, and entirely remove the branch which ends up not being evaluated.

 

Input pinsTypeDescription
Conditionbool-bool4Condition used to pick between Value and ValueIfFalse
Valuefloat-float4
int-int4
bool-bool4
orientation
Value to output when Condition is true
ValueIfFalsefloat-float4
int-int4
bool-bool4
orientation
Value to output when Condition is false
Output pins
Valuefloat-float4
int-int4
bool-bool4
orientation
Output value.
Equal to Value when Condition is true.
Equal to ValueIfFalse when Condition is false.
+ all common properties

 

Integrate

The integrate node performs a time-based integration of the input graph, analytically if possible, otherwise using per-frame accumulation.

 

PropertyTypeDescription
BaseenumIntegration base:

  • Time: Will try to integrate analytically if possible
  • TimeDiscretized: Will integrate using discretized frame-based accumulation
Input pins
Functionfloat-float4Value to integrate along time
Constantfloat-float4Integration base constant (initial value)
Output pins
Integralfloat-float4Integration result
+ all common properties

 

Layer

The layer node represents a particle simulation. It contains a simulation graph.
A layer node cannot be dropped in a simulation graph, it can only be dropped in an event graph.
Layers are “triggered” by an incoming event, which causes a particle to spawn, and be simulated by the graph contained inside the layer.
To open a layer a view its simulation graph, double-click on it.

 

PropertyTypeDescription
AutoEntrypointboolIf enabled, editor will open this template automatically when opening the current graph.
Allows to do quick jumps when opening intermediate-level templates to skip boilerplate template indirections
LODMetricOverrideboolIf enabled, will override the layer’s LOD metrics. Otherwise, will use the effect’s default settings
LODDistanceMinfloatDistance below which the LOD level is at highest detail (lod = 0.0). A negative value will use the effect’s default value.
LODDistanceMaxfloatDistance above which the LOD level is at lowest detail (lod = 1.0). A negative value will use the effect’s default value.
PrewarmPreferredSubdivisionenumHints the runtime on how to subdivide the prewarm frame.

  • Default: will use the global information from the effect.
  • Enabled: will force the subdivision of the frame.
  • Disabled: will force disable the subdivision of the frame.
PrewarmMaxTickDeltafloatMaximum delta time used to subdivide and compute the first frame to prewarm the layer.
Min: 0.001
PrewarmMaxTickCountintMaximum subdivisions to prewarm the layer.
If the maximum subdivisions isn’t enough to prewarm the default time with the maximum delta time, the maximum delta time will be grown accordingly.
Min: 1
PreferredSimLocationenumHints the runtime as to where it should try running the simulation for any child layers this template contains.
IMPORTANT: Only applicable to layergraph, ignored in datagraphs.

  • Auto: Will not enforce anything and will use the current platform’s defaults (CPU).
  • CPU: Will force the sim to run on the CPU.
  • GPU: Will try, if possible, to run the sim on the GPU.
PreferredStorageSizeenumHints the runtime as to how large the storage for this layer will need to be ingame.
It has to take into account the number of simultaneous ingame instances of the effect.
So a layer with few particles but many ingame instances will need a larger storage.It’s usually best to keep this to Auto, unless the storage size has been specifically spotted as a problem.

  • Auto: Will automatically grow pages from 512 to max 2048 as more particles are added. Starts at 1024 on desktop, 512 on mobile/consoles.
  • Tiny: Will set the pages to a fixed size of 32 particles
  • Small: Will set the pages to a fixed size of 128 particles
  • Medium: Will set the pages to a fixed size of 512 particles
  • Large: Will set the pages to a fixed size of 1024 particles

NOTE: The page sizes are indicative and might be adjusted in future SDK updates.

PreferredLocalizationenumHints the runtime as to how insert particles in pages localized or not.

  • Default: will use the global configuration.
  • Localized: will force pages to be localized.
  • NotLocalized: will force pages to not be localized.
DeterminismenumHints the runtime as to how random values should behave.

  • Auto: Will use the project defaults.
  • Disabled: Will force all random values to be non-deterministic (but more efficient, and higher quality).
  • Enabled: Will force all random values to be deterministic.
  • Enabled Fixed: Will force all random values to be deterministic. The seed-modifier does not depend on the parent seed-modifiers.
RandomSeedModifierintModifies a seed of the random generator.
On deterministic templates that receive event from the same parent, the same seed will lead to identical random values.
Min: 0
+ all common properties

 

MathFunction1

This node represents all supported math functions that take a single input value.

All “Fast” versions are faster to compute, but give a lower precision result.

 

PropertyTypeDescription
FunctionenumMath function to apply.

  • Sqrt / FastSqrt: Square-root, uses the absolute value of the input: pow(abs(x), 1.0 / 2.0)
  • Rsqrt / FastRsqrt: Reciprocal square-root, uses the absolute value of the input: 1.0 / sqrt(abs(x))
  • Cbrt / FastCbrt: Cubic-root, uses the absolute value of the input: pow(abs(x), 1.0 / 3.0)
  • Length / FastLength: Outputs the length of the input vector. Always returns a scalar.
  • Normalize / FastNormalize: Normalizes the input vector: Outputs a vector pointing in the same direction as the input vector, but whose length is 1.0
  • Sin / FastSin: Sine function. Input angle is in degrees or radians depending on the value of AngleUnit
  • Cos / FastCos: Cosine function. Input angle is in degrees or radians depending on the value of AngleUnit
  • Tan / FastTan: Tangent function. Input angle is in degrees or radians depending on the value of AngleUnit
  • ArcSin / FastArcSin: Inverse sine function. Output angle is in degrees or radians depending on the value of AngleUnit
  • ArcCos / FastArcCos: Inverse cosine function. Output angle is in degrees or radians depending on the value of AngleUnit
  • ArcTan / FastArcTan: Inverse tangent function. Output angle is in degrees or radians depending on the value of AngleUnit
  • Exp / FastExp: Exponential function (base e): pow(e, x)
  • Exp2 / FastExp2: Exponential function (base 2): pow(2, x)
  • Log / FastLog: Logarithmic function (base e), uses the absolute value of the input: log(abs(x))
  • Log2 / FastLog2: Logarithmic function (base 2), uses the absolute value of the input: log2(abs(x))
  • Rcp / FastRcp: Reciprocal function: 1.0 / x
  • Abs: Absolute value
  • Sign: Sign function. Returns -1.0 when the input is <= -0.0. Returns 1.0 when the input is >= 0.0. Never returns 0.0. Takes signed zeroes into account by extracting the floating-point sign bit (useful to preserve the sign when they are the result of an inversion of a positive or negative infinity value)
  • Ceil: Ceiling rounding: Rounds to the closest integer value >= x
  • Floor: Floor rounding: Rounds to the closest integer value <= x
  • Frac: Fraction: Extracts the fractional part of the input. Output value is always in the [0,1[ range
  • FracSign: Signed fraction: Extracts the fractional part of the input, preserving the sign of the input. Output value is always in the [0,1[ range when the input is positive, and in the ]-1,0] range when the input is negative
  • Saturate: Clamps the input value to the [0,1] range
  • All: Returns true if all components of the input vector are non-zero, otherwise returns false
  • Any: Returns true if any component of the input vector is non-zero, otherwise returns false
  • Neg: Negates the input value: -x
  • OneMinus: Returns one minus the input value: 1.0 - x
  • BitwiseNot: Bitwise NOT operator: Flips all bits of the input value. Only accepts integer values.
AngleUnitenumSpecifies how this function will interpret angles.
Only applies to trigonometric functions

  • Degrees: (default) Will use angles in degrees
  • Radians: Will use angles in radians
Input pins
Valuefloat-float4
int-int4
bool-bool4
Input value
Output pins
Valuefloat-float4
int-int4
bool-bool4
Result
+ all common properties

 

MathFunction2

This node represents all supported math functions that take two input values.

All “Fast” versions are faster to compute, but give a lower precision result.

 

PropertyTypeDescription
FunctionenumMath function to apply.

  • Rand: Random function: Returns a random value uniformly distributed in the range [Value, ValueB[
  • Min: Minimum function: Returns the smallest of the input values. When given vectors, the per-component min is returned in a vector of identical dimensions. Accepts between 2 and 32 inputs.
  • Max: Maximum function: Returns the largest of the input values. When given vectors, the per-component max is returned in a vector of identical dimensions. Accepts between 2 and 32 inputs.
  • Dot: Vector dot-product.
  • Cross: 3D vector cross-product.
  • Step: Step function
  • Discretize: Discretize function
  • Reflect: Reflect function: Reflects (mirrors) the vector Value on the plane defined by the normal ValueB
  • Pow / FastPow: Power (exponentiation) function
    {[0, +∞], [-∞, +∞]} ⟶ [-∞, +∞]
  • ArcTan2 / FastArcTan2: atan2 function: Signed arc-tangent: like atan(), but uses the sign of y to determine which quadrant the angle lies on.
    ]-∞, +∞[ ⟶ [-180, +180] | [-π, +π]
AngleUnitenumSpecifies how this function will interpret angles.
Only applies to trigonometric functions (ArcTan2)

  • Degrees: (default) Will use angles in degrees
  • Radians: Will use angles in radians
InputCountintSpecifies how many inputs the node has.
Min value: 2, Max value: 32
Only applies to the following operations: Min, Max, all other functions will always have 2 inputs
Input pins
Value
ValueB
float-float4
int-int4
bool-bool4
Input values
Output pins
Valuefloat-float4
int-int4
bool-bool4
Result
+ all common properties

 

MathFunction3

This node represents all supported math functions that take three input values.

 

PropertyTypeDescription
FunctionenumMath function to apply.

  • Lerp: Linear interpolation (lerp) function: Lineary blends between Value and ValueB based on the value of Cursor.
    Cursor is an interpolation factor in the [0, 1] range. when Cursor equals 0.0, Value is returned, when Cursor equals 1.0, ValueB is returned. values in between return values between Value and ValueB.
  • Clamp: Clamp function: Clamps the input Value in the range [Min, Max[
    [-∞, +∞] ⟶ [Min, Max]
  • Within: Within function: Returns 1.0 if Value is within the [ValueB, ValueC] range, returns 0.0 otherwise.
    [-∞, +∞] ⟶ [0.0, 1.0]
  • Select: Selection function: Similar to the If node: If Condition is zero (or false), outputs Value, otherwise, if it is non-zero (or true), outputs ValueIfTrue.
Input pins (Lerp)
Value
ValueB
Cursor
float-float4
int-int4
bool-bool4
Input values when Function is set to Lerp
Input pins (Clamp, Within)
Value
Min
Max
float-float4
int-int4
bool-bool4
Input values when Function is set to Clamp or Within
Input pins (Select)
Value
ValueIfTrue
Condition
float-float4
int-int4
bool-bool4
Input values when Function is set to Select
Output pins
Valuefloat-float4
int-int4
bool-bool4
Result
+ all common properties

 

MathWaveform

Samples a waveform

PropertyTypeDescription
FunctionenumMath function to apply.

  • Noise / FastNoise: Evaluates a coherent noise field. Node will always output a single scalar float value, even if the input is a vector. For example, passing a 4D vector samples a 4-dimensional noise field, but the field value is still a scalar.
  • Triangular: Triangular wave function. The return value will be a vector of the same dimension as the input.
  • Square: Square wave function. The return value will be a vector of the same dimension as the input.
  • Saw: Sawtooth wave function: Similar to frac. The return value will be a vector of the same dimension as the input.
Input pins
Valuefloat-float4Input cursor. Range: [-∞, +∞]
Output pins
Valuefloat-float4Result. Range: [-1, 1]
+ all common properties

 

PartialDerivative

The partial derivative node performs an analytical time-based derivative of the input graph if possible, otherwise using per-frame finite difference.
It also allows automatically and efficiently computing the frame-based derivative of the input value, outputting how much the input value has changed since the last frame.

 

PropertyTypeDescription
BaseenumIntegration base:

  • Frame: Frame-based derivative. Wiring in particle position will output the move vector since last frame.
  • Time: Analytical derivative if possible, otherwise falls back to TimeDiscretized. Wiring in the particle position will output the particle velocity.
  • TimeDiscretized: Finite-difference derivative. Wiring in the particle position will output the approximated particle velocity.
Input pins
Functionfloat-float4Value to derive across Base
Output pins
Derivativefloat-float4Derivative of the input Function across Base
+ all common properties

 

Passthrough

Passthrough nodes are helper nodes that do no operation, their only purpose is to redirect wires to tidy up graphs.
You can easily create passthrough nodes in the graph by placing the mouse cursor near a wire, holding Alt+Shift, moving the mouse where you want your passthrough to be, then pressing Left-mouse-button to place the passthrough node.

 

Reinterpret

The reinterpret node reinterprets the raw bits of the input value to the target type.
It is not a type conversion. To convert from float to int or similar, use the TypeCast node.
It performs the same operation as the following script functions:

  • int asint(float x);
  • float asfloat(int x);
  • int4 asint(orientation x);
  • float4 asfloat(orientation x);
  • orientation asorientation(float4 x);

For example, passing the integer 0x3FC00000 to the reinterpret node, and reinterpreting as float, will output the float 1.5
Likewise, passing the float 1.42 to the reinterpret node, and reinterpreting as int, will output the integer 0x3FB5C28F

 

PropertyTypeDescription
TargetTypeenumType to reinterpret into

  • float
  • int
  • orientation
Input pins
Valuefloat-float4
int-int4
orientation
Input value to reinterpret
Output pins
Valuefloat-float4
int-int4
orientation
Output reinterpreted value
+ all common properties

 

Script

The script node allows you to use custom scripts instead of nodes.
Not all operations can be done within scripts (such as pulsing events or querying/inserting into spatial layers), but this will eventually change.

You can expose any number of input and output pins to the script node, to manipulate them inside the script.

See the Scripting Reference page for more details.

 

SetLife

Sets the lifespan of the particle.
Usually takes a constant, or spawn value, but you can also use this node with an evolve value.
Note that if you want to kill a particle at evolve, it is better to use a kill node with a condition rather than using the condition to select between the regular lifespan and a lifespan of zero.

 

Input pinsTypeDescription
LifefloatLifespan of the particle.
Ex: a value of 5.0 will make the particle live for 5 seconds.
+ all common properties

 

Splitter

The splitter node allows you to explode a vector into its separate components. For example, split a 3D vector into distinct X, Y, and Z values.
See also the Constructor node.

 

PropertyTypeDescription
DimensionenumDimensions of the input vector

  • 2D: Split a 2-dimensional vector. Will expose output pins X and Y
  • 3D: Split a 3-dimensional vector. Will expose output pins X, Y and Z
  • 4D: Split a 4-dimensional vector. Will expose output pins X, Y, Z and W
ModeenumSemantic of the value to split, use this to make the effect axis-system independent. The S, U, F nomenclature refer to Side, Up, Forward.
Only applicable to 3D vectors.

  • XYZ: (default) The vector components will be treated as raw X, Y, Z values without any specific transform
  • SUF_RightHanded: X will be treated as the Side axis, Y as the Up axis, and Z as the Forward axis of a right-handed coordinate system.
  • SFU_RightHanded: X will be treated as the Side axis, Y as the Forward axis, and Z as the Up axis of a right-handed coordinate system.
  • SUF_LeftHanded: X will be treated as the Side axis, Y as the Up axis, and Z as the Forward axis of a left-handed coordinate system.
  • SFU_LeftHanded: X will be treated as the Side axis, Y as the Forward axis, and Z as the Up axis of a left-handed coordinate system.
Input pins
X
Y
Z
W
float
int
bool
Value of each separate X, Y, Z, W components. The number of pins available will depend on the Dimension property.
Output pins
Valuefloat2-float4
int2-int4
bool2-bool4
Final assembled vector
+ all common properties

 

StaticTest

The static test node tests for a compile-time property of the input value (is the input value spawn or evolve? is the input value evaluated more frequently than medium frequency ? etc…), and outputs a compile-time bool value.
Useful to make generic templates react differently based on what’s wired into their inputs.

 

PropertyTypeDescription
TestenumWhich test to perform on the input value properties

  • ExecStage: Test the exec stage property of the input value
  • ExecFrequency: Test the exec frequency property of the input value
CompareOpenumDetermines how to compare the selected property of the input value against TestExecStage or TestExecFrequency, based on the value of Test

  • Equal: returns true if the input’s property is equal to the static test value
  • NotEqual: returns true if the input’s property is not equal to the static test value
  • LowerOrEqual: returns true if the input’s property is lower than or equal to the static test value
  • Lower: returns true if the input’s property> is lower than the static test value
  • GreaterOrEqual: returns true if the input’s property is greater than or equal to the static test value
  • Greater: returns true if the input’s property is greater than the static test value

The ordered compare operators (lower/greater) are only available when Test is set to ExecFrequency.

TestExecStageenumExecution stage to compare against. If the input value’s exec stage is equal to the stage specified, the node returns true

  • Spawn
  • Evolve
TestExecFrequencyenumExecution frequency to compare against. If the input value satisfies the comparison defined in ‘ExecFrequencyCmp’, the node returns true

Input pins
Valuefloat-float4
int-int4
bool-bool4
orientation
Input value whose property should be tested
Output pins
ValueboolTest result
+ all common properties

 

StaticTypeSwitch

Similar to an If node. Checks the type of an input test value against a specified type, and uses the result to select two input values at compile time. Only the selected value will be evaluated, the test value, and the other non-selected value will never be evaluated at runtime, and will be removed from the compiled graph.

 

PropertyTypeDescription
TypeEqualToenumWhich test to perform on the input value properties

  • ExecStage: Test the exec stage property of the input value
  • ExecFrequency: Test the exec frequency property of the input value
Input pins
Valuefloat-float4
int-int4
bool-bool4
orientation
Value that will be output by the node if the type test fails
ValueBfloat-float4
int-int4
bool-bool4
orientation
Value that will be output by the node if the type test succeeds
TestTypefloat-float4
int-int4
bool-bool4
orientation
If the type of this value matches the TypeEqualTo property, the node will output ValueB, if it does not match, it will output Value
Output pins
ValueboolSelected value, equal to Value if the types do not match, and equal to ValueB if the types match.
+ all common properties

 

StaticVersionSwitch

Checks for the build versions active in the current bake/compile, and selects between two input values at compile-time based on if one of the specified versions is active in the current build.
Allows for example to conditionally turn on or off certain parts of the simulation graph based on the platform.
Similar to the If node.

 

PropertyTypeDescription
VersionsArray<String>If any of the versions in the list is active for the current compile, outputs Value, otherwise outputs ValueIfFalse
Valuefloat-float4
int-int4
bool-bool4
orientation
Value to output when any item of the Versions list is found in the current compile tags
ValueIfFalsefloat-float4
int-int4
bool-bool4
orientation
Value to output when no items of the Versions array are found in the current compile tags
Output pins
Valuefloat-float4
int-int4
bool-bool4
orientation
Output value.
Equal to Value when no items of the Versions array are found in the current compile tags.
Equal to ValueIfFalse when any item of the Versions list is found in the current compile tags.
+ all common properties

 

Template

The template node is rarely created and manipulated directly, most of the time it will be automatically created and setup by the editor for you.
This node instantiates a template (sub-graph), inside the current graph.

 

PropertyTypeDescription
AutoEntrypointboolIf enabled, editor will open this template automatically when opening the current graph.
Allows to do quick jumps when opening intermediate-level templates to skip boilerplate template indirections.
SubGraphFilePathStringPath to the effect containing the template. (empty means local template in this effect file)
SubGraphNameStringName of the template in the SubGraphFilePath file
PreferredSimLocationenumHints the runtime as to where it should try running the simulation for any child layers this template contains.
IMPORTANT: Only applicable to layergraph, ignored in datagraphs.

  • Auto: Will not enforce anything and will use the current platform’s defaults (CPU).
  • CPU: Will force the sim to run on the CPU.
  • GPU: Will try, if possible, to run the sim on the GPU.
DeterminismenumHints the runtime as to how random values should behave.

  • Auto: Will use the layer/project configuration.
  • Disabled: Will force all random values to be non-deterministic (but more efficient, and higher quality).
  • Enabled: Will force all random values to be deterministic.
  • Enabled Fixed: Will force all random values to be deterministic. The seed-modifier does not depend on the parent seed-modifiers.
RandomSeedModifierintModifies a seed of the random generator.
On deterministic templates that receive event from the same parent, the same seed will lead to identical random values.
Min: 0
+ all common properties

 

TemplateExport

The TemplateExport node allows you to expose custom input or output pins from a template (sub-graph), and specify how they should behave & be displayed in the editor.

PropertyTypeDescription
ExportedNameStringName of the exported value
ExportedTypeenumType of the exported value

  • auto
  • float1
  • float2
  • float3
  • float4
  • int1
  • int2
  • int3
  • int4
  • bool1
  • bool2
  • bool3
  • bool4
  • orientation
  • dataCurve
  • dataGeometry
  • dataImage
  • dataImageAtlas
  • dataAudio
  • dataVectorField
  • dataText
  • dataAnimPath
  • dataEventStream
  • spatialLayer
  • spatialPayload
  • event
ExportedTypeMaskmultiselect enumType-mask of the exported value, when ExportedType is set to auto

  • float1
  • float2
  • float3
  • float4
  • int1
  • int2
  • int3
  • int4
  • bool1
  • bool2
  • bool3
  • bool4
  • orientation
  • dataCurve
  • dataGeometry
  • dataImage
  • dataImageAtlas
  • dataAudio
  • dataVectorField
  • dataText
  • dataAnimPath
  • dataEventStream
SemanticenumSpecifies the semantic of the exported value

  • None: No special semantic
  • 3D_Coordinate: Will be treated as a 3D-space coordinate, and be affected by axis-system conversions, including axis-flips. Works for float3 or int3 types
  • 3D_Scale: Will be treated as 3D-space scaling factors, and be affected by axis-system conversions, except axis-flips. Works for float3 or int3 types
  • Color: Will be treated as a color. Works for float3 or float4 types
  • Angle: Will be treated as an angle.
  • Visibility: Special visibility semantic, only used in the material editor when specifying render features.
TypeenumSpecifies whether this is exported as an input or output pin

  • Input: Will expose an input pin in the parent graph
  • Output: Will expose an output pin in the parent graph
InputTypeenum(input nodes only)
Specifies whether this is exported as a pin, property, attribute, or a combination of those

  • Property: Exposes the value as a static property of the parent node. No dynamic values can be wired in.
  • Link: Exposes the value as a pin of the parent node. It can also be edited inline in the parent node’s propertygrid.
  • Attribute: Exposes the value as an attribute, in the effect interface.
  • LinkAndAttribute: Exposes the value as an attribute, and a pin in the parent node. If something is wired in the parent graph, it will override the attribute entirely, and the attribute will not be visible (unless another node exposes the same attribute).
OrderintExplicit order property used by the editor to sort the various properties & pins in the parent node.
When nodes have identical Order values, the editor will use their vertical position in the graph to compute the final order
VisibleByDefaultboolWhen disabled, the pin will not be visible by default when instantiating this graph, the user will have to explicitly expand the node to see it.
Useful to avoid cluttering graphs with pins which are useful in some rare cases, but unneeded in the majority of other scenarios.
TransformSpaceenum(optional)
Specifies whether this 3D coord should be treated explicitly as a local or worldspace coordinate

  • Auto: Undetermined, let the graph compiler deduce this if possible.
  • World: This is a worldspace quantity.
  • Local: This is a localspace quantity.
TransformModeenum(optional)
Specifies whether this 3D coord should be treated as a position (full transforms) or direction (rotate-only)

  • Auto: Undetermined, let the graph compiler deduce this if possible.
  • Position: This is a 3D position.
  • Direction: This is a 3D direction.
CategoryNameStringName of the category this value should belong to, in the parent node’s propertygrid.
DropDownModeenumControls if the property will be displayed as a drop-down containing a list of values, with either single-selection or multi-selection allowed

  • None: (default) Not a dropdown.
  • SingleSelect: Single-selection dropdown.
  • MultiSelect: Multi-selection dropdown.

When using single-selection dropdowns, the output will be the 0-based index of the selected item in EnumList
When using multi-selection dropdowns, the output value will be a 32-bits bitmask, with 1 bit per entry in EnumList

HasMinboolIf enabled, tells the UI it should not allow the value of the property to go below a minimum value
HasMaxboolIf enabled, tells the UI it should not allow the value of the property to go above a maximum value
UseSliderboolIf enabled, the property will be displayed with a slider whose min and max ranges will be the min and max values
EnumListArray<String>Values to be displayed in the drop-down when DropDownMode is set to something else than None
PassthroughInputString(output nodes only)
Name of the input pin this output should route through when the parent node is deactivated / toggled off.
By default, input and output pins of the same name will be passed-through.
Use this property when you want to passthrough between pins which are not named the same
DefaultValue*float-float4
int-int4
bool-bool4
orientation
data
Default value this pin/property should have when the user initially creates the parent node
MinValue*float-float4
int-int4
bool-bool4
Minimum allowed value. Only used for UI purposes if HasMin is disabled.
MaxValue*float-float4
int-int4
bool-bool4
Maximum allowed value. Only used for UI purposes if HasMax is disabled.
PinRulesenumSpecifies if and how the UI should apply pin visibility rules

  • None: (default) No pin rules.
  • Rule1: Single rule.
  • Rule1_AND_Rule2: Two rules, both conditions are combined with a logican AND.
  • Rule1_OR_Rule2: Two rules, both conditions are combined with a logican OR.
BaseVisibilityenumBase visibility. Used when the visibility rule evaluates to false

  • Visible: (default) The property/pin is visible.
  • Disabled: The property is grayed out and non-editable, but still visible, the pin is hidden.
  • Hidden: The property/pin is hidden.
RuleResultenumVisibility result when the visibility rule evaluates evaluates to true

  • Visible: (default) The property/pin is visible.
  • Disabled: The property is grayed out and non-editable, but still visible, the pin is hidden.
  • Hidden: The property/pin is hidden.
DependentPropertyStringRule1: Name of the exported property to look at to determine the first visibility function
RuleFunctionenumRule1: Operation to apply between the value of DependentProperty and RuleValue

  • Equal
  • NotEqual
  • Lower
  • LowerEqual
  • Greater
  • GreaterEqual
  • Visible
  • Disabled
  • Hidden
RuleValueStringRule1: Value to compare agains the value of DependentProperty, using the operation defined in RuleFunction.
Usually a numeric value.
DependentProperty2StringRule2: Name of the exported property to look at to determine the second visibility function
RuleFunction2enumRule2: Operation to apply between the value of DependentProperty2 and RuleValue2

  • Equal
  • NotEqual
  • Lower
  • LowerEqual
  • Greater
  • GreaterEqual
  • Visible
  • Disabled
  • Hidden
RuleValue2StringRule2: Value to compare agains the value of DependentProperty2, using the operation defined in RuleFunction2.
Usually a numeric value.
Input pins
DefaultValueanyDefault value (input export only, optional)
ValueanyValue to output in the parent graph (output export only)
Output pins
ValueanyValue wired-in the parent graph (input export only)
+ all common properties

 

Transform

The transform node transforms an input 3D coordinate from a source space to a target space. For example, can be used to transform a float3 from localspace to worldspace, or vice-versa.

Note: Usually, you should use the helper templates found in the core template library instead of the raw transform node:

  • local position to world
  • local direction to world
  • world position to local
  • world direction to local
  • localspace

 

PropertyTypeDescription
InputSpaceenumCoordinate-space to convert from:

  • World: Convert from worldspace
  • WorldPrev: Convert from worldspace using the previous world to local matrix
  • Local_Emitter: Convert from localspace
  • LocalPrev_Emitter: Convert from localspace using the previous local to world matrix
OutputSpaceenumCoordinate-space to convert to:

  • World: Convert to worldspace
  • WorldPrev: Convert to worldspace using the previous local to world matrix
  • Local_Emitter: Convert to localspace
  • LocalPrev_Emitter: Convert to localspace using the previous world to local matrix
TransformModeenumWhether or not to translate / rotate the input vector.

  • Full: Apply both translations and rotations
  • Rotate: Apply rotations only
  • Translate: Apply translations only
ApplyScaleboolIf enabled, the transform will take into account the in-engine emitter scale & mirorring
Input pins
Valuefloat33D vector in InputSpace coordinates
Output pins
Valuefloat3converted 3D vector in OutputSpace coordinates
+ all common properties

 

TransformOrientation

The transform orientation node transforms an input orientation from a source space to a target space. Like the Transform node, but for type orientation.

 

PropertyTypeDescription
InputSpaceenumCoordinate-space to convert from:

  • World: Convert from worldspace
  • WorldPrev: Convert from worldspace using the previous world to local matrix
  • Local_Emitter: Convert from localspace
  • LocalPrev_Emitter: Convert from localspace using the previous local to world matrix
OutputSpaceenumCoordinate-space to convert to:

  • World: Convert to worldspace
  • WorldPrev: Convert to worldspace using the previous local to world matrix
  • Local_Emitter: Convert to localspace
  • LocalPrev_Emitter: Convert to localspace using the previous world to local matrix
Input pins
ValueorientationOrientation in InputSpace coordinates
Output pins
Valueorientationconverted orientation in OutputSpace coordinates
+ all common properties

 

TypeCast

This node converts a value to a different type. For example, from float to int.

 

PropertyTypeDescription
TargetTypeenumType to convert into

  • float
  • int
Input pins
Valuefloat-float4
int-int4
Input value to convert
Output pins
Valuefloat-float4
int-int4
Output converted value
+ all common properties

 

Articles

Was this article helpful to you? Yes No

How can we help?