【Unity】ポストエフェクトをシェーダーで実装する（基礎、複数エフェクト適用、描画パス切替）【シェーダー】

Shader "Hidden/NegaPostEffect"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Cull Off ZWrite Off ZTest Always
        Pass
        {
            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;
            };
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                return o;
            }
            sampler2D _MainTex;
            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                col.rgb = 1 - col.rgb; // RGBを反転
                return col;
            }
            ENDCG
        }
    }
}

using UnityEngine;
[ExecuteInEditMode]
public class SimplePostEffect : MonoBehaviour
{
    [SerializeField] private Material effectMaterial;
    private void OnRenderImage(RenderTexture src, RenderTexture dest)
    {
        // ポストエフェクトをかけない場合
        if (effectMaterial == null)
        {
            Graphics.Blit(src, dest);
            return;
        }
        // ポストエフェクトをかける場合
        Graphics.Blit(src, dest, effectMaterial);
    }
}

Shader "Hidden/GrayPostEffect"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Cull Off ZWrite Off ZTest Always
        Pass
        {
            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;
            };
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                return o;
            }
            sampler2D _MainTex;
            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                float monochrome = 0.3 * col.r + 0.6 * col.g + 0.1 * col.b;
                return float4(monochrome.xxx, 1);
            }
            ENDCG
        }
    }
}

Shader "Hidden/RadialBlurPostEffect"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _SampleCount ("Sample Count", Range(4, 16)) = 8
        _Strength ("Strength", Range(0.0, 1.0)) = 0.5
    }
    SubShader
    {
        Cull Off ZWrite Off ZTest Always

        Pass
        {
            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;
            };

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

            sampler2D _MainTex;
            half _SampleCount;
            half _Strength;

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = 0;
                // 中心からの距離
                const half2 symmetryUv = i.uv - 0.5;
                const half distance = length(symmetryUv);
                // 繰り返すごとにより内側のピクセルをサンプリングする
                for (int j = 0; j < _SampleCount; j++)
                {
                    const float uvOffset = 1 - _Strength * j / _SampleCount * distance;
                    col += tex2D(_MainTex, symmetryUv * uvOffset + 0.5);
                }
                col /= _SampleCount;
                return col;
            }
            ENDCG
        }
    }
}

using UnityEngine;

[ExecuteInEditMode]
public class SomePostEffect : MonoBehaviour
{
    [SerializeField] private Material[] effectMaterials;
    private readonly RenderTexture[] _rts = new RenderTexture[2];

    private void OnRenderImage(RenderTexture src, RenderTexture dest)
    {
        if (effectMaterials == null || effectMaterials.Length == 0)
        {
            Graphics.Blit(src, dest);
            return;
        }

        // RenderTextureが未生成であれば生成する
        CheckAndCreateRTs(src);

        // レンダーテクスチャをスワップしながらエフェクトをかける
        Graphics.Blit(src, _rts[0]);
        foreach (var effectMaterial in effectMaterials)
        {
            Graphics.Blit(_rts[0], _rts[1], effectMaterial);
            (_rts[0], _rts[1]) = (_rts[1], _rts[0]); // Swap
        }
        Graphics.Blit(_rts[0], dest);
    }

    private void CheckAndCreateRTs(RenderTexture src)
    {
        if (_rts[0] == null
            || _rts[0].width != src.width
            || _rts[0].height != src.height)
        {
            for (var i = 0; i < _rts.Length; i++)
            {
                var rt = new RenderTexture(src.width, src.height, 16, RenderTextureFormat.ARGB32);
                rt.enableRandomWrite = true;
                rt.wrapMode = TextureWrapMode.Repeat;
                rt.filterMode = FilterMode.Bilinear;
                rt.Create();
                _rts[i] = rt;
            }
        }
    }
}

using UnityEngine;
[ExecuteInEditMode]
public class SelectPostEffect : MonoBehaviour
{
    [SerializeField] private Material selectEffectMaterial;
    private enum UsePass
    {
        UsePass1,
        UsePass2
    }
    [SerializeField] private UsePass usePass;
    private void OnRenderImage(RenderTexture src, RenderTexture dest)
    {
        Graphics.Blit(src, dest, selectEffectMaterial, (int) usePass);
    }
}

using System.Collections;
using UnityEngine;
[ExecuteInEditMode]
public class WipePostEffect : MonoBehaviour
{
    [SerializeField] private Material effectMaterial;
    [SerializeField] private bool isStartWipe;
    private enum UsePass
    {
        WipeX,         // X方向のワイプ
        WipeDirection, // 方向指定のワイプ
        WipeChecker,   // チェッカーボードのワイプ
    }
    [SerializeField] private UsePass usePass;
    private void OnRenderImage(RenderTexture src, RenderTexture dest)
    {
        Graphics.Blit(src, dest, effectMaterial, (int) usePass);
    }
    private static readonly int WipeSize = Shader.PropertyToID("_WipeSize");
    private float _wipeSize = 0.0f;
    private void Start()
    {
        _wipeSize = 0.0f;
        effectMaterial.SetFloat(WipeSize, _wipeSize);
    }
    private void Update()
    {
        // フラグが立ったらワイプ開始
        if (!isStartWipe) return;
        isStartWipe = false;;
        StartCoroutine(StartWipeCoroutine());
    }
    private bool _isDoWipe = false;
    private IEnumerator StartWipeCoroutine()
    {
        if (_isDoWipe) yield break;
        _isDoWipe = true;
        // 一定間隔でワイプ量を変化させる
        _wipeSize = 0.0f;
        while (_wipeSize < 1.0f)
        {
            _wipeSize += 0.8f * Time.deltaTime;
            effectMaterial.SetFloat(WipeSize, _wipeSize);
            yield return null;
        }
        _isDoWipe = false;
    }
}

Shader "Hidden/WipePostEffect"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _WipeSize ("Wipe Size", Range(0.0, 1.0)) = 0.0
        [IntRange] _WipeDirectionX ("Wipe Direction X", Range(-1, 1)) = 1
        [IntRange] _WipeDirectionY ("Wipe Direction Y", Range(-1, 1)) = 1
    }
    SubShader
    {
        Tags { "Queue"="AlphaTest" "RenderType"="TransparentCutout" }
        Cull Off ZWrite Off ZTest Always
        // 共通部分
        CGINCLUDE
        #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;
        };
        v2f vert (appdata v)
        {
            v2f o;
            o.vertex = UnityObjectToClipPos(v.vertex);
            o.uv = v.uv;
            return o;
        }
        sampler2D _MainTex;
        float _WipeSize;
        int _WipeDirectionX;
        int _WipeDirectionY;
        ENDCG
        // X方向
        Pass
        {
            CGPROGRAM
            fixed4 frag (v2f i) : SV_Target
            {
                // ワイプサイズを超えた場合、クリップする
                if (i.uv.x - _WipeSize < 0)
                {
                    return float4(0, 0, 0, 0);
                }
                return tex2D(_MainTex, i.uv);
            }
            ENDCG
        }
        // 方向指定
        Pass
        {
            CGPROGRAM
            fixed4 frag (v2f i) : SV_Target
            {
                float2 pos = i.uv.xy;
                // 指定された向きによって反転させる
                if (_WipeDirectionX < 0) pos.x = 1.0 - pos.x;
                if (_WipeDirectionY < 0) pos.y = 1.0 - pos.y;
                // 斜め方向の場合、ワイプサイズを倍にする
                if (_WipeDirectionX != 0 && _WipeDirectionY != 0) _WipeSize *= 2.0;
                // 向きと位置の内積からクリップするかを求める
                const float2 wipeDirection = float2(abs(_WipeDirectionX), abs(_WipeDirectionY));
                const float t = dot(wipeDirection, pos);
                if (t - _WipeSize < 0)
                {
                    return float4(0, 0, 0, 0);
                }
                return tex2D(_MainTex, i.uv);
            }
            ENDCG
        }
        // チェッカーボード
        Pass
        {
            CGPROGRAM
            fixed4 frag (v2f i) : SV_Target
            {
                // セルのサイズ
                const float cellSizeX = 0.2f;
                const float cellSizeY = 0.2f;
                _WipeSize *= cellSizeX;
                // 行番号を求めて0or1にする
                float t = floor(i.uv.y / cellSizeY);
                t = fmod(t, 2.0f);
                // 奇数行ならX座標をシフトさせて縦じまワイプをかける
                t = fmod(i.uv.x + cellSizeX/2.0 * t, cellSizeX);
                // ワイプサイズを超えた場合、クリップする
                if (t - _WipeSize < 0)
                {
                    return float4(0, 0, 0, 0);
                }
                return tex2D(_MainTex, i.uv);
            }
            ENDCG
        }
    }
}

        // X方向
        Pass
        {
            CGPROGRAM
            fixed4 frag (v2f i) : SV_Target
            {
                // ワイプサイズを超えた場合、クリップする
                if (i.uv.x - _WipeSize < 0)
                {
                    return float4(0, 0, 0, 0);
                }
                return tex2D(_MainTex, i.uv);
            }
            ENDCG
        }

        // 方向指定
        Pass
        {
            CGPROGRAM
            fixed4 frag (v2f i) : SV_Target
            {
                float2 pos = i.uv.xy;
                // 指定された向きによって反転させる
                if (_WipeDirectionX < 0) pos.x = 1.0 - pos.x;
                if (_WipeDirectionY < 0) pos.y = 1.0 - pos.y;
                // 斜め方向の場合、ワイプサイズを倍にする
                if (_WipeDirectionX != 0 && _WipeDirectionY != 0) _WipeSize *= 2.0;
                // 向きと位置の内積からクリップするかを求める
                const float2 wipeDirection = float2(abs(_WipeDirectionX), abs(_WipeDirectionY));
                const float t = dot(wipeDirection, pos);
                if (t - _WipeSize < 0)
                {
                    return float4(0, 0, 0, 0);
                }
                return tex2D(_MainTex, i.uv);
            }
            ENDCG
        }

         // チェッカーボード
        Pass
        {
            CGPROGRAM
            fixed4 frag (v2f i) : SV_Target
            {
                // セルのサイズ
                const float cellSizeX = 0.2f;
                const float cellSizeY = 0.2f;
                _WipeSize *= cellSizeX;
                // 行番号を求めて0or1にする
                float t = floor(i.uv.y / cellSizeY);
                t = fmod(t, 2.0f);
                // 奇数行ならX座標をシフトさせて縦じまワイプをかける
                t = fmod(i.uv.x + cellSizeX/2.0 * t, cellSizeX);
                // ワイプサイズを超えた場合、クリップする
                if (t - _WipeSize < 0)
                {
                    return float4(0, 0, 0, 0);
                }
                return tex2D(_MainTex, i.uv);
            }
            ENDCG
        }
    }