Realistic Commons Explosion Effects
GCC Academy
Hello, this is Park Hyun-sang
In this lecture, we will cover Unreal effects
using the Niagara system
By utilizing various Niagara modules
and connections with other assets,
we will create dynamic effects
that differ from the more static nature of shaders
Using features such as Niagara’s burst
and the shader’s world offset,
we will work on creating an explosion effect
We will specifically use what’s called mesh particles
Instead of relying on sprite images,
we will use meshes like spheres
and cubes as particle elements
The explosion effect leverages instantaneous force
to leave a strong impression
From the fireworks we commonly see in daily life
to more complex explosions,
we will explore various Niagara modules
that allow us to achieve these effects
Setting the Explosion Radius and Crafting the Explosion Effect
We will start from preparing the assets needed
for creating explosion effects
To begin, I created a folder named ExplosionFX
Now create a new Niagara system
For the base template,
we use SingleLoopingParticle
That as the base template,
click the Create button
We name the asset FX_Explosion
for simplicity
After that, we double-click to open the Niagara window,
where we see a preview
of a small sphere within a circular boundary
Here's the outline of the explosion effect
This circular boundary represents the overall range of the explosion
and will be animated to expand over time,
so it's a sphere
One thing to note is,
by default, particles use a sprite setup
It's a flat rectangular mesh
that always faces the camera
That's the basic setup
However, for our explosion effect,
instead of a rectangular sprite,
we need a spherical mesh
So we need a 3D mesh
with an actual volume
To achieve this, over here,
go to the Renderer section and add, not Sprite,
but a Mesh Renderer
while disabling the default Sprite Renderer
Initially, this action removes the sphere preview
In the Meshes section of the Mesh Renderer,
the default gizmo appears as a small arrow shape
So in viewport,
you'll see a little gizmo like so
Searching for sphere
allows us to select
the basic Static Mesh Sphere
Of all spheres,
under the Sky category we have Static
Add that
Now,
when working with static mesh assets,
double click to check for certain conditions to be met
For instance, check that the UV mapping is properly unwrapped
and that the pivot point is centered
In this case, don't use this
To confirm the pivot’s position,
In the viewport,
you can press the F key to move it around
It shows that the grid aligns with the sphere’s center
This confirms that the pivot is correctly placed at the sphere’s center
Therefore, When choosing
a sphere mesh like this,
ensure it meets the following conditions
he grid should align perfectly with the center of the sphere
even when viewed from the side
And the UV mapping should be fully unwrapped,
showing a seamless checker pattern
This is the sphere we want
Currently, in the Initialize Particle section,
the default settings show Sprite Mode as Uniform,
while the Mesh Attribute remains unset,
which is why nothing is visible
Since the Sprite Renderer is not being used,
reset it
and change the Mesh Scale Mode to Uniform
Additionally, reset the Lifetime setting, changing it
from CurrentLoopDuration to a fixed value of 1
After recompiling,
the sphere will become visible like so
In the Emitter settings under the State section, set Life Cycle Mode to Self
This is because we’re creating a one-time explosion effect,
not something continuous like fire or smoke
Set it to Self and then Once
with a default runtime of one second,
that effect only plays for a brief moment
To make the sphere expand,
go to Particle Update and search for Scale Mesh Size
There's our Scale Mesh Size
Connect this to the system,
and examine the Scale Factor setting
This allows transformations such
as elongating the sphere
along the X or Y axis
To make the sphere grow dynamically over time,
use Vector From Curve
Since it’s an explosion,
it should start small and grow rapidly
Reverse the graph’s shape
so that the scale starts at 1 when the lifetime is 0
and reaches 0 at 100 lifetime
Note that as this is a Vector3 parameter,
templates might not apply correctly in certain cases
When this happens, you can drag
to select all of X, Y, and Z, and set them to 0 at the start
At the endpoint, when it reaches 100%,
set the Scale to 1
After that, playing it back
will show the size changing like this
At this point, individual preferences among creators may come into play
For instance, some might set it explicitly to grow 8 times
or 10 times,
something like this
Others might configure the Curve itself to operate
within a value range of 0 and 1
Then, by using the Scale Curve value,
you can specify how much you want it to grow
For example, inputting a value
for 10 times growth
Alternatively, instead of using a Vector,
you can opt for Vector from Plot
to ensure that X, Y, and Z
all have consistent values
This allows you to exclude values as needed
You can choose one of two methods
Either exclude everything directly through the graph
or leave the graph in a range of 0 to 1
and use the Scale Curve value
to designate maximum values
for the Curve
Once you’ve set the size this way,
save it here
and place it in the world
Currently, I’ve configured it to grow 10 times,
so if you look at the size of the sphere connected
to the Mesh Renderer,
you’ll see the Approx Size is 100×100×100,
set to 100 unit
A 1-meter sphere growing 10 times
becomes 10 meters in size
I’ll place this in the world now
Unlike in the preview,
the expanding shape appears much cleaner
Resetting again
shows how the sphere rapidly grows
with a smooth expansion effect
The growth speed of the Scale Mesh
can be adjusted using the curve here,
which can be set to Auto for smooth transitions
By manipulating the curve,
you can also adjust the speed variations over time
After saving, I’ll test it again in the world
Resetting it
shows the sphere initially growing quickly
and then slowing down, as currently configured
This simulates an explosion
with a clearly defined blast radius
Next, we need to apply a material to represent the explosion
I’ll create a material
named M_ExplosionFX
and open the editor to adjust its settings
For the explosion to fade gradually,
I’ll simulate the diminishing effect
like a real explosion
So set it to Translucent
Since explosions emit light,
I’ll leave the material in an Unlit state
To create a fiery effect,
I'll add a shading effect
I’ll use a VectorParameter
and name it FireColor
The default values for this parameter
will be set as Red 8, Green 1, and Blue 0.2
Connecting this to the Emissive Color
gives a preview that appears yellow,
but in reality,
it will have an orange hue
For the flame effect, we need two components,
a bright red burning section and a dark, charcoal-like ash section
For the ash-like portion,
as there’s no need to define a specific color,
we’ll use a Constant3Vector
and set it to black
hese two elements will be blended
using the Linear Interpolate or Lerp function
Instead of manually inputting
a fixed value or a node,
you can add 0
It's the same thing, but this is to demonstrate
how the colors blend dynamically
So for that purpose,
I will use the nodes for this
The current setup connects the colors directly to the Emissive output
When the Alpha value is 0, the FireColor is displayed
When the Alpha value is 1, the black color is shown
That's the setup for now
Let's leave it be
To blend these values dynamically depending on the viewing angle,
we need the basic node
called a Fresnel node
Let's connect it to Lerp
Connecting the Fresnel node to the Lerp’s Alpha input
creates a lighting effect
Comparing this setup to one
where only FireColor is connected
reveals a noticeable difference
Without Fresnel, the sphere’s edges
display a single color, while with Fresnel,
for which we used Lerp,
a gradient effect
appears along the edges, as you can see here
Next, I’ll enhance the appearance
by incorporating a noise texture
Let's bring in a Noise texture
Using a Texture Sample node,
search for Noise under Texture
and select Perlin_Noise
to connect to the ExponentIn input
This creates an effect resembling sunspots,
with areas appearing
partially black and partially bright
Rotating the sphere reveals
that the central region remains bright
The center of the sphere is brighter
regardless of viewing angle,
as you can see here
while the edges maintain a reddish hue
By applying a Multiply node
to the noise values, I can adjust the intensity
For example, setting the multiplier to 3
in this ExponentIn,
it reduces the black regions,
while a value of 0.5
which is half of what it was before
results in
a more pronounced black
The lower the number, the more black it is
The bigger it is,
the more visible the FireColor gets
I will make this a parameter later on
This alone
will make everything look very static
So let's use a Panner node to animate the UV coordinates
and connect to the UVs of Texture Sample
Here it is
Here, the Speed values
are all set to 0
Setting it to 1
results in a swirling, fiery effect
It's spinning right now,
as you can see here
Adjusting the Speed parameter
lets you create the sensation
of flames dancing over the sphere
Finally, I’ll modify the sphere’s surface
to make it appear uneven,
as if it’s distorted by heat
Same thing here,
a Texture Sample node is used
to bring in a normal map
From the StarterContent-Textures,
select the Detail_Rocky normal map
This normal map has a convex shape
Connect it to Texture Sample
Now, we'll onnect it to the World Position Offset
Initially, these changes
aren’t too noticeable,
so let's add a Multiply node to amplify the effect
By setting the value to 10,
it exaggerates the unevenness,
making the surface look bumpy and dynamic
Next, I link the Noise texture’s Panner node
to the UV input of the normal map
At first,
the movement speed is too high with 1,
so let's lower it to 0.1 to create smoother motion
It results in a shimmering,
heat-distorted effect
The World Position Offset allows us
to work on the 3D surface of the sphere,
by literally offsetting it
We move the surface using the normal map,
which represents a texture with a unit length of 1,
or 1cm
ince a 1-unit change
on a 1m sphere
isn’t very noticeable,
let's use the Multiply node to scale the offset
to 5 units or 10 units
A bigger scale
seems to demonstrate this texture better
For now, I will go
with 5 units like so
Then, let's adjust the Fresnel node
Add a Multiply node to control the Fresnel strength
When I set it to 0.5,
the red regions representing FireColor
become more prominent
On the other hand, increasing the value to 2
expands this area,
ore the black area here
The Fresnel node lets me calculate the light’s behavior
Areas directly facing the camera receive a value of 0,
while edges perpendicular to the camera,
so it's 0 here, but the perpendicular part
receives a value of 1
By multiplying these values,
this emphasizes the edge effect,
increasing the black area on the sphere
At this stage, I’ll classify the various numerical values
we’ve discussed into parameters
Instead of controlling them
through a Material Instance,
I’ll set them up to be controlled directly within the Niagara system
First, create a Dynamic Parameter
and connect each parameter step by step
The first parameter will be called FresnelPower,
and I’ll set its default value to 1.2
’ll connect this to the node where Fresnel is multiplied,
allowing us to control the extent of the blackened areas
Next, I’ll create the second parameter, named WorldOffsetVal,
and connect it to the World Offset node
right away, like so
Let’s set its default value to 5,
so the surface takes on a bumpy appearance
For the third parameter, I’ll name it Noise
and connect it between the Fresnel
and Noise Texture nodes at the Multiply point
Let's connect it there
If I set the Noise value
to 0.1, the noise will become more pronounced
Setting it to 1
will narrow the black areas
This parameter overlaps slightly
with FresnelPower,
but is specifically for adjusting noise intensity
That's why it differs from the Fresnel value
Therefore, it will adapt dynamically
as the noise texture changes,
which will provide constant values
by being connected to Noise
Finally, let’s add a fourth parameter
Name it Speed,
with a default value of 1
If I lower it to 0.5, the movement will slow down,
and if I increase it to 2, it will speed up noticeably
But this cause pixelation
So I recommend keeping it
around 0.1 or 0.5 for better visuals
Let's Apply
To set this up, under the Explosion settings,
enable the Material Override in the Mesh Renderer
Click the plus button to add and link the material
And here, select what we just created,
M_ExplosionFX,
using the arrow connection
Next, I’ll go to the Particle Update section
and create a Dynamic Material Parameter
With this, I can control the parameters dynamically
Initially, the light will appear fully visible,
and as time progresses, the FresnelPower
will intensify to about 1.2
Since there is no Noise value,
I’ll also set the Noise parameter to 1
and the WorldOffset to 5cm
Now, there is no animation,
since the Speed is currently 0
Set the Speed to 0.5 for the rotation
If I increase the WorldOffset to 10,
the animation becomes even more pronounced
After saving the setup, I’ll test it in the world
by placing the Niagara system and pressing the reset button
This will confirm that everything works
as we intended
Returning to the Explosion Material,
I notice the color value
that we parameterized
doesn’t necessarily need to be a parameter
Instead, you can use the Particle Color node
to directly modify it within the particle system
I can connect its Alpha channel
to Opacity or mix it
with other various effects
that we’ve previously created
To demonstrate this, I’ll use an Add node
to combine the results of the Fresnel and Dynamic Parameter
Their multiplied values,
for which we'll use this Add
Now, connect this result to the Opacity
At this point, the material might appear gray in the preview
I’ll apply the changes
and switch back to the Niagara interface
In the Particle Update section, click on the plus
to add a new module, Scale Color
I’ll set the Scale RGB values
to match the parameters we defined earlier
8, 1, 0.2,
or Red 8, Green 1, Blue 0.2 are the values
Let’s talk about how we can adjust
the alpha value here
Right now, everything looks fine,
But as the alpha value drops closer to zero and eventually goes below zero,
you’ll start seeing a hole-like effect
And if it continues to decrease all the way
to -1,
the object almost completely disappears
This is why we need to ensure
a controlled transition to make
the fade-out appear smooth and natural
To do this, I’ll use the Float From Curve node
to control how the alpha value changes over time
First, make the value of Scale Alpha
using Float From Curve
I’ll start by setting the initial value at 1
Then, I’ll set the 100% point on the horizontal axis
to around -2
By doing this, we can achieve a fade-out effect
If you find that the fade-out is too soft,
or this may not be what you wanted,
instead of leaving the material as Translucent, we can switch it to Masked
Once we do that, we’ll link the alpha value to the Opacity Mask
Let’s apply this and take a look
Now, the fade-out happens with a rougher texture,
which you can clearly see here
When you preview this effect in the Niagara editor,
you might notice some flickering as it fades out
But when we place it in the actual world and reset it,
the fade-out will appear much more stable,
without any flickering that we saw
Currently, the material is set to render only the front-facing surface of the sphere
It means, as it fades,
you’re only seeing this front part,
this part of the sphere
This front part of the sphere facing the camera
So the back side touching the ground would not be visible
To create a more volumetric appearance,
even for the parts of the sphere you wouldn’t normally see,
we’ll enable the Two-Sided option in the material settings
When enabling Two-Sided, if you’re using Translucent,
it might not calculate the depth
of overlapping surfaces correctly
Instead, it’s better to use Masked
to ensure the full shape of the sphere is rendered properly
Don't forget to enable the Two-Sided option too
Let's reset it to see
Let's look at it from here too
Even here, the back side is also disappearing
That's the effect we just added
Smoke and Spark Effects
Let’s continue by enhancing the explosion effect
First, I’ll copy the SingleLoopingParticle
by using Ctrl+C and Ctrl+V
I’ll rename the original one
to MeshExplosion to keep things organized
and rename the copied particle of SingleLoopingParticle
to FireSmoke
For this new particle, I’ll disable the Mesh Renderer
and instead enable the Sprite Renderer
The original Sprite Renderer
Same with Initialize Particle
Since the Mesh Renderer is no longer in use,
I’ll also reset the Scale Mode in the Initialize Particle settings
to Unset and change the Sprite Attribute
Now, since explosions naturally generate smoke,
let’s create a smoke effect that spreads outwards
To do this, I’ll start by setting up some basic movement for the Sprite Renderer
Let’s temporarily disable the MeshExplosion so we can focus on the smoke
Picture a large explosion
As it expands,
smoke trails spread out from the center
We want to replicate this behavior
by making the smoke particles extend outward as the sphere grows
For this, we need a spawned area
In the Particle Spawn section,
add a Shape Location module
Then, I’ll add an Add Velocity module
to give the particles some movement
You’ll notice that the particles
now appear in random positions
Since this is a sphere,
the particles are forming
within a spherical range randomly,
moving upwards like so
We'll modify the shape of the spawning area
Set the Shape Location to Torus
and increase the Radius to 200
For the velocity, I’ll change it from Linear
to From Point and set the value to 160
This transforms the spawning area to torus,
or a 3D donut-like shape
So in this donut-like shape, the particles will now
spawn randomly within this toroidal volume
I’ll increase the number of particles bursting
to around 50
You’ll see the particles spread outwards like this
The Torus shape we set earlier
is essentially an invisible donut-shaped spawning area
And here,
the Add Velocity module set to From Point
ensures that the particles spread outward
That's what it means
So all these particles
will be radiating away
from the origin point like this
That's the setup we have for now
Next, let’s combine this with the Explosion emitter
Currently, the particle velocity is too low,
causing the smoke particles to get overshadowed by the explosion sphere
To fix this, I’ll increase the velocity to 300 or 400,
adjusting it as necessary
by switching between different camera views
or testing it in the world
Try it yourselves to see
if the speed is appropriate as we designed
If the particle count feels insufficient,
you can boost it to 150 or more,
making the smoke more prominent
If you need more speed,
you can add a number you like,
for example, 600
However, there’s a limitation in the current setup
So when the particle
enlarges from this explosion point,
as it expands,
it transfers the flame
to the ground
That's how the smoke is engendered
The smoke at FireSmoke
originates a bit further away,
from the Torus shape, or the donut shape
creating a continuous stream
that spreads outward in a single burst,
instead of little steps in between
It's not like smoke now
We could change the texture later
This setup lacks the gradual, scattered feel
of actual smoke rising from different points
To address this,
duplicate the FireSmoke emitter using Ctrl+C and Ctrl+V,
resulting in FireSmoke and FireSmoke001
Using the concept of sub-emitters,
I’ll set up the system so that smoke appears
at specific points
As it enlarges,
it can appear where the fire interacts with the ground or other surfaces
Here’s how it will work
As the fire spreads outward,
it will trigger smoke at intervals
as it passes a certain point
At the first interaction point, smoke will rise
Then at the second point, another burst of smoke
Now at the third, so on
Now, let’s enhance the fire effect
by introducing smoke that dynamically spawns as the fire spreads
To achieve this, we’ll use sub-emitters,
also known as sub-particles,
which rely on the data from the main particles
to generate secondary particles
This allows us to control how the secondary particles are created
First, I’ll activate Requires Persistent IDs
in the Emitter Properties for the FireSmoke emitter
It says Requires Persistent ID
We need to enable this
This means
that I'm using the information in FireSmoke
to create sub-particles,
for which this needs to be registered
Next, to the Particle Update section of FireSmoke,
We have three events
Since we want our particle to burst every time the location shifts,
I’ll add a Generate Location Event module
Now, for the sub-particles,
Click on the plus button on stage,
and create a new one
called Event Handler
Specifically, in the Event Handler Properties,
start by setting the Source
on which information is being retrieved
since we have added the ID,
we can search for Location Event in FireSmoke right away
I’ll use the Location Event
from the FireSmoke emitter
By linking the Location Event to the secondary emitter,
I’ll ensure that the sub-particles are spawned based on the events generated by the original particles
For instance, spawn one particle at each event
or ten particles
Those are the decisions we can make now
From the top view, you’ll notice
a significantly larger number of particles being generated
To make this happen,
I’ll use the Receive Location Event
By going to the Event Handler and clicking the + button,
I’ll add the Receive module,
which will allow me to capture and use the events
triggered by the Location Event
Let's see it in the world
After resetting it,
let's move a little further away
This is how it looks like
At this point, you can customize
how the particles spread and
at what speed they expand outward
The Velocity settings apply here as well
When I say
existing Velocity,
I’m referring to the Velocity of FireSmoke,
I’ll decide whether to inherit and propagate
FireSmoke’s Velocity values
or customize them
In this case, since I’m creating
smoke rather than flames,
I’ll apply a smoke image
to the Sprite Renderer in Material
There are two kinds of Smoke here
Let’s assign the Smoke_SubUV option
Click on it
The colors may look off,
but I’ll fix that later using the Scale Color module
The Smoke_SubUV material,
double click on the material
It is essentially a sequence texture for smoke effects,
containing 64 images
arranged in an 8x8 grid
That's in the smoke effect
It's also called
the sequence texture for the smoke effect
To utilize this sequence properly, go to the Sprite Renderer
I'm working on FireSmoke001
For the SubUV Animation,
I’ll specify the total number of images in the texture grid
First, in the Sprite Renderer under SubUV,
let's input 8 and 8
Now at Update,
to animate these images,
up until the 64th image,
I’ll add the Sub UV Animation module
In the Setup section,
I’ll link this module to
the corresponding Sprite Renderer
Here, let's bring it up a little
Now, I’ll adjust the color and alpha values for Sub UV Animation
Now, let's check with the Scale RGB disabled
So originally, it should be white
But we added red
And we also had a problem
where the alpha value went to -1,
or even -2
So let's keep that 0
Let's change the color values
I’ll start by adjusting the Scale RGB
First, I’ll locate the X, Y, Z values, or Red, Green, Blue
Click the dropdown arrow
and switch it to Vector From Curve
Just to make it easier,
I’ll input 8, 1, 0.2 for
the respective Red, Green, and Blue channels
Next, in the graph editor,
when the state reaches 100%, I’ll adjust the red channel to -1,
so it darkens gradually over time
You can see how the previously vibrant red
transitions into a darker shade
For the alpha channel,
I’ll let it fade naturally
Currently, the particles are too small,
and the smoke effect isn’t very noticeable
To fix this, I’ll add the Scale Sprite Size module under the Update section
I’ll ensure the minimum size remains above 0,
around 0.3
Let's set the Uniform Curve Scale to 10 times
Like this
Currently, we’re emitting an enormous number of particles
If we check the actual number being emitted,
it reaches up to approximately
40,000 particles at its peak
If you want to control this number,
you can turn off the Spawn Burst for now
When I disable it, this happens
n the Event Handler, you can also limit the spawn amount
For instance, you could set it to allow only 100 particles
at maximum per frame, as you decide
For the Spawn Number, setting it to 1 is perfectly fine as well
Let's use 1
Now, when we combine this with the Explosion
and view it in the world,
Press reset, and you’ll see the particles spreading out like this
Let’s compare it to
the previous FireSmoke effect
You’ll notice that in the original FireSmoke,
the small, fine particles scatter subtly,
almost like sparks flying out
When using sub-emitters, the smoke’s range and speed become noticeably different
However, since the sub-emitter inherits
the existing velocity,
you’ll need to reduce the speed slightly compared to before
Setting it to around 200 will make it easier
to match the timing relatively well
For FireSmoke001, let’s reduce the Lifetime
under Initialize Particle to about 0.5
This way, the effect bursts out naturally,
and the smoke spreads smoothly
If you feel that
the Velocity causes the particles to crawl across the ground,
which you may not like,
you can switch the Velocity Mode to In Cone
Later, when you check it in the world,
you’ll notice how the particle effects spread across the ground
Switching it to In Cone
allows you to adjust the values
You can do this, for instance
The Axis of the In Cone is currently set to the X-axis with a value of 1,
but if we change this to the Z-axis with a value of 1, the particles will spread upwards
I’ve exaggerated the values here
to make the difference more visible,
but there’s no need to set it as high as 1800
You can reduce it to a lower value
so that the particles move more subtly
This way, the smoke can naturally ascend
by slightly adjusting the speed values
The same applies to the angle and similar settings
You can adjust everything so that the particles spread naturally from a specific explosion range
Next, looking at the color transitions of the flames,
you’ll see that over time,
the red color transitions to black
tarting as red, the color shifts
to black as it moves outward
This transition happens progressively
This helps alleviate the monotony of the effect,
and you can achieve this using sub-emitters
Utilizing sub-emitters like this is an excellent way
to make your particle effects feel richer
Now, for the FireSmoke,
there’s no real need to show those round, red particles
In the Scale Color settings, I’ll reset the Alpha value
Instead of using a curve for the Alpha,
I’ll reset it and set the Scale Alpha
So it's not Float From Curve
Even with 0 for Scale Alpha,
the sub-emitter, like FireSmoke001,
will remain unaffected
The FireSmoke becomes invisible
and gradually sends signals as it moves along
In response to these signals,
FireSmoke001,
which operates as a sub-emitter,
activates and continuously disperses smoke
Even now, the number of particles being emitted is relatively high,
with around 1,500 particles being generated
When creating particles, it can be challenging
to synchronize the timing of the sphere’s expansion,
the particles’ disappearance, and the timing of particle generation
However, by using the Event function,
you can align these elements with more precision
If you feel the frequency of the events is too high,
you can reduce the event trigger cycle to about 15
Or even 1, and see what happens
This is an unnatural sequence
I'm just demonstrating for the purpose of it
So I will set this to 20
So see, dun, dun, dun, like that
That feels like it’s burning the edges while progressing
That's what I made right there
Additionally,
if you’d like to try another effect,
you can right-click and select Add Emitter,
then choose the Omnidirectional Burst template
Let's add this emitter here
When isolating it with the right-click,
you’ll see it creates an explosion effect, like a sudden burst
For this, I’ll set the Velocity value
to a higher range, such as 600–1,200,
so the particles spread farther
We’ll adjust this further when combining it with the actual emitter later
For the Origin Offset,
I’ll leave the default setting of 0 for the Omnidirectional Burst,
without shifting it negatively or downwards
There's no need to make it a minus value
Next, for the Scale Color value,
I’ll set the Scale RGB to 8, 1, 0.2,
creating the appearance of small sparks scattering outwards
Now, let’s add a Collision feature
to this here
Collision
With this feature,
some of the particles, though not all,
will gain collision properties
Resetting this and testing it in the world,
you can see particles bouncing off the ground upon impact,
adding a touch of realism
After testing the isolated mode,
I’ll uncheck the isolated setting
It seems the Velocity needs to be increased
to around 1,200–1,600
Resetting and triggering the effect again,
you’ll see a large explosion effect
accompanied by massive flames,
sparks, smoke, and so on
That's how I made the effect
You can fine-tune settings like Lifetime
and others to achieve
a smoother and more natural result
In this session, make sure to remember
the concept of sub-emitters
In today’s session of the explosion event,
we explored various methods to control speed
We also used shader movements
to control the motion of meshes
By utilizing mesh particles, we created effects like shockwaves and smoke,
visualizing concepts that are typically difficult
to perceive as having volume
Let’s wrap up by summarizing
what we’ve learned in this session
Thank you
Explosion Radius and Explosion Effects Create a Niagara asset using the SingleLoopingParticle template and deactivate the SpriteRenderer
Add MeshRenderer: Change the StaticMesh Index [0] to Sphere Emitter State
Life Cycle Mode: Self, Loop Behavior: Once, Loop Duration Mode: Fixed, Loop Duration: 1.0
Initialize Particle LSprite Size Mode : Unset, Lifetime : Reset (1.0), Mesh Scale Mode : Uniform, 1.0
Scale Mesh Size Add to Particle update에, Scale Factor : Vector From Curve
Vector Curve (x : 0, y : 0), (x : 1, y : 1) Scale Curve : Vector from Float, Value 10
Create M_ExplosionFX Blend Mode: Translucent, Shading Model: Unlit Create Lerp, Lerp A:
VectorParameter (FireColor, 8, 1, 0.2), Lerp B: Constant3Vector (0, 0, 0), Lerp Alpha: Fresnel,
Lerp Output: Emissive Texture Sample: T_Perlin_Noise_M Create Panner: Speed X: 1, Y: 1 / Texture Sample
Connect to Node UV Create Multiply, A: Texture Sample, B: 1, Connect result to Fresnel: ExponentIn에 Multiply Texture Sample:
T_Detail_Rocky_N Connect Panner to Texture Sample Node UV Create Multiply, A: Texture Sample, B: 10, Output:
World Position Offset Create Multiply, A: Fresnel, B: 2, Output: Lerp Alpha
Create Dynamic Parameter: R(FresnelPower, 1.2), G(WorldOffsetVal, 5), B(Noise, 2), A(Speed, 0.5)
Integrate Niagara: Activate Enable Material Override in MeshRenderer
Add Override Materials: Set Index [0] to M_ExplosionFX
Dynamic Material Parameter Module
R(FresnelPower, 1.2), G(WorldOffsetVal, 10), B(Noise, 2), A(Speed, 0.5)
Particle Color Integration Blend Mode: Masked Connect Particle Color Node to Lerp A
Lerp A: Add result of Fresnel and Multiply Connect to Opacity Mask Scale Color Module:R: 8, G: 1, B: 0.2
Scale Alpha: Float from Curve (0 : 1, 1 : -2)
Creating Smoke and Spark Effects FireSmoke Duplicate SingleLoopingParticle and rename it FireSmoke
Spawn Burst: 50, Sprite Size Mode: Uniform/10, Mesh Attributes: Unset
Add ShapeLocation Module Shape Primitive: Torus, Large Radius: 200, Handle Radius: 25
Add Velocity Velocity Mode: From Point, Velocity Speed: 600
Emitter Properties: Activate Requires Persistent ID
Add Generate Location Event
Add Sub FireSmoke by duplicating FireSmoke Add Event Handler to the Stage Deactivate Spawn Burst
Event Handler Properties의 Spawn Number: 10 Add Receive Location Event
SpriteRenderer Material: M_Smoke_subUV, SubUV: (8, 8) Add Sub UV Animation
Add SpriteRenderer
ScaleColor's Scale RGB: (0 : 1) / (1 : -1), Scale Curve: (8, 1, 0.2), Scale Alpha: (0 : 1) / (1 : 0)
Scale Sprite Size Mode: Uniform, Uniform Curve Sprite Scale: (0 : 0.3) / (1 : 1),
Uniform Curve Scale: 10 Spark (OmnidirectionBurst)
Velocity Speed of Add Velocity: Min 1200 / Max 1600, Origin Offset: (0, 0, 0)
Add Collision Module