Realistic Commons Skeletal Effect
GCC Academy
Hello, this is Park Hyun-sang
We will practice
particle expression techniques using skeletal meshes
Skeletal meshes refer
to objects capable of animations, such as walking or running
As the term suggests,
it refers to objects with a skeletal structure
These skeletal meshes can dynamically
move within the content,
creating complex movements
To utilize these skeletal meshes,
you can control particles separately
using features like animation blueprints
However, it can be challenging to match
the exact timing of the animations
Today, we'll learn techniques for synchronizing
the timing accurately as well ass for adding
a sense of speed and dynamism to particle expressions
Particle Techniques Using Skeletal Meshes
Before diving into creating examples,
we will first review
the skeletal meshes we will use
If you want to display skeletal meshes,
make sure your project
includes Starter Content and Third Person assets
in that project
Navigate to the Content folder, then to Characters,
where you will find a folder named Mannequins
Inside the Mannequins folder, locate the Meshes folder
You will see multiple mesh types available there
Among them, you will find an asset labeled SK_Mannequin
Double-click to open this asset,
and you will see the same screen
I am currently viewing
At the top-right corner of the interface,
you’ll notice various icons
The first icon represents the Skeleton,
often abbreviated as SK,
and the second represents
the Skeletal Mesh, or SKM
We usually use them as the prefix of an asset name
Unreal Engine uses a skeletal structure
as the foundation for animations
and the meshes associated with these skeletons
They work together to form a system
that integrates animations,
which are controlled through Animation Blueprints
In summary, skeletal structures form the base,
multiple skeletal meshes are attached to them,
and these meshes
are linked to animation sequences
These sequences include animations
like running, jumping, and walking
And after these,
animation sequences
are later connected via Animation Blueprints
to control specific actions, such as
when to run and when to jump
These blueprints, in turn, are linked to skeletal meshes
through Blueprint Characters
For example, in the Third Person folder
under Blueprints,
you can find BP_ThirdPersonCharacter,
where you can observe the connection
between the skeletal mesh
and the animation blueprint
Let's start with something
that does not need a blueprint on its own
To integrate skeletal meshes with Niagara,
you can utilize animation sequences
like MF_Run_Fw
This is where we can
load our Niagara
By accessing the Notify track in the animation sequence,
you can add a new track,
We have markers here,
such as left and right
Click on Track, and add this
Add Notify Track
Let's not name our Track a number,
but as step
This figure is too fast,
it's hard to pinpoint a location
Reducing the animation playback speed to 0.1
allows for precise marking of
when a foot touches the ground
Say, you want some effects
on the ground as this figure steps on it,
like some dust effect
While it’s possible to manually mark frames
and control effects through blueprints,
which isn't impossible for sure
Animators can provide frame information
For example, 7th frame for the right foot,
17th frame for the left foot,
and 26th frame, another foot
As animators can provide frame information
of the steps on the ground in terms of frames,
we could ask for writing a code according to those frames
so that the effects can come into play
But that's too much work for the two
The animator should record all the information
about the frame so that they can deliver the information
And the programmer should save all the information
in some sort of a data in some storage
to load later
That's a lot of work
If changes to the animation result in frame adjustments
or timing shifts here and there,
the updated frame information would need to be communicated
and revised each time, which is inconvenient
To address this, Unreal Engine allows you
to integrate Niagara directly into the animation track
For instance, at the precise moment
a character’s foot hits the ground,
you can use the Add Notify feature to execute a Niagara particle effect
That's a function that Unreal has
The right foot
Of course, the left foot goes
to this indicator,
or the marker that tells us the current location
Right click, Add Notify
Play Niagara Particle Effect
Let's add this
Then, this assigns it
to enable the effect we want
at this specific frame
Let’s create a quick effect
to be used here
First, I created a folder named SkeletalFX,
then right-clicked to add a new Niagara System
and the Fountain template,
which resembles a fountain-like particle effect
Instead of focusing on the details here,
we’ll focus on how it works
I named the effect
FX_FootStep and keep it open
Disable the Shape
and Gravity options
In Initialize Particle, for one footstep,
if the effect persists for a few seconds,
though we walk a few steps
in that one second,
the effect will stay there
even after a few steps
So set the particle lifespan to around 0.2 to 0.3 seconds,
or for a very short time
I also limited the loop to a single execution
and reduced the duration to
a brief moment for a simple pop, pop
It's a simple effect
Once the effect is ready,
you can search for FX_FootStep in NiagaraEffect
and assign it
FX_FootStep
When played, you’ll see the effect
activate briefly with each footstep hitting the ground
However, if you observe closely,
sometimes the effect lingers in the air
even after the foot has moved
To fix this, I’ll show you how
to align the effect with the skeletal bone
corresponding to the foot’s tip
In the character settings, check Bones - All Hierarchy
to visually display all
the skeletal bone data of the character
You can identify the foot-tip bones labeled as ball_l and ball_r
When the right foot moves,
set ball_r to Socket Name
and for left, ball_l for Footstep
So for the first one, ball_r, and press enter
The second, ball_l
Check accordingly
Now we see the effect moving along the foot
So now, to this remaining right foot,
go to the spot with the R
Copy this Footstep Notify
and paste it here
To the L, or left,
copy, right-click on L, paste
Paste it in here
If locating it is too hard for you,
you can use the scroll to zoom in
and drag to get the precise location
Like this
Save, and let's play it
As they walk, you see the effect
Just like that
In the FX_FootStep effect,
the shape of the velocity cone is aligned with the Z-axis
This configuration ensures that the particle effect
emits upward
In contrast,
when examining the direction of the selected ball component,
you can accurately determine its orientation
Set the coordinate display mode to Local,
represented by a cube icon,
in this cube,
as opposed to the globe icon
for the World coordinate system
In the local coordinate view, you’ll notice that the Z-axis
of the ball is pointing to the right
This is why
Because the Z-axis is set as the primary direction,
the particles are configured to extend along the Z-axis
As a result, the particles naturally
emit outward along this axis
On the left side, this alignment is clearly visible
For the right side,
while the Z-axis also points outward,
a key difference
is observed when the two feet are positioned closer together for comparison
ay attention to the direction of the Y-axis
For the ball on the left side, the Y-axis points downward,
whereas for ball_r on the right side, the Y-axis points upward
In such cases, aligning uniformly
along either the Z-axis
or Y-axis becomes
a challenging task
To address this,
you can adjust
the Rotation Offset value here
That's how you can adjust it
For ball_r, to make the Z-axis
align upward like the Y-axis,
you would rotate the X-axis by 90 degrees
This moves the Y-axis horizontally and aligns the Z-axis upward
Enter a positive Rotation Offset of 90
on the X-axis,
and the particle will emit upward when the foot makes contact
For the left foot, it's the same
Since the Y-axis is downward,
set the Rotation Offset value
to -90, not 90, on the X-axis
This adjustment ensures that particles for both feet
consistently emit upward
in the direction of the instep
If you compare the modified particles
to the unadjusted ones I deliberately left unchanged,
you’ll notice that the unmodified ones
emit particles outward instead of upward
For example, the unedited right foot particles
still flow outward
By setting the Rotation Offset values to 90 for the right foot
and -90 for the left,
the intended effect
of dust particles shooting upwards with each step
is achieved as you see
When you test this
in third-person mode,
let's walk on
You’ll observe the particles
bursting upwards at each footstep,
In addition to these short bursts,
we can also create effects that leave
trails in the direction the player is running
These effects are also
what the Notify can adjust
Such effects are commonly referred to as trail effects,
or ribbon effects in Niagara
A rhythmic gymnast holding a ribbon
creates beautiful patterns
that follow
their hand movements
It's the same effect
Let's create a new Niagara system
using the Dynamic Beam template
and name it FX_Ribbon
Next, disable
any unnecessary modules
Start by turning off Update Beam,
which is a beam
that shoots a straight line
This isn't what we want
We want a natural curve
according to the movement
Spawn Beam, Beam Width, Update Beam,
and Beam Emitter Setup under Emitter Update
All the four beam-related modules
are now disabled or deleted
Let's disable Spawn Burst too
So that's five
Once these modules are turned off,
add a Spawn Rate module to the update section
This is enough for the module setup
Set its value to 10 to define the particle generation rate
For particle size adjustments,
go to the Ribbon Attributes section
and set the Ribbon Width to Direct Set,
assigning it a value of 5
At this point,
no effects may visibly occur
So we won't be using it
But for this example of a ribbon,
add a Velocity module, but instead of using Linear,
set it to From Point
This setting ensures that as the particles are generated,
they align and leave behind a trail
in a ribbon-like form
By reducing the Lifetime,
the ribbon trail becomes shorter
If the Spawn Rate is set to 3,
the ribbon effect appears more segmented,
creating distinct gaps between particle instances,
instead of sprites
So that's the trail in the shape of a ribbon
Increasing the Spawn Rate value
creates a smoother, more continuous ribbon effect
as particles are generated more frequently
That's all set
Back to Run_Fwd,
and to add a sense of speed for running,
add a Notify Track
and label it as Ribbon
At the start of the animation,
or frame 0, insert a Particle Effect Notify
and assign the FX_Ribbon effect
If this plays,
the ribbon will follow the skeletal root,
meaning the effect is going for this root,
which can look unnatural So assign the Socket Name as head,
so the ribbon trail originates from the head
For testing, ensure that
the Velocity module is disabled
So this Ribbon is set
to follow the head
Let's save and play
The ribbon effect will not activate during normal walking
Meaning, the animation
for walking does not enable it properly
but will appear dynamically when the character transitions into running
You can see the trail like so
For the demonstration,
I extended Ribbon from 1 to 3 seconds
It creates a long trail but might appear excessive
Reducing it to 1 second
provides a balanced, concise ribbon trail
as you can see here
Using Notify to create effects
such as footsteps or trails
is not limited to running animations
For instance, when swinging a sword,
you can use the same principle to leave a trail effect
Similarly, at the moment of impact,
you can trigger effects like bursts or debris
at the point of contact, applying the same approach as used for foot
Utilizing the 3D Surface Data of Skeletal Meshes
So far, we’ve focused on spawning particles
and playing them in sync with animation timing
by using skeletal mesh bone data
This time, we will explore how to leverage
the surface data
of skeletal meshes for particle effects
First, create a new Niagara effect
Let's create one
using the basic
Fountain template
and name it FX_SKM
Let's just name it as SKM
Typically, to determine
the particle spawn area,
we used modules like Shape Location
or like static meshes
to target specific 3D objects,
to see where particles
are being created
Similarly, skeletal meshes can provide
location data
to guide particle spawning
For this, use the Skeletal Mesh Location module
Set it up like so
Set the preview mesh
to SKM_Quinn to visualize the effect
Currently, the effect
is influenced by speed,
so the related aspects like velocity,
gravity force,
and drag, causing motion, should be disabled
We can now see
the backbone-like particles
just like so
In the Skeletal Mesh Location module,
there is an option called Mesh Sampling Type,
which is set to Skeleton (Bone) by default
This setting can be switched to use Surface data,
such as Triangles or Vertices,
enabling particle effects to leverage mesh surface details
To better visualize this, reduce the Initialize Particle size
from 6 to smaller values like 1 or 2
and increase the Spawn Rate to around 1500
This adjustment reveals the silhouette
of the preview mesh based on the selected sampling type
Next, ensure that CPU Access for the skeletal mesh is enabled
It's not, so click on Fix Now
to remove the warning message
Once resolved, copy the Skeletal Mesh Location module
and paste it into the Update section
of the Niagara system
So we have this same Skeletal Mesh
also in the Update section like so
Let's now see how to use these
by using a blueprint
to learn about its basic conditions
Right-click,
select Blueprint Class, and generally,
Skeletal mesh is used the most in a character class
Choose Character Class,
name it BP_SKMfx
Double click to open
For a character, we get a capsule like so
See this mesh part?
Inside, add a skeletal mesh component,
the Skeletal Mesh we'll be using
For example, for queen, we can add this asset
Let's place it right
Let's rotate
Set it up like this
Typically, an Animation Blueprint
is assigned
to integrate user inputs,
such as keyboard commands
The blueprint receives user data,
processes it,
and then passes the instructions to the animation blueprint
That's the general design of it
However, since this is an FX tutorial
rather than a Blueprint-focused one,
let's now
set the animation mode not to Blueprint
but to Animation Asset like so
In the Anim to Play field,
search for MF_Run
You get MF_Run_Fwd
Add this animation sequence
Once registered, the specified animation sequence
plays as intended, like so
To incorporate Niagara into this setup,
press the +Add button to include
a Niagara Particle System
as a child of the Mesh component
Assign FX_SKM to the particle system
As shown,
particles now generate on the surface of the mesh
and move in sync
with the character’s animation,
as you can see
If you scroll down to the Rendering section
of the mesh settings
and disable the Visible property,
the mesh will no longer be visible
while the particles continue
to animate in sync with the mesh’s motion
Returning to the Niagara editor,
if you go
under Particle Update
and disable the Skeletal Mesh Location,
as you see,
the preview might not show a significant difference
However, in the Blueprint view,
the particles will only generate momentarily
according to the mesh movement
That way, they fail to fully follow the mesh’s motion
Although setting
a very short Lifetime for the particles,
such as 0.1, might make them
partially visible,
however,
it won’t accurately track the mesh’s movement
To ensure
that the particles follow the mesh consistently,
you must include
the Location module in the update settings
This allows the particle system to continuously receive and update
the mesh’s location information
If you are not satisfied
with the default particle positions
or any of its behavior,
we have Scratch Pad tool
which Niagara provides
for creating custom modules to extend it
To access this feature, navigate to the Update section
and add a new Scratch Pad,
a way to add a new module
This module allows you
to implement your desired functionality
using a visual scripting interface
That's this Scratch Pad
For example, clicking on the System Overview tab
lets you return to the main particle system setup
Additionally, you can double-click
on existing modules
like Skeletal Location
to see the complex node-based scripts they use
to implement the effects
See? The nodes are very complicated
Of course,
we won't be working on something like this today
We'll only use about 5 to 6 nodes
to express something similar
Change the name of ScratchModule of Niagara
Rename, and VoxelModule
That's the new name
VoxelModule, and double-click on it
The Scratch Pad in Niagara
consists of four main components,
InputMap, Map Get, Map Set, and Output
The white arrow-looking icons
mean the order of activation
So they're receiving the information from Map Get,
such as information on the mesh or the color
And other various types of information
collected by Niagara
are processed by layering new data
onto the existing particle information using Map Set,
enabling customization
The InputMap and Output Module are pre-configured,
so you don’t need to worry about them much
Instead, focus on deciding
what information you want
to retrieve and how to apply it
To create a voxel format,
a voxel is essentially
a cube-like structure,
or grid-like sections,
that divides a 3D space into uniform
That's what Voxel is
For that, you need to utilize
the position values of existing particles
Start by selecting Map Get
and searching for Particle Position
And to put them
in a sequence within Particle Position,
add a new Float by pressing the + button for the spacing
Name this float as grid or gridsize
These two pieces of information
will allow you to arrange particles
at regular intervals
Once you’ve retrieved the position data,
you must convert it into a vector format for easier processing
Use the Transform Vector node
for this processing
By selecting Transform Vector,
you automatically generate a node
that converts the position data into an XYZ vector format
The default settings for Source and Destination spaces
should be left as World and Simulation, respectively
Let's leave them be
And then,
bext, extract the output vector pin
and connect it to a Divide or Slash,
to divide them
By dividing the current particle position by the gridsize,
let's clean up the screen a bit
Divide the particle’s position by gridsize
and round it up
by using Round
Finally, once again,
take the rounded result and use the Multiply function
to multiply it by the gridsize once more
This result, go to Map Set node, click on the plus button
Search again for Particle Position
add the Particle Position field,
and connect the final multiplied result to it
This completes the basic setup.
Click Apply
The particles now appear as points instead of following
the original mesh shape
This is because the default value of gridsize
is currently set to 0
In the System Overview, locate the VoxelModule,
which contains the gridsize parameter
Set this parameter to 8
Next, go to Initial Particle
and adjust the Lifetime to 1 second to ensure particles persist longer
Now, you’ll notice that the particle positions
are now aligned uniformly
To explain the logic briefly,
imagine dividing a grid into discrete sections,
like the grid you're seeing here,
like this, 1, 2, 3,
If a particle’s position, for example,
is at 0.6,
divide it by gridsize of 3,
then multiply it back by gridsize of 3
That's multiplied to the rounded result
So this is the expression
The position divided by 3, rounded, then multiplied by 3
So dividing 0.6 by 3
equals to around 0.2,
which is rounded as 0
If it's rounded up, 0.2 by 3 is still 0
So the point that should be at 0.6
is instead now at 0
Similarly, if a particle is at 1.8,
dividing by 3 yields 0.6
It yields 0.6, and let's round it
Rounding it up
results in 1, which is multiplied by 3
So that's now at 3
So the point that should be here
is now instead at an integer position,
like this, at an interval of integer positions
The points are now all there
The Sprite Renderer here
will make the shape
less like Voxel,
so let's disable Sprite Renderer
Instead, click on the plus button under the rendering section
to add a Mesh Renderer
In the Meshes field of the Mesh Renderer,
assign a basic cube asset
The first one we see
is the one in the yellow VR Editor,
which is Cube_01
After compiling,
the system will generate cubes representing the particles
Adjust the size later if necessary
The cubes might initially
appear randomly oriented
To fix this, enable Lock Axis in the renderer settings
and lock the axes as X-axis to 1, Z-axis to 0,
and Y-axis to 0
Fix the axes like this
Under the Skeletal Mesh section,
check the Orientation Sampling field and confirm that it is set to Apply
This may look random to our eyes
But it's actually working with the 3D surface
The 3D surface of the Skeletal Mesh
can align the particles
according to the surface’s orientation,
doing something like this
Like this, not using the 3D surface as the standard
but the direction that we set Lock to
Change the Orientation Sampling setting to Output
Same with Update,
Change the Orientation Sampling setting to Output
Now the sizes are equal,
in equal-sized grids
Each part is very big,
so they're all overlapping on each other
Go to Initialize Particle,
set Mesh Scale Mode to Uniform
Now, drag the size to decrease
Now we see a uniform
shape and interval
between each pair of cubes
Let's go see it in our Blueprint
This is what we have
It's like cubes in an animation
That's how we see it
But, with the grid size,
what if we don't like
the grid interval that we have now?
Let's go to VoxelModule
and change gridsize to 5
It'll overlap again
With 10,
the interval is bigger
due to the equal sized cubes
So should we go with changing gridsize,
and keep changing the size,
and now this size? That's too much work
So let's go to User Parameter
and add a parameter here
Make New, Common, float
Here, the grid name
is UserGrid
Go to gridsize,
click on the arrow pointing downdard
Search for UserGrid
Now you can use the one
that we made in User Parameters
Now, if we type in
either 5 or 10 to UserGrid,
since everything is synched,
it all changes accordingly
Let's sync the same thing
to Initialize Particle
This requires an additional work
So, at Initialize Particle,
we changed it using Mesh Scale Mode
We used to add in values like 0.12,
and now at Uniform Scale,
click on the arrow pointing downward
and go to New Expression
This is similar to Scratch Pad
It's not a complex node
You type in the command like this
This is how you use it
Type it yourself
The user here means this user,
as we see user in User Parameters
Of all parameters that the user has,
this will receive UserGrid
That's what this means
Now press Enter for this to work
UserGrid, this gets the value of it
So type in 10
Then it's 10x the original size
It's 10x bigger than the original cube
Then the cube size matters
Go to Mesh Renderer
and double-click on teh cube
The Approx Size of the cube
is 49x49
Let's just say 50
Then 10 times 50cm
is a cube with 5m long sides
So go to Initialize Particle
Now, to the cube's size,
divide it by 50
That's how we get
the Voxel with no gaps in between
Even if we reduce the size,
we still do not see any gaps
You can go to Skeletal Mesh
And you can still see the animation
of the character with the size we adjusted
I'm using the Run image now,
but it's not just Run
You can use any animation clip to this Mesh
Let's say Idle, and it still stays this way
With Walk, it also has that walking animation
retaining the Voxel action
along with the mesh surface
Like so, in Niagara,
beyond the basic provided modules,
you can utilize tools like Scratch Pads or expressions
to manipulate
and customize effects according to your needs
Before we conclude,
as you see right now,
the flickering and shifting of the cubes or voxels
may become visually distracting
This occurs because particles are continuously
spawning and disappearing,
leading to random positioning
To resolve this, adjust the Emitter State
so that the emitter only runs once
Over time, the particles will gradually fade out
Alternatively, instead the Rate value, you can switch to a Burst setting
Configure it to spawn 1,000 particles
That's a setting you could have
This change ensures that the particles spawn all at once and disappear in unison
To prevent particles from disappearing,
you can disable the Particle Kill functionality
in the particle state settings
Regardless of their lifetime value set in the Initialize Particle section,
disabling the Kill state
ensures that generated particles are maintained consistently
This allows you
to keep the particle count steady
It also avoids
flickering or disappearing effects
This allows you to keep the particle count steady at a visually pleasing density
With a grid size of 5,
you can generate 1,000 or 2,000 particles
and adjust until satisfied with the effect
To further refine this, you can use a New Expression
Set the parameter as User.UserGrid
We used to set UserGrid as big as
UserGrid divided by the cube
But now let's divide first
So let's do 10000/UserGrid
10000 is a random number
Press Enter, and we get 10000 divided by 5
which equals to 2,000
Naturally, as the grid size increases,
the number of particles decreases,
and conversely, as the grid size decreases,
the particle count increases
You don't need to use 10000
You could use 20000, 30000,
or any random number
This allows you to control
the density of particles more freely
by adjusting the grid size
By linking related parameters,
such as the spawn count to the user-defined grid size,
the Voxel spacing to the grid size,
and even the particle size to the grid size,
you can create a streamlined setup
This enables you to control all aspects of the particle system
using just one or two key variables
That concludes this lecture
on Niagara Effect along with Skeletal Meshes
In this session, we explored particle techniques
using skeletal meshes
Unlike traditional particles
that are controlled from static positions,
as they use the mesh as the base for their effects,
they required consideration of many additional factors
Beyond configuring Niagara, we also had
to account for the setup of components within Blueprints
Thus, working with skeletal meshes for particle creation
involve a significant amount of pre-planning
However, if used effectively,
skeletal mesh-based particles can create highly dynamic effects
that go beyond those achievable with Niagara alone
I encourage you to explore these techniques further
This concludes
the Unreal Engine effects lecture
Thank you
Skeletal Mesh-Based Particle Effects Navigate to Content, Characters, Mannequins, Meshes and select the SK_Mannequin asset
In the viewport, select Character, Bones, All Hierarchy
In Niagara, start with the Fountain template and name it FX_FootStep Disable Shape Location and Gravity Force
Set Emitter State, Loop Behavior to Once and Loop Duration to 0.2
In Initialize Particle, set Lifetime min to 0.2 and max to 0.3
Animation Sequence In the viewport, select the animation sequence icon and double-click MF_Run_Fwd in the asset browser
In the timeline, add a Notify Track named step At foot contact times, right-click and add Notify, Play Niagara Particle
Set Niagara System to FX_FootStep For left foot: Rotation Offset: X -90, SocketName: ball_l
For right foot: Rotation Offset: X 90, SocketName: ball_r FX_Ribbon Creation
Use the Dynamic Beam template in Niagara and name it FX_Ribbon Disable Beam Emitter Setup, Spawn Burst, Spawn Beam, Beam Width, and Update Beam
Add a Spawn Rate module, set Spawn rate to 10 In Initialize Particle, set Lifetime to 3, Ribbon Width Mode to Direct Set, and Ribbon Width to 5
In the timeline, add a Notify Track named Ribbon, set Socket Name to head, and play FX_Ribbon
Right-click, select Add Notify, Play Niagara Particle, and set the Socket Name to head
Using Skeletal Mesh for 3D Surface Data Create FX_SKM using the Niagara system with the Fountain template and name it FX_SKM
Add Skeletal Mesh Location, resolve CPU Access errors by clicking Fix Now Preview: SKM_Quinn Mesh Sampling Type:
Surface(Triangles), Spawn Rate: 1500 Copy Skeletal Mesh Location, Paste in Particle Update
Creating FX_FootStep Blueprint Choose Character Class in the Blueprint Class, name it BP_SKMfx Set the Mesh Component Animation Mode
to Use Animations Asset, assign Anim to Play to MF_Run_Fwd, and the Skeletal Mesh Asset to SKM_Quinn Disable Visible in Mesh settings
Add a Niagara component and assign the Niagara System Asset to FX_SKM
Creating the FX_SKM Module In Particle Update, add a New Scratch Pad Module and rename it VoxelModule
In the Map Get node, click [+] to add Particle Position. Add a float named gridsize From the Particle Position output pin, add a Transform Vector
Add a Map Set node, click [+] to add Particle Position Compute (Round(Transform Vector / gridsize) * gridsize)
and connect the result to Map Set > Particle Position Disable the Sprite Renderer module and add a Mesh Renderer module Set Meshes[0] to SM_Cube_01
Enable Lock Axis and set its values to (1, 0, 0) Set Orientation Sampling in both Skeletal Mesh Location modules to Output
Add a UserParameter by clicking [+], select Make New > Common > float, and name it UserGrid For Mesh Uniform Scale,
click the down arrow and select New Expression, input (User.UserGrid / 50) In Particle State, disable Kill Particles When Lifetime
Disable Spawn Rate and add Spawn Burst For Spawn Count, click the down arrow, select New Expression,
and input (10000 / User.UserGrid)