Passing data to Shader Graph

2025-12-19 11:26 UTC gpt-5-2 Open in ChatGPT ↗

Not directly, no.

Shader Graph shaders run on the GPU as part of a render pass. A CommandBuffer is a CPU-side list of rendering commands that Unity submits to the GPU. You can’t “pass a CommandBuffer into Shader Graph” like a parameter.

What you can do is use the CommandBuffer (or any C# code) to set GPU data that the Shader Graph reads.

Ways to pass array-like data into Shader Graph

1) ComputeBuffer / StructuredBuffer (best for big arrays)

Use a ComputeBuffer (or GraphicsBuffer) from C# and bind it to the material. Then, in Shader Graph you read it via a custom node (because Shader Graph doesn’t expose StructuredBuffers as a nice first-class property in all pipelines/versions).

ComputeBuffer buf = new ComputeBuffer(count, sizeof(float) * 4); // float4
buf.SetData(myFloat4Array);

material.SetInt("_Count", count);
material.SetBuffer("_MyBuffer", buf);

Shader Graph

Add a Custom Function Node (HLSL) or Custom HLSL (depending on Unity version).
Declare:

StructuredBuffer<float4> _MyBuffer;
int _Count;

void ReadAt_float(int index, out float4 value)
{
    value = _MyBuffer[index];
}

Then you can feed index and get value.

This is the go-to for things like many points, bones, instances, splines, etc.

2) Texture / RenderTexture as a “data texture” (very Shader-Graph-friendly)

Encode your array into a 1D/2D texture and sample it in Shader Graph.

Put floats in an RFloat / RGBAFloat texture.
Upload from C# with Texture2D.SetPixelData / SetPixels + Apply, or render it via compute/Blit.
In Shader Graph: use Sample Texture 2D with Point filtering for exact values.

Great if you want wide compatibility and avoid custom HLSL nodes.

3) Material.SetVectorArray / SetFloatArray (small arrays only)

Unity supports arrays as material properties:

material.SetVectorArray("_Points", points);
material.SetInt("_Count", points.Length);

But Shader Graph support is limited (often you still need a custom function node to index the array), and there are practical limits on size/performance. Good for “a few dozen” values, not thousands.

4) Global arrays/buffers (if many materials need it)

Instead of material.Set…, use:

Shader.SetGlobalBuffer("_MyBuffer", buf);
Shader.SetGlobalInt("_Count", count);

Then any shader/material can read it.

Where CommandBuffer fits in

A CommandBuffer is useful to:

create/update a RenderTexture (data texture)
dispatch a compute shader that writes to a buffer/texture
set global buffers/textures right before a pass

…but the Shader Graph still consumes the buffer/texture/constant, not the command buffer itself.

If you tell me which render pipeline (Built-in / URP / HDRP) and what the “array info” represents (positions? colors? curve points? instance transforms?), I can recommend the cleanest approach and give you a working minimal example for that pipeline.

In HDRP you still can’t “feed a CommandBuffer into Shader Graph”, but you can feed GPU data that your graph reads. For “an array says which face should be colored”, the cleanest Shader-Graph-friendly solution is:

Best approach in HDRP Shader Graph: face index in the mesh + a data texture

Why this works

Shader Graph can easily sample a texture, but it’s awkward to index arbitrary CPU arrays directly. So you:

store a FaceID per face in the mesh (as a vertex attribute), and
upload your per-face weather result into a 1D lookup texture (or 2D if you prefer), and
in Shader Graph: color = tex(FaceID).

Important mesh requirement

If a vertex is shared by multiple faces, FaceID will interpolate / conflict.
So you need split vertices per face (like a flat-shaded mesh / hard edges). Many procedural meshes already do this; otherwise you may need to duplicate vertices so each triangle has unique vertices.

Step-by-step

1) Store FaceID per triangle in UV2 (or Color)

When building the mesh, write the same FaceID to all 3 vertices of the triangle (e.g. into uv2.x).

FaceID range: 0 .. faceCount-1
Store as float (fine up to ~16 million integer precision in float24 mantissa, but practically you’re safe for typical mesh sizes)

2) Create a “face data” texture

Use width = faceCount, height = 1.

If you just need “color this face or not”: R8 or RFloat
If you need an actual color per face: RGBA32 / RGBAHalf / RGBAFloat

C# (mask example, 0..1 per face)

int faceCount = triangleCount; // one value per triangle
var tex = new Texture2D(faceCount, 1, TextureFormat.RFloat, false, true);
tex.filterMode = FilterMode.Point;
tex.wrapMode = TextureWrapMode.Clamp;

float[] faceMask = new float[faceCount]; // fill from your weather system
tex.SetPixelData(faceMask, 0);
tex.Apply(false, false);

material.SetTexture("_FaceMaskTex", tex);
material.SetFloat("_FaceMaskTexWidth", faceCount);

For frequent updates, keep the texture and call SetPixelData + Apply(false,false) when data changes.

3) Shader Graph: sample the face data texture

In Shader Graph:

Add a Texture2D property: _FaceMaskTex
Add a Float property: _FaceMaskTexWidth
Read FaceID from your chosen attribute:
- If you stored in UV2.x, use UV node set to UV2, take X
Convert FaceID → texture U coordinate:

u = (FaceID + 0.5) / _FaceMaskTexWidth
v = 0.5

Then:

Use Sample Texture 2D (set Sampler State to Point/Clamp if you expose it, or set on the texture as above)
Use sampled R as mask, then Lerp(BaseColor, WeatherColor, mask)

That gives you a per-face weather-driven color.

Alternative (more “pure GPU”): StructuredBuffer + PrimitiveID

If you want to avoid duplicating vertices / storing FaceID, the “ideal” way is to index by SV_PrimitiveID (triangle ID) and read a StructuredBuffer. But Shader Graph doesn’t make PrimitiveID + StructuredBuffer indexing painless; it typically requires a custom HLSL shader or more advanced HDRP customization (custom pass / hand-written shader).

So unless you’re already comfortable dropping to HLSL, the data texture + FaceID attribute is the most practical in Shader Graph.

Quick sanity checklist

✅ Do faces change color “randomly” near edges? → you have shared vertices; you need split vertices per face.
✅ Are you seeing blurred values? → ensure Point filtering and correct (FaceID + 0.5)/width addressing.
✅ Need multiple weather values per face (wetness, snow, heat)? → pack into RGBA channels.

If you tell me whether your “face should be colored” data is binary (yes/no) or a full color, and roughly how many faces you’re targeting (hundreds / thousands / 100k), I’ll recommend the best texture format + update strategy (CPU update vs compute).