Editor: Reference Manual


Blocks

Particle’s properties

LifeTime

editor-ref-block-lifetime

Stores life time of a particle in seconds. Outputs the stored value.

The block has no properties.

CustomProperty[2 | 3 | R]

editor-ref-block-custom-property editor-ref-block-custom-property2 editor-ref-block-custom-property3 editor-ref-block-custom-propertyR

These blocks allow to store arbitrary value of any of supported types (1-, 2-, 3-dimensional value or Rotation).

Properties & inputs:

  • Name (prop):  label on the block. It doesn’t affect anything. Only for convenience.
  • Shared salvo (prop): if true, then withing a burst, “Init value” will be computed only once and shared between all particles in the burst.
  • Init value (in|prop): value to be stored in the CustomProperty when particle is created. Note, that this value will be requested only once for each particle – when it is created.

 Position

editor-ref-block-position

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 particle.

If emitter is standalone, then it’s position will be the same as particle system has.

If emitter is attached to a particle, then it’s position will be position of the particle.

 AttachedEmitter

editor-ref-block-attached-emitter

Allows to attach emitter from the same particle system to each particle of current emitter. Note, that attached emitter can’t be current emitter or related to current emitter by reflection.

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

Properties & inputs:

  • Connected emitter (prop): emitter to attach.
  • On terminate (prop): if true, activates attached emitter only when particle is terminated. In this case generator in attached emitter should has finite shoots or time. Particle considered as completely terminated when all attached emitters finished their shooting. If attached emitter has infinite working time – the particle will never terminated (though it will be invisible).
  • Draw order (prop): specifies when to draw particles in attached emitter.

Functions

Value[2 | 3]

editor-ref-block-values

Outputs 1-, 2- or 3-dimensional value specified in the block properties.

Note, that each component of the value can be represented by input of the block.

Properties & inputs:

  • X, Y, Z (in|prop): components of output value

 Direction(2 | 3)

editor-ref-block-direction2 editor-ref-block-direction3

Outputs direction vector from one point to another with specified length.

Note, that any of properties can be represented by inputs of the block.

Properties & inputs:

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

 RotAroundAxis

editor-ref-block-rotaroundaxis

Outputs rotation about axis vector.

Properties & inputs:

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

 RotFromAxes

editor-ref-block-rotfromaxes

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

There are two axes you need to provide to compute result rotation: “fixed” and “desired”. “Type” property specifies these two axes (fixed + desired). After conversion of result rotation back to coordinate system in space, “fixed” axis will remain unchanged, but “desired” axis is only hint for rotation and after such conversion will lie in a fixed-0-desired plane.

Properties & inputs:

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

 Expression

editor-ref-block-expression

This block works as extended calculator and can compute 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 blocks represent Expression in Blocks Palette as shown on the picture above.  It is done only for convenience and any block can be transformed to desired one.

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

Supported functions:

  • vec2(x, y) – creates 2-dimensional value (vector).
  • vec3(x, y, z) – creates 3-dimensional value (vector).
  • abs(a) – returns absolute value of “a”.
  • length(a) – returns length of 2- or 3-dimensional vector “a”.

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

Properties & inputs:

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

 Lerp[2|3]

editor-ref-block-lerp

Outputs linear interpolation (smooth change) between two values.

When “Interp.” property is zero, there is “A” value on the output, when  it one, there is “B” value on the output.

This block realizes simple mathematical expression: A + (B – A) * Interp.

Properties & inputs:

  • A, B (in|prop): values to interpolate between.
  • Interp. (in|prop): interpolation factor.

Random

editor-ref-block-random

Outputs random value in specified range.

Properties & inputs:

  • Start (in|prop): start of random range.
  • End (in|prop): end of random range.

RandomVec(2|3)

editor-ref-block-randomvec2 editor-ref-block-randomvec3

Outputs random 2- or 3-dimensional value (vector) with specified length.

Properties & inputs:

  • Radius (in|prop): length of the vector.

AxesFromRot

editor-ref-block-axesfromrot

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

Vec3 (2+1)

editor-ref-block-vec3-2plus1

Converts 2-dimensional value (vector) to 3-dimensional by adding Z coordinate.

Properties & inputs:

  • Z (in|prop): Z coordinate.

SplitVec(2|3)

editor-ref-block-splitvec

Splits 2- or 3-dimension value (vector) to X, Y, Z components.

Vec2FromAngle

editor-ref-block-vec2fromangle

Computes 2-dimensional vector by rotation angle and length.

Properties & inputs:

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

AngleFromVec2

editor-ref-block-anglefromvec2

Computes rotation angle of 2-dimensional vector in degrees.

Properties & inputs:

  • Vector (in|prop): input vector.

Curves(1|2|3)

editor-ref-block-curves

These blocks define dependency of output value on input value in user friendly graphical way. Input value corresponds X coordinate in graphical editor and output value corresponds Y coordinate on the graph in certain X input point. In case of Curves2 and Curves3, each component of 2- or 3-dimensional output value will be taken from corresponding graph.

Area2

editor-ref-block-area

Outputs point on hand drawn area. Input is defined in range [0; 1], so this block can be easily used with Random block. When input is the same the output position will be in the same pixel of area. By providing random value to the input of the block, you will have random position on the area.

Properties & inputs:

  • Optimized pix. size (prop): the area will be downscaled to this pixel size. Position inside pixels will be chosen randomly.

Outputs:

  • (square): square of the area in units. One unit corresponds to square of rectangle 100×100.
  • position: random position inside the area.

Path2

editor-ref-block-path

Outputs point on graphically defined path. Input is defined in range [0; 1], where 0 corresponds to start of the path and 1 – to the end.

Properties & inputs:

  • Bezier subdiv. (prop): number of subdivisions in every Bezier segment when it is converted to polyline.

Outputs:

  • (length): length of the path.
  • position: position on the path which corresponds to input value.
  • direction: direction of the path on corresponding to input value position.

Move[2|3]

editor-ref-block-move

Outputs changed 1-, 2- or 3-dimensional input value accordingly to specified speed and spent time from previous frame. This block is used in update chains to make time-dependent change of particles’ properties.

Properties & inputs:

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

ForceMove(2|3)

editor-ref-block-forcemove

Make physically correct change of position and speed (of the particle in most cases) dependently on specified forces, winds, air resistance and spent time from previous frame. This block is used in update chains to make time-dependent change of particles’ properties.

Properties & inputs:

  • position (in): input position to change.
  • velocity (in): input velocity to change.
  • Air resistance (in|prop): air resistance. Most usable values are in range [0.5; 5]
  • Num. forces (prop): number of influence forces.
  • force #… (in|prop): 2- or 3-dimensional value (vector) which specifies an influence force. Length and direction of this vector defines how speed might be changed per second.
  • Num. winds (prop): number of influence winds.
  • wind #… (in|prop): 2- or 3-dimensional value (vector) which defines an influence wind.

Outputs:

  • position: changed position.
  • velocity: changed velocity.

Transform2

editor-ref-block-transform2

Outputs 2-dimensional point transformed by affine transformation represented by position, rotation angle and scale.

Properties & inputs:

  • Position (prop): position.
  • Rotation (prop): rotation.
  • Scale (prop): scale.

InvTransform2

editor-ref-block-invtransform2

Outputs 2-dimenasional point transformed by inverted affine transformation represented by position, rotation angle and scale.

Properties & inputs:

  • Position (prop): position.
  • Rotation (prop): rotation.
  • Scale (prop): scale.

Transform3

editor-ref-block-transform3

Makes a chain of transformations on 3-dimensional 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).

At output you have 3d position (position) and 3d rotation (rotation) which represent result coordinate system.

Properties & inputs:

  • Start position (in|prop): position before transformations.
  • Start rotation (in|prop): rotation before transformations.
  • Num. operations (prop): number of operations in chain to perform.
  • Operation# (prop): type of operation (Shift or Rotation).
  • Shift (in|prop): 3-dimensional vector used for transform step.
  • Rotation (in|prop): rotation used for transform step.

Noise3

editor-ref-block-noise3

Computes 3-dimensional turbulence vector in certain position.

This block emulates turbulence in the space. Input position defines position in that virtual space.

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

Properties & inputs:

  • Additive (prop): if true, input position is added to result.
  • Type (prop): type of interpolation used. Although cubic interpolation gives smoother output change, it is very computationally expensive. It is strongly recommended to use Linear interpolation when it is possible.
  • Smoothness (in|prop): size of turbulence texture in the space. Higher values gives bigger size as well as smoother change for the same input change.
  • Scale (in|prop): scale applied to Low and High properties.
  • Low, High (prop): define range of generated turbulence vector.

Emitter’s Properties

EmitterTime

editor-ref-block-emittertime

Outputs time in seconds after emitter started.

EmitterPosition

editor-ref-block-emitterposition

Outputs 3-dimensional emitter position.

EmitterVelocity

editor-ref-block-emittervelocity3

Outputs 3-dimensional vector of velocity of the emitter. Direction of the vector corresponds direction of emitter movement and the length corresponds to the distance which the emitter will pass in one second.

ParticlesNumber

editor-ref-block-particlesnumber

Outputs current number of particles in the emitter.

(Emitter) CustomProperty[2|3|R]

editor-ref-block-emitterproperty editor-ref-block-emitterproperty2

These blocks add custom properties (stored values) to the emitter. These properties can be used to pass parameters to attached emitters or programmatically pass parameters to the emitter when using in final application (if supported by exported code).

Properies & inputs:

  • Name (prop): user chosen name of the property.
  • Default value (prop): default value of the property. This value will be stored in the property when emitter is created.

Generators

GeneratorPeriodic

editor-ref-block-generatorperiodic

Defines when particles have to be generated.

Generator type can be “Infinite”, “Fixed shots”, “Fixed time”, “Distance”.

Infinite generator generates particles with specified rate (amount per second) and it never stops.

Fixed shots generator works in the same way as Infinite does but it stops after fixed number of particles generated.

Fixed time generator works in the same way as Infinite does but it stops after fixed time spent from it’s start.

Distance generator generates particles dependently on distance the emitter spent.

Properties & inputs:

  • Type (prop): type of generator.
  • Rate (in|prop): number of particles generated per second.
  • Fixed time (prop): time after which generator will be stopped.
  • Fixed shots (prop): number of particles to generate after which generator will be stopped.
  • Start phase (prop): starting phase of the first particle. Lies in range [0;1]. If 1, then the first particle will be generated immediately. If 0, then generator will wait all period accordingly to Rate.
  • Salvo (prop): number of particles in every generator shot.

Terminators

TerminatorCondit

editor-ref-block-terminatorcondit

Checks if particle should be terminated by “less” condition. The block checks it’s two inputs (or properties), and if “Less. value” is greater or equal to “Great. value”, the particle will be terminated.

Both values can be  inputs of the block as well as user defined properties.

Properties & inputs:

  • Less. value (in|prop): lesser value in normal condition.
  • Great. value (in|prop): greater value in normal condition.

Constructors

ConstructorQuads

editor-ref-block-constructorquads

The block generates geometry of particles where each particle represented by quad in the space with texture mapped on it.

Properties & inputs:

  • Exportable (prop): if false, then no geometry will be generated. It is useful when you attached another emitter to particles of current one and you want to have invisible parent particles.
  • Material (prop): material that has to be used for particles rendering.
  • Texture (prop): texture to map on particles.
  • Position (in|prop): 3-dimensional position of currently processed particle.
  • Origin (in|prop): 2-dimensional normalized displace of geometry relatively to position point. If it is (0.5; 0.5), then position point will be in the center of generated quad. If it is (0; 0), then position will be in left bottom corner of the quad. And (1; 1) – in right upper corner of the quad.
  • Rotation type (prop): type of rotation used by the constructor. “Faced” rotation means all particle are faced to camera (XOY plane is visible) and constructor will receive rotation angle about Z axis. “Free” rotation means all particle can be freely rotated in the space and constructor will receive 3-dimensional rotation.
  • Angle (in|prop): rotation angle in degrees for “faced” rotation.
  • Size type (prop): “Quad” means square particle and you specify edge size of this square. “Rect” means rectangle and you specify 2-dimensional value as sizes of it’s edges.
  • Color (in|prop): Color of the particle. This color supposed to be multiplied on a texture before rendering. RGB components of color represented by XYZ accordingly and lie in range [0;1].
  • Alpha (in|prop): transparency of the particle. Lies in [0;1]. If 0, then particle is invisible.
  • Tex channel #0 (prop): type of texture mapping. If “rectangle” then all provided texture used for mapping. If “grid”, then the texture is divided by grid with dimensions corresponding to “Columns” and “Rows” and “tex. index” input used to get cell from this grid to map it to the particle.
  • Columns (prop): number of columns in the texture grid.
  • Rows (prop): number of rows in the texture grid.
  • tex.index (in): 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.