1. Home
    2. /
  2. Editor
    3. /
  3. Emitter Scheme
    4. /
  4. Blocks Reference

Blocks Reference

Table of Contents

    Particle Properties

    AttachedEmitter

    Particle’s property. Attaches another emitter from the same effect to each particle of the current emitter. You can’t attach emitter to itself and you can’t attach reflection of current emitter.

    If attached emitter has Emitter Properties, all of them will be represented by connector at AttachedEmitter block with corresponding label.

    Properties & inputs:

    • Connected emitter (prop): emitter to attach.
    • On terminate (prop): Activates attached emitter only when particle is terminated. In this case it is better to have generator with limited number of shots in attached emitter. Particle considered as completely terminated when all attached emitters don’t have any particles. If attached emitter has infinite number of shots – the parent particle will never be terminated (it can be intended though).
    • Draw order (prop): Specifies when to draw particles of attached emitter.

    CustomProperty[2 | 3 | R]

    Particle’s properties. These blocks store a custom value for a particle. Possible value types are: 1D, 2D, 3D value and Rotation (see block name suffix).

    Properties & inputs:

    • Name (property): Label on the block. The label has no any influence on effect. Only decoration.
    • Shared burst (property): If generator shoots bursts of particles, all particles in a burst will have the same initial value for the block.
    • Init value (input | property): The value to initialize this particle property block when a particle is created..

    Output:

    • Stored value.

    CustomPropertyUpdater

    The block is linked to one of Particle’s property blocks and updates it every frame.

    The block initiates calculation of connected chain of blocks every frame update. Result of calculations is stored in linked Particle’s property block.

    You can identify linked blocks by color label on them.

    LifeTime

    Particle’s property. Stores life time of a particle in seconds.

    The block has no properties.

    Output:

    • Life time of a particle in seconds.

    Position

    Particle’s property. The block works in the same way as CustomProperty3 does, but when particle is created it will add emitter position to Init value of the block.

    If emitter is Standalone, it’s position is the same as the effect has. If emitter is attached to a particle, it’s position is the same as the particle has.

    Properties & inputs (in addition to CustomProperty3):

    • Apply emitter’s rotation (property): Initial position will be rotated accordingly to the emitter’s rotation.

    Output:

    • Current stored position.

    Velocity

    Particle’s property. The block works in the same way as CustomProperty3 does, but when particle is created emitter’s velocity will be added to the Init value.

    Properties & inputs (in addition to CustomProperty3):

    • Apply emitter’s rotation (property): Initial value of the block is considered as a vector and additionally rotated accordingly to emitter’s rotation.
    • Add emitter’s velocity (property): Velocity of the emitter is added to inital value of the block.

    Output:

    • Current stored velocity.

    Functions

    AngleFromVec2

    Function. Calculates rotation angle of 2D vector in degrees.

    Properties & inputs:

    • Vector (input | property): input vector.

    Output:

    • Rotation angle of input vector.

    Area2

    Function. Outputs point on a painted area.

    Valid input range is [0; 1]. The block outputs stable values, so for the same input value every time it has the same output. 

    To have random point on the painted area, connect input to a Random block [0;1).

    Properties & inputs:

    • Optimized pix. size (prop): The painted area will be downsampled to this pixel size. Checkboard in Preview window has cells of this size.

    Outputs:

    • (square): Square of the painted area in units. One unit corresponds to square of rectangle 100×100.
    • position: Position inside the area for the given input.

    AxesFromRot

    Function. Converts rotation to it’s coordinate system axes in space.

    Curves(1|2|3)

    Function. The block represents function graph and provide conversion of input value to the point on the graph.

    Depending on number of graphs output value can be 1D, 2D or 3D value. Each graph provides a value for one of components of output value. Red for X component, Green for Y and Blue for Z.

    Input value is applied to X axis (horizontal) and output is taken as Y value from graphs at that point.

    Properties & inputs:

    • Output type (property): Changes number of graph for the block. And type of the output value as well.
    • X(R), Y(G), Z(B) (property): These properties represent graphs. You can edit the graphs in Graph Editor. 

    Output:

    • Value on graphs in input point.

    Direction(2 | 3)

    Function. Outputs direction vector from one point to another with specified length. Basically, it is normalize(to – from) * length.

    Properties & inputs:

    • From (input | property): “from” point.
    • To (input | property): “to” point.
    • Length (input | property): result vector length.

    Output:

    • Direction with specified length.

    Expression

    This block works as extended calculator and can calculate mathematical expression. It has one or more inputs with specified names (by default a,b,c…) and supports arithmetic operations with braces and a set of simple functions.

    There are four predefined Expression blocks in Blocks Palette as shown on the picture above. These predefined blocks are only for convenience as mostly used operations. Yor can change expression and inputs configuration of any expression block.

    You can change number of inputs with “Inputs number” property and change type and name of the input with it’s “Name” and “Type” properties.

    Along with functions described below, you can use pre-defined variable dt which can be used in update chains of blocks and equals time spent from previous frame in seconds. In other chains (initialization or generation) dt equals to zero.

    Supported functions:

    • vec2(x, y) – creates 2D value (vector).
    • vec3(x, y, z) – creates 3D value (vector).
    • abs(a) – returns absolute value of ‘a’.
    • cross(a, b) – returns cross-product of two 3D vectors.
    • dot(a, b) – returns dot-product of two 2D or 3D vectors.
    • norm(a) – returns normalized 2D or 3D vector ‘a’.
    • length(a) – returns length of 2D or 3D vector ‘a’.
    • length2(a) – returns squared length of 2D or 3D vector ‘a’.
    • round(a) – returns rounded 1D value ‘a’.
    • floor(a) – returns closest integer value less or equal to 1D value ‘a’.
    • ceil(a) – returns closes integer value greater of equal to 1D value ‘a’.
    • sign(a) – returns -1 if ‘a’ is less than 0, 0 if ‘a’ is equal to zero and 1 if ‘a’ is greater than 0. 
    • lerp(a, b, i) – returns linear interpolated value between ‘a’ and ‘b’ accordingly to interpolation factor ‘i’. ‘a’ and ‘b’ can be 1D, 2D or 3D vectors. ‘i’ is 1D value in range [0;1].
    • x(a), y(a), z(a) – return component of vector ‘a’.
    • xy(a), yx(a), xz(a), zx(a), yz(a), zy(a) – return 2D vector which consists of components of vector ‘a’ in order specified by function name.
    • xzy(a), yxz(a), yzx(a), zyx(a), zxy(a) – return 3D vector which consists of components of 3D vector ‘a’ in order specified by function name.

    Examples of expressions:

    • a + b * c – 1.1
    • (a + b) * (c – 1.1)
    • -a
    • a / length(a) * 0.1
    • vec3(a, b * 2, -1) * 100
    • length(xy(a))

    Properties & inputs:

    • Inputs number (property): number of inputs.
    • Expression (property): expression to calculate.
    • Name (property): name of the input.
    • Type (property): type of the input (Float, Vector2, Vector3)

    Output:

    • Result of expression. The type of the output depends on result of expression.

    ForceMove(2|3)

    Function. Takes position and speed of an object (particle) and changes them accordingly to forces, winds and air resistence specified. Basically it’s physics simulating block.

    The block uses dt (time spent from previous frame) to simulate changing of position and velocity of the object. You can specify a set of forces and winds those make influence to the object.

    Usually you pass particle’s position and velocity properties to the block and pass resulting position and velocity to the updaters of these properties.

    Properties & inputs:

    • position (input): Input position to change.
    • velocity (input): Input velocity to change.
    • Air resistance (input | property): Air resistance. Good values are in range [0; 5]
    • Num. forces (prop): Number of influence forces.
    • force #… (in|prop): A force vector. Length and direction of this vector defines changing speed per second.
    • Num. winds (prop): Number of influence winds.
    • wind #… (in|prop): A wind vector. Wind is taken into account only if Air resistance is non-zero. It adds additional wind force accordingly to the speed of the object and Air resistance.

    Outputs:

    • position: New position.
    • velocity: New velocity.

    InvTransform2

    Function. Applies inverted affine transformation to a point.

    The transformation is represented by translation, rotation and scale. First inverted translation is applied, then inverted rotation and then inverted scale.

    Properties & inputs:

    • Translation (property): Translation (not inverted).
    • Rotation (property): Rotation in degrees (not inverted).
    • Scale (property): Scale (not inverted).

    Output:

    • Transformed point.

    Lerp[2|3]

    Function. Outputs linear interpolation (linear smooth change) between two values. Basically it is A + (B – A) * Interp.

    ‘Interp’ should change in range from 0 to 1. If it is 0, the result is A. If it is 1, the result is B. In the middle, A will be smoothly interpolated into B.

    Properties & inputs:

    • A, B (input | property): values to interpolate.
    • Interp. (input | property): interpolation factor. Should be in range [0;1]

    Output:

    • Interpolated value.

    Move[2|3]

    Function. Changes input value with specified speed.

    Uses time spent from previous frame and changes input value accordingly to Speed property. Basically makes: input + speed * dt.

    Properties & inputs:

    • Speed (per sec.) : Speed of changing the input value per second.

    Output:

    • Changed (moved) input value.

    Noise3

    Function. Calculates 3D turbulence vector in certain position of the space.

    There is a pre-defined turbulence (noise) texture which is placed in the space. Smoothness defines size of this texture (length of cube edge). For the input position in the space a value from the texture is taken and scaled accordingly to Scale, Low and High limits.

    Best use case of the block is to generate force in the space for ForceMove3 block in certain particle’s position.

    Properties & inputs:

    • Additive (property):If additive, the result will be position + noise, otherwise only noise.
    • Type (property):Type of interpolation for the noise. Linear will produce less smooth noise texture, but with much less calculations.
    • Smoothness (input | property):Size of noise texture in the space. Making it bigger will lead to more smooth changes of the noise when moving over the space.
    • Animation speed (property): Velocity vector for noise texture in the space.
    • Scale (input | property):Scale of resulting vector.
    • Low, High (property): Low and high limits for the noise texture. By default {-1; -1; -1} and {1; 1; 1}.

    Output:

    • Turbulence in the point of space. Or Position + Turbulence in the point of space if Additive is true.

    Path2

    Function. Outputs a point on a user defined path. Valid range for input is [0; 1], where 0 corresponds to start of the path and 1 – to the end.

    When the block is selected, you can edit the path in Preview window.

    Properties & inputs:

    • Bezier subdiv. (prop): Bezier segments will be split in this number of linear segments each.

    Outputs:

    • (length): length of the path.
    • position: 2D position on the path for the given input value.
    • direction: 2D direction of the path for the given input value.

    Random

    Function. Outputs random value in specified range. The result value will be greater or equal to Start and less than End. It will never equal to End.

    Properties & inputs:

    • Start (input | property): start of random range. The result is greater or equal to Start.
    • End (input | property): end of random range. The result is less than End.

    Output:

    • Random value in specified range.

    RandomVec(2|3)

    Function. Outputs random 2D or 3D vector with specified length.

    Properties & inputs:

    • Radius (input | property): length of the vector.

    Output:

    • Random vector with specified length.

    RotAroundAxis

    Function. Outputs rotation about axis vector for specified angle.

    Properties & inputs:

    • Axis (input | property): vector to rotate about.
    • Angle (input | property): rotation angle in degrees.

    Output:

    • Rotation about specified axis.

    RotFromAxes

    Function. Outputs rotation calculated from two axes of it’s coordinate system in space.

    There are two axes you need to provide to calculate result rotation: ‘fixed’ and ‘desired’. ‘Type’ property specifies these two axes (fixed + desired). Result rotation will describe coordinate system, which has ‘fixed’ axis the same as specified and ‘desired’ axis as close to specified as possible.

    Properties & inputs:

    • Type (property): “fixed” + “desired” axes selection.
    • X, Y, Z (input | property): axes.

    Output:

    • Rotation calculated from two axes.

    SplitVec(2|3)

    Function. Splits 2D or 3D value (vector) to X, Y, Z components.

    Transform2

    Function. Applies affine transformation to a point.

    The transformation is represented by translation, rotation and scale. First scale is applied, then rotation and then translation.

    Properties & inputs:

    • Translation (property): Translation of the point.
    • Rotation (property): Rotation in degrees.
    • Scale (property): Scale

    Output:

    • Transformed point.

    Transform3

    Function. Applies a chain of transformations on 3D coordinate system represented by 3D position (Start position) and 3D rotation (Start rotation).

    All operations applied one by one, and can be either Shift or Rotation. Shift operation performs shift in local coordinates (inside currently transformed coordinate system) as well as Rotation performs rotation about local axis (vector).

    On the output of the block you have 3D position (position) and 3D rotation (rotation) which represent result coordinate system.

    In you want to transform only position, you can pass identity rotation (zero angle) and take only position output of the block.

    Properties & inputs:

    • Start position (input | property): Position before transformations.
    • Start rotation (input | property): Rotation before transformations.
    • Num. operations (property): Number of operations in chain to perform.
    • Operation# (property): Type of the operation (Shift or Rotation).
    • Shift (input | property): Shift applied on the step.
    • Rotation (input | property): Rotation applied on the step.

    Output:

    • position: Position of transformed coordinate system.
    • rotation: Rotation of transformed coordinate system.

    Value[2 | 3]

    Function. Outputs 1D, 2D or 3D value specified in the block properties.

    Each component of the value can be represented by input at the block.

    Properties & inputs:

    • X, Y, Z (input | property): components of output value

    Output:

    • A value assembled from provided components.

    Vec2FromAngle

    Function. Calculates 2D vector by angle and length.

    Properties & inputs:

    • Angle (input | property): rotation angle in degrees.
    • Length (input | propperty): length of the vector.

    Output:

    • Resulting vector.

    Vec3 (2+1)

    Function. Converts 2D value (vector) to 3D by adding Z coordinate.

    Properties & inputs:

    • Z (input | property): Z coordinate.

    Output:

    • 3D value, which is 2D value + Z.

    Emitter Properties

    CustomProperty[2|3|R]

    Emitter’s property. These blocks add custom properties to the emitter. These properties can be used to pass parameters to emitter instances.

    You can pass parameters to attached emitters from parent particle (like color, size or any other value). In this case you will have additional inputs for each emitter’s property on AttachedEmitter block of parent emitter.

    You can also pass parameters to standalone emitters programmatically from your target application. To make that, please refer to programming guide of framework extension library you use.

    Properies & inputs:

    • Name (property): User chosen name of the property.
    • Default value (prop): Default value of the property.

    EmitterPosition

    Emitter’s property. Outputs emitter’s position.

    For standalone emitters – position of the effect.

    For attached emitters – position of parent particle.

    Output:

    • Position of the emitter.

    EmitterRotation

    Emitter’s property. Outputs emitter’s rotation.

    For standalone emitters – rotation of the effect.

    For attached emitters – identity rotation.

    Output:

    • Rotation of the emitter.

    EmitterTime

    Emitter’s property. Outputs time in seconds after emitter started.

    For standalone emitters it will be time since effect started.

    For attached emitters – time after emitter activated on a particle.

    Output:

    • Time in seconds since emitter started.

    EmitterVelocity3

    Emitter’s property. Outputs velocity vector of the emitter.

    The value corresponds to a displace of the emitter per second.

    Outputs:

    • Emitter’s velocity vector.

    ParticlesNumber

    Emitter’s properties. Outputs current number of particles in the instance of emitter.

    The result shows amount of particles in current instance of emitter only.

    Outputs:

    • Number of particles in the instance of emitter.

    SystemTime

    Emitter’s property. Outputs time in seconds since the effect started.

    Generators

    GeneratorDistance

    Generator. Generating particles depending on distance passed by the emitter’s instance.

    Properties & inputs:

    • Distance (property): New shot is made when emitter passes this distance.
    • Start phase (property): Start phase is defined in range from 0 to 1. It assumes that Distance above is 1 and defines how much of that distance the emitter already run before first shot. Thus if the value is 1, the first shot will go immidiately. If the value is 0, the emitter need to pass a distance according to Distance property.
    • Burst (property): Amount of particles generated by one shot.

    Outputs:

    Burst size: Amount of particles in current burst. This output is valid only on initialization of particle’s properties.

    Burst pos.: Defined in range [0;1]. Shows position of current particle in a burst. 0 means first particle, 1 – the last one. This output is valid only on initialization of particle’s properties.

    GeneratorPeriodic

    Generator. Periodically generates particles.

    Generator shoots particles with specified Generating rate (per second).

    You can make fixed number of shots or generate fixed amount of time with Fixed time and Fixed shots properties.

    Properties & inputs:

    • Generating rate (input | property):Number of shots made per second.
    • Fixed time (property):If enabled, you can specify shooting time limit.The generator is enabled since emitter started till the time limit. Then generating is stopped.
    • Fixed shots (property):If enabled, you can specify shots limit. The generator is enabled since emitter started until it made specified amount of shots.  Then generating is stopped.
    • Start phase (property): Start phase is defined in range from 0 to 1. It assumes that time between shots is 1 and defines delay before first shot. Thus if the value is 1, the first shot will go immidiately. If the value is 0, the generator will wait the period of time based on ‘Generating rate’ property.
    • Burst (property): Amount of particles generated by one shot.

    Outputs:

    Burst size: Amount of particles in current burst. This output is valid only on initialization of particle’s properties.

    Burst pos.: Defined in range [0;1]. Shows position of current particle in a burst. 0 means first particle, 1 – the last one. This output is valid only on initialization of particle’s properties.

    Terminators

    TerminatorCondit

    Terminator. Compares two inputs and if Less. value is bigger than Great. value, the particle is terminated.

    Properties & inputs:

    • Less. value (input | property): Lesser value.
    • Great. value (input | property): Greater value.

    TerminatorPath

    Terminator. Terminates particle if it crosses a user defined path.

    Constructors

    ConstructorQuads

    Constructor. Generates quad geometry for a particle.

    Properties & inputs:

    • Generate geometry (property): Whether generate geometry for particles or not. If you don’t wan’t to see particles of this emitter, set it to false. Usually, geometry generation is turned off for particles with attached emitters.
    • Blend mode (property): Defines blending mode for particles of the emitter. Normal – particles are blended as normal texture with alpha. Add – particles’ color is added to the color of background. Multiply – particles’ color is multiplied by the color of background.
    • Texture (property): Defines path to textures for particles.
    • Position (input | property): 3-dimensional position of currently processed particle.
    • Origin (input | property): Displacement of particle’s geometry relatively to particle’s position. Defined in normalized coordinates, where {1;1} is equal to {width;height} of the particle.{0;0} produces quad with particle’s position at the center. {0.5;0.5} – particle’s position at top right corner. {-0.5;-0.5} – particle’s position at bottom left corner.
    • Rotation type (property): Faced rotation produces geometry always rotated to the camera. Free rotation allows to define rotation in 3D space independently to the camera.
    • Angle (input | property): Rotation angle in degrees.
    • Size type (property): Quad size type produces particles with the same width and height. Rect size type allows to specify width and height of particles independently.
    • Color (input | property): Defines color of particles. The color will be multiplied to the color of texture and blended with the scene accordingly to Blend Mode. Each component of color defined in range [0;1].
    • Alpha (input | property): Defines transparency of particles. Defined in range [0;1]. 0 – means fully transparent.
    • Texture mapping (property): Defines how particle geometry will be mapped with texture. Whole texture will map whole texture to a particle. Grid will define a grid from texture with cells of equal size. Then a frame with specific index can be chosen for the particle.
    • Columns (property): Number of columns in the texture grid.
    • Rows (property): Number of rows in the texture grid.
    • tex.index (input): index of texture cell in the grid to map to the particle geometry. Lies in range [0; Columns * Rows]. Cells are taken from the first row first, then second and so on.

    Other blocks

    Positioner

    Every frame this block determines current particle’s position.

    If a chain of blocks is connected to the block, it initiates calculation of the chain every frame. The result will be used as particle’s position.