Unity Engine Lab 2

Step 1: VFX Graph

The VFX effect we’ll be creating will simulate snowfall. For that, we’ll need an FBX file of a snowflake that we exported earlier in the Blender tutorial.
The first step is to create the actual VFX graph.

After opening the created VFX graph, you should see something like this:

Before we dive into creating, let’s quickly go over the logic and theory of what we’re looking at:

1. Section

This is the Blackboard.
The Blackboard serves as a centralized place for storing and managing parameters, properties, and other data that can be used by nodes within the graph. Its main features include:

• Parameter Management – Defining and handling parameters such as colors, sizes, or booleans.
• Data Binding – Nodes in the graph can be linked to the Blackboard, so changing a parameter dynamically affects other parts of the graph.
• Graph Communication – Nodes can communicate with each other by writing and reading data from the Blackboard.
• Exposed Parameters – Parameters that we want to control externally, e.g., from scripts.

2. Section

Here we see the structure of our effect. This is where we add components, set properties, and shape the overall behavior of the effect. The main parts are:

• Spawn – Modules like “Spawn” or “Burst” used to control particle generation.
• Initialize Particle – Module for defining initial particle properties.
• Update Particle – Module that defines how particles evolve over time.
• Output Particle Quad – Module that determines how particles are rendered in the scene.

Each module can be customized based on our needs, so we don’t have to use all of them.
Pressing SPACE allows you to add a new module and browse all available options.

3. Section

The Play Controls window is used to preview the effect. It includes Play, Stop, and Pause options, as well as Play Rate, which controls the playback speed.

That’s all we need to know for now — let’s get started.

Step 2: Diving In

To add an element to our system, press Space or right-click.
However, be careful whether you’re creating a block or a node.
If you want to create a block, your cursor must be inside a block area.

The difference between them:

• Node – A self-contained element that processes data and controls the flow of the effect in the graph.
• Block – Components that exist only within specific contexts (e.g., Spawn system, Initialize particle, etc.).

First, we’ll modify how our snowfall effect appears.
In the Spawn section, the constant mode means particles spawn and disappear constantly — which is perfect for snow, so we’ll leave it as is.

Instead, we’ll remove the Set Lifetime Random block and add a new one named Set Position Random (Per-component).
This lets us define random positions for each spawned particle within a specified range.
Next, we’ll add a lifetime for these particles using Add Lifetime, which gives each particle the same lifespan.
Finally, we can randomize their size with Set Scale.XYZ Random (Per-component).

We can now delete the entire Output Particle Quad block because we want the final particle to be our Blender FBX snowflake file.
Click and drag from the previous block’s output downwards, release, and choose Output Particle Mesh.

As you can see, the particles currently have no texture.

When you expand the asset, you’ll see it consists of a material and an object.
The material isn’t relevant since we didn’t create one in Blender — we only need the object itself.
Drag the object into the Mesh field under Output Particle Mesh.
Then set the color mapping to Gradient Mapped and choose white.

As you may notice, the texture now appears — though it may be very small.
In that case, adjust the snowflake size and play around with it.
One major issue is that the snowflakes are rotated incorrectly.

After adjusting the rotation, our scene should look something like this:

Step 3: Enhancing the Scene

Right now, our scene looks pretty empty. Let’s improve it by adding some fog.

Fog can be found under:
Window > Rendering > Lighting > Environmental

This small tweak already makes the scene look much better.
We can enhance it even further by adding a different skybox.

Step 4: Adding More Effects

A VFX graph doesn’t have to contain only one particle initialization module — it can generate an unlimited number of effects.
This means we can enhance our snowfall by adding higher-quality flakes in the center of the effect near the camera, creating a richer and more detailed look.

Add the following blocks:
Set Velocity Random (Per-component), Set Lifetime Random (Uniform), Set Position Random (Per-component), Set Scale.XYZ (Per-component), and Set Angle.XYZ Random (Per-component) — and adjust them as shown in the image.

As before, set the output to Output Particle Mesh, insert the snowflake asset, and apply color mapping using Gradient Mapped.

The final result should look like this:

Step 5: Controlling the Effect via Script

To control the effect via script, we need to expose parameters in the VFX Graph. This allows us to modify them using code. To make a parameter exposed, click the “+” button in the Blackboard.

Add a “Float” named SpawnRate and link it to Constant Spawn Rate. You can now access and modify this value via script.

Similarly to SpawnRate, add the following parameters (WindVelocity_low, WindVelocity_high, SnowflakeSize_low, and SnowflakeSize_high). Unlike SpawnRate, these will affect XYZ positions and velocities, so instead of “Float,” select “Vector3”. Connect them to their respective blocks in the graph.

Now we can implement the script.

Right-click in the Project window and choose C# Script. Rename it to SnowstormToggle and open it with a double-click.

This script demonstrates how to modify exposed parameters through code. It includes a simple void method that will be triggered via a button we’ll create later.

using UnityEngine;
using UnityEngine.VFX;

public class SnowstormToggle : MonoBehaviour
{
    public VisualEffect snowfallEffect;
    private bool isSnowstorm = false;

    private float normalSpawnRate = 50000;
    private Vector3 normalSnowflakeSize_low = new Vector3(4f, 4f, 4f);
    private Vector3 normalSnowflakeSize_high = new Vector3(7f, 7f, 7f);
    private Vector3 normalWind_low = new Vector3(1, -1, 1);
    private Vector3 normalWind_high = new Vector3(5, -5, 5);

    private float stormSpawnRate = 100000;
    private Vector3 stormSnowflakeSize_low = new Vector3(8f, 8f, 8f);
    private Vector3 stormSnowflakeSize_high = new Vector3(11f, 11f, 11f);
    private Vector3 stormWind_low = new Vector3(5, -5, 5);
    private Vector3 stormWind_high = new Vector3(10, -10, 10);

    public void ToggleSnowstorm()
    {
        if (isSnowstorm)
        {
            snowfallEffect.SetFloat("SpawnRate", stormSpawnRate);
            snowfallEffect.SetVector3("SnowflakeSize_low", stormSnowflakeSize_low);
            snowfallEffect.SetVector3("SnowflakeSize_high", stormSnowflakeSize_high);
            snowfallEffect.SetVector3("WindVelocity_low", stormWind_low);
            snowfallEffect.SetVector3("WindVelocity_high", stormWind_high);
        }
        else
        {
            snowfallEffect.SetFloat("SpawnRate", normalSpawnRate);
            snowfallEffect.SetVector3("SnowflakeSize_low", normalSnowflakeSize_low);
            snowfallEffect.SetVector3("SnowflakeSize_high", normalSnowflakeSize_high);
            snowfallEffect.SetVector3("WindVelocity_low", normalWind_low);
            snowfallEffect.SetVector3("WindVelocity_high", normalWind_high);
        }

        isSnowstorm = !isSnowstorm;
    }
}

To apply this script to a button, it is necessary to create an "Empty Object" in the hierarchy using "Create Empty". After creating this object, move the script into it.

In "Snowfall effect", insert the VFX graph for the snowfall.

In the next step, create a button in the hierarchy under UI > Button. You will see a large canvas appear, which contains the button. This canvas represents the user interface in the game. The fact that it looks strange in the scene view doesn’t matter.

Next, open the button in the Inspector and under "On Click", use the "+" to add an on-click effect — in other words, what happens when the user clicks the button. Then, drag the object containing the script into the On Click event field. After you have the object with the script there, click on No function > (class name) > (void method name).

If you now press Play in Unity, you will see a button in the game that adjusts the effect according to the script.

Now you can try changing these values and test what works best for your effect.