4-tap Sobel filter

2025-11-25 13:10 UTC gpt-5-1-thinking Open in ChatGPT ↗

Here’s a plug-and-play 4-tap Sobel-ish edge filter you can drop into a Shader Graph Custom Function (HLSL file mode). It works on a single channel (uses .r) and uses only 4 texture samples.

HLSL function (Sobel4Tap_float)

// 4-tap Sobel-like edge detection for a single channel
// Ready for Shader Graph Custom Function (HLSL file)

// Signature for Shader Graph (Function Name: Sobel4Tap, Type: float)
void Sobel4Tap_float(
    Texture2D     tex,         // source texture
    SamplerState  texSampler,  // sampler for the source texture
    float2        uv,          // UV to sample
    float2        texelSize,   // 1.0 / texture resolution
    out float     edge         // single-channel edge strength
)
{
    // Diagonal samples
    float s1 = tex.Sample(texSampler, uv + texelSize * float2(-1.0, -1.0)).r; // top-left
    float s2 = tex.Sample(texSampler, uv + texelSize * float2( 1.0,  1.0)).r; // bottom-right
    float s3 = tex.Sample(texSampler, uv + texelSize * float2( 1.0, -1.0)).r; // top-right
    float s4 = tex.Sample(texSampler, uv + texelSize * float2(-1.0,  1.0)).r; // bottom-left

    // 4-tap Sobel-like gradients
    float gx = s1 - s2;
    float gy = s3 - s4;

    // Edge magnitude
    edge = sqrt(gx * gx + gy * gy);
}

How to wire it in Shader Graph

Create an HLSL file (e.g. Sobel4Tap.hlsl) and paste the code above.
In Shader Graph, add a Custom Function node:
- Source: File
- Function Name: Sobel4Tap_float
Add inputs to the node (order must match the function):
1. Texture2D – Name: tex
2. SamplerState – Name: texSampler
3. Vector2 – Name: uv
4. Vector2 – Name: texelSize
Add one Float output named edge.

Getting `uv` and `texelSize`

uv: usually from Screen Position (Raw) → split XY.
texelSize: float2(1.0 / width, 1.0 / height); in Shader Graph you can:
- Use Screen Size node, take XY, do 1 / ScreenSize.

The edge output is a single-channel edge strength you can use as a mask or feed into further effects.

Yep, that error is Unity being picky about texture types, not your math.

Shader Graph is actually passing a typed texture (or even a UnityTexture2D wrapper), while the function I gave used the old untyped Texture2D. Let’s fix it so you can drop it in without complaints.

Option A – Works in recent Shader Graph (recommended)

Use UnityTexture2D as input and the SAMPLE_TEXTURE2D macro.
In the Custom Function node, set the texture input type to Texture2D (Unity will wrap it as UnityTexture2D for the HLSL).

HLSL (`Sobel4Tap.hlsl`)

// 4-tap Sobel-like edge detection for a single channel
// For Unity Shader Graph Custom Function (file mode)

void Sobel4Tap_float(
    UnityTexture2D tex,   // texture input (set as Texture2D in Shader Graph)
    float2 uv,            // UV
    float2 texelSize,     // 1.0 / resolution
    out float edge        // single-channel edge strength
)
{
    // Diagonal samples (single channel: .r)
    float s1 = SAMPLE_TEXTURE2D(tex.tex, tex.samplerstate, uv + texelSize * float2(-1.0, -1.0)).r; // top-left
    float s2 = SAMPLE_TEXTURE2D(tex.tex, tex.samplerstate, uv + texelSize * float2( 1.0,  1.0)).r; // bottom-right
    float s3 = SAMPLE_TEXTURE2D(tex.tex, tex.samplerstate, uv + texelSize * float2( 1.0, -1.0)).r; // top-right
    float s4 = SAMPLE_TEXTURE2D(tex.tex, tex.samplerstate, uv + texelSize * float2(-1.0,  1.0)).r; // bottom-left

    float gx = s1 - s2;
    float gy = s3 - s4;

    edge = sqrt(gx * gx + gy * gy);
}

Shader Graph setup

Custom Function node (File mode):

Source: your Sobel4Tap.hlsl
Function Name: Sobel4Tap_float

Inputs (in this exact order):

tex – Texture2D
uv – Vector2
texelSize – Vector2

Outputs:

edge – Float

No separate sampler input is needed in this variant; it’s inside UnityTexture2D.

Option B – Typed `Texture2D<float4>` (if you don’t use UnityTexture2D)

If your project is older / simpler and Shader Graph passes Texture2D<float4> instead, just change the parameter type:

void Sobel4Tap_float(
    Texture2D<float4> tex,
    SamplerState      texSampler,
    float2            uv,
    float2            texelSize,
    out float         edge
)
{
    float s1 = tex.Sample(texSampler, uv + texelSize * float2(-1.0, -1.0)).r;
    float s2 = tex.Sample(texSampler, uv + texelSize * float2( 1.0,  1.0)).r;
    float s3 = tex.Sample(texSampler, uv + texelSize * float2( 1.0, -1.0)).r;
    float s4 = tex.Sample(texSampler, uv + texelSize * float2(-1.0,  1.0)).r;

    float gx = s1 - s2;
    float gy = s3 - s4;

    edge = sqrt(gx * gx + gy * gy);
}

Inputs (Shader Graph):

tex – Texture2D
texSampler – SamplerState
uv – Vector2
texelSize – Vector2
Output: edge – Float

If you tell me which render pipeline & Unity version you’re on (URP/HDRP/Built-in), I can lock it exactly to that style, but one of the two above should immediately fix the “cannot convert from struct Texture2D / UnityTexture2D to Texture2D<float…>” error.

I now want to make a generic depth blur function. it need to access the depth texture and not receive texture as input

void Blur_float( UnityTexture2D tex, // source texture UnitySamplerState texSampler, // sampler for the source texture out float Result) float2 uv, float4 screenParams, float shadowBlurRadius, out float result) {

// ---- 4-tap blur ----
// Use a small cross/corner kernel; tweak _ShadowBlurRadius for strength.

    // _ScreenParams.zw == (1/width, 1/height)
    float2 texel = screenParams.zw * shadowBlurRadius;

    // A simple 4-corner kernel
    float2 k0 = float2(-0.5, -0.5) * texel;
    float2 k1 = float2( 0.5, -0.5) * texel;
    float2 k2 = float2(-0.5,  0.5) * texel;
    float2 k3 = float2( 0.5,  0.5) * texel;

    // The screen-space shadow texture encodes attenuation (1 = lit, 0 = fully shadowed)
    // Names are from URP; adjust if your shader has different sampler names.
    float s0 = SAMPLE_TEXTURE2D(tex, texSampler, uv + k0).r;
    float s1 = SAMPLE_TEXTURE2D(tex, texSampler, uv + k1).r;
    float s2 = SAMPLE_TEXTURE2D(tex, texSampler, uv + k2).r;
    float s3 = SAMPLE_TEXTURE2D(tex, texSampler, uv + k3).r;

    result = (s0 + s1 + s2 + s3) * 0.25;

}

You can do this cleanly in Shader Graph by sampling the scene depth directly using Unity’s built-in macro SHADERGRAPH_SAMPLE_SCENE_DEPTH, so you don’t need a UnityTexture2D or sampler input at all.

Here’s a ready-to-drop-in function that does a simple 4-tap blur of the depth buffer around a UV:

// Depth blur using the camera depth texture.
// Uses SHADERGRAPH_SAMPLE_SCENE_DEPTH so no texture/sampler inputs are needed.
//
// Function name for Custom Function node (Name field): DepthBlur
// Actual function symbol (for float precision): DepthBlur_float

void DepthBlur_float(
    float2 uv,              // normalized screen UV (0–1)
    float4 screenParams,    // Unity _ScreenParams: (width, height, 1/width, 1/height)
    float  blurRadius,      // radius multiplier (e.g. 1–3)
    out float result        // blurred depth (raw depth)
)
{
    // screenParams.zw == (1/width, 1/height)
    float2 texel = screenParams.zw * blurRadius;

    // 4-corner offset kernel
    float2 k0 = float2(-0.5, -0.5) * texel;
    float2 k1 = float2( 0.5, -0.5) * texel;
    float2 k2 = float2(-0.5,  0.5) * texel;
    float2 k3 = float2( 0.5,  0.5) * texel;

    // Sample scene depth; macro provided by Shader Graph
    float d0 = SHADERGRAPH_SAMPLE_SCENE_DEPTH(uv + k0);
    float d1 = SHADERGRAPH_SAMPLE_SCENE_DEPTH(uv + k1);
    float d2 = SHADERGRAPH_SAMPLE_SCENE_DEPTH(uv + k2);
    float d3 = SHADERGRAPH_SAMPLE_SCENE_DEPTH(uv + k3);

    // Simple average blur
    result = (d0 + d1 + d2 + d3) * 0.25;
}

Shader Graph setup

Custom Function Node:

Type: File (point it to your .hlsl file containing the function)
Name: DepthBlur
(Shader Graph will call DepthBlur_float under the hood)

Inputs (in this exact order):

uv – Vector2
- You can use Screen Position node → Mode: Raw → divide XY by W to get normalized UV (or use the default Scene Depth node style UVs if already normalized).
screenParams – Vector4
- Plug Unity’s Screen Parameters node here.
blurRadius – Float
- Your blur strength parameter (e.g. 1–3).

Outputs:

result – Float
- This is raw depth (same as Scene Depth in Raw mode). You can convert/normalize it in the graph if you like.

Notes / gotchas

Make sure Depth Texture is enabled in your render pipeline (URP/HDRP), otherwise the depth buffer will be invalid or constant.citeturn0search0turn0search13
For more control (Linear01 / Eye depth), you can convert result using nodes or HLSL functions like Linear01Depth / LinearEyeDepth with _ZBufferParams if your pipeline headers expose them.citeturn0search13
Because this uses SHADERGRAPH_SAMPLE_SCENE_DEPTH, it correctly handles platform differences and works the same way the Scene Depth node does.citeturn0search5

If you want, I can also give you a variant that outputs Linear01 depth directly instead of raw.