1. 项目概述：为什么要在URP里实现Kawase模糊？

如果你在Unity的通用渲染管线（URP）里做过屏幕特效，尤其是像Bloom（辉光）这类需要模糊效果的，大概率会接触到“Kawase模糊”这个名字。它不像高斯模糊那样名声在外，但在游戏和实时渲染的后处理领域，Kawase模糊是一个兼顾性能和效果的经典选择。简单来说，它是一种通过多次降采样和简单采样来实现高效、高质量模糊的算法。

我第一次在URP项目里需要实现一个自定义的Bloom效果时，就遇到了性能瓶颈。标准的Gaussian Blur虽然质量好，但采样次数多，在移动端或需要处理高分辨率RT时，帧率下降很明显。后来在翻阅一些商业游戏和开源渲染管线的源码时，发现很多都采用了Kawase Blur的变体。它的核心思路非常巧妙：用多次、固定偏移的降采样操作，来模拟高斯核的权重分布，从而用极少的采样次数（每次Pass仅采样4次）达到近似高斯模糊的平滑效果。

对于URP开发者而言，理解并实现Kawase模糊有几个直接的好处：

1. 性能优势显著：在保证视觉效果可接受的前提下，其性能通常优于同等级别的高斯模糊，特别适合移动平台或性能敏感的场景。
2. 集成门槛低：算法本身不复杂，可以很方便地封装成一个可复用的Renderer Feature和Volume Component，无缝集成到URP的后处理堆栈中。
3. 应用场景广泛：不仅是Bloom，任何需要屏幕空间模糊的地方都能用上，比如景深、镜头污迹、UI模糊、速度模糊等。

所以，这个项目就是带你从零开始，在URP中实现一个完整的、可配置的Kawase模糊后处理效果。我们会从原理讲起，然后手把手写Shader和C#脚本，最后集成到URP管线中，并分享一些调优和避坑的经验。

2. Kawase模糊的核心原理与方案选型

在动手写代码之前，我们必须先搞清楚Kawase模糊到底是怎么工作的，以及为什么它比传统高斯模糊更高效。这决定了我们后续的实现方案和参数设计。

2.1 传统高斯模糊的瓶颈

为了理解Kawase的优势，我们先快速回顾一下标准的高斯模糊。它通常在一个Pass里，对当前像素周围一定半径（比如7x7）内的所有像素进行采样，每个采样点的权重根据高斯函数计算。一个7x7的高斯模糊，每个像素就需要采样49次纹理。即使使用双Pass（水平+垂直）分离优化，每个像素也需要采样7+7=14次。在Full HD（1920x1080）分辨率下，这就是数千万次的纹理采样，对带宽和ALU都是不小的压力。

2.2 Kawase模糊的“降采样迭代”哲学

Kawase模糊由日本开发者Masaki Kawase提出，其核心思想不是在一个Pass里采样一大片区域，而是通过多次迭代的降采样（Downsample）操作，逐步扩大模糊范围。

它的单次迭代操作（一个Pass）极其简单：

1. 将渲染目标（Render Texture）的尺寸减半（降采样）。
2. 对降采样后的每个像素，采样原图中该像素对应位置周围固定偏移的四个点（例如：偏移(0, 0), (1, 0), (0, 1), (1, 1)）。
3. 将这四个采样结果取平均值，写入当前像素。

这个操作的Shader代码可能只有寥寥几行。但关键在于迭代。假设我们从全分辨率开始：

• 迭代1：渲染到1/2大小的RT。此时，每个像素融合了原图2x2区域的信息，相当于一个轻微的模糊。
• 迭代2：以上一个1/2大小的RT作为输入，渲染到1/4大小的RT。此时，每个像素融合了上一个RT的2x2区域，而这个区域又对应原图的4x4区域。模糊范围扩大了。
• 迭代3、4...：继续这个过程，每次降采样，模糊范围呈指数级增长。

经过N次迭代后，我们得到了一个非常小的、高度模糊的图像。最后，通常还需要一个上采样（Upsample）过程，将这个小模糊图逐步放大回原尺寸（或目标尺寸），并在上采样过程中与之前的中间结果进行混合，以得到更平滑的过渡和更好的质量。

注意：纯粹的Kawase模糊在多次降采样后，由于持续取平均，图像会变得非常“平”，丢失细节。因此，现代实现（如UE4/UE5的Bloom，以及很多URP/BRP的Bloom实现）常采用一种“金字塔”式混合，即在降采样后，进行上采样并与前一级的降采样结果进行混合，这被称为“Kawase Blur”或“Dual Filter Blur”的变体。我们项目实现的就是这种更实用的版本。

2.3 URP中的实现方案选型

在URP中实现后处理，主要有两种方式：

1. RenderFeature+Volume组件：这是URP推荐的标准方式。我们可以创建一个KawaseBlurRendererFeature，将其添加到URP渲染器数据中。同时，创建一个KawaseBlurSettings脚本继承自VolumeComponent，用于在场景或后处理Volume中调节参数（如迭代次数、模糊强度）。这种方式灵活、可配置，能与URP的后处理系统完美融合。
2. 直接修改URP源码：直接修改UniversalRenderer.cs或相关的后处理Pass。这种方式更底层，性能可能略有优势，但丧失了灵活性和可维护性，升级URP版本时容易出错。

我们选择第一种方案。理由很充分：它符合URP的设计范式，非侵入式，方便在不同项目间迁移，也便于美术和策划通过Volume实时调节效果。性能上，通过合理的RT管理和Shader优化，完全能满足大部分项目需求。

3. 核心组件构建：Shader与C#脚本

理论清晰后，我们开始构建核心组件：负责模糊计算的Shader，以及负责流程控制和参数传递的C#脚本。

3.1 Kawase模糊Shader实现

我们先编写核心的Shader。这个Shader需要处理两个阶段：降采样（Downsample）和上采样（Upsample）。通常我们可以用一个Shader，通过不同的参数来控制。

创建一个新的Shader文件，比如KawaseBlur.shader。我们使用HLSL来编写核心逻辑。

Shader "Hidden/Universal Render Pipeline/KawaseBlur" { HLSLINCLUDE #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" TEXTURE2D(_SourceTex); SAMPLER(sampler_SourceTex); float4 _SourceTex_TexelSize; // 提供纹理的像素大小信息 float _Offset; // 采样偏移量，控制模糊强度 struct Attributes { uint vertexID : SV_VertexID; }; struct Varyings { float4 positionCS : SV_POSITION; float2 uv : TEXCOORD0; }; Varyings Vert(Attributes input) { Varyings output; // 使用顶点ID生成全屏三角形，这是URP后处理的标准做法，比渲染四边形更高效。 output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID); output.uv = GetFullScreenTriangleTexCoord(input.vertexID); return output; } // Kawase模糊的核心采样函数 float4 SampleKawase(float2 uv) { // 计算四个固定方向的偏移 float2 offset = _SourceTex_TexelSize.xy * _Offset; float4 col = 0; col += SAMPLE_TEXTURE2D(_SourceTex, sampler_SourceTex, uv); col += SAMPLE_TEXTURE2D(_SourceTex, sampler_SourceTex, uv + float2(offset.x, 0)); col += SAMPLE_TEXTURE2D(_SourceTex, sampler_SourceTex, uv + float2(0, offset.y)); col += SAMPLE_TEXTURE2D(_SourceTex, sampler_SourceTex, uv + float2(offset.x, offset.y)); return col * 0.25; // 取平均值 } float4 FragDownsample(Varyings input) : SV_Target { return SampleKawase(input.uv); } // 上采样Pass可能还需要混合（例如用于Bloom），这里先实现基础版本 float4 FragUpsample(Varyings input) : SV_Target { // 基础的上采样就是简单的双线性采样，混合逻辑在C#端控制 return SAMPLE_TEXTURE2D(_SourceTex, sampler_SourceTex, input.uv); } ENDHLSL SubShader { Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline"} // Pass 0: 降采样 Pass { Name "KawaseDownsample" ZTest Always ZWrite Off Cull Off HLSLPROGRAM #pragma vertex Vert #pragma fragment FragDownsample ENDHLSL } // Pass 1: 上采样 Pass { Name "KawaseUpsample" ZTest Always ZWrite Off Cull Off HLSLPROGRAM #pragma vertex Vert #pragma fragment FragUpsample ENDHLSL } } }

关键点解析：

• _Offset参数：这是Kawase模糊的“灵魂”。在降采样Pass中，它通常设置为一个较小的值（如0.5, 1.0）。它乘以纹理的像素大小(_TexelSize)，决定了每次采样时四个点的偏移距离。_Offset越大，单次Pass的模糊范围越大，但可能产生更明显的“块状”感，通常需要配合更多迭代次数来平滑。
• GetFullScreenTriangleVertexPosition：URP提供的工具函数，用于生成覆盖整个屏幕的三角形，比传统的四边形网格更高效，顶点数更少。
• SampleKawase函数：严格遵循了Kawase模糊的定义，只采样4次。这是其高性能的根源。

3.2 Volume组件与Renderer Feature脚本

接下来，我们创建C#脚本来管理这个效果。

第一步：创建Volume组件 (KawaseBlurSettings.cs)这个脚本定义了在Volume中可调节的参数。

using UnityEngine; using UnityEngine.Rendering; using UnityEngine.Rendering.Universal; [System.Serializable, VolumeComponentMenu("Custom/Kawase Blur")] public class KawaseBlurSettings : VolumeComponent, IPostProcessComponent { public ClampedIntParameter iteration = new ClampedIntParameter(4, 1, 8); public ClampedFloatParameter offset = new ClampedFloatParameter(1.0f, 0.5f, 5.0f); public ClampedFloatParameter intensity = new ClampedFloatParameter(1.0f, 0.0f, 5.0f); public BoolParameter useSourceRT = new BoolParameter(false); public bool IsActive() => intensity.value > 0; public bool IsTileCompatible() => false; // 通常后处理效果不兼容瓦片渲染 }

• iteration：模糊迭代次数。次数越多，模糊半径越大，效果越平滑，但消耗也越大。通常4-6次在1080p下就有不错的效果。
• offset：对应Shader中的_Offset参数。
• intensity：最终效果的强度系数，可以用于动态控制模糊的显隐。
• useSourceRT：一个调试选项。如果为true，则直接显示降采样过程中的某个中间RT，方便观察模糊金字塔的每一层。

第二步：创建Renderer Feature (KawaseBlurRendererFeature.cs)这是核心的渲染逻辑控制器。它负责创建和管理渲染Pass，申请和释放RT，并执行模糊的迭代过程。

using UnityEngine; using UnityEngine.Rendering; using UnityEngine.Rendering.Universal; public class KawaseBlurRendererFeature : ScriptableRendererFeature { [System.Serializable] public class Settings { public RenderPassEvent renderPassEvent = RenderPassEvent.BeforeRenderingPostProcessing; public Shader shader; // 可以在这里添加更多Feature级别的设置，如降采样滤波器模式 } public Settings settings = new Settings(); private KawaseBlurPass _renderPass; private Material _material; public override void Create() { if (settings.shader == null) { Debug.LogWarning("Kawase Blur Shader not assigned."); return; } _material = CoreUtils.CreateEngineMaterial(settings.shader); _renderPass = new KawaseBlurPass(_material, settings.renderPassEvent); } public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData) { if (_material == null || !renderingData.postProcessingEnabled) return; var stack = VolumeManager.instance.stack; var component = stack.GetComponent<KawaseBlurSettings>(); if (component == null || !component.IsActive()) return; _renderPass.ConfigureInput(ScriptableRenderPassInput.Color); _renderPass.Setup(component); renderer.EnqueuePass(_renderPass); } protected override void Dispose(bool disposing) { CoreUtils.Destroy(_material); } private class KawaseBlurPass : ScriptableRenderPass { private Material _material; private KawaseBlurSettings _volumeSettings; private RTHandle[] _blurPyramid; // 用于存储模糊金字塔的RT句柄数组 private const int MaxIterations = 16; // 最大迭代次数，根据Volume参数中的上限设定 public KawaseBlurPass(Material material, RenderPassEvent evt) { _material = material; renderPassEvent = evt; _blurPyramid = new RTHandle[MaxIterations]; } public void Setup(KawaseBlurSettings settings) { _volumeSettings = settings; } public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor) { // 根据当前相机的RT描述符，配置模糊金字塔RT的格式和尺寸 // 通常使用半精度浮点格式（R16G16B16A16_SFloat）以兼顾质量和性能 // 使用RTHandle系统来管理RT生命周期，避免每帧分配 for (int i = 0; i < _volumeSettings.iteration.value; i++) { // 每一层尺寸减半 int width = cameraTextureDescriptor.width >> (i + 1); int height = cameraTextureDescriptor.height >> (i + 1); // 确保尺寸不小于1 width = Mathf.Max(1, width); height = Mathf.Max(1, height); RenderingUtils.ReAllocateIfNeeded(ref _blurPyramid[i], new Vector2Int(width, height), cameraTextureDescriptor.colorFormat, name: $"_KawaseBlurPyramid{i}"); } } public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData) { if (_material == null || _volumeSettings == null) return; CommandBuffer cmd = CommandBufferPool.Get("Kawase Blur"); using (new ProfilingScope(cmd, new ProfilingSampler("KawaseBlur"))) { var source = renderingData.cameraData.renderer.cameraColorTargetHandle; int iteration = _volumeSettings.iteration.value; float offset = _volumeSettings.offset.value; // 1. 降采样过程 RTHandle lastDown = source; for (int i = 0; i < iteration; i++) { _material.SetFloat("_Offset", offset); Blitter.BlitCameraTexture(cmd, lastDown, _blurPyramid[i], _material, 0); // 使用Pass 0 (Downsample) lastDown = _blurPyramid[i]; } // 2. 上采样与混合过程 (这里实现基础的Bloom式混合) RTHandle lastUp = _blurPyramid[iteration - 1]; for (int i = iteration - 2; i >= 0; i--) { // 设置上采样源 _material.SetTexture("_SourceTex", lastUp); // 执行上采样到更大尺寸的RT Blitter.BlitCameraTexture(cmd, _blurPyramid[i], _blurPyramid[i], _material, 1); // 使用Pass 1 (Upsample)，这里简化了，实际可能需要混合 // 更常见的Bloom混合是：Blit到_blurPyramid[i]时，将lastUp作为_SourceTex，并可能使用Additive混合模式 // 此处为清晰起见，先实现基础功能。复杂的混合我们稍后优化。 lastUp = _blurPyramid[i]; } // 3. 将最终模糊结果与原始图像混合（可选，Bloom需要，纯模糊则直接覆盖） // 这里先实现简单的屏幕叠加 _material.SetFloat("_Intensity", _volumeSettings.intensity.value); _material.SetTexture("_BlurTex", lastUp); Blitter.BlitCameraTexture(cmd, source, source, _material, 2); // 假设我们创建了第三个Pass用于最终混合 } context.ExecuteCommandBuffer(cmd); CommandBufferPool.Release(cmd); } public override void FrameCleanup(CommandBuffer cmd) { // RTHandle的释放由RTHandleSystem管理，通常不需要在这里手动释放 } } }

重要提示：上面的代码是一个高度简化的框架，特别是上采样和混合部分。一个生产级的Kawase模糊（尤其是用于Bloom）其上采样过程通常不是简单的Blit，而是会将当前上采样结果与对应层级的降采样结果进行加权混合（有时称为“双滤波”），以避免光晕过平。我们会在下一章节的“完整流程实现”中完善这个逻辑。

4. 完整流程实现与URP集成

现在我们已经有了核心的Shader和C#框架，接下来需要完善渲染Pass的逻辑，并将其集成到URP管线中。

4.1 完善Kawase模糊的渲染Pass

我们需要修改KawaseBlurPass的Execute方法，实现一个更接近工业标准的、用于Bloom的Kawase模糊流程（双滤波近似）。这个流程能产生更平滑、能量守恒更好的光晕。

首先，更新我们的Shader，增加一个用于上采样并混合的Pass。

// 在原有的SubShader中添加一个新的Pass // Pass 2: 上采样并混合（用于Bloom效果） Pass { Name "KawaseUpsampleBlend" ZTest Always ZWrite Off Cull Off Blend One One // 使用加法混合，将模糊层叠加 HLSLPROGRAM #pragma vertex Vert #pragma fragment FragUpsampleBlend TEXTURE2D(_BlurTex); // 这是来自上一级（更模糊）的纹理 SAMPLER(sampler_BlurTex); float4 _BlurTex_TexelSize; float4 FragUpsampleBlend(Varyings input) : SV_Target { // 对当前层级的纹理进行上采样（这里为了质量，可以使用双线性或双立方采样） // 简单起见，我们使用硬件双线性过滤 float4 currentColor = SAMPLE_TEXTURE2D(_SourceTex, sampler_SourceTex, input.uv); // 采样更模糊的上一级纹理 float4 blurrierColor = SAMPLE_TEXTURE2D(_BlurTex, sampler_BlurTex, input.uv); // 将两者相加。在实际Bloom中，这里可能会乘上一个权重系数来控制混合程度 return currentColor + blurrierColor; } ENDHLSL }

然后，重写C#端的执行逻辑：

public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData) { if (_material == null || _volumeSettings == null) return; CommandBuffer cmd = CommandBufferPool.Get("Kawase Blur"); using (new ProfilingScope(cmd, new ProfilingSampler("KawaseBlur"))) { var source = renderingData.cameraData.renderer.cameraColorTargetHandle; int iteration = Mathf.Min(_volumeSettings.iteration.value, MaxIterations); float offset = _volumeSettings.offset.value; // --- 降采样阶段 --- RTHandle lastDown = source; for (int i = 0; i < iteration; i++) { _material.SetFloat("_Offset", offset); // 使用降采样Pass (0) CoreUtils.SetRenderTarget(cmd, _blurPyramid[i], ClearFlag.None, Color.clear); Blitter.BlitTexture(cmd, lastDown, new Vector4(1, 1, 0, 0), _material, 0); lastDown = _blurPyramid[i]; } // --- 上采样与混合阶段 (双滤波) --- RTHandle lastUp = _blurPyramid[iteration - 1]; for (int i = iteration - 2; i >= 0; i--) { // 准备上采样混合Pass (2) _material.SetTexture("_SourceTex", _blurPyramid[i]); // 当前层级（较清晰） _material.SetTexture("_BlurTex", lastUp); // 上一级（较模糊） // 渲染到当前层级的RT，并使用加法混合叠加更模糊的内容 CoreUtils.SetRenderTarget(cmd, _blurPyramid[i], ClearFlag.None, Color.clear); Blitter.BlitTexture(cmd, _blurPyramid[i], new Vector4(1, 1, 0, 0), _material, 2); lastUp = _blurPyramid[i]; } // --- 最终合成到屏幕 --- // 现在lastUp就是金字塔最底层（全分辨率或接近全分辨率）的模糊结果 // 我们可以选择多种方式与原图混合：Additive（Bloom）、Screen、Overlay等。 // 这里实现一个简单的强度控制加法混合。 _material.SetFloat("_Intensity", _volumeSettings.intensity.value); _material.SetTexture("_BlurTex", lastUp); // 使用一个单独的合成Pass（假设是Pass 3），将模糊图以指定强度加到原图上 Blitter.BlitCameraTexture(cmd, source, source, _material, 3); } context.ExecuteCommandBuffer(cmd); CommandBufferPool.Release(cmd); }

流程解读：

1. 降采样：从原图开始，每次迭代渲染到尺寸减半的RT中，使用Pass 0进行Kawase模糊。我们得到了一个模糊金字塔（_blurPyramid），最顶层是最模糊的小图。
2. 上采样与混合（双滤波）：从金字塔的倒数第二层开始，向上处理。对于每一层，我们将当前层的纹理和上一层（更模糊）的纹理作为输入，使用Pass 2进行上采样并加法混合。这样，每一层都融合了比自身更模糊的信息，最终在底层得到一个平滑的、从清晰到模糊过渡良好的结果。这是获得高质量光晕的关键。
3. 最终合成：将最终处理好的模糊图（lastUp），以一定的强度（_Intensity）通过混合模式（如Additive）叠加到原始屏幕图像上。

4.2 在URP渲染器中启用

1. 将编写好的KawaseBlur.shader放入项目。
2. 将KawaseBlurSettings.cs和KawaseBlurRendererFeature.cs放入项目。
3. 在Unity编辑器中，打开URP Asset（通常为UniversalRP-HighQuality等）。
4. 在Renderer Features列表处，点击“Add Renderer Feature”，选择“Kawase Blur Renderer Feature”。
5. 在新增的Feature中，将Shader字段拖拽赋值为我们创建的KawaseBlur.shader。
6. 在场景中创建一个Volume（全局或局部），在其Profile中添加“Kawase Blur”覆盖。
7. 调整Volume中的参数（Iteration, Offset, Intensity），立即可以在Game视图看到模糊效果。

4.3 参数调优指南

• Iteration（迭代次数）：这是控制模糊半径和性能的主要参数。从3开始尝试。对于1080p，4次迭代通常能获得很好的效果和性能平衡。每增加一次迭代，模糊半径大致翻倍，但渲染的RT尺寸也减半，因此性能消耗并非线性增长，低分辨率层的开销较小。
• Offset（偏移量）：控制单次Pass的采样范围。默认从1.0开始。增加它（如1.5）可以让单次模糊更“激进”，在较少迭代次数下获得较大模糊半径，但可能让模糊效果显得更“脏”或出现条状瑕疵。减少它（如0.5）会让每次模糊更轻微，需要更多迭代来达到相同半径，但效果更平滑。通常与迭代次数配合调整。
• Intensity（强度）：最终模糊图与原始图像的混合强度。对于Bloom，通常设置在0.5到2.0之间，取决于艺术风格。

实操心得：在移动平台上，建议将迭代次数限制在4次以内，并使用半精度浮点（R16G16B16A16_SFloat）格式的RT。如果用于全屏模糊（如UI背景），可以适当降低起始分辨率（比如从1/2分辨率开始降采样），能大幅提升性能。

5. 常见问题、性能分析与排查技巧

即使按照步骤实现，在实际项目中仍可能遇到各种问题。这里记录一些我踩过的坑和解决方案。

5.1 常见问题速查表

5.2 性能深度分析与优化建议

1. 带宽是首要敌人：后处理效果，尤其是全屏效果，最大的性能瓶颈往往是GPU内存带宽。Kawase模糊每次迭代的纹理尺寸减半，这天然地降低了带宽压力。第1次降采样（全分辨率到半分辨率）是最贵的。如果性能吃紧，可以考虑从半分辨率甚至四分之一分辨率开始构建模糊金字塔，牺牲一些边缘精度换取大幅性能提升。

2. 利用RTHandle系统：如代码所示，始终使用RTHandle来申请和管理RT。RTHandleSystem会智能地复用RT，避免每帧都进行昂贵的分配和释放操作。这是URP高性能后处理的基石。

3. 精度与格式选择：

   • PC/主机：可以使用R16G16B16A16_SFloat，在质量和性能间取得良好平衡。
   • 移动端（主流）：R11G11B10_FLOAT格式是一个非常好的选择，它只有32位/像素，带宽占用小，且能表示HDR颜色，非常适合Bloom这类需要一定范围的颜色操作。
   • 移动端（低端）：如果效果允许，可以使用R8G8B8A8_UNORM。但要注意，这可能会在明亮的Bloom区域产生条带现象。

4. 迭代次数与视觉质量的权衡：不要盲目追求高迭代次数。4次迭代对于大多数1080p的Bloom需求已经足够。你可以通过稍微增加_Offset值（如1.2）来在相同迭代次数下获得更大的模糊半径，但这会牺牲一些平滑度。最好的方法是让美术在目标平台上直接调节，找到质量和帧率的甜蜜点。

5. 区分“应用级”模糊和“屏幕级”模糊：

   • 屏幕级模糊：即本项目的全屏后处理。开销固定，与场景复杂度无关。
   • 应用级模糊：比如只模糊UI背景。这时，你应该使用一个独立的相机渲染UI到RT，然后只对这个RT进行Kawase模糊，最后再叠加到屏幕上。这样可以避免对昂贵的3D场景进行全屏模糊，性能好得多。

5.3 调试技巧

• 使用Frame Debugger：这是调试渲染流程的神器。一步步查看每个KawaseBlurPass的输入输出，确认RT尺寸、纹理内容是否正确。
• 暴露中间RT：在Volume设置中增加一个DebugMode或useSourceRT参数。在Shader中，根据这个参数直接输出中间某层的模糊RT到屏幕，可以直观地看到每一级金字塔的效果，便于调整Offset和迭代次数。
• Profiler GPU Usage：在Unity Profiler的GPU模块中，可以清晰地看到KawaseBlur各个Pass的耗时，帮助你定位是ALU计算瓶颈还是纹理采样带宽瓶颈。

实现一个稳定高效的URP后处理效果，一半靠正确的代码，另一半靠对管线流程和性能特性的理解。Kawase模糊作为一个经典的算法，其价值不仅在于效果本身，更在于它教你如何用有限的性能预算，通过巧妙的算法设计达到目标。当你需要其他自定义后处理效果时，这套Renderer Feature+Volume+RTHandle的框架和调试思路，完全可以复用。