Unity's Visual Effect Graph (hereinafter referred to as VFX Graph) is a powerful tool that utilizes the GPU to draw large numbers of particles at high speed. VFX Graphs often sample textures (such as noise maps) to control movement. However, bugs may occur, such as "particles disappear from the screen as soon as a texture is dynamically passed from a C# script" or "the way the noise is applied is distorted, resulting in unintended behavior."

In this article, we will investigate the cause of the sampling failure that occurs when passing dynamic textures from C# to VFX Graph, and explain the solution steps to safely transfer parameters and stabilize particle control.

For beginners: How would you describe this problem in real life?

Let's compare the relationship between the VFX Graph and dynamic textures to the "projector and slide film" used in school classes.

VFX Graph is a projector that reads a given image (slide film) and projects light particles according to the pattern. When using a pre-prepared image, the film is fixed from the beginning, so a clear image will be projected onto the wall without any problems.

But suppose in the middle of class the teacher (C# script) wants to insert a new handmade film (dynamic texture). At this time, if the resolution setting of the film is misaligned with the projector's frame, or if the film itself is made in a special format and does not transmit light, only a pitch-black shadow will be visible on the wall. This is the true nature of the "particles disappearing" phenomenon. Furthermore, even if you write the wrong slot name (variable name) and insert it in a different location, the machine will not be able to read it. For it to work correctly, you need to match the settings of the receiving slot (Blackboard) and the standard of the film you are handing (C# assignment).

Problem symptoms and specific phenomena

When this texture passing bug occurs, the following symptoms are observed.

  • The moment you assign a texture from the script, all the particles that were out until then become invisible (disappear).
  • No error is displayed in the console, but only the VFX Bounds remain drawn.
  • The light and dark of the passed texture may be interpreted as reversed, or the sample may be extremely enlarged or reduced, causing particles to move unnaturally.

Possible cause: Why is the interpretation incorrect?

There are three main reasons why dynamic texture binding to VFX Graph fails:

  1. Blackboard variable type mismatch: The type of the public variable on the VFX Graph side is not the Texture2D expected on the C# side, but is an incompatible type. Or, the reference name of the variable and the string specified in C# do not exactly match.
  2. Spelling mistakes due to direct string specification in C#: If you continue to specify properties directly with strings in the script, such as vfx.SetTexture("MyNoiseTex", texture), it is easy to cause binding failures due to typos.
  3. Texture instance state: Dynamically generated RenderTexture etc. are bound in a "null state that has not yet been completely constructed" and are treated as zero sampling (black) on the VFX Graph side.

Specific solutions and approaches

The implementation steps to ensure this problem is avoided and dynamic texture transfer is successful are as follows.

1. Unification of variable types and "Reference" names on the VFX Graph side

Open the VFX Graph editor and check the following two points in the Blackboard panel.

  • The variable type is Texture2D.
  • The name of the Reference field (e.g. m_NoiseTex) must match the name you call from C#. (*The Reference name is used for binding, not the display name).

2. Fast and secure binding using PropertyToID

Setting a texture by specifying a string every frame on the C# side not only causes bugs due to typos, but also creates a search load inside Unity. To prevent this, use Shader.PropertyToID to convert it to an integer type ID in advance, and then perform the binding via that. 

using UnityEngine;
using UnityEngine.VFX;

public class VFXTextureBinder : MonoBehaviour
{
    [SerializeField] private VisualEffect targetVFX;
    [SerializeField] private Texture2D dynamicNoiseTexture;

    // Specify the Reference name set in Blackboard of VFX Graph
    private static readonly int NoiseTexPropertyId = Shader.PropertyToID("m_NoiseTex");

    void Start()
    {
        if (targetVFX == null) targetVFX = GetComponent();
        ApplyDynamicTexture();
    }

    public void ApplyDynamicTexture()
    {
        if (targetVFX != null && dynamicNoiseTexture != null)
        {
            // Secure and fast texture configuration via ID
            targetVFX.SetTexture(NoiseTexPropertyId, dynamicNoiseTexture);
            Debug.Log("Successfully bound dynamic texture to VFX Graph.");
        }
    }
}

Confirmation checklist useful in practice

This is a practical checklist to check when passing textures to VFX Graph.

Confirmation items Countermeasures/confirmation steps
Check Reference name Does the Reference name of the Blackboard variable exactly match the specified name in C#?
Exposed setting Is the Exposed checkbox of the texture variable on Blackboard turned on?

Summary

Dynamic texture binding from C# to VFX Graph is the foundational technology for creating powerful dynamic visuals. If the display disappears or breaks, you can eliminate bugs by checking the Reference settings of variables, building reliable binding paths with Shader.PropertyToID, and checking the instance state of the texture itself.