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

// 首先由两个类组成
// 继承自 ScriptableRendererFeature 的 CustomRenderPassFeature
// 继承自 ScriptableRenderPass 的 CustomRenderPass

// CustomRenderPassFeature 负责把 Render Pass添加到 Renderer里面。
// Render Feature 在 renderpipline的任意阶段
public class CustomRenderPassFeature : ScriptableRendererFeature
{
    // 室实际的渲染工作
    // 在 ScriptableRenderPass 里，可以在狗仔甘薯里面去指定了 Event 在什么时间点执行（默认是不透明之后画）
    class CustomRenderPass : ScriptableRenderPass
    {
        // Configure() 在执行渲染过程之前，Renderer 将调用次方法。如果需要配置渲染目标及其清除状态，并创建临时渲染目标纹理，那就要重写这个方法。
        // 如果渲染过程未重写这个方法，则该渲染过程将渲染到激活状态下 Camera 的渲染目标。
        // 在每次 Execute 调用的前一帧调用，用来设置传递需要的东西
        public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
        {
        }
        // https://docs.unity3d.com/ScriptReference/Rendering.ScriptableRenderContext.html
        // Execute() 是这个类的核心方法，定义我们的执行规则；包含渲染逻辑，设置渲染状态，绘制渲染器或绘制程序网络，调度计算等。
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
        }

        // 可用于释放通过此过程创建的分配资源。完成渲染相机后调用。就可以使用此回调释放此渲染过程创建的所有资源。
        public override void FrameCleanup(CommandBuffer cmd)
        {
        }
    }

    CustomRenderPass m_ScriptablePass;  // 实例化
    // Create() 用来初始化这个 Feature 的资源。这里初始化完了之后要给 AddRenderPasses 函数来在渲染中插入改pass
    public override void Create()
    {
        m_ScriptablePass = new CustomRenderPass();
        // 通过 Event 控制在render pipline的何时插入 Pass 以及顺序
        m_ScriptablePass.renderPassEvent = RenderPassEvent.AfterRenderingOpaques;
    }



    // AddRenderPasses() 在 Renderer 中插入一个或多个 ScriptableRenderPass，对这个Renderer 每个摄像机都设置一次
    // 每个相机，没帧调用一次
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        renderer.EnqueuePass(m_ScriptablePass);
    }
}

屏幕HSV

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

[ExecuteInEditMode] // 让编辑器在不运行状态下运行
public class mybiltxf : ScriptableRendererFeature
{
    [System.Serializable]   // renderfeature 的面板
    public class mysetting//定义一个设置的类
    {
        public string PassName = "调色";
        public Material mymat;
        [Range(0, 1)] public float Brightness = 1;
        [Range(0, 1)] public float Saturate = 1;
        [Range(-1, 2)] public float Constrast = 1;
        public RenderPassEvent passEvent = RenderPassEvent.AfterRenderingTransparents; // 增加一个可控渲染事件来决定渲染位置
    }
    public mysetting setting = new mysetting(); // 实例化
    class CustomRenderPass : ScriptableRenderPass//自定义pass
    {
        public Material passMat = null;
        public float Brightness;
        public float Saturate;
        public float Constrast;
        public string name;
        public FilterMode passfiltermode { get; set; } //图像的模式，这里设置方便整体调整，这里相当于拿相机rt的设置
        private RenderTargetIdentifier passSource { get; set; } //源图像,目标图像
        public RenderTargetIdentifier Temp1;
        string passTag; // 给cmd对象池用来调用的

        public void setup(RenderTargetIdentifier sour) // 把相机的图像copy过来
        {
            this.passSource = sour;
        }
        //类似OnRenderimagePass，图像处理部分
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData) 
        {
            int TempID1 = Shader.PropertyToID("Temp1");
            int brightness = Shader.PropertyToID("_brightness");
            int saturate = Shader.PropertyToID("_saturate");
            int contranst = Shader.PropertyToID("_contranst");

            CommandBuffer cmd = CommandBufferPool.Get(passTag); // 类似于cbuffer，把整个渲染命令圈起来
            RenderTextureDescriptor opaquedesc = renderingData.cameraData.cameraTargetDescriptor;   // 拿到相机数据
            cmd.GetTemporaryRT(TempID1, opaquedesc); //申请一个临时图像
            Temp1 = new RenderTargetIdentifier(TempID1);

            cmd.SetGlobalFloat(brightness, Brightness);  // 往shader里传面板上的值
            cmd.SetGlobalFloat(saturate, Saturate);
            cmd.SetGlobalFloat(contranst, Constrast);

            cmd.Blit(passSource, Temp1, passMat,0);  //把源贴图输入到材质对应的pass里处理，并把处理结果的图像存储到临时图像；
            cmd.Blit(Temp1, passSource);             //然后把临时图像又存到源图像里 

            context.ExecuteCommandBuffer(cmd); //执行命令缓冲区的该命令
            CommandBufferPool.Release(cmd); //释放该命令
        }
    }
    CustomRenderPass mypass;

    public override void Create()//进行初始化,这里最先开始
    {
        mypass = new CustomRenderPass();
        mypass.renderPassEvent = setting.passEvent; // 渲染位置
        mypass.Brightness = setting.Brightness; // 参数
        mypass.Saturate = setting.Saturate;
        mypass.Constrast = setting.Constrast;   
        mypass.passMat = setting.mymat; // 读取材质球
        mypass.name = setting.PassName; // frameDebug 里的渲染名字
    }
    //传值到pass里
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        mypass.setup(renderer.cameraColorTarget);
        renderer.EnqueuePass(mypass);   // 设置到渲染流程中
    }
}

shader

Shader "WX/URP/Post/post"
{

    Properties
    {
        [HideInInspector]_MainTex ("MainTex", 2D) = "white" {}
        // _brightness ("Brightness", Range(0, 1)) = 1
        // _saturate ("Saturate", Range(0, 1)) = 1
        // _contranst ("Constrast", Range(-1, 2)) = 1
    }

    SubShader
    {

        Tags {"RenderPipeline" = "UniversalRenderPipeline"}
        Cull Off ZWrite Off ZTest Always
        HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        CBUFFER_START(UnityPerMaterial)
        float _brightness;
        float _saturate;
        float _contranst;
        CBUFFER_END
        
        TEXTURE2D(_MainTex);
        SAMPLER(sampler_MainTex);

        struct a2v
        {
            float4 positionOS: POSITION;
            float2 texcoord: TEXCOORD;
        };

        struct v2f
        {
            float4 positionCS: SV_POSITION;
            float2 texcoord: TEXCOORD;
        };

        ENDHLSL

        pass
        {
            HLSLPROGRAM
            #pragma vertex VERT
            #pragma fragment FRAG

            v2f VERT(a2v i)
            {
                v2f o;
                o.positionCS = TransformObjectToHClip(i.positionOS.xyz);
                o.texcoord = i.texcoord;
                return o;
            }

            half4 FRAG(v2f i): SV_TARGET
            {
                half4 tex = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.texcoord);
                //灰度图，即计算明度。用的是Luminance公式，在sRGB空间下
                float gray = 0.21 * tex.x + 0.72 * tex.y + 0.072 * tex.z;
                tex.xyz *= _brightness;//计算亮度
                tex.xyz = lerp(float3(gray, gray, gray), tex.xyz, _saturate); //饱和度。这里相当于在去色后和当前的图中lerp了
                tex.xyz = lerp(float3(0.5, 0.5, 0.5), tex.xyz, _contranst); //对比度
                return tex;
            }
            ENDHLSL
        }
    }
}

Kawase

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

[ExecuteInEditMode] // 让编辑器在不运行状态下运行
public class Kawase : ScriptableRendererFeature
{
    [System.Serializable]   // renderfeature 的面板
    public class featureSetting
    {
        public string passRenderName = "KawaseBlur";
        public Material passMat;
        [Range(1, 10)] public int downsample = 1;
        [Range(1, 10)] public int loop = 2;
        [Range(0.5f, 5)] public float blur = 0.5f;
        [Range(0, 1)] public float lerp = 1;    // 对比process前后区别
        public RenderPassEvent passEvent = RenderPassEvent.AfterRenderingTransparents;  // copy具体哪个阶段的图像
    }
    public featureSetting setting = new featureSetting();  // 实例化
    class CustomRenderPass : ScriptableRenderPass
    {
        public Material passMat = null;
        public string passName;
        public int passdownsample = 1;
        public int passloop = 2;
        public float passblur = 4;
        public float lerp = 1;
        string passTag; // 名字，方便从frameDebug里看到
        // public RenderTargetIdentifier Scoure;
        private RenderTargetIdentifier passSource { get; set; } // 源图像

        public void setup(RenderTargetIdentifier sour) // 把相机的图像copy过来，具体哪张取决于renderEvent
        {
            this.passSource = sour;
        }
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            // 类似shaderGUI里的传递，这里就不是setfloat了，就是拿shaderProperty的ID了,因为下面要用id创建临时图像
            int TempID1 = Shader.PropertyToID("Temp1");         // 临时图像，也可以用 Handle，ID不乱就可以
            int TempID2 = Shader.PropertyToID("Temp2");
            int Lerp = Shader.PropertyToID("_Lerp");
            int ScoureID = Shader.PropertyToID("_SourceTex");   // 为了方便对比prosses前后的区别

            CommandBuffer cmd = CommandBufferPool.Get(passTag); // 类似于cbuffer，把整个渲染命令圈起来
            RenderTextureDescriptor getCameraData = renderingData.cameraData.cameraTargetDescriptor;   // 拿到相机数据，方便创建共享屬性的rt
            int width = getCameraData.width / passdownsample;   // downSample
            int height = getCameraData.height / passdownsample;

            // 获取临时渲染纹理 注意hdr的支持
            cmd.GetTemporaryRT(TempID1, width, height, 0, FilterMode.Bilinear, RenderTextureFormat.DefaultHDR); // 申请一个临时图像，并设置相机rt的参数进去
            cmd.GetTemporaryRT(TempID2, width, height, 0, FilterMode.Bilinear, RenderTextureFormat.DefaultHDR);
            cmd.GetTemporaryRT(ScoureID, getCameraData);

            RenderTargetIdentifier Temp1 = TempID1;
            RenderTargetIdentifier Temp2 = TempID2;
            RenderTargetIdentifier Scoure = ScoureID;
            // Scoure = new RenderTargetIdentifier(ScoureID);   // 感觉上下两种效果上区别不大       

            // 设置参数
            cmd.SetGlobalFloat("_Blur", 1f);
            cmd.SetGlobalFloat(Lerp, lerp);
            // 拷贝
            cmd.Blit(passSource, Scoure);           // 把原始图像存起来做lerp操作，对比前后变化
            cmd.ReleaseTemporaryRT(ScoureID);       // 释放 RT 
            cmd.Blit(passSource, Temp1, passMat);   //把源贴图输入到材质对应的pass里处理，并把处理结果的图像存储到临时图像；
            for (int t = 1; t < passloop; t++)      // 每次循环相当于把已经模糊的图片放进来进行模糊运算
            {
                cmd.SetGlobalFloat("_Blur", t * passblur); // 1.5
                cmd.Blit(Temp1, Temp2, passMat);
                var temRT = Temp1;
                Temp1 = Temp2;
                Temp2 = temRT;
            }
            // cmd.SetGlobalFloat("_Blur", passloop * passblur); // 这里相当于在loop外又模糊一次，还不如直接调 passloop 的参数
            // cmd.Blit(Temp1, passSource, passMat);
            cmd.Blit(Temp1, passSource);

            // 释放
            cmd.ReleaseTemporaryRT(TempID1);    // 看起来好像如果不释放的话就会一直运行，会影响 passSource 的 Tex 图像
            cmd.ReleaseTemporaryRT(TempID2);
            context.ExecuteCommandBuffer(cmd);  //执行命令缓冲区的该命令
            CommandBufferPool.Release(cmd);     //释放该命令
        }
    }
    CustomRenderPass m_ScriptablePass;
    public override void Create()
    {
        m_ScriptablePass = new CustomRenderPass();
        m_ScriptablePass.renderPassEvent = setting.passEvent;   // 渲染位置
        m_ScriptablePass.passMat = setting.passMat;             // 材质
        m_ScriptablePass.passName = setting.passRenderName;     // 渲染名称
        m_ScriptablePass.passblur = setting.blur;               // 变量
        m_ScriptablePass.passloop = setting.loop;
        m_ScriptablePass.passdownsample = setting.downsample;
        m_ScriptablePass.lerp = setting.lerp;
    }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        m_ScriptablePass.setup(renderer.cameraColorTarget);     // 通过setup函数设置不同的渲染阶段的渲染结果进 passSource 里面
        renderer.EnqueuePass(m_ScriptablePass);                 // 执行
    }
}

shader

Shader "WX/URP/Post/Kawaseblur"
{
    Properties
    {
      _MainTex("MainTex",2D) = "white"{}
    //_Blur("Blur",float)=2
      // _Lerp("对比前后区别",range(0,1)) = 1
    }
        SubShader
    {
        Tags{"RenderPipeline" = "UniversalRenderPipeline"}

        Cull Off ZWrite Off ZTest Always
        HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

        CBUFFER_START(UnityPerMaterial)
        float _Blur,_Lerp;
        float4 _MainTex_TexelSize;
        CBUFFER_END

        TEXTURE2D(_MainTex);
        SAMPLER(sampler_MainTex);
        TEXTURE2D(_SourceTex); // 原图
        SAMPLER(sampler_SourceTex);

         struct a2v
         {
             float4 positionOS:POSITION;
             float2 texcoord:TEXCOORD;
         };

         struct v2f
         {
             float4 positionCS:SV_POSITION;
             float2 texcoord:TEXCOORD;
         };
         v2f VERT(a2v i)//水平方向的采样
            {
                v2f o;
                o.positionCS = TransformObjectToHClip(i.positionOS.xyz);
                o.texcoord = i.texcoord;
                return o;
            }
         half4 FRAG(v2f i) :SV_TARGET
            {
                float4 col;
                half4 tex = SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,i.texcoord);
                // 其实感觉这里的意思是 UV + 方向 * 贴图大小的像素距离 * 偏移量
                tex += SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,i.texcoord + float2(-1,-1) * _MainTex_TexelSize.xy * _Blur);   
                tex += SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,i.texcoord + float2(1,-1) * _MainTex_TexelSize.xy * _Blur);
                tex += SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,i.texcoord + float2(-1,1) * _MainTex_TexelSize.xy * _Blur);
                tex += SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,i.texcoord + float2(1,1) * _MainTex_TexelSize.xy * _Blur);
                tex /= 5;
                float3 Source = SAMPLE_TEXTURE2D(_SourceTex,sampler_SourceTex,i.texcoord).rgb;
                tex.rgb = lerp(Source,tex.rgb,_Lerp);
                // return half4(Source,1);  // debug
                return tex;
            }
        ENDHLSL

        pass
        {
            HLSLPROGRAM
            #pragma vertex VERT
            #pragma fragment FRAG
            ENDHLSL
        }
    }
}

径向模糊

using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
// 让编辑器在不运行状态下运行
[ExecuteInEditMode]
public class radialBlur : ScriptableRendererFeature
{
    // 让这些设置可以显示在面板上
    [System.Serializable]
    public class setting
    {
        public string PassName = "径向模糊";
        public Material RadialBlurMat = null;
        [Range(0, 1)] public float x = 0.5f;
        [Range(0, 1)] public float y = 0.5f;
        [Range(1, 24)] public int loop = 5;
        [Range(1, 16)] public float blur = 3;
        [Range(1, 4)] public int downsample = 2;
        [Range(0, 1)] public float instensity = 1;
        public RenderPassEvent passEvent = RenderPassEvent.AfterRenderingTransparents;
    }
    public setting mysetitng = new setting(); // 实例化
    class CustomRenderPass : ScriptableRenderPass
    {
        public Material mymat;
        public string name;
        public float x;
        public float y;
        public int loop;
        public float instensity;
        public float blur;
        public int downsample;
        public RenderTargetIdentifier Source { get; set; }
        //public RenderTargetIdentifier BlurTex;
        public RenderTargetIdentifier Temp1;
        public RenderTargetIdentifier Temp2;
        int ssW;
        int ssH;
        public void setupmypass(RenderTargetIdentifier source)
        {
            this.Source = source;
        }
        // 执行
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            // int BlurTexID = Shader.PropertyToID("_BlurTex"); // 模糊前的,shader 里没有这张图
            int TempID1 = Shader.PropertyToID("Temp1"); // 空的临时图像
            int TempID2 = Shader.PropertyToID("_SourceTex"); // 
            int loopID = Shader.PropertyToID("_Loop");
            int Xid = Shader.PropertyToID("_X");
            int Yid = Shader.PropertyToID("_Y");
            int BlurID = Shader.PropertyToID("_Blur");
            int instenID = Shader.PropertyToID("_Instensity");  // 其实就是pass2 lerp用的

            RenderTextureDescriptor SSdesc = renderingData.cameraData.cameraTargetDescriptor;   // 拿到相机数据
            ssH = SSdesc.height / downsample;
            ssW = SSdesc.width / downsample;
            CommandBuffer cmd = CommandBufferPool.Get(name); // 通过对象池来调用，大量数据处理的时候特别有用
            cmd.GetTemporaryRT(TempID1, ssW, ssH, 0, FilterMode.Bilinear, RenderTextureFormat.RGB111110Float);//用来存降采样的
            //cmd.GetTemporaryRT(BlurTexID, SSdesc);  // 模糊图前的 ，pass2 要用
            cmd.GetTemporaryRT(TempID2, SSdesc);    // 这边不降采样的图就直接拿相机的渲染设置了

            // 实例化
            Temp1 = new RenderTargetIdentifier(TempID1);
            Temp2 = new RenderTargetIdentifier(TempID2);

            cmd.SetGlobalFloat(loopID, loop);
            cmd.SetGlobalFloat(Xid, x);
            cmd.SetGlobalFloat(Yid, y);
            cmd.SetGlobalFloat(BlurID, blur);
            cmd.SetGlobalFloat(instenID, instensity);

            // 一个Blit就是FrameDebug里一次结果
            cmd.Blit(Source, Temp1);    // 存储降采样的源图，用于pass0计算模糊图
            cmd.Blit(Source, Temp2);    // 存储源图，用来lerp前后效果的（正常不应该这么用，在shader的for循环里做手脚）
            cmd.Blit(Temp1, Source, mymat, 0);//pass0的模糊计算
            // 清理
            //cmd.ReleaseTemporaryRT(BlurTexID);
            cmd.ReleaseTemporaryRT(TempID1);
            cmd.ReleaseTemporaryRT(TempID2);
            context.ExecuteCommandBuffer(cmd);  // 调用
            CommandBufferPool.Release(cmd); // 清理
        }
    }
    CustomRenderPass m_ScriptablePass;
    public override void Create()
    {
        m_ScriptablePass = new CustomRenderPass();
        m_ScriptablePass.renderPassEvent = mysetitng.passEvent;
        m_ScriptablePass.blur = mysetitng.blur;
        m_ScriptablePass.x = mysetitng.x;
        m_ScriptablePass.y = mysetitng.y;
        m_ScriptablePass.instensity = mysetitng.instensity;
        m_ScriptablePass.loop = mysetitng.loop;
        m_ScriptablePass.mymat = mysetitng.RadialBlurMat;
        m_ScriptablePass.name = mysetitng.PassName;
        m_ScriptablePass.downsample = mysetitng.downsample;
    }
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        if (mysetitng.RadialBlurMat != null)
        {
            m_ScriptablePass.setupmypass(renderer.cameraColorTarget);
            // 把括号里的pass根据渲染设置（是有Create设置的）丢到渲染流程中
            renderer.EnqueuePass(m_ScriptablePass);
        }
        else
        {
            Debug.LogError("径向模糊材质球丢失！");
        }
    }
}

shader

Shader"WX/URP/Post/radialBrul"
{
    Properties
    {
        _MainTex("tex",2D) = "white"{}
    }
        SubShader
    {
        Tags{"RenderPipeline" = "UniversalRenderPipeline"}
        Cull Off ZWrite Off ZTest Always

        HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        float4 _MainTex_ST;
        float _Loop;
        float _Blur;
        float _Y;
        float _X;
        float _Instensity;
        TEXTURE2D(_MainTex);
        SAMPLER(sampler_MainTex);
        TEXTURE2D(_SourceTex); // 原图
        SAMPLER(sampler_SourceTex);

         struct a2v
         {
             float4 positionOS:POSITION;
             float2 texcoord:TEXCOORD;
         };

         struct v2f
         {
             float4 positionCS:SV_POSITION;
             float2 texcoord:TEXCOORD;
         };
        ENDHLSL

        pass
        {

            HLSLPROGRAM
            #pragma vertex VERT
            #pragma fragment FRAG

            v2f VERT(a2v i)
            {
                v2f o;
                o.positionCS = TransformObjectToHClip(i.positionOS.xyz);
                o.texcoord = i.texcoord;
                return o;
            }

            half4 FRAG(v2f i) :SV_TARGET
            {
                float4 col = 0;
                float2 dir = (i.texcoord - float2(_X,_Y)) * _Blur * 0.01;
                for (int t = 0; t < _Loop; t++)
                {
                    col += SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,i.texcoord + dir * t) / _Loop;
                }
                float4 Source = SAMPLE_TEXTURE2D(_SourceTex,sampler_SourceTex,i.texcoord);//得到屏幕原始图
                return lerp(Source,col,_Instensity);
            }
            ENDHLSL
        }
    }
}

real模板

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

[ExecuteInEditMode] // 让编辑器在不运行状态下运行
public class FullScreen : ScriptableRendererFeature
{
    [System.Serializable]   // renderfeature 的面板
    public class featureSetting
    {
        public string passRenderName = "渲染pass的名字";
        public Material passMat;
        public Color MainColor;
        public RenderPassEvent passEvent = RenderPassEvent.AfterRenderingTransparents;
    }
    public featureSetting setting = new featureSetting();  // 实例化
    class CustomRenderPass : ScriptableRenderPass
    {
        public Material passMat = null;
        public string passName;
        public Color MainColor;
        string passTag; // 给cmd对象池用来调用的
        private RenderTargetIdentifier passSource { get; set; } //源图像,这里一般是cameraColorTex

        public void setup(RenderTargetIdentifier sour) // 把相机的图像copy过来
        {
            this.passSource = sour;
        }
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            int TempID1 = Shader.PropertyToID("_MaskTex");
            int MColor = Shader.PropertyToID("_MainColor");

            CommandBuffer cmd = CommandBufferPool.Get(passTag); // 类似于cbuffer，把整个渲染命令圈起来
            RenderTextureDescriptor getCameraData = renderingData.cameraData.cameraTargetDescriptor;   // 拿到相机数据，方便创建共享屬性的rt
            cmd.GetTemporaryRT(TempID1, getCameraData); //申请一个临时图像，并设置相机rt的参数进去
            RenderTargetIdentifier Temp1 = TempID1;
            // 设置参数
            cmd.SetGlobalColor(MColor, MainColor);
            // 拷贝
            cmd.Blit(passSource, Temp1, passMat, -1);  //把源贴图输入到材质对应的pass里处理，并把处理结果的图像存储到临时图像；
            cmd.Blit(Temp1, passSource);             //然后把临时图像又存到源图像里 

            cmd.ReleaseTemporaryRT(TempID1);
            context.ExecuteCommandBuffer(cmd); //执行命令缓冲区的该命令
            CommandBufferPool.Release(cmd); //释放该命令
        }
    }
    CustomRenderPass m_ScriptablePass;
    public override void Create()
    {
        m_ScriptablePass = new CustomRenderPass();
        m_ScriptablePass.renderPassEvent = setting.passEvent;   // 渲染位置
        m_ScriptablePass.passMat = setting.passMat;             // 材质
        m_ScriptablePass.passName = setting.passRenderName;     // 渲染名称

        m_ScriptablePass.MainColor = setting.MainColor;         // 变量
    }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        m_ScriptablePass.setup(renderer.cameraColorTarget);     // 通过setup函数设置不同的渲染阶段的渲染结果进 passSource 里面
        renderer.EnqueuePass(m_ScriptablePass);                 // 执行
    }
}

shader

Shader "Neilyodog/URPUnlitShaderBasic"
{
    Properties
    { 
        _MainTex("主贴图",2D) = "white"{}
        // _MainColor("主颜色",color) = (1,1,1,1)
        _MaskTex("mask",2D) = "white"{}
    }
    SubShader
    {
        Tags {"Queue"="Geometry" "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" }
        Pass
        {
            HLSLPROGRAM

            #pragma prefer_hlslcc gles
            #pragma exclude_renderers d3d11_9x

            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_fog

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"  
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"   

            struct Attributes
            {
                float4 positionOS   : POSITION;  
                float2 uv : TEXCOORD0;              
            };
            struct Varyings
            {
                float4 positionHCS  : SV_POSITION;
                float2 uv : TEXCOORD0;
                float fogCoord : TEXCOORD1;
            };            
            
            CBUFFER_START(UnityPerMaterial)
            float4 _MainTex_ST;
            float4 _MainColor;
            CBUFFER_END

            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);
            TEXTURE2D(_MaskTex);
            SAMPLER(sampler_MaskTex);

            Varyings vert(Attributes v)
            {
                Varyings o;
                o.positionHCS = TransformObjectToHClip(v.positionOS.xyz);
                o.uv = TRANSFORM_TEX(v.uv,_MainTex);
                o.fogCoord = ComputeFogFactor(o.positionHCS.z);
                return o;
            }    
            half4 frag(Varyings i) : SV_Target
            {
                float2 screenUV = i.positionHCS.xy / _ScreenParams.xy;
                half4 c = SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,i.uv);
                half mask = SAMPLE_TEXTURE2D(_MaskTex,sampler_MaskTex,screenUV).r;
                //return half4(mask.xxx,1);
                c *= _MainColor * mask;
                c.rgb = MixFog(c.rgb,i.fogCoord);
                return c;
            }
            ENDHLSL
        }
    }
}

源文件

径向模糊
radialBlur.cs

radialBlur.shader

HSV
HSV.cs

HSV.shader

Kawase
Kawase.cs

Kawase.shader

分析

开头贴标签

第一部分

在继承 ScriptableRendererFeature 的类里面

设置renderer面板

第二部分

在继承 ScriptableRenderPass 的类里面

声明变量
从相机上copy图像
#核心#重写 Execute 函数，来控制如何渲染（记得清理缓存）
给renderer面板传递参数

添加pass

using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
// 让编辑器在不运行状态下运行
[ExecuteInEditMode]
public class radialBlur : ScriptableRendererFeature
{
    // 让这些设置可以显示在面板上
    [System.Serializable]
    public class setting
    {
        public string PassName = "径向模糊";
        public Material RadialBlurMat = null;
        [Range(0, 1)] public float x = 0.5f;
        [Range(0, 1)] public float y = 0.5f;
        [Range(1, 24)] public int loop = 5;
        [Range(1, 16)] public float blur = 3;
        [Range(1, 4)] public int downsample = 2;
        [Range(0, 1)] public float instensity = 0.5f;
        public RenderPassEvent passEvent = RenderPassEvent.AfterRenderingTransparents;
    }
    public setting mysetitng = new setting(); // 实例化
    class CustomRenderPass : ScriptableRenderPass
    {
        public Material mymat;
        public string name;
        public float x;
        public float y;
        public int loop;
        public float instensity;
        public float blur;
        public int downsample;
        public RenderTargetIdentifier Source { get; set; }
        //public RenderTargetIdentifier BlurTex;
        public RenderTargetIdentifier Temp1;
        public RenderTargetIdentifier Temp2;
        int ssW;
        int ssH;
        public void setupmypass(RenderTargetIdentifier source)
        {
            this.Source = source;
        }
        // 执行
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            // int BlurTexID = Shader.PropertyToID("_BlurTex"); // 模糊前的,shader 里没有这张图
            int TempID1 = Shader.PropertyToID("Temp1");
            int TempID2 = Shader.PropertyToID("_SourceTex"); // 
            int loopID = Shader.PropertyToID("_Loop");
            int Xid = Shader.PropertyToID("_X");
            int Yid = Shader.PropertyToID("_Y");
            int BlurID = Shader.PropertyToID("_Blur");
            int instenID = Shader.PropertyToID("_Instensity");  // 其实就是pass2 lerp用的
            
            RenderTextureDescriptor SSdesc = renderingData.cameraData.cameraTargetDescriptor;   // 拿到相机数据
            ssH = SSdesc.height / downsample;
            ssW = SSdesc.width / downsample;
            CommandBuffer cmd = CommandBufferPool.Get(name); // 通过对象池来调用，大量数据处理的时候特别有用
            cmd.GetTemporaryRT(TempID1, ssW, ssH, 0, FilterMode.Bilinear, RenderTextureFormat.RGB111110Float);//用来存降采样的
            //cmd.GetTemporaryRT(BlurTexID, SSdesc);  // 模糊图前的 ，pass2 要用
            cmd.GetTemporaryRT(TempID2, SSdesc);    // 这边不降采样的图就直接拿相机的渲染设置了
            
            // 实例化
            Temp1 = new RenderTargetIdentifier(TempID1);
            Temp2 = new RenderTargetIdentifier(TempID2);
            
            cmd.SetGlobalFloat(loopID, loop);
            cmd.SetGlobalFloat(Xid, x);
            cmd.SetGlobalFloat(Yid, y);
            cmd.SetGlobalFloat(BlurID, blur);
            cmd.SetGlobalFloat(instenID, instensity);
            
            // 一个Blit就是FrameDebug里一次结果
            cmd.Blit(Source, Temp1);    // 存储降采样的源图，用于pass0计算模糊图
            cmd.Blit(Source, Temp2);    // 存储源图，用来lerp前后效果的（正常不应该这么用，在shader的for循环里做手脚）
            cmd.Blit(Temp1, Source, mymat, 0);//pass0的模糊计算
            // 清理
            //cmd.ReleaseTemporaryRT(BlurTexID);
            cmd.ReleaseTemporaryRT(TempID1);
            cmd.ReleaseTemporaryRT(TempID2);
            context.ExecuteCommandBuffer(cmd);  // 调用
            CommandBufferPool.Release(cmd); // 清理
        }
    }
    CustomRenderPass m_ScriptablePass;
    public override void Create()
    {
        m_ScriptablePass = new CustomRenderPass();
        m_ScriptablePass.renderPassEvent = mysetitng.passEvent;
        m_ScriptablePass.blur = mysetitng.blur;
        m_ScriptablePass.x = mysetitng.x;
        m_ScriptablePass.y = mysetitng.y;
        m_ScriptablePass.instensity = mysetitng.instensity;
        m_ScriptablePass.loop = mysetitng.loop;
        m_ScriptablePass.mymat = mysetitng.RadialBlurMat;
        m_ScriptablePass.name = mysetitng.PassName;
        m_ScriptablePass.downsample = mysetitng.downsample;
    }
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        if (mysetitng.RadialBlurMat != null)
        {
            m_ScriptablePass.setupmypass(renderer.cameraColorTarget);
            // 把括号里的pass根据渲染设置（是有Create设置的）丢到渲染流程中
            renderer.EnqueuePass(m_ScriptablePass);
        }
        else
        {
            Debug.LogError("径向模糊材质球丢失！");
        }
    }
}

shader

Shader"WX/URP/Post/radialBrul"
{
    Properties
    {
        _MainTex("tex",2D) = "Wwhite"{}
    }
        SubShader
    {
        Tags{"RenderPipeline" = "UniversalRenderPipeline"}
        Cull Off ZWrite Off ZTest Always

        HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        float4 _MainTex_ST;
        float _Loop;
        float _Blur;
        float _Y;
        float _X;
        float _Instensity;
        TEXTURE2D(_MainTex);
        SAMPLER(sampler_MainTex);
        TEXTURE2D(_SourceTex); // 原图
        SAMPLER(sampler_SourceTex);

         struct a2v
         {
             float4 positionOS:POSITION;
             float2 texcoord:TEXCOORD;
         };

         struct v2f
         {
             float4 positionCS:SV_POSITION;
             float2 texcoord:TEXCOORD;
         };
        ENDHLSL

        pass
        {

            HLSLPROGRAM
            #pragma vertex VERT
            #pragma fragment FRAG

            v2f VERT(a2v i)
            {
                v2f o;
                o.positionCS = TransformObjectToHClip(i.positionOS.xyz);
                o.texcoord = i.texcoord;
                return o;
            }

            half4 FRAG(v2f i) :SV_TARGET
            {
                float4 col = 0;
                float2 dir = (i.texcoord - float2(_X,_Y)) * _Blur * 0.01;
                for (int t = 0; t < _Loop; t++)
                {
                    col += SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,i.texcoord + dir * t) / _Loop;
                }
                float4 Source = SAMPLE_TEXTURE2D(_SourceTex,sampler_SourceTex,i.texcoord);//得到屏幕原始图
                return lerp(Source,col,_Instensity);
            }
            ENDHLSL
        }
    }
}

一些坑

public面板
如果采用新建一个 setting 类的方式去创建面板的话，大概流程是：

class setting
public setting
ScriptableRenderPass public 一样的 setting
Execute 中 SetGlobalFloat
Create 中把外部面板中的数据拿到 ScriptableRenderPass 中去
同时，shader中注意 Properties 中不用新建数据

对于Blit 函数
cmd.Blit(a,b,mat,-1); 等同于

mat.SetTexture(“_a”,a);

cmd.Blit(null,b,mat,-1);

cmd.Blit和Blit等效果

cameraColorTarget用 var格式
(当时还不懂var是啥意思)

CommandBufferPool.Release(cmd) & cmd.clear()
CommandBufferPool.Release(cmd) : 把资源释放掉了,cmd就没了

cmd.clear() : 只是把这个buffer里面的命令清空

原神fullScreen三角形
对于 GetTemporaryRT 函数
相当于new RT，然后给RenderTargetIdentifier

添加“获取临时渲染纹理”命令。（一般是获取相机的RT数据）

开启HDR后需要把 Format 改成 DefaultHDR

跟着相机走的话可以这样写

这样写跟一个一个数据去getCameraData的最终呈现效果不一样

– 另外感觉一些数值，例如depth buffer如果不需要的话应该可以存更低的精度

对于 ReleaseTemporaryRT 函数
必须释放，不然会内存泄漏，只是释放的时机不同

旭辉老师说是如果cmd.GetTemporaryRT出来的话，释放cmd这个应该就会释放，但遇到过如果不释放就黑屏的问题

CommandBufferPool.Get(“name”)
相当于给这个cmd起名，方便后面查找
RenderTargetIdentifier & RenderTargetHandle 的区别
Handle是自己定义的

所有涉及到bilt计算的RT都需要给一个临时rt
因为最终material面板上这个tex的位置应该是一张rt
如果该pass没有贴图，blit会默认给MainTex
blit(RTID,cameraSource) 会自动把RTID给MainTex
给贴图赋值
只有两种Set可以，bilt并不行
Filter
cmd.GetTemporal & RenderTexture.GetTemporal
陈参说cmd只有一帧，返回的是handle(类似指针)；而renderTexture是持续的。
对于 context.ExecuteCommandBuffer(cmd)
看官方自带的 RenderObjectsPass.cs 中，执行cmd的方法执行了两次