Float   _DissolveAmount   Range(0, 1)
Color   _EdgeColor         HDR
Texture2D _NoiseTex

using UnityEngine;

public class DissolveController : MonoBehaviour
{
    [SerializeField] private Renderer _renderer;
    [SerializeField] private float _duration = 2f;

    private static readonly int DissolveAmount = Shader.PropertyToID("_DissolveAmount");
    private MaterialPropertyBlock _mpb;

    private void Awake()
    {
        _mpb = new MaterialPropertyBlock();
    }

    public void StartDissolve()
    {
        StartCoroutine(DissolveRoutine());
    }

    private System.Collections.IEnumerator DissolveRoutine()
    {
        float elapsed = 0f;
        while (elapsed < _duration)
        {
            elapsed += Time.deltaTime;
            float t = Mathf.Clamp01(elapsed / _duration);

            _mpb.SetFloat(DissolveAmount, t);
            _renderer.SetPropertyBlock(_mpb);

            yield return null;
        }
    }
}

using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class OutlineRendererFeature : ScriptableRendererFeature
{
    [System.Serializable]
    public class Settings
    {
        public Material outlineMaterial;
        public RenderPassEvent renderPassEvent = RenderPassEvent.AfterRenderingOpaques;
        public LayerMask layerMask = -1;
    }

    public Settings settings = new();
    private OutlineRenderPass _pass;

    public override void Create()
    {
        _pass = new OutlineRenderPass(settings);
    }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        if (settings.outlineMaterial != null)
            renderer.EnqueuePass(_pass);
    }

    private class OutlineRenderPass : ScriptableRenderPass
    {
        private readonly Settings _settings;
        private FilteringSettings _filteringSettings;

        public OutlineRenderPass(Settings settings)
        {
            _settings = settings;
            renderPassEvent = settings.renderPassEvent;
            _filteringSettings = new FilteringSettings(RenderQueueRange.opaque, settings.layerMask);
        }

        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            var drawSettings = CreateDrawingSettings(
                new ShaderTagId("UniversalForward"),
                ref renderingData,
                SortingCriteria.CommonOpaque);
            drawSettings.overrideMaterial = _settings.outlineMaterial;

            context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref _filteringSettings);
        }
    }
}

Shader Graph recipe:
1. Base colour     → Multiply by _HoloColor (HDR cyan/green).
2. Scan-lines      → Frac(WorldPos.y * _LineFrequency + _Time * _ScrollSpeed)
                      → Step(0.5) → multiply into Alpha.
3. Glitch          → Random Range on UV.x triggered by frac(_Time * speed) < threshold.
4. Fresnel rim     → Add to Emission for edge glow.
5. Surface type    → Transparent, Alpha blend.

using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class DamageVignette : MonoBehaviour
{
    [SerializeField] private Volume _volume;
    [SerializeField] private float _maxIntensity = 0.5f;
    [SerializeField] private float _fadeSpeed = 2f;

    private Vignette _vignette;
    private float _currentIntensity;

    private void Start()
    {
        _volume.profile.TryGet(out _vignette);
    }

    public void Flash()
    {
        _currentIntensity = _maxIntensity;
    }

    private void Update()
    {
        if (_currentIntensity > 0f)
        {
            _currentIntensity -= Time.deltaTime * _fadeSpeed;
            _currentIntensity = Mathf.Max(0f, _currentIntensity);
            _vignette.intensity.Override(_currentIntensity);
        }
    }
}

Shader Graph (Unlit, Full-Screen):
1. URP Sample Buffer (BlitSource) → output colour.
2. Split R, G, B.
3. Dot with luminance weights (0.2126, 0.7152, 0.0722).
4. Combine back to RGB.
5. Lerp between original and grayscale by _Intensity property.
6. Output to Base Color.

Shader "Custom/SimpleUnlit"
{
    Properties
    {
        _BaseColor ("Base Color", Color) = (1,1,1,1)
        _MainTex   ("Texture",   2D)    = "white" {}
    }
    SubShader
    {
        Tags { "RenderPipeline"="UniversalPipeline" "RenderType"="Opaque" }

        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode"="UniversalForward" }

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

            struct Attributes
            {
                float4 positionOS : POSITION;
                float2 uv         : TEXCOORD0;
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv         : TEXCOORD0;
            };

            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);

            CBUFFER_START(UnityPerMaterial)
                float4 _BaseColor;
                float4 _MainTex_ST;
            CBUFFER_END

            Varyings vert(Attributes IN)
            {
                Varyings OUT;
                OUT.positionCS = TransformObjectToHClip(IN.positionOS.xyz);
                OUT.uv = TRANSFORM_TEX(IN.uv, _MainTex);
                return OUT;
            }

            half4 frag(Varyings IN) : SV_Target
            {
                half4 tex = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv);
                return tex * _BaseColor;
            }
            ENDHLSL
        }
    }
}

// Preferred: MaterialPropertyBlock
private static readonly int ColorProp = Shader.PropertyToID("_BaseColor");
private MaterialPropertyBlock _mpb;

private void Awake() => _mpb = new MaterialPropertyBlock();

public void SetColor(Color color)
{
    _renderer.GetPropertyBlock(_mpb);
    _mpb.SetColor(ColorProp, color);
    _renderer.SetPropertyBlock(_mpb);
}