[Unity URP] UI発光シェーダー(UI Glow Shader)。
マルチパスでUIをぼやっと光らせる処理。

Shader "UI/Glow3Pass"
{
    Properties 
    {
        [HideInInspector] _MainTex("-", 2D) = "white"{} 
        [HideInInspector] _CustomTex("-", 2D) = "white"{}
        [HideInInspector] _Luminance("-", float) = 0
        [HideInInspector] _BlurCount("-", float) = 0
        [HideInInspector] _BlurDistance("-", float) = 0          
        [HideInInspector] _BlurPower("-", float) = 0
    }

    SubShader
    {
        Tags
        {
            "RenderPipeline" = "UniversalPipeline"
            "Queue" = "Transparent" 
        }
        Cull Off
        ZWrite Off

        HLSLINCLUDE      
            #pragma vertex vert
            #pragma fragment frag
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            
            TEXTURE2D(_MainTex);        
            SAMPLER(sampler_MainTex);            

            
            TEXTURE2D(_CustomTex);        
            SAMPLER(sampler_CustomTex);
            
            float4 _CustomTex_TexelSize;    

            
            CBUFFER_START(UnityPerMaterial)
                half _Luminance;           
                int _BlurCount;
                half _BlurDistance;
                half _BlurPower;                
            CBUFFER_END

            static const half MaxLuminance = 10;
            static const half HalfLuminance = MaxLuminance / 2;
            static const half MaxBlurPower = 10;
            
            struct Attributes
            {
                half2 uv : TEXCOORD0;
                float4 positionOS : POSITION;
                half4 color : COLOR;
            };

            struct Varyings
            {
                half2 uv : TEXCOORD0;
                float4 positionCS : SV_POSITION;
                half4 color : COLOR;
            };

            Varyings vert (Attributes input)
            {
                Varyings output;
                output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                output.uv = input.uv;
                output.color = input.color;
                return output;
            }

            
            half4 executeBlur(half2 uv, half2 direction)
            {
                
                
                half clampLuminance = clamp(_Luminance, 0, HalfLuminance) / HalfLuminance;
                half fixBlurDistance = _BlurDistance * clampLuminance;

                half4 color = 0;
                for (int shift = -_BlurCount; shift <= _BlurCount; shift++)  
                {  
                    half2 offset = direction * shift * fixBlurDistance * _CustomTex_TexelSize;
                    color += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv + offset); 
                }  
                
                color /= (_BlurCount * 2 + 1);  
                
                color.a *= (_BlurPower / MaxBlurPower);
                return color;
            }

            
            half3 cubicIn(half curParam, half maxParam, half3 originCol, half3 finalCol)
            {
                finalCol -= originCol;
                curParam /= maxParam;
                return finalCol * curParam * curParam * curParam + originCol;
            }            
        ENDHLSL    

        
        Pass
        {
            Blend SrcAlpha OneMinusSrcAlpha    

            HLSLPROGRAM
            
            half4 frag (Varyings input) : SV_Target
            {    
                
                
                half4 original = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, input.uv);

                
                half4 blurred = SAMPLE_TEXTURE2D(_CustomTex, sampler_CustomTex, input.uv);
                
                
                
                
                half4 combine = lerp(blurred, original, original.a); 
                
                
                
                half3 finalCol = combine.rgb + (combine.rgb * MaxLuminance * 2);
                combine.rgb = cubicIn(_Luminance, MaxLuminance, combine.rgb, finalCol);
                
                half addWhite = saturate((_Luminance - 7) / 3);
                combine.rgb += addWhite;

                return combine;
            }
            ENDHLSL
        }

        
        Pass
        {
            Blend One Zero   

            HLSLPROGRAM
            
            half4 frag (Varyings input) : SV_Target
            {    
                return executeBlur(input.uv, half2(1, 0));
            }
            ENDHLSL
        }        

        
        Pass
        {
            Blend One Zero            

            HLSLPROGRAM
            
            half4 frag (Varyings input) : SV_Target
            {    
                return executeBlur(input.uv, half2(0, 1)); 
            }
            ENDHLSL
        }        
    }
}

using System;
using DG.Tweening;
using UnityEngine;
using UnityEngine.UI;

[ExecuteAlways]



public class Glow3PassController : MonoBehaviour
{
    [Serializable]
    
    
    
    private class Parameters
    {
        [SerializeField, Range(0, 10)] private float luminance = 5;
        public float Luminance => luminance;
        [SerializeField, Range(0, 10)] private int blurCount = 5;
        public int BlurCount => blurCount;
        [SerializeField, Range(0, 10)] private float blurDistance = 3;
        public float BlurDistance => blurDistance;
        [SerializeField, Range(0, 10)] private float blurPower = 5;    
        public float BlurPower => blurPower;        

        
        private float _lastLuminance;
        private int _lastBlurCount;  
        private float _lastBlurPower;  
        private float _lastBlurDistance;

        
        
        
        public bool CahngedParameter => !Mathf.Approximately(luminance, _lastLuminance) || blurCount != _lastBlurCount ||
                                        !Mathf.Approximately(blurPower, _lastBlurPower) || !Mathf.Approximately(blurDistance, _lastBlurDistance);        

        
        
        
        public void UpdateParameter()
        {
            _lastLuminance = luminance;
            _lastBlurCount = blurCount;
            _lastBlurPower = blurPower;
            _lastBlurDistance = blurDistance;
        }
    }

    [SerializeField] private Image targetImage;
    [SerializeField] private Shader targetShader;
    [SerializeField] private Parameters parameters;

    private Texture2D sourceTexture;
    private Material createdMaterial;
    private RenderTexture tmpRenderTexture1;
    private RenderTexture tmpRenderTexture2;

    
    
    
    private bool NeedsInitialization => sourceTexture == null || sourceTexture != targetImage.sprite.texture || 
                                        createdMaterial == null || targetImage.material != createdMaterial ||
                                        tmpRenderTexture1 == null || tmpRenderTexture2 == null;

    
    
    
    private void Init()
    {
        Release();

        sourceTexture = targetImage.sprite.texture;
        createdMaterial = new (targetShader);
        createdMaterial.hideFlags = HideFlags.DontSave;
        targetImage.material = createdMaterial;            

        
        
        tmpRenderTexture1 = new RenderTexture(sourceTexture.width / 2, sourceTexture.height /2, 0);
        tmpRenderTexture2 = new RenderTexture(sourceTexture.width / 2, sourceTexture.height / 2, 0);

        
        
        targetImage.material.SetTexture("_CustomTex", tmpRenderTexture2);

        
        UpdateTexture();
    }

    
    
    
    private void Start()
    {
        if (NeedsInitialization)
        {
            Init();
        }
    }

    
    
    
    private void Update()
    {
        if (targetImage == null || targetImage.sprite == null || targetShader == null)
        {
            return;    
        }

        if (NeedsInitialization)
        {
            Init();         
        }
        else if(parameters.CahngedParameter)
        {
            UpdateTexture();
        }
    }

    
    
    
    private void UpdateTexture()
    {
        parameters.UpdateParameter();

        
        createdMaterial.SetFloat("_Luminance", parameters.Luminance);
        
        createdMaterial.SetInt("_BlurCount", parameters.BlurCount);
        createdMaterial.SetFloat("_BlurPower", parameters.BlurPower);
        createdMaterial.SetFloat("_BlurDistance", parameters.BlurDistance);         

        
        
        Graphics.Blit(sourceTexture, tmpRenderTexture1, createdMaterial, 1);
        
        Graphics.Blit(tmpRenderTexture1, tmpRenderTexture2, createdMaterial, 2);
    }

    
    
    
    private void Release()
    {
        if (tmpRenderTexture1 != null)
        {
            tmpRenderTexture1.Release();
            tmpRenderTexture2.Release();            
        }
        if (createdMaterial != null)
        {
            DestroyImmediate(createdMaterial);  
        }
    }

    
    
    
    private void OnDisable()
    {
        Release();
    }
}