// 1. 打开Unity Hub
// 2. 点击"New Project"
// 3. 选择"3D (URP)"或"2D (URP)"模板
// 4. 创建项目

// 1. 打开Package Manager (Window > Package Manager)
// 2. 搜索"Universal RP"
// 3. 点击Install

// 或者手动编辑 Packages/manifest.json
{
  "dependencies": {
    "com.unity.render-pipelines.universal": "14.0.8",
    "com.unity.render-pipelines.core": "14.0.8"
  }
}

using UnityEditor;
using UnityEngine.Rendering.Universal;

public class URPSetup : EditorWindow
{
    [MenuItem("Tools/Setup URP")]
    static void SetupURP()
    {
        // 创建URP Asset
        var urpAsset = UniversalRenderPipelineAsset.Create();
        AssetDatabase.CreateAsset(urpAsset, "Assets/Settings/URPAsset.asset");
        
        // 创建Renderer
        var rendererData = ScriptableRendererData.CreateRendererData();
        AssetDatabase.CreateAsset(rendererData, "Assets/Settings/ForwardRenderer.asset");
        
        // 设置为激活管线
        UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset = urpAsset;
        
        Debug.Log("URP Setup Complete!");
    }
}

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

public class MaterialUpgrader
{
    [MenuItem("Tools/Upgrade Materials to URP")]
    static void UpgradeMaterials()
    {
        string[] guids = AssetDatabase.FindAssets("t:Material");
        int upgraded = 0;
        
        foreach (string guid in guids)
        {
            string path = AssetDatabase.GUIDToAssetPath(guid);
            Material mat = AssetDatabase.LoadAssetAtPath<Material>(path);
            
            if (mat.shader.name.Contains("Standard"))
            {
                mat.shader = Shader.Find("Universal Render Pipeline/Lit");
                upgraded++;
            }
        }
        
        AssetDatabase.SaveAssets();
        Debug.Log($"Upgraded {upgraded} materials to URP");
    }
}

// 方法1：通过菜单创建
// Assets > Create > Rendering > URP Asset (with Universal Renderer)

// 方法2：通过代码创建
using UnityEditor;
using UnityEngine.Rendering.Universal;

public class CreateURPAsset
{
    [MenuItem("Assets/Create/Custom URP Asset")]
    static void Create()
    {
        var asset = UniversalRenderPipelineAsset.Create();
        var path = "Assets/Settings/CustomURPAsset.asset";
        AssetDatabase.CreateAsset(asset, path);
        AssetDatabase.SaveAssets();
        
        // 分配Renderer
        var rendererData = ScriptableObject.CreateInstance<UniversalRendererData>();
        AssetDatabase.CreateAsset(rendererData, "Assets/Settings/CustomRenderer.asset");
        
        // 链接Renderer到Asset
        SerializedObject so = new SerializedObject(asset);
        so.FindProperty("m_RendererDataList").arraySize = 1;
        so.FindProperty("m_RendererDataList.Array.data[0]").objectReferenceValue = rendererData;
        so.ApplyModifiedProperties();
    }
}

// 启用深度纹理的影响
public class DepthTextureExample : MonoBehaviour
{
    // 在Shader中访问深度纹理
    // Shader代码
}

// HDR对后处理的影响示例
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class HDRController : MonoBehaviour
{
    public Volume volume;
    
    void Start()
    {
        // 检查HDR是否启用
        bool isHDR = QualitySettings.activeColorSpace == ColorSpace.Linear;
        
        if (volume.profile.TryGet<Bloom>(out var bloom))
        {
            // HDR下Bloom效果更明显
            bloom.intensity.value = isHDR ? 1.0f : 0.5f;
        }
    }
}

// 运行时切换抗锯齿
using UnityEngine;
using UnityEngine.Rendering.Universal;

public class AAController : MonoBehaviour
{
    private UniversalAdditionalCameraData cameraData;
    
    void Start()
    {
        cameraData = GetComponent<UniversalAdditionalCameraData>();
    }
    
    public void SetAntiAliasing(AntialiasingMode mode, AntialiasingQuality quality)
    {
        cameraData.antialiasing = mode;
        cameraData.antialiasingQuality = quality;
    }
    
    // MSAA示例
    public void EnableMSAA()
    {
        SetAntiAliasing(AntialiasingMode.None, AntialiasingQuality.High);
        // MSAA需要在URP Asset中配置
    }
    
    // FXAA示例
    public void EnableFXAA()
    {
        SetAntiAliasing(AntialiasingMode.FastApproximateAntialiasing, 
                       AntialiasingQuality.Medium);
    }
    
    // SMAA示例
    public void EnableSMAA()
    {
        SetAntiAliasing(AntialiasingMode.SubpixelMorphologicalAntiAliasing,
                       AntialiasingQuality.High);
    }
}

// 动态分辨率调整
using UnityEngine;
using UnityEngine.Rendering.Universal;

public class DynamicResolution : MonoBehaviour
{
    public UniversalRenderPipelineAsset urpAsset;
    private float targetFPS = 60f;
    private float currentScale = 1.0f;
    
    void Update()
    {
        float currentFPS = 1.0f / Time.deltaTime;
        
        // 根据帧率动态调整渲染分辨率
        if (currentFPS < targetFPS - 5f && currentScale > 0.5f)
        {
            currentScale -= 0.05f;
            urpAsset.renderScale = currentScale;
        }
        else if (currentFPS > targetFPS + 5f && currentScale < 1.0f)
        {
            currentScale += 0.05f;
            urpAsset.renderScale = currentScale;
        }
        
        Debug.Log($"FPS: {currentFPS:F1}, Render Scale: {currentScale:F2}");
    }
}

// 主光源阴影配置
using UnityEngine;

public class MainLightSetup : MonoBehaviour
{
    public Light mainLight;
    
    void ConfigureMainLight()
    {
        // 设置为主光源
        mainLight.type = LightType.Directional;
        
        // 阴影配置
        mainLight.shadows = LightShadows.Soft;
        mainLight.shadowStrength = 0.8f;
        mainLight.shadowBias = 0.05f;
        mainLight.shadowNormalBias = 0.4f;
        
        // 渲染层设置
        mainLight.renderingLayerMask = 1; // Default layer
    }
}

// 附加光源管理器
using UnityEngine;
using System.Collections.Generic;

public class AdditionalLightsManager : MonoBehaviour
{
    public int maxAdditionalLights = 8;
    private List<Light> additionalLights = new List<Light>();
    
    void Start()
    {
        // 查找所有附加光源
        Light[] allLights = FindObjectsOfType<Light>();
        
        foreach (Light light in allLights)
        {
            if (light.type != LightType.Directional)
            {
                additionalLights.Add(light);
            }
        }
        
        OptimizeLights();
    }
    
    void OptimizeLights()
    {
        // 按重要性排序（距离、强度）
        additionalLights.Sort((a, b) => 
        {
            float distA = Vector3.Distance(Camera.main.transform.position, a.transform.position);
            float distB = Vector3.Distance(Camera.main.transform.position, b.transform.position);
            float scoreA = a.intensity / (distA + 1f);
            float scoreB = b.intensity / (distB + 1f);
            return scoreB.CompareTo(scoreA);
        });
        
        // 只保留最重要的N个光源
        for (int i = 0; i < additionalLights.Count; i++)
        {
            additionalLights[i].enabled = i < maxAdditionalLights;
        }
    }
    
    void Update()
    {
        // 每帧更新光源优先级
        OptimizeLights();
    }
}

using UnityEngine;
using UnityEngine.Rendering.Universal;

[CreateAssetMenu(menuName = "Rendering/Quality Preset")]
public class QualityPreset : ScriptableObject
{
    [Header("URP Asset References")]
    public UniversalRenderPipelineAsset lowQualityAsset;
    public UniversalRenderPipelineAsset mediumQualityAsset;
    public UniversalRenderPipelineAsset highQualityAsset;
    
    [Header("Quality Settings")]
    public int shadowDistance = 50;
    public ShadowResolution shadowResolution = ShadowResolution._1024;
    public int msaaLevel = 4;
    public float renderScale = 1.0f;
    
    public void ApplyQuality(QualityLevel level)
    {
        UniversalRenderPipelineAsset targetAsset = null;
        
        switch (level)
        {
            case QualityLevel.Low:
                targetAsset = lowQualityAsset;
                ConfigureLowQuality(targetAsset);
                break;
            case QualityLevel.Medium:
                targetAsset = mediumQualityAsset;
                ConfigureMediumQuality(targetAsset);
                break;
            case QualityLevel.High:
                targetAsset = highQualityAsset;
                ConfigureHighQuality(targetAsset);
                break;
        }
        
        UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset = targetAsset;
        QualitySettings.SetQualityLevel((int)level);
    }
    
    void ConfigureLowQuality(UniversalRenderPipelineAsset asset)
    {
        asset.shadowDistance = 30f;
        asset.renderScale = 0.75f;
        asset.msaaSampleCount = 0;
        asset.supportsCameraDepthTexture = false;
    }
    
    void ConfigureMediumQuality(UniversalRenderPipelineAsset asset)
    {
        asset.shadowDistance = 50f;
        asset.renderScale = 1.0f;
        asset.msaaSampleCount = 2;
        asset.supportsCameraDepthTexture = true;
    }
    
    void ConfigureHighQuality(UniversalRenderPipelineAsset asset)
    {
        asset.shadowDistance = 100f;
        asset.renderScale = 1.0f;
        asset.msaaSampleCount = 4;
        asset.supportsCameraDepthTexture = true;
        asset.supportsCameraOpaqueTexture = true;
    }
}

public enum QualityLevel
{
    Low,
    Medium,
    High
}

using UnityEngine;
using UnityEngine.UI;

public class QualityManager : MonoBehaviour
{
    public QualityPreset preset;
    public Dropdown qualityDropdown;
    
    void Start()
    {
        qualityDropdown.onValueChanged.AddListener(OnQualityChanged);
        
        // 检测平台自动设置质量
        AutoDetectQuality();
    }
    
    void OnQualityChanged(int index)
    {
        preset.ApplyQuality((QualityLevel)index);
        Debug.Log($"Quality changed to: {(QualityLevel)index}");
    }
    
    void AutoDetectQuality()
    {
        int qualityLevel = 1; // Default: Medium
        
        #if UNITY_ANDROID || UNITY_IOS
        // 移动平台默认低质量
        qualityLevel = 0;
        
        // 根据设备性能调整
        if (SystemInfo.systemMemorySize > 4096)
            qualityLevel = 1;
        #else
        // PC平台根据显存判断
        if (SystemInfo.graphicsMemorySize > 4096)
            qualityLevel = 2;
        else if (SystemInfo.graphicsMemorySize > 2048)
            qualityLevel = 1;
        #endif
        
        qualityDropdown.value = qualityLevel;
    }
}

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

public class RendererSetup
{
    [MenuItem("Tools/Create Forward Renderer")]
    static void CreateForwardRenderer()
    {
        var rendererData = ScriptableObject.CreateInstance<UniversalRendererData>();
        rendererData.name = "ForwardRenderer";
        
        AssetDatabase.CreateAsset(rendererData, "Assets/Settings/ForwardRenderer.asset");
        AssetDatabase.SaveAssets();
        
        Debug.Log("Forward Renderer created!");
    }
    
    [MenuItem("Tools/Create Deferred Renderer")]
    static void CreateDeferredRenderer()
    {
        // Deferred需要特殊设置
        var rendererData = ScriptableObject.CreateInstance<UniversalRendererData>();
        rendererData.name = "DeferredRenderer";
        
        // 通过反射设置Deferred模式（Editor only）
        SerializedObject so = new SerializedObject(rendererData);
        so.FindProperty("m_RenderingMode").enumValueIndex = 1; // Deferred
        so.ApplyModifiedProperties();
        
        AssetDatabase.CreateAsset(rendererData, "Assets/Settings/DeferredRenderer.asset");
        AssetDatabase.SaveAssets();
        
        Debug.Log("Deferred Renderer created!");
    }
}

using UnityEngine;
using UnityEngine.Rendering.Universal;

public class RendererSwitcher : MonoBehaviour
{
    public UniversalRenderPipelineAsset urpAsset;
    public ScriptableRendererData forwardRenderer;
    public ScriptableRendererData deferredRenderer;
    
    public void SwitchToForward()
    {
        SetRenderer(0); // 假设Forward是索引0
        Debug.Log("Switched to Forward Renderer");
    }
    
    public void SwitchToDeferred()
    {
        SetRenderer(1); // 假设Deferred是索引1
        Debug.Log("Switched to Deferred Renderer");
    }
    
    void SetRenderer(int index)
    {
        // 通过反射访问私有字段
        var field = typeof(UniversalRenderPipelineAsset).GetField(
            "m_DefaultRendererIndex", 
            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance
        );
        field?.SetValue(urpAsset, index);
    }
}

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

public class CustomRendererFeature : ScriptableRendererFeature
{
    [System.Serializable]
    public class Settings
    {
        public RenderPassEvent renderPassEvent = RenderPassEvent.AfterRenderingOpaques;
        public Material material;
        public Color tintColor = Color.white;
    }
    
    public Settings settings = new Settings();
    private CustomRenderPass customPass;
    
    // 创建Pass实例（只调用一次）
    public override void Create()
    {
        customPass = new CustomRenderPass(settings);
    }
    
    // 每帧调用，将Pass添加到渲染队列
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        if (settings.material == null)
        {
            Debug.LogWarning("Material is missing!");
            return;
        }
        
        // 配置Pass
        customPass.Setup(renderer);
        
        // 添加到渲染队列
        renderer.EnqueuePass(customPass);
    }
    
    // 自定义RenderPass类
    class CustomRenderPass : ScriptableRenderPass
    {
        private Settings settings;
        private RTHandle tempTexture;
        private ScriptableRenderer renderer;
        
        public CustomRenderPass(Settings settings)
        {
            this.settings = settings;
            renderPassEvent = settings.renderPassEvent;
        }
        
        public void Setup(ScriptableRenderer renderer)
        {
            this.renderer = renderer;
        }
        
        // 配置渲染目标和参数
        public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
        {
            // 创建临时纹理
            RenderTextureDescriptor descriptor = cameraTextureDescriptor;
            descriptor.depthBufferBits = 0; // 不需要深度
            
            RenderingUtils.ReAllocateIfNeeded(
                ref tempTexture, 
                descriptor, 
                FilterMode.Bilinear, 
                TextureWrapMode.Clamp,
                name: "_TempTexture"
            );
        }
        
        // 执行渲染命令
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            CommandBuffer cmd = CommandBufferPool.Get("CustomRenderPass");
            
            // 获取相机颜色目标
            RTHandle cameraTarget = renderer.cameraColorTargetHandle;
            
            // 设置材质参数
            settings.material.SetColor("_TintColor", settings.tintColor);
            
            // Blit操作：从相机目标复制到临时纹理，应用材质
            Blitter.BlitCameraTexture(cmd, cameraTarget, tempTexture, settings.material, 0);
            
            // 复制回相机目标
            Blitter.BlitCameraTexture(cmd, tempTexture, cameraTarget);
            
            context.ExecuteCommandBuffer(cmd);
            CommandBufferPool.Release(cmd);
        }
        
        // 清理资源
        public override void OnCameraCleanup(CommandBuffer cmd)
        {
            tempTexture?.Release();
        }
    }
}

using UnityEngine;
using UnityEngine.Rendering.Universal;

[CreateAssetMenu(menuName = "Rendering/X-Ray Renderer Feature")]
public class XRayRendererFeature : ScriptableRendererFeature
{
    [System.Serializable]
    public class XRaySettings
    {
        public string passName = "X-Ray Pass";
        public RenderPassEvent renderEvent = RenderPassEvent.AfterRenderingTransparents;
        
        [Header("Filter Settings")]
        public LayerMask layerMask = -1;
        public string lightModeTag = "UniversalForward";
        
        [Header("Override Settings")]
        public Material overrideMaterial;
        public int overrideMaterialPassIndex = 0;
        
        [Header("X-Ray Settings")]
        public Color xrayColor = Color.green;
        [Range(0, 1)] public float xrayAlpha = 0.5f;
        
        [Header("Depth Settings")]
        public bool writeDepth = false;
        public CompareFunction depthTest = CompareFunction.Greater;
    }
    
    public XRaySettings settings = new XRaySettings();
    private XRayPass xrayPass;
    
    public override void Create()
    {
        xrayPass = new XRayPass(settings);
    }
    
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        if (settings.overrideMaterial == null) return;
        
        renderer.EnqueuePass(xrayPass);
    }
    
    class XRayPass : ScriptableRenderPass
    {
        private XRaySettings settings;
        private FilteringSettings filteringSettings;
        private RenderStateBlock renderStateBlock;
        
        private static readonly ShaderTagId shaderTagId = new ShaderTagId("UniversalForward");
        
        public XRayPass(XRaySettings settings)
        {
            this.settings = settings;
            renderPassEvent = settings.renderEvent;
            
            // 配置过滤设置
            filteringSettings = new FilteringSettings(RenderQueueRange.all, settings.layerMask);
            
            // 配置渲染状态
            renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
            
            if (!settings.writeDepth)
            {
                renderStateBlock.depthState = new DepthState(false, settings.depthTest);
                renderStateBlock.mask |= RenderStateMask.Depth;
            }
        }
        
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            CommandBuffer cmd = CommandBufferPool.Get(settings.passName);
            
            // 设置材质参数
            settings.overrideMaterial.SetColor("_XRayColor", settings.xrayColor);
            settings.overrideMaterial.SetFloat("_XRayAlpha", settings.xrayAlpha);
            
            // 创建绘制设置
            var drawingSettings = CreateDrawingSettings(
                shaderTagId,
                ref renderingData,
                SortingCriteria.CommonOpaque
            );
            
            drawingSettings.overrideMaterial = settings.overrideMaterial;
            drawingSettings.overrideMaterialPassIndex = settings.overrideMaterialPassIndex;
            
            // 执行绘制
            context.DrawRenderers(
                renderingData.cullResults,
                ref drawingSettings,
                ref filteringSettings,
                ref renderStateBlock
            );
            
            context.ExecuteCommandBuffer(cmd);
            CommandBufferPool.Release(cmd);
        }
    }
}

// 运行时启用Decal
using UnityEngine;
using UnityEngine.Rendering.Universal;

public class DecalManager : MonoBehaviour
{
    public DecalProjector decalPrefab;
    
    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            if (Physics.Raycast(ray, out RaycastHit hit))
            {
                CreateDecal(hit.point, hit.normal);
            }
        }
    }
    
    void CreateDecal(Vector3 position, Vector3 normal)
    {
        DecalProjector decal = Instantiate(decalPrefab, position, Quaternion.identity);
        
        // 对齐到表面
        decal.transform.rotation = Quaternion.LookRotation(-normal);
        
        // 随机旋转
        decal.transform.Rotate(0, 0, Random.Range(0, 360));
        
        // 随机缩放
        float scale = Random.Range(0.5f, 1.5f);
        decal.transform.localScale = Vector3.one * scale;
        
        // 5秒后销毁
        Destroy(decal.gameObject, 5f);
    }
}

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

public class SSAOController : MonoBehaviour
{
    public Volume volume;
    private ScreenSpaceAmbientOcclusion ssao;
    
    void Start()
    {
        if (volume.profile.TryGet<ScreenSpaceAmbientOcclusion>(out ssao))
        {
            ConfigureSSAO();
        }
    }
    
    void ConfigureSSAO()
    {
        // 启用SSAO
        ssao.active = true;
        
        // 基础设置
        ssao.Intensity.value = 0.5f;          // 强度
        ssao.Radius.value = 0.25f;            // 采样半径
        ssao.Falloff.value = 100f;            // 衰减距离
        
        // 质量设置
        ssao.SampleCount.value = ScreenSpaceAmbientOcclusionSampleCount.Medium;
        
        // 可选：启用After Opaque
        ssao.AfterOpaque.value = false;
    }
    
    // 运行时调整
    public void SetSSAOIntensity(float intensity)
    {
        ssao.Intensity.value = Mathf.Clamp01(intensity);
    }
    
    public void SetSSAOQuality(int quality)
    {
        switch (quality)
        {
            case 0:
                ssao.SampleCount.value = ScreenSpaceAmbientOcclusionSampleCount.Low;
                break;
            case 1:
                ssao.SampleCount.value = ScreenSpaceAmbientOcclusionSampleCount.Medium;
                break;
            case 2:
                ssao.SampleCount.value = ScreenSpaceAmbientOcclusionSampleCount.High;
                break;
        }
    }
}

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

public class BlurRendererFeature : ScriptableRendererFeature
{
    [System.Serializable]
    public class BlurSettings
    {
        public RenderPassEvent renderPassEvent = RenderPassEvent.AfterRenderingTransparents;
        public Material blurMaterial;
        
        [Range(0, 5)] public int blurIterations = 2;
        [Range(0, 10)] public float blurRadius = 2f;
        [Range(1, 8)] public int downSample = 2;
    }
    
    public BlurSettings settings = new BlurSettings();
    private BlurRenderPass blurPass;
    
    public override void Create()
    {
        blurPass = new BlurRenderPass(settings);
    }
    
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        if (settings.blurMaterial == null)
        {
            Debug.LogWarning("Blur material is missing!");
            return;
        }
        
        blurPass.Setup(renderer);
        renderer.EnqueuePass(blurPass);
    }
    
    class BlurRenderPass : ScriptableRenderPass
    {
        private BlurSettings settings;
        private ScriptableRenderer renderer;
        
        private RTHandle[] blurTextures = new RTHandle[2];
        private static readonly int blurRadiusID = Shader.PropertyToID("_BlurRadius");
        
        public BlurRenderPass(BlurSettings settings)
        {
            this.settings = settings;
            renderPassEvent = settings.renderPassEvent;
        }
        
        public void Setup(ScriptableRenderer renderer)
        {
            this.renderer = renderer;
        }
        
        public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
        {
            // 创建降采样的临时纹理
            RenderTextureDescriptor descriptor = cameraTextureDescriptor;
            descriptor.width /= settings.downSample;
            descriptor.height /= settings.downSample;
            descriptor.depthBufferBits = 0;
            
            RenderingUtils.ReAllocateIfNeeded(ref blurTextures[0], descriptor, 
                FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_BlurTemp0");
            RenderingUtils.ReAllocateIfNeeded(ref blurTextures[1], descriptor, 
                FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_BlurTemp1");
        }
        
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            CommandBuffer cmd = CommandBufferPool.Get("Blur Effect");
            
            RTHandle source = renderer.cameraColorTargetHandle;
            
            // 设置模糊参数
            settings.blurMaterial.SetFloat(blurRadiusID, settings.blurRadius);
            
            // 降采样到第一个临时纹理
            Blitter.BlitCameraTexture(cmd, source, blurTextures[0]);
            
            // 多次模糊迭代
            for (int i = 0; i < settings.blurIterations; i++)
            {
                // 水平模糊
                settings.blurMaterial.SetVector("_BlurDirection", new Vector4(1, 0, 0, 0));
                Blitter.BlitCameraTexture(cmd, blurTextures[0], blurTextures[1], settings.blurMaterial, 0);
                
                // 垂直模糊
                settings.blurMaterial.SetVector("_BlurDirection", new Vector4(0, 1, 0, 0));
                Blitter.BlitCameraTexture(cmd, blurTextures[1], blurTextures[0], settings.blurMaterial, 0);
            }
            
            // 升采样回相机目标
            Blitter.BlitCameraTexture(cmd, blurTextures[0], source);
            
            context.ExecuteCommandBuffer(cmd);
            CommandBufferPool.Release(cmd);
        }
        
        public override void OnCameraCleanup(CommandBuffer cmd)
        {
            blurTextures[0]?.Release();
            blurTextures[1]?.Release();
        }
    }
}