Perlin noise shader graph

2025-12-11 10:58 UTC gpt-5-1-thinking Open in ChatGPT ↗

You

Perlin-noise implementation ready to be pasted in shader graph Custom node

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Here’s a ready-to-paste 2D Perlin noise implementation for a Unity Shader Graph Custom Function Node (HLSL).

Use it as a String custom node, with:

• Function Name: PerlinNoise2D_float
• Inputs:
  • UV (Vector2)
  • Scale (Float)
• Output:
  • Out (Float)

// 2D Perlin Noise for Unity Shader Graph Custom Function Node
// Function name: PerlinNoise2D_float
// Inputs : float2 UV, float Scale
// Output: float Out

// Fade function (Perlin's smoothing curve)
float2 PerlinFade(float2 t)
{
    return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
}

// Pseudo-random gradient vector based on input lattice point
float2 PerlinRandomGradient(float2 p)
{
    // Hash based on sine; cheap and repeatable
    float f = frac(sin(dot(p, float2(127.1, 311.7))) * 43758.5453123);
    float angle = f * 6.28318530718; // 2 * PI
    return float2(cos(angle), sin(angle));
}

// Main 2D Perlin noise function
void PerlinNoise2D_float(float2 UV, float Scale, out float Out)
{
    float2 p = UV * Scale;

    // Lattice coordinates
    float2 i0 = floor(p);
    float2 f0 = frac(p);
    float2 i1 = i0 + float2(1.0, 0.0);
    float2 i2 = i0 + float2(0.0, 1.0);
    float2 i3 = i0 + float2(1.0, 1.0);

    // Gradient vectors at the four corners
    float2 g00 = PerlinRandomGradient(i0);
    float2 g10 = PerlinRandomGradient(i1);
    float2 g01 = PerlinRandomGradient(i2);
    float2 g11 = PerlinRandomGradient(i3);

    // Distance vectors from each corner to p
    float2 d00 = f0 - float2(0.0, 0.0);
    float2 d10 = f0 - float2(1.0, 0.0);
    float2 d01 = f0 - float2(0.0, 1.0);
    float2 d11 = f0 - float2(1.0, 1.0);

    // Dot products between gradients and distance vectors
    float v00 = dot(g00, d00);
    float v10 = dot(g10, d10);
    float v01 = dot(g01, d01);
    float v11 = dot(g11, d11);

    // Smooth interpolation weights
    float2 w = PerlinFade(f0);

    // Interpolate along x
    float vx0 = lerp(v00, v10, w.x);
    float vx1 = lerp(v01, v11, w.x);

    // Interpolate along y
    float value = lerp(vx0, vx1, w.y);

    // Map from roughly [-1,1] to [0,1]
    Out = value * 0.5 + 0.5;
}

How to wire it in Shader Graph:

1. Add a Custom Function node.
2. Set Source to String.
3. Paste all the code above.
4. Function Name: PerlinNoise2D_float.
5. Add inputs:
   • UV — Vector2
   • Scale — Float
6. Add output:
   • Out — Float

Then plug Out into whatever you like (albedo, height, etc.). If you want, I can also give you a 3D version or a tiling variant.