Shader not working after updating Unity

Unity Engine
1

I’ve attached a shader to a screen renderer, however, the parts that should be alpha, are completely black and I can’t see what should be on the camera (Culling Mask: Everything).

The shader worked perfectly before updating Unity to 5.6 (I was on 5.4 before and now I’m on 2017). I have no idea why it’s not working and a friend of mine used it and said it was working on his end. Did something update behind the scenes I’m not seeing that changed the way alphas work in Unity?

Here’s the code for my screen renderer:

using UnityEngine;
using System.Collections;
[ExecuteInEditMode]
public class ScreenRenderer : MonoBehaviour
{
    public Material mat;

    void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        Graphics.Blit(source, destination, mat);
    }
}

And here’s the shader I’m using:

// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'

Shader "Custom/ScreenRenderer_Circle"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Color("Color", Color) = (0,0,0,0)
        _OffX("Offset X", Float) = 0
        _OffY("Offset Y", Float) = 0
        _Radius ("Radius", Range(0, 2.5)) = 0

    }
    SubShader
    {
        // No culling or depth
        Cull Off ZWrite Off ZTest Always

        Pass
        {
            Tags {
            "Queue" = "Transparent"
            }

            Blend SrcAlpha OneMinusSrcAlpha

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
           
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _Color;
            float _Radius, _OffX, _OffY;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                return o;
            }

            float4 frag (v2f i) : SV_Target
            {
                float2 screen = normalize(_ScreenParams.xy);
                float X = (_OffX - i.uv.x) * screen.x, Y = (_OffY - i.uv.y)  * screen.y;
                float uvDist = (X * X) + (Y * Y);
                float cenDist = (_Radius * _Radius) - uvDist;
                float alphaVal = (cenDist > uvDist) ? 1 : 0;

                return _Color - alphaVal;
            }
            ENDCG
        }
    }
}
2

The behavior of OnRenderImage() and Blit() being able to use hardware blending has always struck me as an unintended feature with some performance implications when using MSAA.

The short version is if you’re doing an image effect and using “Blend” in your shader, you’re “doing it wrong”, or at least using a possibly unintended feature. The _MainTex being passed to the shader is the background that would have been there before, so your shader should instead look like:

Shader "Custom/ScreenRenderer_Circle"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Color("Color", Color) = (0,0,0,0)
        _OffX("Offset X", Float) = 0
        _OffY("Offset Y", Float) = 0
        _Radius ("Radius", Range(0, 2.5)) = 0
    }
    SubShader
    {
        // No culling or depth
        Cull Off ZWrite Off ZTest Always
        Pass
        {
            CGPROGRAM
            #pragma vertex vert_img
            #pragma fragment frag
        
            #include "UnityCG.cginc"
            sampler2D _MainTex;
            float4 _Color;
            float _Radius, _OffX, _OffY;
            float4 frag (v2f_img i) : SV_Target
            {
                float2 screen = normalize(_ScreenParams.xy);
                float X = (_OffX - i.uv.x) * screen.x, Y = (_OffY - i.uv.y)  * screen.y;
                float uvDist = (X * X) + (Y * Y);
                float cenDist = (_Radius * _Radius) - uvDist;
                float alphaVal = (cenDist > uvDist) ? 0 : 1;
                half4 color = tex2D(_MainTex, i.uv);
                color.rgb = lerp(color.rgb, _Color.rgb, alphaVal * _Color.a);
                return color;
            }
            ENDCG
        }
    }
}

The biggest change is sampling the _MainTex and the lerp near the end.

I’m using vert_img instead of the original vertex function; it’s exactly the same code as what was written, and got rid of the Tags since they’re not necessary.

1 Like
3

Thank you very much!

This fixed everything in that shader and I was able to fix another shader having this same issue.

I was unaware how much unneeded code was in these shaders. If you have any recommended reading/videos for a beginner to get a better grasp of shader coding, I’d also appreciate it.

1 Like
4

Stuff like vert_img and v2f_img are defined in UnityCG.cginc, so just looking through that file will give you a lot of it. Those and the other things I removed don’t really hurt anything, they also don’t do anything either so it’s just visual clutter if you can remove them. If there’s anything else you do need to do in the vertex shader it’s good to have it there, but for the effect you’re doing it’s not.

If you create an Image Effect Shader from the Create > Shader dialog it’ll still have the vert function written out, but otherwise it’s about as stripped down of an image effect shader as you can get (while still doing something).

I’d recommend reading this to start with.

There are a ton of other tutorials out there, both in text and video form. Not all are useful since things have changed over the decade Unity has been out, but it’s still a lot of good information.