Particle System

The Particle System Nodes can be used to render a complex simulation of particles in the Ventuz Scene.

Generally, a Particle System can consist of any number of streams which will all be calculated and then rendered one after another. Each Stream consists of several Modules which emit, modify and render Particles in a specified order.

List of available Modules

Emitters		Movement Modifiers
Lissajous	Creates particles on a Lissajous curve.	Shape Force	Forces to Points, Spheres, Planes, etc.
Grid	Creates a rectangular grid of particles.	Field Force	Forces based on pseudo random variations.
Source	Creates a continuous stream of particles.	Position Offset	Misuse force calculation for other effects.
Mesh Vertex	Creates a particle on each vertex of a mesh.	Directional Gravity	Adds a directional gravity force.
Mesh Splitter	Subdivides/splits a mesh.	Explosion Force	Creates an explosion force in a single frame.
Nexus Random	Randomly creates particles inside a primitive volume for Nexus Rendering.	Collision Plane	Creates a Plane that particles will collide with.
Data	Creates particles with parameters given in an array.	Collision Shape	Define Shapes and Primitives that particles will collide with.
Secondary	Creates a stream of particles at each position of a particle read from a buffer.	Accelerate	Adds a Force to the particle with a direction relative to its current velocity.
Path	Creates particles along a given path.	Rotation Modifiers
Torus Knot	Creates particles on a Torus Knot curve.	Orientate to Path	Defines the 3d-rotation of particles within a path to follow the direction of the path.
Renderers		Orientate to Velocity	Takes the velocity of an object to determine 3d rotation.
Sprite	Renders billboard aligned sprites as particles.	Orientate to Center	Defines the 3d-rotation of particles towards a center.
Mesh	Renders the particles as meshes.	Rotate by Euler	Rotates the Particle around its local axes by the given angles.
Surface	Renders Particles as a Mesh Surface.	Rotate around Axis	Rotates the Particle around an axis relative to its direction by a specific angle.
Splitter	Renders the splitters created by the Mesh Splitter.	Rotate Randomly	Rotates each Particle by an individual random amount.
Mesh Extruder	Renders a mesh along a path created through the particle stream.	Attribute Modifiers
Lines	Renders a line along a path created through the particle stream.	Remap	Remaps an attribute to a given target.
Nexus	Renders Particles as Triangles, Edges and Points for Nexus Rendering.	Math	Performs a mathematical operation on two attributes and applies the result to a given target.
Special		Swizzle	Remaps the Channels of an Attribute to another Attribute channel-wise.
Repeater	Repeats all particles, applying a transformation to the repetition.	Constant Color	Applies a constant color and alpha.
Link Out	Writes all particles in a named buffer.	Gradient	Apply a texture gradient to one of the particle's attributes.
Link In	Reads particles from a named buffer.	Texture	Takes two attributes and uses them as texture coordinates for a texture lookup. Applies that to a target attribute.
Simulation	Is used to create a simulation loop and changes the behavior of most modules.	Animation	Takes an attribute, adds some random and/or animation over time to it and applies it to another attribute.
Simulation Constant Count	Is used to create a simulation loop and changes the behavior of most modules while keeping a constant count of particles.	Touch	Provides Feedback about the hovered particle and its attributes as well as changes one of its attributes.
		Data Animation	Uses a data array to modify the particle's attributes.

Usage

A Particle System must be placed in the scene's hierarchy by using the Particle System Node. It can consist of several Particle Streams. They can be placed either as Property Groups in the Particle System or as Content Nodes and bound to an Input of the Particle System Node.

Inline Stream	Content Node Stream

Each Stream consists of several Modules that fall in these categories:

• Emitters create particles
• Modifiers move and modify particles
• Renderers render particles
• Specials modules do more specific things

A useful particle system needs at least one Emitter and one Renderer. Modules can be mixed with minimal limitations, so you can have more than one renderer or additional emitters and animations between renderers.

Each particle system can have multiple Streams of modules, allowing you to create more complex systems like a Source Emitter whose Particles work as Emitters themselves.

Properties

• Steps Per Frame: Defines the count of simulation steps that should be performed per frame. This can increase the accuracy of the particle movements that occur in a simulation loop.

• Max Steps Per Render: If the framerate drops, the number of simulation steps will be increased to compensate. This keeps timing constant and clusters synchronized in low-framerate situations. If the time needed for simulation is slower than realtime, this would lead to ever-increasing simulation steps and slower and slower framerates. To prevent this, the number of simulation steps per render must be limited.

• Enable Functional Time Override: If set to true, each functional particle stream will use the Function Time Override to calculate the current Position of each Particle. By default, these streams will use the Cluster Clock to calculate the current attributes of each particle. Functional Time Override Unit sets the unit of the incoming time override. The unit seconds needs 0.000 precision.

• Reset on Activation: Resets functional and simulation particle systems when the scene is loaded.

• Reset: Resets functional and simulation Particle Systems.

Particle Streams

There are two different types of behaviors of Particle Streams: Simulating and functional Streams. As soon as you place a Simulation Module in a Stream, it is handled as a simulating one.

In a Simulating particle system, the particles are moved a bit each frame, new particles are added and old particles are removed as appropriate. This makes it impossible to play backwards or skip into the middle of a scene, but allows for very complex behavior.

In contrast, in a Functional particle system, the position of each particle is calculated from scratch, without knowing any previous position. This allows only for simple movements, but you can move forwards and backwards in time. Both kinds of particle systems will create the same movements each time they are run, as long as they are run on the same hardware specs. There is no true random.

Each particle stream can define a Maximum Particle Count to prevent render stalls whenever the logic of the scene emits more particles than can be handled in a frame or simulation step. Lastly you can change the Name of a particle stream. This way you can more easily recognize their usage in the particle system node. Inline Particle Streams use a property, while Extracted Content Node Streams use the node's name in the Content Editor.

You can disable a particle stream by clicking on the icon and pressing CTRL-B. Or, click the checkmark in the upper left corner of the particle stream properties. These two methods are linked, and changing this will reset the particle system.

To temporarily and dynamically disable a stream, the stream has the disable computation property. This can be bound, and changing the value will not reset the particle system.

For the stream to be operational, both the checkmark must be checked and the disable computation property must be off.

Emitters

Continuous particle emitters like "fountains" add some particles each frame while old particles are removed; they work the same in simulating and functional particle systems. With static emitters like grids or Lissajous curves, particles have unlimited lifetime. This is OK for functional particle systems. Static emitters in simulating particle systems will create all particles in the first frame and let them fly through the simulation. There are options to create more particles, kill all particles from this emitter, or create a force for each particle to its birth position.

Buffers

Particle Streams can write to or read from a Particle Buffer. This is used to communicate between the Streams inside a Particle System. For example, one stream can write each particle's position to the buffer which can be used by another stream as the positions of its emitters.

Some of the most common use cases:

• Rocket Smoke: A Particle Stream can write the position of a rocket particle into a buffer using the Link Out Module. This is read in a second stream with a Secondary Emitter that can emit particles at the current position of the rocket to simulate e.g. smoke.
• Firework: A Particle Stream can fire an event each time a particle dies using the Simulation Loop Module, holding all of its attributes like its position. This can be written to a buffer as well and then used in a second stream on a Secondary Emitter with the help of the Burst property that defines how many particles should be emitted once the event occurs.
• Layer Effects: You can render a particle several times with different renderers. This can either be done in one stream if you just want to add Modules after the first rendering, or via the Link Out and Link In Modules if you want to also remove e.g. a Noise Effect from the second rendering.

In all use cases, make sure that you use the right names for the Buffer Properties they write to or read from.

Paths

Some modules create one or more Paths. These paths can be used to modify particle properties like size and color, or hint rendering. For each module there is documentation on how many paths are created or used. The paths are put on a stack, using a path does not remove it from the stack. Example: you have a Lissajous emitter, creating a path. This will be Path0. Then you have a repeater, creating another path. Now the repeater will be path0, and the Lissajous will be path1. Paths can be open or closed, depending on the module and its parameters. Paths do not work inside the simulation loop since particles can change order inside simulation loops at any time, but after the simulation loop paths can be created, for instance through repeaters.

Nexus

Nexus Rendering allows for the rendering of Triangles, Edges and Points from particles by using the Nexus Renderer. For this, the particles need to provide all necessary information that is only applied by certain emitters. Currently you can use the Nexus Random Emitter and the Mesh Vertex Emitter to set the required attributes.

Basically, with the Emitters, you have a pre-selection of triangles and edges along the emitted particles that are either created randomly (Nexus Random Emitter) or with the information from a mesh (Mesh Vertex Emitter). On the Nexus Renderer Module you can then select the actually visible Triangles, Edges and Points respectively as well as apply their Material.

Particle Attributes

Each particle can have the following attributes:

Name	Values	Range	Default value	Description
Age	1 Value	0..1	0	Represents the particle's current time in life. 0 is just born, 1 is about to die.
Path0 / Path1	1 Value	0..1	0	Describes the relative position of a particle along a path. Paths are special attributes in that they also give information about the next and last particle and whether these are connected or not.
Color+Alpha	4 Values (r,g,b,a)	0..1	1	Color and Alpha used for rendering.
Amount	1 Value	0..1	1	A single value that can be used by several modules to adjust the strength of their effect per particle. Does not affect the particle directly.
Activation	1 Value	0..1	1	This value is set by events like collision and explosion, and remembered afterwards (in a simulation)
Creation Time	1 Value	0..infinite	-	creation time in seconds since the particle was created
Size	3 Values (x,y,z)	any	1	This scales the particle along the axes of the particle's space. It will be multiplied with the rendered object's size.
Sprite Rotation	1 Value	0..1	0	Will rotate the rendering of a sprite.
Velocity	3 Values (x,y,z)	any	0	The current movement speed in units per second.
Animation	1 Value	0..1 or indices of loaded animation	0	Determines the frame of a given Flipbook Loader Animation that should be rendered for this particle. With a Flipbook Control Material Stage you can change the range used to address the different frames of the animation.
Object ID	1 Value	0..n, positive integers	-	Each emitted particle will get the lowest unused Object ID so that each particle has a unique value on this attribute.
Aux0-3	1-4 Values	any	1	Can be used to do any kind of calculation or as a buffer for a value for later usage. Does not affect the particle directly. The number of values changes depending on the type of input given - e.g. if a color is written to Aux, it will have 3 Values; if the age is used, it has 1 Value.
Random	4 Values	0..1	-	Random number that is fixed to the particle.
Position	3 Values (x,y,z)	any	-	The current position of the particle in the particle system's space.

Each value is stored as a 4-byte float. An average particle with position, velocity, color and age would be 11 attributes or 44 bytes. When setting MaxParticleCount to one million, each particle buffer will be 44 MB of GPU memory. The system tries to optimize number of values per particle, and smaller is also faster.

Some particle modules also allow reading the following derived values:

Name	Values	Range	Derived From	Description
Color	3 Values (r,g,b)	0..1	Color+Alpha	Color used for rendering.
Alpha	1 Value	0..1	Color+Alpha	Alpha used for rendering.
PointDist	1 Value	0..infinite	Position	Distance of particle to point.
AxisDist	1 Value	0..infinite	Position	Distance of particle to axis / line.
PlaneDist	1 Value	0..infinite	Position	Distance of particle to plane.

In addition to this, many particle modules allow reading the following values that are not stored per particle

Name	Values	Range	Default value	Description
Null	1 Value	0	0	fixed to 0
One	1 Value	1	1	fixed to 1
Time	1 Value	0..infinite	-	time since particle system was started or reset
Constant	1 Value	any	-	a constant that can be set in the module

The Simulation Loop

In simulating particle systems, the particles go through a loop, with the particles active at the end of the frame being fed back into the simulation at the start of the next frame. Inside the simulation loop, emitters only add newborn particles and animations only do one step of simulation.

You can have additional emitter and animation modules after the simulation module. Their effect is not fed back.

Renderers are always placed after the simulation module.

Usage of Modules

Most of the time, you first add an emitter and a renderer to the stream, so there is something to see. Then add more modules and streams as you need.

Some modules are only allowed in a certain position:

• In a Functional stream
• Inside the Simulation loop
• After the simulation loop

Most modules are allowed everywhere, but some modules come with limitations where they can be placed. In the module description, the letters FSA will tell you where the module is allowed. Example:

FS -- This Module would only be allowed in Functional streams and in Simulation loops, but not After a simulation loop.

The Modules are applied to the stream in the order of the Property Group List. Animation and Render Modules are only applied to particles that already exist when they are processed, and only regard Animation Modules that have already been processed. Streams as well are computed in the order of the Property Group List - buffers need to be written to before you can read out these attributes.

Emitters

All Emitters have a Transform Property Group. This changes the location of the emitter in the system.

Continuous Emitters

Continuous emitters create a defined amount of particles in each calculation step of the particle system.

Source

	FSA	Creates a stream of particles.

This is your basic "fountain" type particle emitter.

Rate defines the absolute number of particles emitted per second. Amount will control the number of particles per second relative to Rate; this can be used to easily fade in or fade out particle emission.

You can randomize the Position of birth and the Speed of the generated particles with the Random Position and Random Speed properties. The Random Shape properties change the range of these random vectors: Box generates vectors with each component in the given range - resulting in a box-like alignment of particles. Sphere generates vectors with a length in that range so that particles appear inside a sphere. Bubble creates vectors that point to the surface of a spheroid. Disk ignores the input on the Z-Axis and only creates randomized 2-dimensional vectors that lie on a disk. Ring also creates 2-dimensional vectors that point to the edge of a circle. Same Random uses the same random number for the position and speed per particle - this will create particles that move away from the center of the emitter if the same Random Shape is used for the speed and position.

The randomization can be controlled with the Limit Random property. It limits the period of the particle emitter to 2⁽ⁿ⁺¹⁾. Set this to 31 for the best possible randomness, lower it to create flawed randomness that might give you some additional structure. With Random Seed you can additionally change the base seed of the randomization. This can be used to prevent the exact same random numbers on several source emitters with the same settings.

Speed adds an additional offset to the initial speed of the particles.

Lifetime changes how many seconds will pass until the particle dies. Random Lifetime will randomize that value - giving a range around that given value as a percentage. And Jitter randomizes the birth time of particles - the steadiness of the birth of particles is especially visible at low rates, and so Jitter can help in these cases.

Trigger Burst immediately emits as many particles as provided in the Burst Property when triggered. Trigger Enable/Disable disables or enables the Emitter. For feedback see the TriggerEnabled Output Property.

ApplyTransformRotation applies the rotation of the Transformation Property Group to the emitted particle when enabled.

Secondary

	S	Creates a stream of particles at each position of a particle read from a buffer.

Can be used to emit particles at the positions of the particles of another stream in this system. It can use all values written to the particle buffer of the other system. All properties behave the same as in the Source Emitter.

Link Name changes the used buffer. Buffers can be created e.g. with the Link Out Module.

Additionally, the Translate properties can add an offset to the particle's position from the current emitter. Per Particle Amount changes the Rate of each emitter created from the buffer based on its Amount Attribute. This way each placed emitter can emit a different amount of particles. Whenever an Event is fired in the linked buffer, the system will emit as many particles as given in the Burst property for the next simulation step. An event is fired e.g. by the Simulation module. By using Original Speed you can apply the speed (or a multiple of it) of the original particle to the emitted particles. Forward From changes how the forward vector of the emitted particles should be determined: you can either use the velocity vector or the forward vector from the buffer.

Static Emitters

In contrast to continuous emitters, the static emitters only generate particles once. When used in a simulation loop, all static emitters can use the same properties for lifetime control.

There are 3 modes for this. In Lifetime Mode each particle has a predefined Lifetime. Each time the Trigger event is fired, new particles are emitted. In Manual Kill Mode you can create new particles with the Trigger event and eventually Kill them again. When Auto Kill is enabled Trigger will also kill all existing particles. The Force control moves particles back to their original position by applying a Force towards it. You can move particles or the original position to see the effect. If the original position is animated, for instance in Lissajous, the particle will be forced to that new position. The force increases with distance.

Grid

	FSA	Creates a rectangular grid of particles.

Creates an open path for each X and Y.

The Grid generates particles in a grid formation. You can change the Size of the grid and the particle Count along each axis. Jitter applies a randomization to the position of the emitted particles.

Since the Grid generates paths along both the X and Y Axis, you can choose which attribute to write to with the Path Out X/Y properties.

When loading a Texture, its color will be applied to the particles' color attributes based on their X and Y positions. If Alpha Kill is enabled and the Alpha of the texture goes below the Alpha Kill Threshold, no particle is emitted at that position.

AxisAligned is set by default and will have the rendered geometries aligned along the particles' axes whenever the particle system moves or rotates. If disabled, the rendered geometry particles will follow their initial rotation. See below:

Axis Aligned (default)	Not Axis Aligned

Lissajous

	FSA	Creates particles on a Lissajous curve.

Creates a closed path for the Lissajous figure.

With the Lissajous curve you can create particles along a ​Lissajous Curve. You can change the number of emitted particles with the Particle Count property.

The Frequency, Phase and Amplitude properties adjust the appearance of the Lissajous Curve. PhaseSpeed automatically animates Phase. Use integer values for the frequency to create closed curves. Phase can be used to animate, and the amplitude scales the curve.

With the Up Vector property you can change the calculation of the up vector of each particle. Each of the two calculation modes might generate artifacts in different situations.

The Lissajous emitter creates a path along the generated particles. With the Path Out property you can change the used attribute for that.

Torus Knot

	FSA	Creates particles on a torus knot curve.

Creates a closed path as torus knot figure.

Creates particles along a ​Torus Knot path. Particle Count sets the total amount of particles along the path.

Path Out sets the output channel for the single path values of the particles. Knot P and Knot Q define the shape of the knot, together with the InnerRadius and the OuterRadius of the knot. Use Phase to shift the particle position along the path.

Mesh Vertex

	FSA	Creates a particle on each vertex of a mesh.

With the Mesh Vertex emitter you can create a particle on each vertex of a Mesh given by a Geometry Provider Property Group or Node. The Frame property changes the used frame of the used mesh.

Additionally you can write certain properties of each vertex to the emitted particle's Attributes. The Normal can be written to the Forward attribute of the particle - rotating the particles along the surface of the emitting mesh. It can also be written to the particle's Speed so it appears to be emitted away from the surface of the emitting mesh. Using the Speed property you can control the strength of that effect. With Color to Alpha you can write the color and alpha properties to the corresponding attributes. And with UV to Aux you can read the UV Coordinates of the vertex and write them to the Aux0 and Aux1 attributes of the particle. With this you can e.g. apply a Texture module based on these two attributes. Duplicate Vertices enables the emission of particles with the same position. Recalculate Normals enables correct lighting when rendering the mesh with the Surface Renderer. While turned off, doubles are culled. Turning this off is best used for rendering of transparent sprites, but best turned on for rendering of a mesh surface. Use the Skinning Matrices array input to connect animated mesh data to your particle system by simply binding the output property Skinning Matrices from the Animation Rig node.

Mesh Splitter

	FSA	Splits a mesh into parts to render with the Splitter render module.

The Mesh Splitter can split up a mesh into subdivisions. These splits are rendered with the Splitter render module or their center positions with any other renderer.

Select one of the built-in geometries, bind a Text Source (e.g. Text Layout) or provide an own mesh as base for the splitter.

The VertexTransform transforms the vertices of the base mesh before the split.

There are multiple ways to split meshes:

• Subset Splitter: Split along predefined mesh subsets. Use this if you pre-split meshes with 3d modelling software, or with the 3d-text node, where each letter is a subset.
• Triangle Splitter: The fastest and ugliest splitter, splits the surface along preexisting triangulation. This is often fast enough to animate in realtime.
• Voronoi Surface Splitter: Splits the surface of a mesh along a 3d Voronoi partition, creating some thickness through extrusion. This is much faster than a full Voronoi split, and provides a different look.
• Voronoi Splitter: Splits along the borders of a 3d Voronoi partition. This is very nice but slow during scene loading, so other options are provided just in case.
• BSP Splitter: Splits along a binary space partition tree, which is much faster than a Voronoi split, but you can always see that one first plane that splits through the whole mesh, which is ugly.

A few properties are common among all or most splitters:

• RandomSeed: Select a deterministic outcome for the randomization.

Common for the Voronoi based splitters:

• GridTransform: Translate, Scale and Rotate the Voronoi grid points. Scaling differently in X, Y and Z creates interesting patterns.
• GridJitter: How much the Voronoi center points are moved off the center of the Voronoi grid. At 0, you split into cubes.

Common for the cutting splitters (Voronoi, BSP):

• SurfaceMaterial: Material for the original mesh
• InsideMaterial: Material for the created split-surfaces.
• InsideUVScaling: Scaling for the UVs used with the InsideMaterial.

Common for the surface based splitters (Triangle, Voronoi surface):

• SurfaceMaterial: Material for the original source surface.
• ExtrudeDepth: Depth of the extrusion.
• ExtrudeShrink: Make the inside of the extrusion smaller. This helps to avoid seeing the sides of the extrusion at sharp edges of the original mesh.
• ExtrudeMode defines if the split should be extruded to have a depth and how many different Materials should be applied.
• Extra for Voronoi Surface: BackMaterial (material for the inside of the extrusion) and EdgeMaterial (material for the sides of the extruded chunks).

Off	No extrusion, the SurfaceMaterial is applied on front and back
Single Material	Extrusion with ExtrudeDepth and the SurfaceMaterial applied with UV-mapping on the front and back and with triplanar mapping on the side
Surface and Edge Material	The front and back use SurfaceMaterial and the side has an extra EdgeMaterial
Surface, Edge and Back Material	All sides have their own Material slot.

Triangle splitter properties:

• ClumpCount: Do not stop splitting until we have this many chunks, or we are down to single triangles.
• ClumpPercentage: Do not stop splitting until we have as many chunks as this percentage of the number of triangles. With 220 triangles and 20%, we create at least 44 chunks. At 100%, each chunk is a single triangle. At 0%, the number of chunks is determined by the ClumpCount.

BSP splitter properties:

• MaxLevel: Stop subdividing at this level.
• MaxSize: Stop subdividing when the chunk is smaller than this.
• RandomCenter: Randomize center for new splits.
• RandomAngle: Randomize angle for new splits.

Data

	FSA	Creates particles with parameters provided via arrays.

Creates an open path along the emitted particles

The Data emitter generates particles that have the properties given in the list of Data Providers. It will create as many Particles as given in the Count property. It writes the Path that it outputs to the defined attribute of the Path Out property.

Data Providers

You can provide the Data Emitter with different kinds of arrays that are freely combinable. The array elements are written to the corresponding parameter of each particle. With the Beyond Array property you can change how the Array should be filled if the emitter's Count property is greater than the given array's length. Default will fill it with 0's, Wrap will start with the values at the beginning of the array again, Clamp uses the last value or the last few values depending on the usage (e.g. it uses the last three values of a Color array). Lastly, you can just Cut off the Array at that position to not write to the attributes anymore.

• Position: The Particles' Positions, given in XYZ repeating every three elements - [P1X, P1Y, P1Z, P2X, P2Y, P2Z, P3X, ...]
• Position (Single): The Particles' Positions along a single axis.
• Position (Range): The Particles' Positions along a single axis, given as the start and end position.
• Position (Arc): The Particles' Positions along an arc. The Arc is given as the start and end position and a curvature around an axis.

• Velocity: The Particle's Velocity, given in XYZ repeating every three elements. Only working in a simulation loop.
• Forward: The Forward Vector, given in XYZ repeating every three elements. This is used to orientate a particle.
• Tangent: The Up Vector of a Particle, given in XYZ repeating every three elements. The second needed Vector to orientate a particle.
• Matrix: Full Translation, Rotation, Scaling Matrix of each Particle, given as Matrix Elements repeating every 16 Elements.

• Color and Alpha Groups: The Color and Alpha Values of a Particle, respectively, given in RGB and/or A in a range from 0-255. Groups marked with (float) take a range from 0-1.
• Size: Uniform Scaling.
• Aux: This array writes one value to the Aux Parameter of each particle.

• Multi: All needed Parameters in a single Array - Position is always given in XYZ. Other Parameters can be added using the Attributes dropdown. Color and Alpha use a range of 0-1.
• Range: The same as Position (Range) but it can be mapped on any attribute of the particle.
• Random: Applies random values in a given Range and applies these to an attribute. For this you can adjust the Random Seed.
• Geo Data: Applies longitude and latitude values to the position of the particle.

Path

	FSA	Creates particles along a given path.

Creates an open path along the emitted particles

The Path Emitter will take a Path from any Path Provider Node and emit particles along it.

In the Path Property Option you can change the used path. It can either load a path directly with the Path Loader or get a path from the scenes logic with a Path Property Property Group.

Particles Count defines how many particles should be emitted along the path. Extent represents the percentage of the path that should be used to emit particles. Mid is the center of that portion of the path. Jitter changes how steadily the particles are emitted.

Since the Path Emitter also writes to the Path attribute of the particles, with the Path Out property you can change which attribute is used for that. Multiple Paths will generate one path along each segment of the path. The next segment starts generating its own path. This is e.g. needed for rendering with a Mesh Extruder renderer so that between the segments the extruder will not draw its tube.

Nexus Random

	FSA	Randomly creates particles inside a primitive volume for Nexus Rendering.

For more information on Nexus in general have a look at the Nexus Rendering section.

The Nexus Random Emitter creates particles inside a primitive volume randomly. The particles gain all attributes needed by the Render Nexus module to bring Triangles, Edges and Points to the screen.

For this, the particles are emitted together with information on

• which 2 particles are connected via an edge and
• which 3 particles form a triangle.

The points as well as the edges and triangles are created randomly while following several rules like the primitive emission shape, maximum distances between points or count numbers. They are explained in the following:

Random Shape defines the shape of the primitive that the particles should be emitted in. Box creates positions on the surface or inside of a box. Sphere is the same but for a spheroid. Bubble only creates positions on the surface of a spheroid. Disk is a 2-dimensional shape with particles spread across an ellipse, while Ring only creates positions on the edge. The Size of all shapes can be changed in each dimension. Their Density defines the distribution of the particles. A density of 1 will distribute particles regularly. A higher density will emit more particles near the center of the shape and a lower density will push the particles towards the edges of the shapes. The Bubble and Ring shapes also have a Thickness that affects the range in which the particles can be positioned around the edges of the shapes. This way the ring will have a torus-like shape.

Point Count defines the number of emitted particles. Seed defines the base for the random numbers generated by this module. If all properties are the same, even the Seed property, the module will emit exactly the same particles on all machines - this is especially useful for cluster rendering.

Edge Flags offers two options for the edge generation. Absolute Count and Relative Count change how the Edge Count property is interpreted. Absolute defines a number of edges for all emitted particles. Relative creates edges relative to the number of particles. Random Any lets the emitter ignore the Minimum and Maximum Distance properties. Random Best Fit, on the other hand, will search for the nearest particle that is not yet connected and create an edge there. The edge generation will stop prematurely if the Maximum Distance is reached and will ignore particles that are closer to the current particle than the Minimum Distance.

These properties also exist for the generation of Triangles and have the same behavior - as triangles are created through groups of 3 particles instead of 2.

Movement Modifiers

These are the animation modules that directly modify position, 3d-Rotation, speed and movement.

Shape Force

	FSA	Forces to Points, Spheres, Planes, etc.

The Shape Force bundles all force types that have a center / plane of gravity and a specific falloff in different directions, depending on the shape selected.

All Shape Forces share the Amount slider to set the strength from 0% to 100%. Per Particle Amount uses the Amount attribute of each particle as multiplier for the applied force. Similarly, Use Activation takes the Activation attribute of the particles for the individual force strength.

The force is composed of the force Shape property group and an independent Falloff setting, defining how the distance relates to force. With Target, the force value can be mapped to a different, non-positional channel.

This is the whole force pipeline with each segment individually controllable:

To have a better visual representation of the selected force, activate the Non-Render-Objects:

Shape

Shape	Description	Properties	Example Image
Point	Point force with a center of gravity at origin.	CenterXYZ sets the center of gravity/origin.
Plane Distance	Center of gravity is a plane (white) with a gravity falloff to parallel planes (red), depending on the Falloff settings	CenterXYZ as origin and the rotation with Inclination and Azimuth.
Plane Direction	One side of the plane is equivalent to the Plane Distance force. This side is visualized in red. On the back side, the distance is always 0. The force works best with Rubberband falloff.	CenterXYZ as origin and the rotation with Inclination and Azimuth. Invert switches the front and back side.
Axis	The force vector of each particle points towards the defined axis.	CenterXYZ as origin and the rotation with Inclination and Azimuth.
Vortex	Creates a vortex force around the defined axis.	CenterXYZ as origin and the rotation with Inclination and Azimuth. Invert applies the vortex effect in the opposite direction.
Sphere Surface	Attracts the particles towards the surface of a sphere. Might want to use with the rubberband force.	CenterXYZ as origin and Radius for the sphere radius.

Falloff

Falloff	Description	Properties	Example Image
Physical	Uses the physically correct formula f=1/r^2 to calculate. Since this results in very strong force at small radius, the Min Radius caps the force at the level of this radius and applies it to closer particles too.	Max Radius sets the distance of the lowest applied force. Particles beyond this range have zero force. Strength at Unit distance sets the force level per unit distance radius. This will level the overall strength.
Linear	Linear correlation from force to distance, with the maximum force at minimum radius	Radius defines the range for the linear scale. Outside the radius, the force is minimum. Strength at Center sets the maximum force at the center point. Gamma lets you adjust the falloff curve with a gamma correction.
Rubberband	The rubberband force applies a high force at higher distance/radius and low/no force at center region.	Max Radius sets the radius where the maximum force is applied. Beyond this radius, the max force is applied, too. Strength at Max Radius sets the strength of the force at this maximum point and beyond. Gamma lets you adjust the falloff curve with a gamma correction.

Target

With the Target section, the force vector / strength can be mapped to other channels, and these values can be reused in other modifiers.

Target	Description	Properties
None	No external target is selected. The force affects only the acceleration of the particles.
Auxiliary Output (Simple)	Maps the force strength to a selected Target channel.	Disable Force Output switches off the force acceleration and writes to the Target channel only. Strength scales the force value written to the channel.
Force Strength to Aux	Similar mode to simple mode, but with more mapping functions.	Operation lets you switch how to write to the channel, with either overwriting, adding or multiplying with the existing channel values. Map Output Min / Max scale the Target output with a minimum and maximum value.
Force Vector to Aux	Writes the force vector as 3 components to the channel (R,G,B)	Bias shifts all values by the set value. Try 0.5 to overcome negative vector values.
Direct Position	Writes the force directly to the position of the particle. This mode is equivalent to the Position Offset modifier and the legacy (pre V8.3) functional particle system. The mode only works in non-simulation.	Strength scales the force applied to the position.

Field Force

	FSA	Forces based on pseudo random variations.

The Field Force modifier generally applies its force in the whole 3D space. It is not limited by a radius, like the Shape Force. The 3D coordinates and a noise formula are used to calculate a force vector or strength.

The Amount slider sets the strength from 0% to 100% of the force to all particles. Per Particle Amount uses the Amount attribute of each particle as multiplier for the applied force. Similarly, Use Activation takes the Activation attribute of the particles for the individual force strength. Strength X,Y,Z scales the effect depending on the x,y,z-axis, whereas Strength All scales the effect for all axes uniformly.

The direction and strength are calculated from the particle position. The Transform property allows you to scale, rotate and translate the space before this calculation is done, transforming the force field like an axis node.

Field

Field	Description	Properties	Example Image
Simplex Noise	Uses a ​simplex noise algorithm for the force calculation	Phase shifts the algorithm to create a changing force field; PhaseSpeed automatically animates the phase. Falloff determines the relation of highest and lowest values. Octaves sets the number of higher-order octaves of the noise. Usually the noise is in the range (-1, 1); with Absolute, the sign is not taken into account.
Curl Noise	Creates a force field based on divergence-free noise. This mimics fluid-like movements without considering interactions between particles.	Same as Simplex Noise
Wobble	Creates a force based on a sine function. This creates a visibly repeating pattern. Odd rotations can create visually interesting patterns.	Phase X,Y,Z shift the phase of the algorithm in the axis components and altogether with Phase All. PhaseSpeed animates the phase automatically.

Some notes about the simplex and curl noise parameters:

The noise can have several octaves that overlay the resulting noise with higher frequency curves. With Octaves you can control their number. Falloff changes the effect each octave has on the result; it is calculated as follows:

This is how the falloff works:

  Octave0
+ Octave1 * falloff
+ Octave2 * falloff * falloff
+ Octave3 * falloff * falloff * falloff
  ...

1.0 means all octaves are the same, 0.0 means the second octave is already diminished to nothing. Each octave generates values between -1 and 1. If Absolute is turned on the absolute values of the octaves' results are added together. This leads to more mountain-looking results.

Note that with Amount at 100%, curl noise will prohibit any movement that does not align with the curl field, negating any other force you may apply, including gravity. Reducing the amount will allow other forces by that much: with 75% Amount for curl noise, other forces will work to 25% against the curl noise.

Position Offset

	FA	Misuse force calculation for other effects.

This node does the same as a Field Force with target set to Direct Position.

Directional Gravity

	FSA	Adds a directional gravity force.

The Gravity module will create a directional force given by the GravityX/Y/Z properties. With Amount you can easily scale the resulting vector.

With Per Particle Amount, the Amount value of each particle is used to determine the strength of the gravity effect.

Use Activation only applies the effect if the Activation property of the particle is set. The Activation value also determines the effect's strength.

Explosion

	FSA	Creates an explosion force for a single frame.

The Explosion Force applies an explosion style force to all particles in range for a single frame.

PerParticleAmount applies the explosion force depending on the Amount value of the particle. If ExplodeAtReset is true, the explosion applies when the particle system resets. Center (X,Y,Z) defines the center of the explosion.

MinRadius sets the inner radius where the force is at max. MaxRadius is the outer radius of the applied force. Outside this radius, the force is 0.

Gamma defines the curve of how distance correlates to force: Force = 1 - r ^gamma. Amount sets the force amplitude.

Activity

The explosion force can set an Activity value to the particles. It is unique for each particle. Other modifiers, mainly forces, can read out the activity value and apply their force depending on this value, similar to the Amount value. This is useful when certain forces should be applied only after an explosion.

ActivityUpdate: Off disables writing to Activity. Set overwrites the value with this node's Activity. Max uses maximum Activity value from this node or existing value of particle. Add adds node Activity value to current value.

ActivityCurve: curve of force to Activity per particle. Sharp: very high slope for high force values. Linear: linear curve. Flat: low slope for high force region. Full: All particles in range of the force have full Activity. All: All particles get full Activity.

ActivityAmount: the full Activity value the node sets. 100 (1.0 internally) is the maximum value Activity can become. So adding to this value won't have an impact.

Collision Plane

	S	Creates a Plane that particles will collide with.

Fires an Event in a given Buffer.

Whenever a particle collides with the plane created by the Collision Plane module, it will be either Killed or Bounced off, adjustable in the Mode property. The Center defines the pivot of the plane, while the Inclination and Azimuth affect its rotation. Invert rotates the plane by 180°.

Whenever a particle collides with the plane and the Event Enable flag is turned on, an event is written to the Buffer given in Event Name. You can use that event in another stream - e.g. with the Secondary Emitter's Burst property.

On collision, the node can write to the Activity property of the particle.

ActivityUpdate: Off disables writing to Activity. Set overwrites the value with this node's Activity. Max uses maximum Activity value from this node or existing value of particle. Add adds node Activity value to current value.

ActivityAmount: the full Activity value the node sets.

Collision Shape

	S	Define Shapes and Primitives that particles will collide with.

Fires an Event in a given Buffer.

Whenever a particle collides with a selected Shape created by the Collision Shape module, it will be either Killed or Bounced off, adjustable in the Mode property.

The Shape can be defined to be either a Plane, Rectangle, Circle, Sphere or Cube. The Transform can be used to position the Shape in the 3D Space. With the Invert you can have the collision normal direction inverted, which applies for example for a spherical shape, while it will then use the inside of that shape, for example the sphere, to take it as a collision. The Epsilon can be seen as an outliner for the selected shape; it will kind of increase the thickness of the shape. The Epsilon can be increased if particles still pass through the collision shape.

Whenever a particle collides with the shape and the Event Enable flag is turned on, an event is written to the Buffer given in Event Name. You can use that event in another stream - e.g. with the Secondary Emitter's Burst property.

The Activity section is identical to the Collision Plane.

Orientate to Path

	FA	Defines the 3d-rotation of particles within a path to follow the direction of the path.

Reads a path (open or closed).

The Orientate to Path module is used to orientate the particles along the tangents of a path. This is especially useful when rendering the path with a Mesh Extruder to make the tube a lot more consistent than with otherwise rotated particles.

Orientate to Velocity

	FSA	Takes the velocity of an object to determine 3d rotation.

The Orientate to Velocity module is used to orientate the particles along their velocity vectors.

Orientate to Center

	FSA	Applies a rotation on each particle to orient to a defined center point.

With Per Particle Amount, the Amount value of each particle is used to determine the strength of the gravity effect.

Use Activation only applies the effect if the Activation property of the particle is set. The Activation value also scales the effect's strength.

Center (X, Y, Z) defines the center point coordinates where the particles orient to. UpVector (X, Y, Z) is the normalized up-vector to overwrite the up-vector of the particle's geometry. UpVectorForce overwrites the up-vector of the particle geometry to the given vector. It needs to be enabled for the UpVector property to have an effect. The up-vector is used to calculate the rotation matrix together with the vector from the particle's position to the center point.

Rotate by Euler Angles

	FSA	Rotates the Particle around its local axes by the given angles.

The Rotate by Euler Angles module can be used to rotate particles in the 3D space. Like with an Axis, you can apply a Rotation around each Axis relative to the current orientation of the particle. The rotation will be applied to all Particles.

With the Speed and Random Speed properties you can add a change over time as well. Amount scales the strength of the rotation and Random Amount adds a random offset for each particle.

If Per Particle Amount is turned on, each change in rotation will be scaled with the particle's Amount attribute. The Order lets you change how to apply the resulting rotation matrix.

Use Activation only applies the effect if the Activation property of the particle is set. The Activation value also scales the rotation strength.

Rotate by Axis and Angle

	FSA	Rotates the Particle around an axis relative to its direction by a specific angle.

The Rotate by Axis and Angle module can be used to rotate particles in the 3D space. You can define an Axis that you want to rotate around by creating a vector starting from the particle's center. The axis is spanned relatively to the orientation of each particle.

The Speed and Random Speed properties allow you to change the rotation over time. Amount scales the strength of the rotation and Random Amount adds a random offset for each particle.

If Per Particle Amount is turned on, each change in rotation will be scaled with the particle's Amount attribute. The Order lets you change how to apply the resulting rotation matrix.

Use Activation only applies the effect if the Activation property of the particle is set. The Activation value also scales the rotation strength.

Rotate Randomly

	FSA	Rotates each Particle by an individual random amount.

The Rotate Randomly module can be used to rotate particles in the 3D space. Each particle will be rotated by an individual direction. Speed and Amount apply the same speed to all rotations. RandomSpeed and RandomAmount add a random speed to each particle.

If Per Particle Amount is turned on, each change in rotation will be scaled with the particle's Amount attribute. The Order lets you change how to apply the resulting rotation matrix.

Use Activation only applies the effect if the Activation property of the particle is set. The Activation value also scales the rotation strength.

Accelerate

	S	Adds a Force to the particle with a direction relative to its current velocity.

The Accelerate module adds a force to each particle in their space. The Force properties define the strength of the force in all its axes. Amount can easily fade in and out that effect. Per Particle Amount will further change the strength of the effect, based on the Amount attribute of the particle - this gives particle-wise control over this effect.

Use Activation only applies the effect if the Activation property of the particle is set. The Activation value also scales the rotation strength.

Brake applies a decrease of velocity in each simulation tick. If enabled, Randomize applies a random offset to the force defined through Random Sideways and Random Upwards.

Attribute Modifiers

These are the animation modules that modify attributes like color, size and sprite rotation that do not affect position and movement.

Most of the Attribute Modifiers use Source and Target attributes of the particle. Their usual ranges go from 0 to 1. You have different options for sources and targets:

Sources

• Null always uses the value 0 for each particle.
• One always uses the value 1 for each particle.
• Age reads the normalized lifetime - just born particles have an age 0 while currently dying ones have 1.
• Path0 and Path1 interpolate between 0 and 1 along a path generated by another module.
• Color reads all three color channels. If you only need one channel you can define that in the Channel property.
• Alpha uses the current Alpha attribute of the particle.
• Color+Alpha reads all of the above channels and uses these.
• Amount reads the amount attribute.
• Size uses the current scaling of the particle. You can either use all scaled axes or define a single axis' scaling to read from. Also, you can add a scaling to the output value to fit it to your current usage.
• Sprite Rotation returns the screen space rotation of each particle going from 0 to 1.
• Velocity reads the speed, scaling from 0 to 1 once the Max Speed is reached.
• Animation reads the animation attribute of the particle.
• ObjectId// uses the ID of the current particle.
• Aux0-3 uses one of the 4 auxiliary channels.
• Random generates a random value for each particle. You can change the Random Seed to a value between 0 and 31.
• Time uses the Particle System's current time. This is usually the Cluster Clock. In a functional system, if EnableFunctionalTime of the Particle System is enabled it will use its FunctionalTimeOverride property instead.
• Position uses the current offset from the particle system's origin. You can define which Axis you want to use and adjust the Scale of this reading.
• Constant defines a custom value that is used for each particle.
• Point Distance calculates the distance to a given point via the Center properties. You can scale the output with the Size property.
• Axis Distance uses the distance of a particle to a given axis. Its pivot is given through the Center properties, its rotation via Yaw and Pitch. Size again changes the scaling of the output.
• Plane Distance reads the distance of each particle to a given plane. The plane's pivot is given by the Center properties, its rotation via Yaw and Pitch. The Mode can be changed between a One Sided calculation and a Mirrored calculation. The output can be scaled using Size.

Targets:

• Color writes to the color channels of the particle. If a scalar is used for this, all channels are affected.
• Alpha writes to the alpha attribute.
• Color+Alpha writes to both the color channel and the alpha attributes. If a scalar is used for this, all of them are affected.
• Amount writes to the amount attribute.
• Size writes to the size attribute. With Axis you choose which axis to affect. If using a Scalar you can use Uniform to write the same value to all axes. RGB->XYZ writes a vector of three values to the axes' values.
• Sprite Rotation affects the screen space rotation if the particles are rendered as sprites.
• Animation changes the animation attribute used for particle wise texture animations.
• Position affects the current position of the particle. You can change the affected Axis. Here you can choose to write a vector with three values to all axes by using the RGB->XYZ option. These options are available as World Positions (relative to the Particle System's origin) or Local Positions (relative to the Particle's position and rotation).
• Aux0-3 will write to one of the auxiliary channels. If you write a scalar to it, they will from now on be handled as a scalar; if using a vector, the auxiliary channel is used as a vector.

Gradient

	FSA	Apply a texture gradient to one of the particle's attributes.

The Gradient module uses a particle's attribute, defined in Source, to look up in the given Gradient texture along its V coordinate. The result will be written to the defined Target attribute.

Using the Amount you can interpolate the Target attribute's value between its original value (0%) and the modified value (100%).

With Stretch you can scale the gradient, defining the count of its repetitions.

You can define whether to Wrap or Clamp at the borders of the texture. Operation changes the function that is used to write the sampled value to the existing attribute. Default uses the usual operation for the chosen Target. You can change that to Overwrite, Addition or Multiplication.

The MappingMode decides how the input value is mapped onto the gradient: with StretchAndOffset//, the input value is first multiplied by Stretch and then added to Offset. In MinAndMaxRange//, MapInputMin defines which input value is mapped to the start of the gradient and MapInputMax defines which input value is mapped to the end of the gradient.

Texture

	FSA	Takes two attributes and uses them as texture coordinates for a texture lookup. Applies that to a target attribute.

The Texture module works similarly to the Gradient module. The difference is that Texture will look up along the U and V coordinates of a texture instead of only the V coordinate.

The Texture property group option changes the used texture. Amount interpolates the Target attribute's value between its original value (0%) and the modified value (100%).

The sources of the lookup can be changed with the TextureU and TextureV properties. Also you need to define a Target.

With the Scale, Rotate, Translate and Pivot properties you can change the 2D transformation of the used texture. Wrap changes the behavior of the texture at its borders - you can either Clamp, Wrap, have a black, white, transparent border or mirror (once).

Lastly, you can Remap the output of the module to adjust it to the target attribute.

Animation

	FSA	Takes an attribute, adds some random and/or animation over time to it and applies it to another attribute.

The Animation module can be used to add a random and/or time dependent offset to an attribute (Source) and apply it to any other attribute (Target). The Amount then interpolates between the original value (0%) and the modified value (100%) of the target attribute.

Base adds an offset to the target that is independent from the source and is constant along all particles. Base Random adds a randomized value unique for each particle. Speed and Speed Random add a constant or random value, respectively, that is multiplied with the source. Finally, Time and Time Random do this depending on the current time. Once an output of 1 is reached it will start over at 0.

The calculation formula is: TARGET = Base + BaseRandom*internalRandom + time + SOURCE * (Speed + SpeedRandom*internalRandom) with time = ParticleSystemTime * (Time + TimeRandom*internalRandom)

Lastly, you can change the Operation that is used for the application to the target value. Default uses the usual operation for the chosen Target. You can change that to Overwrite, Addition or Multiplication.

Constant Color

	FSA	Applies a constant color and alpha.

The Constant Color module simply adjusts the Color and Alpha attributes of each particle. Amount changes the strength of that effect, interpolating between the original (0%) and the modified value (100%).

Remap

	FSA	Remaps an attribute to a given target.

Reads a value from a given source attribute and applies it to another target attribute, while remapping it from the input range to the output range. Amount changes the value of the target attribute between the original and the new value. Source defines the attribute to read from and Target describes the one to write to. Operation changes the used function to write the result to the target attribute. Default uses the usual operation for the chosen Target. You can change that to Overwrite, Addition or Multiplication.

The Map Input properties change the range of the input values while Map Output defines the output range. With the Function you can define the interpolation between the MapOutputMin and MapOutputMax properties. There are different types of functions that you can choose from:

• Linear creates a linear interpolation from Min to Max without clamping or wrapping.
• Linear Clamped uses a linear interpolation while using the Min and Max values if the result is lower or higher.
• Linear Wrapped uses linear interpolation starting from Min once Max is reached.
• Ease In uses an easing function with small slope near Min and great slope near Max.
• Ease Out uses a function with a great slope near Min and a small one near Max.
• Ease In Out uses a function with small slopes near Min and Max and a high slope in the middle.
• Gamma creates a power function with the exponent given in Gamma.
• Sine creates a simple sine curve, starting and ending in the middle of the Min and Max values.
• Ramp In Out has an incoming and outgoing ramp. The RampIn value defines the end of the ramp, measured from the lowest value. RampOut defines the start of the out ramp, measured from the highest value. 25 for both values works fine.
• Step maps the input onto a step function with n Steps. Values higher than the maximum input values are extrapolated with the same step size.
• Step Clamped uses the same step function as Step, but values higher than Map Input Max are clamped to the max value.
• Step Wrapped starts the step function from Min when the Max value is reached or higher.

Math

	FSA	Performs a mathematical operation on two attributes and applies the result to a given target.

The Math module reads a value from two given Source attributes, uses them for a calculation and applies its result to another Target attribute, remapping it with the given parameters. Amount changes the value of the target attribute between the original and the new value. Operation changes the used function to write the result to the target attribute. Default uses the usual operation for the chosen Target. You can change that to Overwrite, Addition or Multiplication.

The Function is the operator that is used for the calculation with the two sources:

• SelectA ignores SourceB completely and just uses SourceA.
• SelectB ignores SourceA completely and just uses SourceB.
• Add uses an addition.
• Sub results in a subtraction of SourceB from SourceA.
• Mul is a multiplication.
• Div uses a division of SourceA by SourceB.
• Mod's result is the remainder of the division of SourceA by SourceB.
• Pow results in SourceA raised to the power of SourceB.
• Sine results in ((SourceA + SourceB) * 2 * 3.14159265)

The Map Output properties can be used to scale the result to the proper range. Clamping enables you to choose to either Clamp or Wrap or do None of them whenever the output value exceeds the limits.

Swizzle

	FSA	Remaps the Channels of an Attribute to another Attribute channelwise.

The Swizzle node can be used to rearrange the Channels of an Attribute. You can read all Channels of one Source Attribute and then write its values to another Destination Attribute in another order. For example, you can take the RGB values of the Color attribute and write them to the particle's Position in the order BRG.

The order can be chosen either with a Simple dropdown or, if these options are not enough, with the Advanced mode. With the latter you can choose the source channel for each of the channels of the destination attribute.

Touch

	FSA	Provides Feedback about the hovered particle and its attributes as well as changes one of its attributes.

The Touch module allows for interaction with the particle system. It provides feedback about the last hovered particle. This can be done by changing a Particle's Attribute as well as providing Output Properties.

You can change the color with the Hover To Color Alpha property. It will apply the Hover Color and Alpha to the hovered particle with the given amount. With Hover and Touch To Attr you can write the information about whether a particle is currently hovered or touched to the corresponding attribute.

When a particle is clicked you can also fire an event in a buffer. This can be used to e.g. emit particles on a Secondary Emitter in another stream whenever a particle is clicked. For this you will need to add a Link Out Module as well and define its name in the Click Event Name property. With Click Event Enable you can turn the event emission on and off.

You can pass information on the hovered particle outside the Particle System as well by using its Output Properties. Touch Inside and Pressed return whether the current touch point is hovering a particle and whether it is pressed (mainly used for mouse interaction). The Events Touch Enter, Leave, Begin and End fire respectively to the change of these flags.

PosX, Y and Z return the position of the Particle in world space. This can be changed to the Particle System's local space with the Local Position input property. Feedback Value defines an attribute of the hovered particle that you want to use in the Outputs of the Particle System.

Finally there are options to adjust the selection of the hovered particle. You can disable the module temporarily with the Disable Touch property. The Scale changes the size of the particles for the interaction - when set to 1 it is simply using each particle's size property. Which changes the preferred particle if several are hovered. Any will choose the one that is first found by the shader code. Frontmost selects the one that is nearest to the camera, and Nearest chooses the Particle that has the smallest distance to the touch point.

Data Animation

	FSA	Uses a data array to modify the particle's attributes.

The Data Animation module applies the value of an array to each particle in a stream depending on one of their attributes - similar to the Data Emitter that applies these values only on their creation.

With the Source property you can define which attribute of the particle determines the used array element. The ParticleNr is the current number of the particle in the particle system - this can change between frames, especially when using a Source Emitter. ObjectId is stable across frames since each particle has a unique ID. Lastly you can also use the Aux or Path properties.

You can change the Position, Size, Color, an Aux attribute, the Sprite Rotation or Animation with this module. The used attribute is defined by the Destination property. The Operation that is used for this process can be set to Add, Subtract, Multiply or Set.

The Overrun property changes how to handle arrays with fewer elements than there are particles. Ignore does not apply anything to the particles, Clamp applies the last value of the array and Loop starts at the beginning once the end of the array is reached.

Renderers

All Renderer Modules have one or more Material Property Groups, which give the option to add a Material to the rendering of only one Module. This Material will be appended to whatever Material is applied to the Particle System via the Hierarchy. This means it will by default inherit all options of the Hierarchy Material Node and only overwrite those that are defined in the Material Property Group. A Material can also be applied to such a Property Group via a Content Node Material Provider.

Sprite

	FA	Renders billboard aligned sprites as particles.

The Sprite module renders billboarded textures on the screen. The module can hold a Material Definition. By default, a Sprite Renderer has a Material with a No Light lighting model, a Texture Loader material stage, a Linear Dodge alpha blending and a z-testing option to Not Write anything to the z-buffer.

You can adjust the uniform Scale of the sprites as well as change their Aspects. The aspect is calculated with the formula 2^x. So if you need an Aspect of 16:9 you need to type 0.83 (which is log₂(16/9)). If you need an aspect of 9:16 it simply is -0.83.

The Offset properties add a translation of the sprites to their particle's positions in screen space. You can fade out the sprites when they come near the camera by using the Z Near Fadeout Enable and Z Near Fadeout properties.

Sorting lets you apply a sorting algorithm to the particles for this rendering. There are different options to choose how the particles should be sorted. Depth sorts them using the distance to the camera. Distance sorts them using the distance to the particle system's origin, and Age sorts them using the particles' age. With the Reverse flag you can change the direction of sorting. Sort Precision changes the number of executed passes. For example, 5 Bit has 1 sorting pass only regarding the 5 most significant bits. 15 Bit has 3 passes and regards the 15 most significant bits. Turn the precision down to save performance and turn it up if you see a lot of Z Sorting artefacts in your particle system - but most of the time the default value of 15 Bit should be fine.

Culling is adjustable for the sprites' front- or backfaces or neither.

You can change the direction of Billboarding:

• Toward Camera: Align the sprites towards the camera.
• Along Forward: Rotate along the Forward Vector of the particle.
• Along Speed: Rotate along the Velocity of the particle. Normally this only exists after a simulation.
• Along Direction: Use Billboard Reference to create a Rotation Vector to which the particles will be aligned.
• Toward Position: Rotate towards a Position given through the Billboard Reference.
• Toward Axis: Rotates towards an Axis defined in the Billboard Reference.
• Normals Toward Position: Only changes the normals' directions towards a position but leaves the rotation of the particle as it is.
• Normals Toward Axis: Only changes the normals' directions towards an axis but leaves the rotation of the particle as it is.
• Invert: Can be used to invert the resulting vector. Only applies to Toward Position and Toward Axis billboarding.
• Update Normal: When directions are changed in any modifiers in the particle system, the sprites' normals need to be updated during the rendering. Turn this off if you want to keep the original direction of the particles' normals.

The Billboard Reference uses a Transformation property group. Alignment enables you to choose which axes are locked to the billboarding. The VR option locks the X and Y axes and is useful for cameras that have an animated roll.

Mesh

	FA	Renders the particles as meshes.

The Mesh module renders a mesh on the positions of the particles. You can change the used Mesh using the according property group option. See Geometry Provider Node for more information on the usage of these property groups. With the Transform property group you can append a matrix to the particle's position, rotation and size. Lastly you can add a Material Definition to the renderer that is applied to all rendered geometries.

Sorting lets you apply a sorting algorithm to the particles for this rendering. There are different options to choose how the particles should be sorted. Depth sorts them using the distance to the camera. Distance sorts them using the distance to the particle system's origin, and Age sorts them using the particles' age. With the Reverse flag you can change the direction of sorting. Sort Precision changes the number of executed passes. For example, 5 Bit has 1 sorting pass only regarding the 5 most significant bits. 15 Bit has 3 passes and regards the 15 most significant bits. Turn the precision down to save performance and turn it up if you see a lot of Z Sorting artefacts in your particle system - but most of the time the default value of 15 Bit should be fine.

Mesh Extruder

	FA	Renders a mesh along a path created through the particle stream.

The Mesh Extruder generates a mesh along a path that was created by other modules. You can change its appearance with the Profile property group option.

Tesselate changes the tessellation along the extrusion, while Max Segment limits the maximum number of tessellations. Interpolation changes the type of interpolation between the particles - you can choose from Linear and Cubic. When Twirl from Amount is enabled the profile will be rotated based on the Amount attribute of the particles.

You can repeat the rendering of the extrusion along particles in a buffer by providing it with a name in the Repeater property. Since the Repeater puts a Path on the Stack, you cannot repeat the rendering of the Mesh Extruder with it, and thus you need to use particles from another stream.

You can use the Slicer property group option to enable a slicing of the extruder. Segment changes the number of segments along the extrusion. The Percentage property defines the length of each segment. You can start the slicing at a different position along the extrusion with the Offset property.

With Middle Mesh you can generate a mesh that will be rendered along the path. In its property group you can define a Mesh, a Transformation Matrix and a Material. Lastly, the Step property changes the distance between the meshes along the extrusion.

First and Last Mesh can be used to add a Material to the beginning and end of the extrusion as well. Their options work the same as the ones of Middle Mesh.

Lines

	FA	Renders a line along a path created through the particle stream.

The Lines module creates a 2D line along a given path. This will use a rendering technique similar to the one of the Path Renderer Node.

This module holds a Material definition. Here you can change the Line Options. In the material you can also choose to render e.g. as Path.

Surface

	FA	Renders Particles as a Mesh Surface.

The Surface module renders particles as a surface if they hold information necessary for that. Currently you can apply the needed information to the particles' attributes using the Mesh Vertex Emitter. You can apply a Material to the rendering using the corresponding property group.

Splitter

	FA	Renders Splitters from a Mesh Splitter.

The Splitter module renders the splitter particles created by a Mesh Splitter Emitter. Multiple Splitter modules can render the same split particles. A Material stage is applied on all splitter particles. The material will overwrite the material of the Mesh Splitter Emitter or the hierarchy.

Nexus

	FA	Renders Particles as Triangles, Edges and Points for Nexus Rendering.

For more information on Nexus in general have a look at the Nexus Rendering section.

The Nexus Module renders Triangles, Edges and Points, when particles have the required information as described in the Nexus Rendering section.

The module will give you options to select which particles to render for triangles, edges and points each. Each particle will be assigned a value that represents the amount with which it should be drawn. You can completely disable the rendering of one group by disabling the corresponding Property Group or by setting the Disable Rendering flag in the Flags property. The Amount To Color flag multiplies the selection of each particle with the selected value determined through the Selector property groups. The Edges and Points Property Group has a Select Edges From Triangles or Edges flag that adds the calculated value of the triangles or edges to their own. This can be used to make all edges visible that enclose a triangle. Disable it to have completely independent values for each.

Amount can be used to fade in and out the drawn objects - it is multiplied with the rate of selection of each particle. Bias on the other hand adds the given value, providing each particle with a certain minimum value.

Lastly you can apply a Material to each group of objects.

The Selectors can be used to add an amount to each particle following different rules. If you use more than one selector, their sum is used.

Each module has an Amount that multiplies the resulting value of each particle. Selectors that are using the position of the Particles have a flag on how to interpret the position - Position Deformed uses the position of the particles during the current rendering. Position Original uses the position that the particles had during their emission. Position Change uses the difference between those two. Also, they have a Transformation with which you can translate, scale and rotate the selector's origin.

The different types of Selectors will be explained in the following:

Perlin With Phase

Creates a 4-dimensional Perlin noise. The position of each particle is used to determine its value. Additionally you can animate the noise over its fourth dimension using the Phase property. PhaseSpeed automatically animates Phase. Bias adds an offset to the results and Gamma changes the function of the applied values from a linear one to a curved one.

The noise can have several octaves that overlay the resulting noise with higher frequency curves. With Octaves you can control their number. Falloff changes the effect each octave has on the result; it is calculated as follows:

  Octave0
+ Octave1 * falloff
+ Octave2 * falloff * falloff
+ Octave3 * falloff * falloff * falloff
  ...

1.0 means all octaves are the same, 0.0 means the second octave is already diminished to nothing. Each octave generates values between -1 and 1. If Absolute is turned on the absolute values of the octaves' results are added together. This leads to more mountain-looking results.

Distance

Adds a value relative to the distance of an object to the origin of the system. You can add a Threshold and adjust the curvature of the resulting values with the Gamma. High gamma fades out earlier while low gamma fades out at greater distances. You can either calculate the distance with the length of the difference between the particle's position and the origin with the flag Sphere. Or you can do that using the sum of each component of the difference vector using the Box flag. Lastly, you can Invert the result with the according flag so that a particle becomes more visible when far away from the center.

Size

Applies a value that is relative to the size of a triangle or edge. This module cannot be applied to a point for obvious reasons. You can adjust the range of the used input sizes with the Minimum and Maximum properties. The Fuzz properties add a linear falloff to either the lower or higher limit. With the Invert flag you can invert the values.

Random

Either enables or disables an object with a specified Probability. Additionally you can adjust the Seed of the random number generator.

Wave

Wave creates a waving curve in 3D space to determine the value of each object. Again, you can animate this using the Phase property. Also, you can change the Frequency of the applied wave as well as the Pulsewidth. The latter determines the length of the positive portion of the wave. The Gamma adjusts the slope of the curve of the applied value.

The Flags adjust some options of the wave like its shape. Sphere will emit the waves in all directions evenly starting from a point. Box will emit the waves along the 3 Cartesian axes starting from a point. Cylinder emits waves in all directions starting from an axis. Plane emits waves in a single direction (along an axis). Plane Mirrored emits waves in two directions starting from a point on an axis. Repeated adjusts whether the wave should be repeated infinitely or if it should appear only a single time.

Lastly, you can adjust the form of the wave. Sine creates a common sine wave, Half Sine uses only the positive portion of the wave. Rectangle applies a rectangular wave, effectively alternating between the minimum and maximum instead of interpolating. Ramp Up increases the value linearly and then starts over; Ramp Down decreases the value linearly instead before starting over.

Amount To Selection

Write the particle's Amount value to the Selection value of the Edge/Triangle/Point. The value is clamped to the (0...1) range. Invert inverts the Selection value. Mixing defines which particle value of an edge or triangle is used: Minimum, Maximum or Average particle value.

Amount Range

The Amount value of the particles is read out, and if it fits in the range of Min to Max, the Selection value is set to 1 (100%). The MinFuzz and MaxFuzz set a range where the Selection values fade from 0 to 1, either below the Min or above the Max value.

Special

Simulation

	--	Is used to create a simulation loop and changes the behavior of most modules.

The Simulation module creates a simulation loop in your particle stream. You can add a Friction to the simulation that applies a deceleration to each particle's velocity in each tick of the simulation. If Enable Time Event is set to true the module will fire an event in the buffer defined by Timeout Event every time a particle dies.

The Grid property group allows you to add forces between nearby particles, based on the Smoothed Particle Hydrodynamics (SPH) technique, which creates fluid-like behavior. More about that below.

Simulation Constant Count

	--	Is used to create a simulation loop and changes the behavior of most modules while keeping a constant count of particles.

The Simulation Constant Count module creates a simulation loop in your particle stream. You can add a Friction to the simulation that applies a deceleration to each particle's velocity in each tick of the simulation. Contrary to the Simulation module, this module will keep the particle counts and orders constant - meaning you can use modifiers or renderers that need to use e.g. the Path attribute.

Repeater

	FA	Repeats all particles, applying a transformation to the repetition.

Creates a path per particle along its repetitions.

The Repeater module can be used to repeat the execution of the particle stream up until this module for a given number of times (Repeat Count). In Flags you can define which attributes of the particles to change over each repetition. The Local flag changes the used repeater coordinate system to the local one of the base. The Mirror flag applies the repetitions twice, once mirrored.

Scale, Rotate, Translate and Pivot append a transformation during each repetition.

Random Rotate, Size and Translate apply a random sprite rotation, change in size and translation between the repetitions. They must be activated in Flags. Random Seed changes the seed for the randomization.

Since the Repeater creates a path, you can choose to which attribute you want to write it using the Path Out property.

Link Out

	FA	Writes all particles in a named buffer.

Writes each particle with its attributes to the buffer given in Link Name. These particles can then be used by other particle streams.

Link In

	FA	Reads particles from a named buffer.

These can be inserted in another particle stream of the same particle system to emit static particles at every position given in the buffer defined through Link Name.

Smoothed Particle Hydrodynamics

Smoothed Particle Hydrodynamics (SPH) allows you to simulate forces between particles, including simulation of pressure and viscosity, which can lead to fluid-like behavior.

To do this, we need to test each particle against each other particle, something that is as slow as it sounds. So we divide the world into a grid and compare each cell to its 26 neighbor cells (3*3*3-1). There is no outer limit to the grid; if particles spread beyond the grid, far-away particles share a cell at reduced efficiency, but grids of a million cells are no problem and occasional double-bookings are fine. The size of a grid-cell, on the other hand, is the fundamental parameter: the cell-size is the maximum radius at which particles can interact, and interaction at the edge of the radius will be weak, so a large radius is good for simulation quality, but that is bad for speed as more particles must be tested against each other.

The settings for SPH are found in the simulation node, inside the grid property.

SPH comes in two flavors: simple and advanced. Simple gives all the control needed to create good looking and plausible simulations, while the advanced mode has more control and options for less plausible but interesting movements.

Grid Parameters

• GridCount: in steps: 32, 1k, 32k, 1M, 16M. This is the number of cells in the grid. Take number of expected particles, divide by 5 or so, round up. The 32 size is just for testing. Each step adds a fixed cost, so going from 1k to 32k is as expensive as going from 32k to 1M.

• GridScale: size of a grid-cell. This is the maximum radius at which particles can interact.

SPH basics

The core of the SPH math is that for each particle, a pressure is estimated by looking at how many neighbors are found and how far away they are. A resting pressure is set, and particles which are at resting pressure are not moved. Lower pressure makes particles move towards each other, and higher pressure makes them move apart. This is all one needs to "flock" particles, but it can lead to particles building clumps. So a second force is added which is solely based on particle distance, not pressure, to move particles apart from each other when they are too close.

This gives us our first SPH properties:

• PressureInRest: Rest-Pressure.
• PressureForce: Force that is used to equalize pressure differences between particles
• DeclumpingFactor: Short range force to keep particles at a minimum distance. This is expressed as multiples of the PressureForce, as these are related to each other.

Viscoelasticity can be simulated with a third force: as particles are in interaction range, the speed between them is averaged, making the simulation medium feel stickier.

• Viscosity1: linear viscosity factor

Sometimes you will experience "explosive" behaviors: clusters of particles exhibit large pressure and therefore large forces. This can be fixed by limiting pressure and viscosity forces.

• LimitForce: limit the force to a maximum; low numbers mean limiting to low forces, very large numbers mean very little limiting, as the limit is large. 0 will disable limiting.

You can output the pressure to a particle attribute. This is useful for debugging as well as visual effect:

• OutputPressure: Export pressure to particles for other effects.

Advanced SPH Attributes

Most of the time you will not need these options, but if you want to experiment deeper, you can. The property group is designed so that switching from simple to advanced will always yield the same result; switching from advanced to simple will lose the additional settings - save before trying.

The weighting kernel is a function that determines how the force between particles is reduced with the distance going from very near to the length of the grid.

In this graph, the curves of the spikier kernels are below those of the flatter kernels. If you have a force that attracts and a force that repels, you want the repel force to be "spikier" and stronger than the attract force, so that at near distances the repelling wins and at larger distances the attraction wins.

Note that the physically correct 1/r^2 is not available. First, that goes to infinity at short distance - an explosive option. But mostly you should not think of these functions as force functions but as averaging functions.

You can set the weighting kernel for declumping and pressure force. You can also set quadratic viscosity to shape how that effect works:

• PressureKernel: Weighting kernel used for pressure.
• DeclumpingKernel: Weighting kernel used for declumping.
• Viscosity2: quadratic viscosity factor

You can now set different limits for the 3 forces:

• LimitPressureFactor
• LimitCollisionFactor
• LimitViscosityFactor

The LimitForce will be multiplied with the 3 factors. Any value yielding 0 will disable the limit. By default, collision factor is 0 to mimic the behavior of the simple mode.

There are two flags that change how the math is implemented:

• AlternativeIntegration: Integration is how the forces turn into speed, and how speed moves particles. This switches to an alternate way of doing this, usually less correct but sometimes more visually interesting.
• NoRestPressure: The way the pressure in rest is calculated is different (and wrong), but again this can lead to interesting results. Rarely used.

Tweaking SPH

The most important parameter to set is the GridSize. With the "Non-Render Objects" display enabled and the particle system module selected, the grid will be displayed. Make sure the grid is not too small (no interaction between particles) and not too big (too many particles to check). Poor performance is usually caused by an overly large grid. Changing the grid size will dramatically change the range of all other properties, so it must be decided first.

Set the GridCount to maximum, and when done tweaking, test if smaller values give better performance. 1M should be good.

Next, set a PressureInRest. Usually, a value around 10 will do. You only see the effect if you set a "PressureForce". Slowly increase it until you see an effect; if that does not work, try a vastly different PressureInRest, like 100 or 1.

The next value is Viscosity1. Increasing it will make particle streams more coherent and make particles that collide as they move from different directions interact more strongly.

Once reasonable ranges for these properties have been found, real tweaking can start:

• Slowly change PressureAtRest, PressureForce, DeclumpingFactor and Viscosity1.
• It can be worth trying a different GridSize before going in too deep, as that can change how the particle system feels.
• You can copy, paste and block a particle node to quickly save good settings before experiments.
• If you are happy except for some unwanted explosions, try LimitForce.
• Mapping OutputPressure to the default rainbow color gradient can help with understanding pressure. Also, it looks nice.
• Abruptly changing parameters by animating the properties can create interesting shapes.

The particle sources are as important as the SPH settings:

• Density of the particle sources affects the behavior of the system, mostly considering a reasonable GridSize and PressureAtRest.
• You can create a stream of particles with the source emitter.
• The source emitter can also create a bunch of particles at once with the Burst feature. Set Rate to 0 in this case.
• Slowly animating source emitter properties like Rate and RandomSpeedAll can make the system feel more alive.
• If newly born particles look bad as they need to get ordered by the influence of the SPH into the proper shape, you can fade them in by lifetime after a second or so. This is done by animating alpha or size.

You can switch from simple SPH to advanced without losing information, and change some of the advanced properties.

• Remember to switch back to simple SPH when you were not successful with the advanced options.
• It's always worth trying AlternateIntegration (in the ExtraFlags); usually it does nothing, but sometimes makes things more stable or interesting.
• Also in the ExtraFlags you can find NoRestPressure: This drastically changes how rest pressure is interpreted and requires re-tweaking of all parameters.
• The most powerful feature and hardest to pull off is changing the weighting kernels. Usually the DeclumpingKernel should be spikier than the PressureKernel, meaning higher up the drop-down list. Usually...

Debugging and Performance

The Particle System offers two ways to find out what is going on in it, since it cannot provide any feedback to the UI of the particles' attributes.

Performance

The performance monitor received new tokens for the measurement of the particle system on both the CPU and GPU.

Statistics

You can get detailed information about each particle system with the performance statistics:

For each particle system node and stream inside a node, it shows the following values:

• number of particles / max particles as a bar
• "func", "simvar" or "simfixed" for functional, simulated, or simulated constant count

and the number of particles that in this frame did the following

• emit: emitted
• linkout: written out to a link buffer (sent to other particle streams)
• linkin: read from a link buffer (read from other particle streams)
• sim: in simulation loop
• repeat: repeated (repeater module)
• split: written and read back due to splitting the compute shader
• sprites: rendered as sprites
• meshes: rendered as meshes

This is especially useful when creating complex multi-stream particle systems and you don't know where your particles go missing.

Modules

Each stream holds a Visualization of which attributes are read and affected by each module. You can collapse and expand that visualization by clicking the triangle on the right of the Modules' List.

Each line displays one Particle Attribute and each node represents a read or write operation. A line only exists as long as the attribute is of interest for the optimized shader of the particle system. When reading from an Attribute, the node is a circle ; if the module writes to it, the node is a colored square . The nodes on the visualization are kept in the colors of the modules - and thus the colors also represent the according operation.

	Write	Creation of new particles, setting the marked attributes - this does not affect already existing particles!
	Write	Modification of attributes on already existing particles.
	Read	Reading from an attribute.
	Read	Rendering a particle using all marked attributes.
/	Read/Write	Reading or writing for operations other than the above, like writing to a buffer. See the module's documentation for more information on the processed operation.

Since special modules do not process operations on the attributes that belong in any of these categories, their nodes are simply orange.

A dotted line in the visualization between two modules means that the particle system needs to create a second shader for all modules behind that line. This generally happens after the 12th module or a Repeater module. To process the particles in a second shader, they need to be written to and read from a buffer, which might be a bottleneck for performance. So you should always try to minimize the number of dotted lines in the visualization.

Cluster Synchronization

Preconditions for Cluster Particles

If you want to run particle simulations in a cluster, you should use the same GPU and GPU chips. For instance you can mix an Asus 5090 with a Gigabyte 5090 GPU, as they both use the same chip (NVIDIA GB202), but if you mix CPUs or GPUs from different vendors or generations it is likely that floating-point operations are rounded differently, resulting in simulation results that slowly diverge.

Conditions for Desynchronization

Even with those preconditions met, there are some situations where different machines in a cluster might diverge:

A well-built cluster may still diverge if all of these conditions are met:

• The particle system uses the simulation module (or constant count simulation).
• One of the machines drops a frame while the others don't.
• One of the properties of the particle modules is modified by a mover or LFO.

On the other hand, the following situations will always work:

• Functional particle systems are always safe.
• Multiple GPUs in a single machine - as the frame drop is synchronized, they will not diverge.
• The PhaseSpeed property found in Field Force, Lissajous and Nexus Renderer works fine as it does not require an LFO, Mover or other binding.

What exactly is happening here? Let's assume a frame is dropped on machine A while two frames are rendered on machine B.

Machine B will do the "correct" thing:

• frame 1: update all Movers, LFOs and bindings
• frame 1: run the simulation
• frame 2: update all Movers, LFOs and bindings
• frame 2: run the simulation
• frame 3: update all Movers, LFOs and bindings
• frame 3: run the simulation

Machine A has dropped a frame:

• frame 1: update all Movers, LFOs and bindings
• frame 1: run the simulation
• frame 2: dropped
• frame 3: update all Movers, LFOs and bindings
• frame 3: run the simulation
• frame 3: run the simulation

So both machines run the simulation the same number of times, so that movement speed is not affected by the frame drop.

But machine A will run the simulation twice with frame 3 parameters, while machine B will run correctly with frame 2 and frame 3 parameters.

This explains why particle systems without movers/LFOs on parameters will not desync.

Smoothed Particle Hydrodynamics are Exceptionally Sensitive

A desynchronization is made a lot worse by the smoothed particle hydrodynamics, because a single particle out of sync will propagate its wrong position to all neighboring particles, spreading the desynchronization to the whole frame, consistently, even when the original bad particle has died.

So in a complex simulation without SPH, a single particle at the wrong position is easy to overlook, and once that particle dies, everything is fine.

But with SPH, a single bad particle will spread its influence to neighboring particles, and those neighboring particles will stay in their bad positions even after the initial particle has died.

Copyright 2026 Ventuz Technology